Merge lp:~andreas-pokorny/mir/add-display-configuration-output-assembly-to-display-device into lp:mir

[Andreas Pokorny]

Add means to query display output configuration from DisplayDevice

This adds methods to DisplayDevice and HwcWrapper to assemble a DisplayConfigurationOutput using the fb and hwc interfaces and EGL. The code is largely borrowed from mir::graphics::android::Framebuffers. This change does not yet make mir::android::DisplayConfiguration use this code path.

Adds a method to query the output configuration for a hwc display. With this MP the code path is not yet in use, but just prepared.

[Kevin DuBois (kdub)]

407 +++ src/platform/graphics/android/real_hwc_wrapper.cpp
This is supposed to be an adapter layer around the hwc interface. Its kept thin and mostly in terms of hwc types so that the logs can closely reflect the actual calls to the 3rd party code. This lets us collaborate more easily with vendors. It shouldn't be doing heavy lifting. The code that was added is a duplication of the code in framebuffers.cpp

77 +++ src/platform/graphics/android/display_configuration_utilities.h
given this would only be used by the fb device, it would probably be better to be in an anonymous namespace closer to the creation of the the fb_device.cpp file instead of in the two types of DisplayDevices that rely on the framebuffer device.

200 +#include <EGL/egl.h>
201 +#include <EGL/eglext.h>
I've gone through some pains to keep egl out of the displaydevice setup, would like to keep the egl stuff in the DisplayBuffer or the HwcFallbackRenderer

290 + for(auto config : configs)
const&

review: Needs Fixing

[Kevin DuBois (kdub)]

52 + 25.4f * float(device.width) / float(device.xdpi),
53 + 25.4f * float(device.height) / float(device.ydpi)
magic numbers

873 +TEST_F(HWC10Tests, display_configuration_matches_expectations)
847 +TEST_F(PostHWC10Tests, queries_egl_configuration)
introduction of new terminology with HWC10 and PostHWC10. In current code, hwc 1.0 is called HwcFbDevice, hwc 1.1+ is called HwcDevice.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2008
http://jenkins.qa.ubuntu.com/job/mir-ci/1942/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/2295/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/2302
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/2230/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-utopic-amd64-ci/282
        deb: http://jenkins.qa.ubuntu.com/job/mir-utopic-amd64-ci/282/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-utopic-armhf/1167/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/1942/rebuild

review: Needs Fixing (continuous-integration)

[Alberto Aguirre (albaguirre)]

Is this being reworked based on kdub's feedback?

Or should we review as is?

Unmerged revisions

2008. By Andreas Pokorny on 2014-10-29

Add means to query display output configuration from DisplayDevice

This adds a methods to DisplayDevice and HwcWrapper to assemble a
DisplayConfigurationOutput using the fb and hwc interfaces and EGL.
The code is largely borrowed from mir::graphics::android::Framebuffers.
This change does not yet make mir::android::DisplayConfiguration use this
code path.

=== modified file 'src/platform/graphics/android/CMakeLists.txt'
--- src/platform/graphics/android/CMakeLists.txt	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/CMakeLists.txt	2014-10-29 12:29:38 +0000
@@ -14,6 +14,7 @@
   buffer.cpp
   display.cpp
   display_configuration.cpp
+  display_configuration_utilities.cpp
   display_buffer.cpp
   output_builder.cpp
   hwc_layerlist.cpp

=== added file 'src/platform/graphics/android/display_configuration_utilities.cpp'
--- src/platform/graphics/android/display_configuration_utilities.cpp	1970-01-01 00:00:00 +0000
+++ src/platform/graphics/android/display_configuration_utilities.cpp	2014-10-29 12:29:38 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by:
+ *   Andreas Pokorny <[e-mail]>
+ */
+
+#include "display_configuration_utilities.h"
+#include "android_format_conversion-inl.h"
+
+#include "mir/graphics/display_configuration.h"
+#include "mir/geometry/point.h"
+#include "mir/geometry/size.h"
+
+#include <hardware/gralloc.h>
+#include <hardware/fb.h>
+
+namespace mg = mir::graphics;
+namespace mga = mg::android;
+namespace geom = mir::geometry;
+mg::DisplayConfigurationOutput mga::create_output_configuration_from_fb(framebuffer_device_t const& device)
+{
+    geometry::Size size_in_mm(
+        25.4f * float(device.width) / float(device.xdpi),
+        25.4f * float(device.height) / float(device.ydpi)
+        );
+
+    return mg::DisplayConfigurationOutput
+    {
+        mg::DisplayConfigurationOutputId{0},
+        mg::DisplayConfigurationCardId{0},
+        mg::DisplayConfigurationOutputType::lvds,
+        { mga::to_mir_format(device.format) }, // query for more?
+        { {geom::Size{device.width, device.height}, double(device.fps)}},
+        0,
+        size_in_mm,
+        true,
+        true,
+        geom::Point{0,0}, // top left
+        0,
+        mga::to_mir_format(device.format),
+        mir_power_mode_on,
+        mir_orientation_normal
+    };
+}

=== added file 'src/platform/graphics/android/display_configuration_utilities.h'
--- src/platform/graphics/android/display_configuration_utilities.h	1970-01-01 00:00:00 +0000
+++ src/platform/graphics/android/display_configuration_utilities.h	2014-10-29 12:29:38 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by:
+ *   Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_DISPLAY_CONFIGURATION_UTILITIES_H_
+#define MIR_GRAPHICS_ANDROID_DISPLAY_CONFIGURATION_UTILITIES_H_
+
+struct framebuffer_device_t;
+namespace mir
+{
+namespace graphics
+{
+struct DisplayConfigurationOutput;
+namespace android
+{
+DisplayConfigurationOutput create_output_configuration_from_fb(framebuffer_device_t const& device);
+}
+}
+}
+#endif /* MIR_GRAPHICS_ANDROID_DISPLAY_CONFIGURATION_UTILITIES_H_ */

=== modified file 'src/platform/graphics/android/display_device.h'
--- src/platform/graphics/android/display_device.h	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/display_device.h	2014-10-29 12:29:38 +0000
@@ -20,6 +20,7 @@
 #define MIR_GRAPHICS_ANDROID_DISPLAY_SUPPORT_PROVIDER_H_
 
 #include "mir/graphics/renderable.h"
+#include "mir/graphics/display_configuration.h"
 #include "mir_toolkit/common.h"
 #include <EGL/egl.h>
 
@@ -50,6 +51,7 @@
         RenderableList const& list,
         RenderableListCompositor const& list_compositor) = 0;
     virtual bool apply_orientation(MirOrientation orientation) const = 0;
+    virtual DisplayConfigurationOutput get_output_configuration(DisplayConfigurationOutputId id) const = 0;
 
 protected:
     DisplayDevice() = default;

=== modified file 'src/platform/graphics/android/fb_device.cpp'
--- src/platform/graphics/android/fb_device.cpp	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/fb_device.cpp	2014-10-29 12:29:38 +0000
@@ -16,14 +16,18 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
+#include "fb_device.h"
+#include "swapping_gl_context.h"
+#include "framebuffer_bundle.h"
+#include "buffer.h"
+#include "display_configuration_utilities.h"
+
 #include "mir/graphics/buffer.h"
 #include "mir/graphics/android/native_buffer.h"
 #include "mir/graphics/android/sync_fence.h"
-#include "swapping_gl_context.h"
-#include "android_format_conversion-inl.h"
-#include "fb_device.h"
-#include "framebuffer_bundle.h"
-#include "buffer.h"
+
+// usage of HWC_DISPLAY_PRIMARY to identify output attached to framebuffer:
+#include "hardware/hwcomposer_defs.h"
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
@@ -80,3 +84,12 @@
         fb_device->enableScreen(fb_device.get(), enable);
     }
 }
+
+
+mg::DisplayConfigurationOutput mga::FBDevice::get_output_configuration(mg::DisplayConfigurationOutputId id) const
+{
+    if (id.as_value() != HWC_DISPLAY_PRIMARY)
+        BOOST_THROW_EXCEPTION(std::runtime_error("only primary display supported"));
+
+    return mga::create_output_configuration_from_fb(*fb_device);
+}

=== modified file 'src/platform/graphics/android/fb_device.h'
--- src/platform/graphics/android/fb_device.h	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/fb_device.h	2014-10-29 12:29:38 +0000
@@ -42,6 +42,7 @@
         SwappingGLContext const& context,
         RenderableList const& list,
         RenderableListCompositor const& list_compositor);
+    DisplayConfigurationOutput get_output_configuration(DisplayConfigurationOutputId id) const override;
 
 private:
     std::shared_ptr<framebuffer_device_t> const fb_device;

=== modified file 'src/platform/graphics/android/hwc_device.cpp'
--- src/platform/graphics/android/hwc_device.cpp	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/hwc_device.cpp	2014-10-29 12:29:38 +0000
@@ -25,6 +25,15 @@
 #include "framebuffer_bundle.h"
 #include "buffer.h"
 #include "hwc_fallback_gl_renderer.h"
+#include "android_format_conversion-inl.h"
+
+#include "mir/geometry/size.h"
+#include "mir/geometry/point.h"
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+
+#include <boost/throw_exception.hpp>
 #include <limits>
 #include <algorithm>
 
@@ -63,6 +72,59 @@
     }
     return false;
 }
+
+std::vector<MirPixelFormat> determine_hwc11_fb_formats()
+{
+    static EGLint const fb_egl_config_attr [] =
+    {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+        EGL_FRAMEBUFFER_TARGET_ANDROID, EGL_TRUE,
+        EGL_NONE
+    };
+
+    const EGLint config_size = 64;
+    EGLConfig fb_egl_config[config_size];
+    int matching_configs;
+    EGLint major, minor;
+    auto egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    eglInitialize(egl_display, &major, &minor);
+    eglChooseConfig(egl_display, fb_egl_config_attr, fb_egl_config, config_size, &matching_configs);
+
+    std::vector<MirPixelFormat> formats;
+    std::transform(fb_egl_config, fb_egl_config+matching_configs,
+                   std::back_inserter(formats),
+                   [&](EGLConfig const& cfg)
+                   {
+                       int visual_id;
+                       eglGetConfigAttrib(egl_display, cfg, EGL_NATIVE_VISUAL_ID, &visual_id);
+                       return mga::to_mir_format(visual_id);
+                   }
+                  );
+
+    std::sort(begin(formats), end(formats));
+    formats.erase(
+        std::unique(
+             begin(formats),
+             std::remove_if(begin(formats), end(formats),
+                            [](MirPixelFormat const& item )
+                            {
+                                return item == mir_pixel_format_invalid;
+                            })
+             ),
+        end(formats)
+        );
+
+    if (formats.empty())
+    {
+        //we couldn't figure out the fb format via egl. In this case, we
+        //assume abgr_8888. HWC api really should provide this information directly.
+        formats.push_back(mir_pixel_format_abgr_8888);
+    }
+
+    eglTerminate(egl_display);
+    return formats;
+}
 }
 
 mga::HwcDevice::HwcDevice(std::shared_ptr<HwcWrapper> const& hwc_wrapper,
@@ -194,3 +256,57 @@
 {
     onscreen_overlay_buffers.clear();
 }
+
+mg::DisplayConfigurationOutput mga::HwcDevice::get_output_configuration(DisplayConfigurationOutputId id) const
+{
+    // TODO: only support primary for now, external is not allowed for now
+    if (id.as_value() != HWC_DISPLAY_PRIMARY &&
+        id.as_value() != HWC_DISPLAY_EXTERNAL)
+        BOOST_THROW_EXCEPTION(std::runtime_error("display not supported"));
+
+    auto configs = hwc_wrapper->get_display_configs(id);
+
+    if (configs.empty())
+        BOOST_THROW_EXCEPTION(std::runtime_error("No configs available for display"));
+
+    std::vector<MirPixelFormat> formats{ determine_hwc11_fb_formats() };
+    MirPixelFormat current_format = formats[0];
+
+    std::vector<DisplayConfigurationMode> modes;
+    geometry::Size output_size(0, 0);
+
+    for(auto config : configs)
+    {
+        auto attributes = hwc_wrapper->get_display_config_attributes(id, config);
+        modes.push_back(DisplayConfigurationMode{attributes.size, attributes.refresh_rate_hz});
+        geometry::Size size_in_mm(
+            25.4f * attributes.size.width.as_float() / float(attributes.dpi_x),
+            25.4f * attributes.size.height.as_float() / float(attributes.dpi_y)
+            );
+
+        if (size_in_mm.width.as_int() * size_in_mm.height.as_int() > output_size.width.as_int() * output_size.height.as_int())
+            output_size = size_in_mm;
+    }
+
+    size_t preferred_mode_index = 0;
+
+    return mg::DisplayConfigurationOutput
+    {
+        id,
+        mg::DisplayConfigurationCardId{0},
+        id.as_value() == HWC_DISPLAY_PRIMARY?
+            mg::DisplayConfigurationOutputType::lvds:
+            mg::DisplayConfigurationOutputType::hdmia,
+        std::move(formats),
+        std::move(modes),
+        preferred_mode_index,
+        output_size,
+        true,
+        true,
+        geometry::Point{0,0}, // top left
+        0, // current mode
+        current_format,
+        mir_power_mode_on,
+        mir_orientation_normal
+    };
+}

=== modified file 'src/platform/graphics/android/hwc_device.h'
--- src/platform/graphics/android/hwc_device.h	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/hwc_device.h	2014-10-29 12:29:38 +0000
@@ -50,6 +50,7 @@
         SwappingGLContext const& context,
         RenderableList const& list,
         RenderableListCompositor const& list_compositor);
+    DisplayConfigurationOutput get_output_configuration(DisplayConfigurationOutputId id) const override;
 
 private:
     bool buffer_is_onscreen(Buffer const&) const;

=== modified file 'src/platform/graphics/android/hwc_fb_device.cpp'
--- src/platform/graphics/android/hwc_fb_device.cpp	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/hwc_fb_device.cpp	2014-10-29 12:29:38 +0000
@@ -21,6 +21,7 @@
 #include "hwc_vsync_coordinator.h"
 #include "framebuffer_bundle.h"
 #include "android_format_conversion-inl.h"
+#include "display_configuration_utilities.h"
 #include "hwc_wrapper.h"
 #include "hwc_fallback_gl_renderer.h"
 #include "mir/graphics/buffer.h"
@@ -88,3 +89,11 @@
 {
     return false;
 }
+
+mg::DisplayConfigurationOutput mga::HwcFbDevice::get_output_configuration(mg::DisplayConfigurationOutputId id) const
+{
+    if (id.as_value() != HWC_DISPLAY_PRIMARY)
+        BOOST_THROW_EXCEPTION(std::runtime_error("only primary display supported"));
+
+    return mga::create_output_configuration_from_fb(*fb_device);
+}

=== modified file 'src/platform/graphics/android/hwc_fb_device.h'
--- src/platform/graphics/android/hwc_fb_device.h	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/hwc_fb_device.h	2014-10-29 12:29:38 +0000
@@ -44,6 +44,7 @@
         SwappingGLContext const& context,
         RenderableList const& list,
         RenderableListCompositor const& list_compositor);
+    DisplayConfigurationOutput get_output_configuration(DisplayConfigurationOutputId id) const override;
 
 private:
     std::shared_ptr<HwcWrapper> const hwc_wrapper;

=== modified file 'src/platform/graphics/android/hwc_wrapper.h'
--- src/platform/graphics/android/hwc_wrapper.h	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/hwc_wrapper.h	2014-10-29 12:29:38 +0000
@@ -19,6 +19,9 @@
 #ifndef MIR_GRAPHICS_ANDROID_HWC_WRAPPER_H_
 #define MIR_GRAPHICS_ANDROID_HWC_WRAPPER_H_
 
+#include "mir/graphics/display_configuration.h"
+#include "mir/geometry/size.h"
+
 #include <hardware/hwcomposer.h>
 #include <memory>
 
@@ -42,6 +45,16 @@
     virtual void display_on() const = 0;
     virtual void display_off() const = 0;
 
+    virtual std::vector<uint32_t> get_display_configs(DisplayConfigurationOutputId id) const = 0;
+    struct Attributes
+    {
+        geometry::Size size;
+        uint32_t dpi_x;
+        uint32_t dpi_y;
+        double refresh_rate_hz;
+    };
+    virtual Attributes get_display_config_attributes(DisplayConfigurationOutputId id, uint32_t config) const = 0;
+
 protected:
     HwcWrapper() = default;
     HwcWrapper& operator=(HwcWrapper const&) = delete;

=== modified file 'src/platform/graphics/android/real_hwc_wrapper.cpp'
--- src/platform/graphics/android/real_hwc_wrapper.cpp	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/real_hwc_wrapper.cpp	2014-10-29 12:29:38 +0000
@@ -111,3 +111,48 @@
     }
     logger->log_display_off();
 }
+
+std::vector<uint32_t> mga::RealHwcWrapper::get_display_configs(DisplayConfigurationOutputId id) const
+{
+    const int num_configs_to_query = 10;
+    uint32_t query_results[num_configs_to_query];
+    size_t configs_received = num_configs_to_query;
+
+    if (auto rc = hwc_device->getDisplayConfigs(hwc_device.get(), id.as_value(), query_results, &configs_received))
+    {
+        std::stringstream ss;
+        ss << "error querying display configs for display " << id.as_value() << ". rc = " << std::hex << rc;
+        BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
+    }
+
+    return {query_results, query_results + configs_received};
+}
+
+mga::HwcWrapper::Attributes mga::RealHwcWrapper::get_display_config_attributes(DisplayConfigurationOutputId id, uint32_t config) const
+{
+    /* note: some drivers (qcom msm8960) choke if this is not the same size array
+       as the one surfaceflinger submits */
+    static uint32_t const display_attribute_request[] =
+    {
+        HWC_DISPLAY_WIDTH,
+        HWC_DISPLAY_HEIGHT,
+        HWC_DISPLAY_VSYNC_PERIOD,
+        HWC_DISPLAY_DPI_X,
+        HWC_DISPLAY_DPI_Y,
+        HWC_DISPLAY_NO_ATTRIBUTE,
+    };
+    int32_t size_values[sizeof(display_attribute_request) / sizeof (display_attribute_request[0])] = {};
+
+    if (auto rc = hwc_device->getDisplayAttributes(hwc_device.get(), id.as_value(), config,
+                                                   display_attribute_request, size_values))
+    {
+        std::stringstream ss;
+        ss << "error querying attributes configs for display " << id.as_value() << ". rc = " << std::hex << rc;
+        BOOST_THROW_EXCEPTION(std::runtime_error(ss.str()));
+    }
+
+    //HWC_DISPLAY_VSYNC_PERIOD is specified in nanoseconds
+    double refresh_rate_hz = (size_values[2] > 0 ) ? 1000000000.0/size_values[2] : 0.0;
+    return {{size_values[0], size_values[1]}, uint32_t(size_values[3]), uint32_t(size_values[4]), refresh_rate_hz};
+ }
+

=== modified file 'src/platform/graphics/android/real_hwc_wrapper.h'
--- src/platform/graphics/android/real_hwc_wrapper.h	2014-10-01 06:25:56 +0000
+++ src/platform/graphics/android/real_hwc_wrapper.h	2014-10-29 12:29:38 +0000
@@ -44,6 +44,8 @@
     void vsync_signal_off() const override;
     void display_on() const override;
     void display_off() const override;
+    std::vector<uint32_t> get_display_configs(DisplayConfigurationOutputId id) const override;
+    Attributes get_display_config_attributes(DisplayConfigurationOutputId id, uint32_t config) const override;
 private:
     static size_t const num_displays{3}; //primary, external, virtual
     //note: the callbacks have to extend past the lifetime of the hwc_composer_device_1 for some

=== modified file 'tests/include/mir_test_doubles/mock_display_device.h'
--- tests/include/mir_test_doubles/mock_display_device.h	2014-10-01 06:25:56 +0000
+++ tests/include/mir_test_doubles/mock_display_device.h	2014-10-29 12:29:38 +0000
@@ -42,6 +42,7 @@
         graphics::RenderableList const&,
         graphics::android::RenderableListCompositor const&));
     MOCK_CONST_METHOD1(apply_orientation, bool(MirOrientation));
+    MOCK_CONST_METHOD1(get_output_configuration, graphics::DisplayConfigurationOutput(graphics::DisplayConfigurationOutputId));
 };
 }
 }

=== modified file 'tests/include/mir_test_doubles/mock_fb_hal_device.h'
--- tests/include/mir_test_doubles/mock_fb_hal_device.h	2014-03-06 06:05:17 +0000
+++ tests/include/mir_test_doubles/mock_fb_hal_device.h	2014-10-29 12:29:38 +0000
@@ -34,8 +34,8 @@
 class MockFBHalDevice : public framebuffer_device_t
 {
 public:
-    MockFBHalDevice(unsigned int const width, unsigned int const height,
-                    int const pf, int const numfbs)
+    MockFBHalDevice(unsigned int const width, unsigned int const height, int const pf,
+                    float const xdpi, float const ydpi, float const fps, int const numfbs)
         : framebuffer_device_t({
             hw_device_t(),
             0,
@@ -43,9 +43,9 @@
             height,
             0,
             pf,
-            0.0f,
-            0.0f,
-            0.0f,
+            xdpi,
+            ydpi,
+            fps,
             0,
             1,
             numfbs,
@@ -59,6 +59,12 @@
         enableScreen = hook_enableScreen;
     }
 
+    MockFBHalDevice(unsigned int const width, unsigned int const height,
+                    int const pf, int const numfbs)
+        : MockFBHalDevice(width, height, pf, 1.0f, 1.0f, 2.0f, numfbs)
+    {
+    }
+
     MockFBHalDevice()
         : MockFBHalDevice(1,1,1,1)
     {

=== modified file 'tests/include/mir_test_doubles/mock_hwc_device_wrapper.h'
--- tests/include/mir_test_doubles/mock_hwc_device_wrapper.h	2014-10-01 06:25:56 +0000
+++ tests/include/mir_test_doubles/mock_hwc_device_wrapper.h	2014-10-29 12:29:38 +0000
@@ -39,6 +39,9 @@
     MOCK_CONST_METHOD0(vsync_signal_off, void());
     MOCK_CONST_METHOD0(display_on, void());
     MOCK_CONST_METHOD0(display_off, void());
+    MOCK_CONST_METHOD1(get_display_configs, std::vector<uint32_t>(graphics::DisplayConfigurationOutputId));
+    MOCK_CONST_METHOD2(get_display_config_attributes, Attributes(graphics::DisplayConfigurationOutputId, uint32_t));
+
 };
 
 }

=== modified file 'tests/unit-tests/graphics/android/test_fb_device.cpp'
--- tests/unit-tests/graphics/android/test_fb_device.cpp	2014-10-01 06:25:56 +0000
+++ tests/unit-tests/graphics/android/test_fb_device.cpp	2014-10-29 12:29:38 +0000
@@ -47,10 +47,14 @@
 
         width = 413;
         height = 516;
+        dpi_x = 96.0f;
+        dpi_y = 96.0f;
+        fps = 120.0f;
         fbnum = 4;
         format = HAL_PIXEL_FORMAT_RGBA_8888;
 
-        fb_hal_mock = std::make_shared<NiceMock<mtd::MockFBHalDevice>>(width, height, format, fbnum);
+        fb_hal_mock = std::make_shared<NiceMock<mtd::MockFBHalDevice>>(width, height, format,
+                                                                       dpi_x, dpi_y, fps, fbnum);
         mock_buffer = std::make_shared<NiceMock<mtd::MockBuffer>>();
         native_buffer = std::make_shared<mtd::StubAndroidNativeBuffer>();
         ON_CALL(*mock_buffer, native_buffer_handle())
@@ -60,6 +64,7 @@
     }
 
     unsigned int width, height, format, fbnum;
+    float dpi_x, dpi_y, fps;
     std::shared_ptr<mtd::MockFBHalDevice> fb_hal_mock;
     std::shared_ptr<mtd::MockBuffer> mock_buffer;
     std::shared_ptr<mir::graphics::NativeBuffer> native_buffer;
@@ -140,3 +145,43 @@
     fbdev.mode(mir_power_mode_off);
     fbdev.mode(mir_power_mode_on);
 }
+
+TEST_F(FBDevice, throws_on_wrong_display_id)
+{
+    mga::FBDevice fbdev(fb_hal_mock);
+    EXPECT_THROW(
+        {fbdev.get_output_configuration(mg::DisplayConfigurationOutputId{HWC_DISPLAY_VIRTUAL});},
+        std::runtime_error);
+    EXPECT_THROW(
+        {fbdev.get_output_configuration(mg::DisplayConfigurationOutputId{HWC_DISPLAY_EXTERNAL});},
+        std::runtime_error);
+    EXPECT_NO_THROW(
+        {fbdev.get_output_configuration(mg::DisplayConfigurationOutputId{HWC_DISPLAY_PRIMARY});});
+}
+
+TEST_F(FBDevice, display_output_configuration_matches)
+{
+    using namespace testing;
+    mga::FBDevice fbdev(fb_hal_mock);
+    EXPECT_THAT(
+        fbdev.get_output_configuration(mg::DisplayConfigurationOutputId{HWC_DISPLAY_PRIMARY}),
+        Eq(
+            mg::DisplayConfigurationOutput
+            {
+                mg::DisplayConfigurationOutputId{HWC_DISPLAY_PRIMARY},
+                mg::DisplayConfigurationCardId{0},
+                mg::DisplayConfigurationOutputType::lvds,
+                {mir_pixel_format_argb_8888},
+                {{{413, 516}, 120.0f}},
+                0,
+                {109, 136},
+                true,
+                true,
+                {0, 0},
+                0,
+                mir_pixel_format_abgr_8888,
+                mir_power_mode_on,
+                mir_orientation_normal
+            }
+          ));
+}

=== modified file 'tests/unit-tests/graphics/android/test_hwc_common_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc_common_device.cpp	2014-10-01 06:25:56 +0000
+++ tests/unit-tests/graphics/android/test_hwc_common_device.cpp	2014-10-29 12:29:38 +0000
@@ -36,7 +36,8 @@
 #include <memory>
 #include <gtest/gtest.h>
 
-namespace mga=mir::graphics::android;
+namespace mg=mir::graphics;
+namespace mga=mg::android;
 namespace mtd=mir::test::doubles;
 namespace geom=mir::geometry;
 
@@ -65,28 +66,90 @@
     return std::make_shared<mga::HwcDevice>(hwc_device, coordinator, file_ops);
 }
 
-template<typename T>
-class HWCCommon : public ::testing::Test
+class HWCCommonFixture : public ::testing::Test
 {
 protected:
-    virtual void SetUp()
+    void setup_display_config()
+    {
+        ON_CALL(*this->mock_device, get_display_configs(primary))
+            .WillByDefault(testing::Return(std::vector<uint32_t>{0}));
+
+        ON_CALL(*this->mock_device, get_display_configs(external))
+            .WillByDefault(testing::Return(std::vector<uint32_t>{1}));
+
+        ON_CALL(*this->mock_device, get_display_config_attributes(primary, 0))
+            .WillByDefault(testing::Return(
+                    mga::HwcWrapper::Attributes{
+                        geom::Size{280,190},
+                        320,  // dpi x
+                        320,  // dpi y
+                        60    // hz
+                        }));
+
+        ON_CALL(*this->mock_device, get_display_config_attributes(external, 1))
+            .WillByDefault(testing::Return(
+                    mga::HwcWrapper::Attributes{
+                        geom::Size{1920,1200},
+                        120,  // dpi x
+                        120,  // dpi y
+                        60    // hz
+                        }));
+    }
+    void setup_egl_configs()
     {
         using namespace testing;
-
-        mock_fbdev = std::make_shared<mtd::MockFBHalDevice>();
-        mock_device = std::make_shared<testing::NiceMock<mtd::MockHWCDeviceWrapper>>();
-        mock_vsync = std::make_shared<testing::NiceMock<mtd::MockVsyncCoordinator>>();
+        ON_CALL(mock_egl,eglChooseConfig(_,_,_,_,_))
+            .WillByDefault(
+                Invoke([](EGLDisplay, EGLint const *, EGLConfig * configs, EGLint config_size, EGLint * num_config)
+                       {
+                          if (config_size >= 3)
+                             configs[1] = EGLConfig(42);
+                          if (config_size >= 2)
+                             configs[1] = EGLConfig(13);
+                          if (config_size >= 1)
+                             configs[0] = EGLConfig(21);
+                          *num_config = std::min(3,config_size);
+                          return EGL_TRUE;
+                       })
+                );
+
+        ON_CALL(mock_egl,eglGetConfigAttrib(_,_,_,_))
+            .WillByDefault(
+                Invoke([](EGLDisplay, EGLConfig config, EGLint attribute, EGLint * value) -> EGLBoolean
+                       {
+                          if (!value) return EGL_FALSE;
+                          if (attribute!=EGL_NATIVE_VISUAL_ID) return EGL_FALSE;
+
+                          if (config == EGLConfig(42))
+                              *value = 0; // place holder for format that cannot be converted to mir format
+                          if (config == EGLConfig(13))
+                              *value = HAL_PIXEL_FORMAT_RGBA_8888;
+                          if (config == EGLConfig(21))
+                              *value = HAL_PIXEL_FORMAT_RGBX_8888;
+                          return EGL_TRUE;
+                       })
+                );
     }
-
     testing::NiceMock<mtd::MockEGL> mock_egl;
-    std::shared_ptr<mtd::MockVsyncCoordinator> mock_vsync;
-    std::shared_ptr<mtd::MockHWCDeviceWrapper> mock_device;
-    std::shared_ptr<mtd::MockFBHalDevice> mock_fbdev;
+    std::shared_ptr<mtd::MockVsyncCoordinator> mock_vsync = std::make_shared<testing::NiceMock<mtd::MockVsyncCoordinator>>();
+    std::shared_ptr<mtd::MockHWCDeviceWrapper> mock_device = std::make_shared<testing::NiceMock<mtd::MockHWCDeviceWrapper>>();
+    std::shared_ptr<mtd::MockFBHalDevice> mock_fbdev = std::make_shared<mtd::MockFBHalDevice>(900, 600, HAL_PIXEL_FORMAT_RGBX_8888,
+                                                                                             400.0f, 400.0f, 67.6f, 1);
+
+    mg::DisplayConfigurationOutputId primary{HWC_DISPLAY_PRIMARY};
+    mg::DisplayConfigurationOutputId external{HWC_DISPLAY_EXTERNAL};
+    mg::DisplayConfigurationOutputId virtual_output{HWC_DISPLAY_VIRTUAL};
 };
 
+template<typename T>
+using HWCCommon = HWCCommonFixture;
+
 typedef ::testing::Types<mga::HwcFbDevice, mga::HwcDevice> HWCDeviceTestTypes;
 TYPED_TEST_CASE(HWCCommon, HWCDeviceTestTypes);
 
+using PostHWC10Tests = HWCCommonFixture;
+using HWC10Tests = HWCCommonFixture;
+
 TYPED_TEST(HWCCommon, test_proc_registration)
 {
     using namespace testing;
@@ -228,3 +291,174 @@
         auto device = make_hwc_device<TypeParam>(this->mock_device, this->mock_fbdev, this->mock_vsync);
     });
 }
+
+TEST_F(HWC10Tests, throws_on_non_primary_display_output_configurations)
+{
+    using namespace testing;
+    auto device = make_hwc_device<mga::HwcFbDevice>(this->mock_device, this->mock_fbdev, this->mock_vsync);
+
+    EXPECT_THROW({
+        device->get_output_configuration(this->external);
+    }, std::runtime_error);
+    EXPECT_THROW({
+        device->get_output_configuration(this->virtual_output);
+    }, std::runtime_error);
+}
+
+TEST_F(PostHWC10Tests, throws_on_virtual_display_output_configurations)
+{
+    using namespace testing;
+    this->setup_display_config();
+    auto device = make_hwc_device<mga::HwcDevice>(this->mock_device, this->mock_fbdev, this->mock_vsync);
+
+    EXPECT_THROW({device->get_output_configuration(this->virtual_output);}, std::runtime_error);
+    EXPECT_NO_THROW({device->get_output_configuration(this->external);});
+    EXPECT_NO_THROW({device->get_output_configuration(this->primary);});
+}
+
+TEST_F(PostHWC10Tests, queries_hwc_device_for_configs)
+{
+    using namespace testing;
+    this->setup_display_config();
+
+    auto device = make_hwc_device<mga::HwcDevice>(this->mock_device, this->mock_fbdev, this->mock_vsync);
+
+    EXPECT_CALL(*this->mock_device, get_display_configs(this->primary));
+
+    device->get_output_configuration(this->primary);
+}
+
+TEST_F(PostHWC10Tests, throws_on_no_available_hwc_configurations)
+{
+    using namespace testing;
+    auto device = make_hwc_device<mga::HwcDevice>(this->mock_device, this->mock_fbdev, this->mock_vsync);
+
+    ON_CALL(*this->mock_device, get_display_configs(_))
+        .WillByDefault(Return(std::vector<uint32_t>{}));
+    EXPECT_THROW({
+        device->get_output_configuration(this->primary);
+        }, std::runtime_error);
+}
+
+TEST_F(PostHWC10Tests, queries_display_config_attributes)
+{
+    using namespace testing;
+    this->setup_display_config();
+    auto device = make_hwc_device<mga::HwcDevice>(this->mock_device, this->mock_fbdev, this->mock_vsync);
+
+    EXPECT_CALL(*this->mock_device, get_display_config_attributes(this->primary, 0));
+
+    device->get_output_configuration(this->primary);
+}
+
+TEST_F(PostHWC10Tests, display_configuration_matches_expectations)
+{
+    using namespace testing;
+    this->setup_display_config();
+    auto device = make_hwc_device<mga::HwcDevice>(this->mock_device, this->mock_fbdev, this->mock_vsync);
+
+    EXPECT_THAT(
+        device->get_output_configuration(this->primary),
+        Eq(
+            mg::DisplayConfigurationOutput
+            {
+                this->primary,
+                mg::DisplayConfigurationCardId{0},
+                mg::DisplayConfigurationOutputType::lvds,
+                {mir_pixel_format_abgr_8888},
+                {{{280, 190}, 60}},
+                0,
+                {22, 15},
+                true,
+                true,
+                {0, 0},
+                0,
+                mir_pixel_format_abgr_8888,
+                mir_power_mode_on,
+                mir_orientation_normal
+            }
+            ));
+}
+
+TEST_F(PostHWC10Tests, display_configuration_matches_expectations_on_external_display)
+{
+    using namespace testing;
+    this->setup_display_config();
+    auto device = make_hwc_device<mga::HwcDevice>(this->mock_device, this->mock_fbdev, this->mock_vsync);
+
+    EXPECT_THAT(
+        device->get_output_configuration(this->external),
+        Eq(
+            mg::DisplayConfigurationOutput
+            {
+                this->external,
+                mg::DisplayConfigurationCardId{0},
+                mg::DisplayConfigurationOutputType::hdmia,
+                {mir_pixel_format_abgr_8888},
+                {{{1920, 1200}, 60}},
+                0,
+                {406, 254},
+                true,
+                true,
+                {0, 0},
+                0,
+                mir_pixel_format_abgr_8888,
+                mir_power_mode_on,
+                mir_orientation_normal
+            }
+            ));
+}
+
+TEST_F(PostHWC10Tests, queries_egl_configuration)
+{
+    using namespace testing;
+    this->setup_display_config();
+    this->setup_egl_configs();
+    auto device = make_hwc_device<mga::HwcDevice>(this->mock_device, this->mock_fbdev, this->mock_vsync);
+
+    EXPECT_CALL(mock_egl,eglChooseConfig(_,_,_,_,_)).Times(1);
+    EXPECT_CALL(mock_egl,eglGetConfigAttrib(_,_,EGL_NATIVE_VISUAL_ID,_)).Times(3);
+
+    device->get_output_configuration(this->primary);
+}
+
+TEST_F(PostHWC10Tests, converts_egl_configs_to_mir_pixel_formats)
+{
+    using namespace testing;
+    this->setup_display_config();
+    this->setup_egl_configs();
+    auto device = make_hwc_device<mga::HwcDevice>(this->mock_device, this->mock_fbdev, this->mock_vsync);
+
+    EXPECT_THAT(
+        device->get_output_configuration(this->primary).pixel_formats,
+        Eq(std::vector<MirPixelFormat>({mir_pixel_format_abgr_8888, mir_pixel_format_xbgr_8888}))
+          );
+}
+
+TEST_F(HWC10Tests, display_configuration_matches_expectations)
+{
+    using namespace testing;
+    auto device = make_hwc_device<mga::HwcFbDevice>(this->mock_device, this->mock_fbdev, this->mock_vsync);
+
+    EXPECT_THAT(
+        device->get_output_configuration(this->primary),
+        Eq(
+            mg::DisplayConfigurationOutput
+            {
+                this->primary,
+                mg::DisplayConfigurationCardId{0},
+                mg::DisplayConfigurationOutputType::lvds,
+                {mir_pixel_format_xbgr_8888},
+                {{{900, 600}, 67.6f}},
+                0,
+                {57, 38},
+                true,
+                true,
+                {0, 0},
+                0,
+                mir_pixel_format_xbgr_8888,
+                mir_power_mode_on,
+                mir_orientation_normal
+            })
+          );
+}