Merge lp:~andreas-pokorny/mir/add-pixel-format-to-display-configuration into lp:mir/0.1

[Andreas Pokorny]

Adds a mir pixel format parameter to DisplayConfiguration::configure_output

So within DisplayConfigurationPolicy the format can be specified for each output.
The pixel format parameter is still ignored by android and also mesa to some degree,
which only validates it. It is supported by nested display. The default configuration
policy implementation tries to select an opaque format though.

=== modified file 'benchmarks/CMakeLists.txt'
--- benchmarks/CMakeLists.txt	2013-10-15 10:10:05 +0000
+++ benchmarks/CMakeLists.txt	2014-01-02 11:14:12 +0000
@@ -2,7 +2,9 @@
   benchmarks
 )
 
-add_subdirectory(android-input)
+if (MIR_ENABLE_TESTS)
+  add_subdirectory(android-input)
+endif ()
 add_subdirectory(cpu)
 add_subdirectory(memory)
 
 
=== modified file 'doc/building_source_for_android.md'
--- doc/building_source_for_android.md	2013-12-17 18:24:51 +0000
+++ doc/building_source_for_android.md	2014-01-02 11:14:12 +0000
@@ -51,35 +51,24 @@
 ubuntu package) to produce armhf code. This is typically the quickest way to
 compile and run code, and is well suited for a development workflow.
 
--  Be sure that the cross compiler that you are using matches the target
-   environment. (eg, make sure you're using the trusty toolchain if you're
-   targeting a trusty phablet image) You can specify the toolchain version
-   thusly:
-
-        $ apt-get install g++-arm-linux-gnueabihf/trusty
-
--  Get access to armhf packages via apt-get. On an amd64/ia32 system, you can
-   do this by adding a file like the one below to /etc/apt/sources.list.d/
-
-        #example sources.list with armhf dependencies
-        deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports/ trusty main restricted universe multiverse
-    
-    Then you should run:
-
-        $ apt-get update
-
-    To test, try downloading a package like this:
-
-        $ apt-get download my-package:armhf
-
--  Once you're able to download armhf packages from the repository, the 
-   cross-compile-chroot.sh script provides an example of how to download
-   a partial chroot with the mir dependencies, and compile the source for
-   android targets.
-
-   The script sets up a partial chroot via tools/setup-partial-armhf-chroot.sh
-   and then runs build commands similar to this:
-
-        $ mkdir mir/build; cd mir/build
-        $ MIR_NDK_PATH=/path/to/depenendcies/chroot cmake -DCMAKE_TOOLCHAIN_FILE=../cmake/LinuxCrossCompile.cmake -DBoost_COMPILER=-gcc -DMIR_PLATFORM=android ..
-        $ make
+Initial setup of a desktop machine for cross-compiling to armhf is simple:
+
+    $ sudo apt-get install g++-arm-linux-gnueabihf/trusty debootstrap
+    $ sudo sh -c 'echo "deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports/ trusty main restricted universe multiverse" > /etc/apt/sources.list.d/armhf-xcompile.list'
+    $ sudo apt-get update
+
+Now to test that everything is working you can try downloading a package like
+this:
+
+    $ apt-get download gcc:armhf
+
+Once you're able to download armhf packages from the repository, the 
+cross-compile-chroot.sh script provides an example of how to build Mir for
+armhf:
+
+    $ ./cross-compile-chroot.sh
+    $ ls -l build-android-arm/*  # binaries to copy to your device
+
+To speed up the process for future branches you may wish to cache the files
+downloaded by setting environment variable MIR_NDK_PATH to point to a directory
+that cross-compile-chroot.sh should reuse each time.
 
=== modified file 'examples/demo-shell/window_manager.cpp'
--- examples/demo-shell/window_manager.cpp	2013-12-17 18:24:51 +0000
+++ examples/demo-shell/window_manager.cpp	2014-01-02 11:14:12 +0000
@@ -151,8 +151,9 @@
                     power_mode = mir_power_mode_off;
 
                 conf->configure_output(output.id, output.used,
-                                       output.top_left, 
+                                       output.top_left,
                                        output.current_mode_index,
+                                       output.current_format,
                                        power_mode);
             });
             display_off = !display_off;
 
=== modified file 'examples/server_configuration.cpp'
--- examples/server_configuration.cpp	2013-10-21 10:40:19 +0000
+++ examples/server_configuration.cpp	2014-01-02 11:14:12 +0000
@@ -61,14 +61,16 @@
                     available_outputs_for_card[conf_output.card_id] > 0)
                 {
                     conf.configure_output(conf_output.id, true, geom::Point{max_x, 0},
-                                          preferred_mode_index, mir_power_mode_on);
+                                          preferred_mode_index, conf_output.current_format,
+                                          mir_power_mode_on);
                     max_x += conf_output.modes[preferred_mode_index].size.width.as_int();
                     --available_outputs_for_card[conf_output.card_id];
                 }
                 else
                 {
                     conf.configure_output(conf_output.id, false, conf_output.top_left,
-                                          conf_output.current_mode_index, mir_power_mode_on);
+                                          conf_output.current_mode_index, conf_output.current_format,
+                                          mir_power_mode_on);
                 }
             });
     }
@@ -88,13 +90,15 @@
                 if (!done && conf_output.connected && conf_output.modes.size() > 0)
                 {
                     conf.configure_output(conf_output.id, true, geom::Point{0, 0},
-                                          preferred_mode_index, mir_power_mode_on);
+                                          preferred_mode_index, conf_output.current_format,
+                                          mir_power_mode_on);
                     done = true;
                 }
                 else
                 {
                     conf.configure_output(conf_output.id, false, conf_output.top_left,
-                                          conf_output.current_mode_index, mir_power_mode_on);
+                                          conf_output.current_mode_index, conf_output.current_format,
+                                          mir_power_mode_on);
                 }
             });
     }
 
=== modified file 'include/platform/mir/graphics/display_configuration.h'
--- include/platform/mir/graphics/display_configuration.h	2013-12-17 18:24:51 +0000
+++ include/platform/mir/graphics/display_configuration.h	2014-01-02 11:14:12 +0000
@@ -104,7 +104,7 @@
     /** The index in the 'modes' vector of the current output mode. */
     size_t current_mode_index;
     /** The index in the 'pixel_format' vector of the current output pixel format. */
-    size_t current_format_index;
+    MirPixelFormat current_format;
     /** Current power mode **/
     MirPowerMode power_mode;
 };
@@ -135,8 +135,8 @@
     virtual void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const = 0;
 
     /** Configures an output. */
-    virtual void configure_output(DisplayConfigurationOutputId id, bool used,
-                                  geometry::Point top_left, size_t mode_index, MirPowerMode power_mode) = 0;
+    virtual void configure_output(DisplayConfigurationOutputId id, bool used, geometry::Point top_left,
+                                  size_t mode_index, MirPixelFormat format, MirPowerMode power_mode) = 0;
 
 protected:
     DisplayConfiguration() = default;
 
=== added file 'include/platform/mir/graphics/pixel_format_utils.h'
--- include/platform/mir/graphics/pixel_format_utils.h	1970-01-01 00:00:00 +0000
+++ include/platform/mir/graphics/pixel_format_utils.h	2014-01-02 11:14:12 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright © 2013 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_PIXEL_FORMAT_UTILS_H_
+#define MIR_GRAPHICS_PIXEL_FORMAT_UTILS_H_
+
+#include "mir_toolkit/common.h"
+
+namespace mir
+{
+namespace graphics
+{
+
+/*!
+ * \name MirPixelFormat utility functions
+ *
+ * A set of functions to query details of MirPixelFormat
+ * TODO improve this through https://bugs.launchpad.net/mir/+bug/1236254
+ * \{
+ */
+bool contains_alpha(MirPixelFormat format);
+int red_channel_depth(MirPixelFormat format);
+int blue_channel_depth(MirPixelFormat format);
+int green_channel_depth(MirPixelFormat format);
+int alpha_channel_depth(MirPixelFormat format);
+bool valid_mir_pixel_format(MirPixelFormat format);
+/*!
+ * \}
+ */
+
+
+}
+}
+
+#endif
 
=== modified file 'include/platform/mir/graphics/platform.h'
--- include/platform/mir/graphics/platform.h	2013-12-17 18:24:51 +0000
+++ include/platform/mir/graphics/platform.h	2014-01-02 11:14:12 +0000
@@ -81,7 +81,7 @@
      * Creates the display subsystem.
      */
     virtual std::shared_ptr<Display> create_display(
-        std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy) = 0;
+            std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy) = 0;
 
     /**
      * Gets the IPC package for the platform.
 
=== added file 'include/shared/mir/logging/input_timestamp.h'
--- include/shared/mir/logging/input_timestamp.h	1970-01-01 00:00:00 +0000
+++ include/shared/mir/logging/input_timestamp.h	2014-01-02 11:14:12 +0000
@@ -0,0 +1,35 @@
+/*
+ * Copyright © 2013 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: Daniel van Vugt <[e-mail]>
+ */
+
+#ifndef MIR_LOGGING_INPUT_TIMESTAMP_H_
+#define MIR_LOGGING_INPUT_TIMESTAMP_H_
+
+#include "mir_toolkit/event.h"
+#include <string>
+
+namespace mir
+{
+namespace logging
+{
+
+std::string input_timestamp(nsecs_t when);
+
+}
+}
+
+#endif // MIR_LOGGING_INPUT_TIMESTAMP_H_
 
=== modified file 'include/shared/mir_toolkit/client_types.h'
--- include/shared/mir_toolkit/client_types.h	2013-12-17 18:24:51 +0000
+++ include/shared/mir_toolkit/client_types.h	2014-01-02 11:14:12 +0000
@@ -230,7 +230,7 @@
 
     uint32_t num_output_formats;
     MirPixelFormat* output_formats;
-    uint32_t current_output_format;
+    MirPixelFormat current_output_format;
 
     uint32_t card_id;
     uint32_t output_id;
 
=== modified file 'include/test/mir_test_doubles/mock_surface_renderer.h'
--- include/test/mir_test_doubles/mock_surface_renderer.h	2013-12-17 18:24:51 +0000
+++ include/test/mir_test_doubles/mock_surface_renderer.h	2014-01-02 11:14:12 +0000
@@ -31,8 +31,9 @@
 
 struct MockSurfaceRenderer : public compositor::Renderer
 {
+    MOCK_CONST_METHOD0(begin, void());
     MOCK_CONST_METHOD2(render, void(compositor::CompositingCriteria const&, graphics::Buffer&));
-    MOCK_CONST_METHOD0(clear, void());
+    MOCK_CONST_METHOD0(end, void());
 
     ~MockSurfaceRenderer() noexcept {}
 };
 
=== modified file 'include/test/mir_test_doubles/null_display_configuration.h'
--- include/test/mir_test_doubles/null_display_configuration.h	2013-09-12 21:36:55 +0000
+++ include/test/mir_test_doubles/null_display_configuration.h	2014-01-02 11:14:12 +0000
@@ -35,7 +35,7 @@
     void for_each_output(std::function<void(graphics::DisplayConfigurationOutput const&)>) const
     {
     }
-    void configure_output(graphics::DisplayConfigurationOutputId, bool, geometry::Point, size_t, MirPowerMode) override
+    void configure_output(graphics::DisplayConfigurationOutputId, bool, geometry::Point, size_t, MirPixelFormat, MirPowerMode) override
     {
     }
 };
 
=== modified file 'include/test/mir_test_doubles/stub_display_configuration.h'
--- include/test/mir_test_doubles/stub_display_configuration.h	2013-12-17 18:24:51 +0000
+++ include/test/mir_test_doubles/stub_display_configuration.h	2014-01-02 11:14:12 +0000
@@ -79,7 +79,7 @@
                 ((i % 2) == 0),
                 ((i % 2) == 1),
                 top_left,
-                mode_index, 1u,
+                mode_index, pfs[1u],
                 mir_power_mode_off
             };
 
@@ -107,7 +107,8 @@
                 graphics::DisplayConfigurationOutputType::vga,
                 std::vector<MirPixelFormat>{mir_pixel_format_abgr_8888},
                 {{rect.size, 60.0}},
-                0, geometry::Size{}, true, true, rect.top_left, 0, 0, mir_power_mode_on
+                0, geometry::Size{}, true, true, rect.top_left, 0,
+                mir_pixel_format_abgr_8888, mir_power_mode_on
             };
 
             outputs.push_back(output);
@@ -122,13 +123,13 @@
         cards.push_back(card);
     }
 
-    void for_each_card(std::function<void(graphics::DisplayConfigurationCard const&)> f) const
+    void for_each_card(std::function<void(graphics::DisplayConfigurationCard const&)> f) const override
     {
         for (auto const& card : cards)
             f(card);
     }
 
-    void for_each_output(std::function<void(graphics::DisplayConfigurationOutput const&)> f) const
+    void for_each_output(std::function<void(graphics::DisplayConfigurationOutput const&)> f) const override
     {
         for (auto& disp : outputs)
         {
@@ -136,7 +137,7 @@
         }
     }
 
-    void configure_output(graphics::DisplayConfigurationOutputId, bool, geometry::Point, size_t, MirPowerMode)
+    void configure_output(graphics::DisplayConfigurationOutputId, bool, geometry::Point, size_t, MirPixelFormat, MirPowerMode) override
     {
     }
 
 
=== modified file 'src/client/display_configuration.cpp'
--- src/client/display_configuration.cpp	2013-12-17 18:24:51 +0000
+++ src/client/display_configuration.cpp	2014-01-02 11:14:12 +0000
@@ -88,7 +88,7 @@
     {
         output.output_formats[i] = static_cast<MirPixelFormat>(msg.pixel_format(i));
     }
-    output.current_output_format = msg.current_format();
+    output.current_output_format = static_cast<MirPixelFormat>(msg.current_format());
 
     output.position_x = msg.position_x();
     output.position_y = msg.position_y();
 
=== modified file 'src/client/logging/input_receiver_report.cpp'
--- src/client/logging/input_receiver_report.cpp	2013-12-17 18:24:51 +0000
+++ src/client/logging/input_receiver_report.cpp	2014-01-02 11:14:12 +0000
@@ -19,6 +19,7 @@
 #include "input_receiver_report.h"
 
 #include "mir/logging/logger.h"
+#include "mir/logging/input_timestamp.h"
 
 #include <boost/throw_exception.hpp>
 
@@ -53,7 +54,7 @@
     ss << "  scan_code: " << ev.scan_code << std::endl;
     ss << "  repeat_count: " << ev.repeat_count << std::endl;
     ss << "  down_time: " << ev.down_time << std::endl;
-    ss << "  event_time: " << ev.event_time << std::endl;
+    ss << "  event_time: " << ml::input_timestamp(ev.event_time) << std::endl;
     ss << "  is_system_key: " << ev.is_system_key << std::endl;
     ss << "}";
 }
@@ -73,7 +74,7 @@
     ss << "  x_precision: " << ev.x_precision << std::endl;
     ss << "  y_precision: " << ev.y_precision << std::endl;
     ss << "  down_time: " << ev.down_time << std::endl;
-    ss << "  event_time: " << ev.event_time << std::endl;
+    ss << "  event_time: " << ml::input_timestamp(ev.event_time) << std::endl;
     ss << "  pointer_count: " << ev.pointer_count << std::endl;
     for (unsigned int i = 0; i < ev.pointer_count; i++)
     {
 
=== modified file 'src/platform/graphics/CMakeLists.txt'
--- src/platform/graphics/CMakeLists.txt	2013-12-17 18:24:51 +0000
+++ src/platform/graphics/CMakeLists.txt	2014-01-02 11:14:12 +0000
@@ -10,6 +10,7 @@
   display_configuration.cpp
   null_display_report.cpp
   buffer_basic.cpp
+  pixel_format_utils.cpp
 )
 
 add_library(
 
=== modified file 'src/platform/graphics/android/android_display_configuration.cpp'
--- src/platform/graphics/android/android_display_configuration.cpp	2013-12-17 18:24:51 +0000
+++ src/platform/graphics/android/android_display_configuration.cpp	2014-01-02 11:14:12 +0000
@@ -31,7 +31,9 @@
                         true,
                         true,
                         geom::Point{0,0},
-                        0, 0, mir_power_mode_on},
+                        0,
+                        mir_pixel_format_abgr_8888,
+                        mir_power_mode_on},
           card{mg::DisplayConfigurationCardId{0}, 1}
 {
 }
@@ -62,7 +64,7 @@
     f(configuration);
 }
 
-void mga::AndroidDisplayConfiguration::configure_output(mg::DisplayConfigurationOutputId, bool, geom::Point, size_t, MirPowerMode power_mode)
+void mga::AndroidDisplayConfiguration::configure_output(mg::DisplayConfigurationOutputId, bool, geom::Point, size_t, MirPixelFormat, MirPowerMode power_mode)
 {
     configuration.power_mode = power_mode;
 }
 
=== modified file 'src/platform/graphics/android/android_display_configuration.h'
--- src/platform/graphics/android/android_display_configuration.h	2013-12-17 18:24:51 +0000
+++ src/platform/graphics/android/android_display_configuration.h	2014-01-02 11:14:12 +0000
@@ -37,7 +37,7 @@
 
     void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const;
     void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const;
-    void configure_output(DisplayConfigurationOutputId, bool, geometry::Point, size_t, MirPowerMode power_mode);
+    void configure_output(DisplayConfigurationOutputId, bool, geometry::Point, size_t, MirPixelFormat, MirPowerMode power_mode);
 
 private:
     DisplayConfigurationOutput configuration;
 
=== modified file 'src/platform/graphics/mesa/real_kms_display_configuration.cpp'
--- src/platform/graphics/mesa/real_kms_display_configuration.cpp	2013-12-17 18:24:51 +0000
+++ src/platform/graphics/mesa/real_kms_display_configuration.cpp	2014-01-02 11:14:12 +0000
@@ -18,6 +18,7 @@
 
 #include "real_kms_display_configuration.h"
 #include "drm_mode_resources.h"
+#include "mir/graphics/pixel_format_utils.h"
 
 #include <cmath>
 #include <limits>
@@ -26,9 +27,15 @@
 #include <stdexcept>
 #include <algorithm>
 
-namespace mg = mir::graphics;
-namespace mgm = mir::graphics::mesa;
-namespace geom = mir::geometry;
+
+namespace mir
+{
+namespace graphics
+{
+namespace mesa
+{
+
+namespace geom = geometry;
 
 namespace
 {
@@ -59,28 +66,33 @@
     return round(vrefresh_hz * 10.0) / 10.0;
 }
 
-mg::DisplayConfigurationOutputType
+DisplayConfigurationOutputType
 kms_connector_type_to_output_type(uint32_t connector_type)
 {
-    return static_cast<mg::DisplayConfigurationOutputType>(connector_type);
-}
-
-}
-
-mgm::RealKMSDisplayConfiguration::RealKMSDisplayConfiguration(int drm_fd)
+    return static_cast<DisplayConfigurationOutputType>(connector_type);
+}
+
+bool format_available_in_pixel_formats(MirPixelFormat format, DisplayConfigurationOutput const& output)
+{
+    return output.pixel_formats.end() != find(output.pixel_formats.begin(), output.pixel_formats.end(), format);
+}
+
+}
+
+RealKMSDisplayConfiguration::RealKMSDisplayConfiguration(int drm_fd)
     : drm_fd{drm_fd}
 {
     update();
 }
 
-mgm::RealKMSDisplayConfiguration::RealKMSDisplayConfiguration(
+RealKMSDisplayConfiguration::RealKMSDisplayConfiguration(
     RealKMSDisplayConfiguration const& conf)
     : KMSDisplayConfiguration(), drm_fd{conf.drm_fd},
       card(conf.card), outputs{conf.outputs}
 {
 }
 
-mgm::RealKMSDisplayConfiguration& mgm::RealKMSDisplayConfiguration::operator=(
+RealKMSDisplayConfiguration& RealKMSDisplayConfiguration::operator=(
     RealKMSDisplayConfiguration const& conf)
 {
     if (&conf != this)
@@ -93,23 +105,23 @@
     return *this;
 }
 
-void mgm::RealKMSDisplayConfiguration::for_each_card(
+void RealKMSDisplayConfiguration::for_each_card(
     std::function<void(DisplayConfigurationCard const&)> f) const
 {
     f(card);
 }
 
-void mgm::RealKMSDisplayConfiguration::for_each_output(
+void RealKMSDisplayConfiguration::for_each_output(
     std::function<void(DisplayConfigurationOutput const&)> f) const
 {
     for (auto const& output : outputs)
         f(output);
 }
 
-void mgm::RealKMSDisplayConfiguration::configure_output(
+void RealKMSDisplayConfiguration::configure_output(
     DisplayConfigurationOutputId id, bool used,
     geometry::Point top_left, size_t mode_index,
-    MirPowerMode power_mode)
+    MirPixelFormat format, MirPowerMode power_mode)
 {
     auto iter = find_output_with_id(id);
 
@@ -120,9 +132,15 @@
         if (used && mode_index >= output.modes.size())
             BOOST_THROW_EXCEPTION(std::runtime_error("Invalid mode_index for used output"));
 
+        if (used && !valid_mir_pixel_format(format))
+            BOOST_THROW_EXCEPTION(std::runtime_error("Invalid format for used output"));
+        if (used && !format_available_in_pixel_formats(format, output))
+            BOOST_THROW_EXCEPTION(std::runtime_error("Format not available for used output"));
+
         output.used = used;
         output.top_left = top_left;
         output.current_mode_index = mode_index;
+        output.current_format = format;
         output.power_mode = power_mode;
     }
     else
@@ -131,7 +149,7 @@
     }
 }
 
-uint32_t mgm::RealKMSDisplayConfiguration::get_kms_connector_id(
+uint32_t RealKMSDisplayConfiguration::get_kms_connector_id(
     DisplayConfigurationOutputId id) const
 {
     auto iter = find_output_with_id(id);
@@ -145,7 +163,7 @@
     return id.as_value();
 }
 
-size_t mgm::RealKMSDisplayConfiguration::get_kms_mode_index(
+size_t RealKMSDisplayConfiguration::get_kms_mode_index(
     DisplayConfigurationOutputId id,
     size_t conf_mode_index) const
 {
@@ -159,12 +177,12 @@
 
     return conf_mode_index;
 }
-void mgm::RealKMSDisplayConfiguration::update()
+void RealKMSDisplayConfiguration::update()
 {
     DRMModeResources resources{drm_fd};
 
     size_t max_outputs = std::min(resources.num_crtcs(), resources.num_connectors());
-    card = {mg::DisplayConfigurationCardId{0}, max_outputs};
+    card = {DisplayConfigurationCardId{0}, max_outputs};
 
     resources.for_each_connector([&](DRMModeConnectorUPtr connector)
     {
@@ -172,7 +190,7 @@
     });
 }
 
-void mgm::RealKMSDisplayConfiguration::add_or_update_output(
+void RealKMSDisplayConfiguration::add_or_update_output(
     DRMModeResources const& resources,
     drmModeConnector const& connector)
 {
@@ -224,7 +242,8 @@
     {
         outputs.push_back({id, card_id, type, formats, modes, preferred_mode_index,
                            physical_size, connected, false, geom::Point(),
-                           current_mode_index, 0u, mir_power_mode_on});
+                           current_mode_index, mir_pixel_format_xrgb_8888,
+                           mir_power_mode_on});
     }
     else
     {
@@ -235,25 +254,30 @@
         output.physical_size_mm = physical_size;
         output.connected = connected;
         output.current_mode_index = current_mode_index;
+        output.current_format = mir_pixel_format_xrgb_8888;
     }
 }
 
-std::vector<mg::DisplayConfigurationOutput>::iterator
-mgm::RealKMSDisplayConfiguration::find_output_with_id(DisplayConfigurationOutputId id)
-{
-    return std::find_if(outputs.begin(), outputs.end(),
-                        [id](DisplayConfigurationOutput const& output)
-                        {
-                            return output.id == id;
-                        });
-}
-
-std::vector<mg::DisplayConfigurationOutput>::const_iterator
-mgm::RealKMSDisplayConfiguration::find_output_with_id(DisplayConfigurationOutputId id) const
-{
-    return std::find_if(outputs.begin(), outputs.end(),
-                        [id](DisplayConfigurationOutput const& output)
-                        {
-                            return output.id == id;
-                        });
+std::vector<DisplayConfigurationOutput>::iterator
+RealKMSDisplayConfiguration::find_output_with_id(DisplayConfigurationOutputId id)
+{
+    return std::find_if(outputs.begin(), outputs.end(),
+                        [id](DisplayConfigurationOutput const& output)
+                        {
+                            return output.id == id;
+                        });
+}
+
+std::vector<DisplayConfigurationOutput>::const_iterator
+RealKMSDisplayConfiguration::find_output_with_id(DisplayConfigurationOutputId id) const
+{
+    return std::find_if(outputs.begin(), outputs.end(),
+                        [id](DisplayConfigurationOutput const& output)
+                        {
+                            return output.id == id;
+                        });
+}
+
+}
+}
 }
 
=== modified file 'src/platform/graphics/mesa/real_kms_display_configuration.h'
--- src/platform/graphics/mesa/real_kms_display_configuration.h	2013-12-17 18:24:51 +0000
+++ src/platform/graphics/mesa/real_kms_display_configuration.h	2014-01-02 11:14:12 +0000
@@ -39,8 +39,8 @@
 
     void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const;
     void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const;
-    void configure_output(DisplayConfigurationOutputId id, bool used,
-                          geometry::Point top_left, size_t mode_index, MirPowerMode power_mode);
+    void configure_output(DisplayConfigurationOutputId id, bool used, geometry::Point top_left,
+                          size_t mode_index, MirPixelFormat format, MirPowerMode power_mode);
 
     uint32_t get_kms_connector_id(DisplayConfigurationOutputId id) const;
     size_t get_kms_mode_index(DisplayConfigurationOutputId id, size_t conf_mode_index) const;
 
=== added file 'src/platform/graphics/pixel_format_utils.cpp'
--- src/platform/graphics/pixel_format_utils.cpp	1970-01-01 00:00:00 +0000
+++ src/platform/graphics/pixel_format_utils.cpp	2014-01-02 11:14:12 +0000
@@ -0,0 +1,71 @@
+/*
+ * Copyright © 2013 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 "mir/graphics/pixel_format_utils.h"
+
+namespace mir
+{
+namespace graphics
+{
+
+bool contains_alpha(MirPixelFormat format)
+{
+    return (format == mir_pixel_format_abgr_8888 ||
+            format == mir_pixel_format_argb_8888);
+}
+
+int red_channel_depth(MirPixelFormat format)
+{
+    if (mir_pixel_format_invalid < format &&
+        format < mir_pixel_formats)
+        return 8;
+    return 0;
+}
+
+int blue_channel_depth(MirPixelFormat format)
+{
+    if (mir_pixel_format_invalid < format &&
+        format < mir_pixel_formats)
+        return 8;
+    return 0;
+}
+
+int green_channel_depth(MirPixelFormat format)
+{
+    if (mir_pixel_format_invalid < format &&
+        format < mir_pixel_formats)
+        return 8;
+    return 0;
+}
+
+int alpha_channel_depth(MirPixelFormat format)
+{
+    if (format == mir_pixel_format_abgr_8888 ||
+        format == mir_pixel_format_argb_8888)
+        return 8;
+    return 0;
+}
+
+bool valid_mir_pixel_format(MirPixelFormat format)
+{
+    return (format > mir_pixel_format_invalid &&
+            format < mir_pixel_formats);
+}
+
+}
+}
 
=== modified file 'src/server/compositor/default_display_buffer_compositor.cpp'
--- src/server/compositor/default_display_buffer_compositor.cpp	2013-12-17 18:24:51 +0000
+++ src/server/compositor/default_display_buffer_compositor.cpp	2014-01-02 11:14:12 +0000
@@ -135,10 +135,11 @@
         mc::OcclusionMatch occlusion_match;
         scene->reverse_for_each_if(occlusion_search, occlusion_match);
 
-        renderer->clear();
+        renderer->begin();
         mc::RenderingOperator applicator(*renderer, save_resource, local_frameno);
         FilterForVisibleSceneInRegion selector(view_area, occlusion_match);
         scene->for_each_if(selector, applicator);
+        renderer->end();
 
         display_buffer.post_update();
     }
 
=== modified file 'src/server/compositor/gl_renderer.cpp'
--- src/server/compositor/gl_renderer.cpp	2013-12-17 18:24:51 +0000
+++ src/server/compositor/gl_renderer.cpp	2014-01-02 11:14:12 +0000
@@ -117,7 +117,7 @@
 
 }
 
-mc::GLRenderer::Resources::Resources() :
+mc::GLRenderer::GLRenderer(geom::Rectangle const& display_area) :
     vertex_shader(0),
     fragment_shader(0),
     program(0),
@@ -128,24 +128,6 @@
     vertex_attribs_vbo(0),
     texture(0)
 {
-}
-
-mc::GLRenderer::Resources::~Resources()
-{
-    if (vertex_shader)
-        glDeleteShader(vertex_shader);
-    if (fragment_shader)
-        glDeleteShader(fragment_shader);
-    if (program)
-        glDeleteProgram(program);
-    if (vertex_attribs_vbo)
-        glDeleteBuffers(1, &vertex_attribs_vbo);
-    if (texture)
-        glDeleteTextures(1, &texture);
-}
-
-void mc::GLRenderer::Resources::setup(geometry::Rectangle const& display_area)
-{
     GLint param = 0;
 
     /* Create shaders and program */
@@ -235,14 +217,23 @@
     glUseProgram(0);
 }
 
-mc::GLRenderer::GLRenderer(geom::Rectangle const& display_area)
+mc::GLRenderer::~GLRenderer() noexcept
 {
-    resources.setup(display_area);
+    if (vertex_shader)
+        glDeleteShader(vertex_shader);
+    if (fragment_shader)
+        glDeleteShader(fragment_shader);
+    if (program)
+        glDeleteProgram(program);
+    if (vertex_attribs_vbo)
+        glDeleteBuffers(1, &vertex_attribs_vbo);
+    if (texture)
+        glDeleteTextures(1, &texture);
 }
 
 void mc::GLRenderer::render(CompositingCriteria const& criteria, mg::Buffer& buffer) const
 {
-    glUseProgram(resources.program);
+    glUseProgram(program);
 
     if (criteria.shaped() || criteria.alpha() < 1.0f)
     {
@@ -255,32 +246,36 @@
     }
     glActiveTexture(GL_TEXTURE0);
 
-    glUniformMatrix4fv(resources.transform_uniform_loc, 1, GL_FALSE,
+    glUniformMatrix4fv(transform_uniform_loc, 1, GL_FALSE,
                        glm::value_ptr(criteria.transformation()));
-    glUniform1f(resources.alpha_uniform_loc, criteria.alpha());
+    glUniform1f(alpha_uniform_loc, criteria.alpha());
 
     /* Set up vertex attribute data */
-    glBindBuffer(GL_ARRAY_BUFFER, resources.vertex_attribs_vbo);
-    glVertexAttribPointer(resources.position_attr_loc, 3, GL_FLOAT,
+    glBindBuffer(GL_ARRAY_BUFFER, vertex_attribs_vbo);
+    glVertexAttribPointer(position_attr_loc, 3, GL_FLOAT,
                           GL_FALSE, sizeof(VertexAttributes), 0);
-    glVertexAttribPointer(resources.texcoord_attr_loc, 2, GL_FLOAT,
+    glVertexAttribPointer(texcoord_attr_loc, 2, GL_FLOAT,
                           GL_FALSE, sizeof(VertexAttributes),
                           reinterpret_cast<void*>(sizeof(glm::vec3)));
 
     /* Use the renderable's texture */
-    glBindTexture(GL_TEXTURE_2D, resources.texture);
+    glBindTexture(GL_TEXTURE_2D, texture);
 
     buffer.bind_to_texture();
 
     /* Draw */
-    glEnableVertexAttribArray(resources.position_attr_loc);
-    glEnableVertexAttribArray(resources.texcoord_attr_loc);
+    glEnableVertexAttribArray(position_attr_loc);
+    glEnableVertexAttribArray(texcoord_attr_loc);
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-    glDisableVertexAttribArray(resources.texcoord_attr_loc);
-    glDisableVertexAttribArray(resources.position_attr_loc);
+    glDisableVertexAttribArray(texcoord_attr_loc);
+    glDisableVertexAttribArray(position_attr_loc);
 }
 
-void mc::GLRenderer::clear() const
+void mc::GLRenderer::begin() const
 {
     glClear(GL_COLOR_BUFFER_BIT);
 }
+
+void mc::GLRenderer::end() const
+{
+}
 
=== modified file 'src/server/compositor/gl_renderer.h'
--- src/server/compositor/gl_renderer.h	2013-12-17 18:24:51 +0000
+++ src/server/compositor/gl_renderer.h	2014-01-02 11:14:12 +0000
@@ -32,32 +32,22 @@
 {
 public:
     GLRenderer(geometry::Rectangle const& display_area);
+    virtual ~GLRenderer() noexcept;
 
+    void begin() const override;
     void render(CompositingCriteria const& info, graphics::Buffer& buffer) const override;
-    void clear() const override;
-
-    ~GLRenderer() noexcept {}
+    void end() const override;
 
 private:
-    class Resources
-    {
-    public:
-        Resources();
-        ~Resources();
-        void setup(geometry::Rectangle const& display_area);
-
-        GLuint vertex_shader;
-        GLuint fragment_shader;
-        GLuint program;
-        GLuint position_attr_loc;
-        GLuint texcoord_attr_loc;
-        GLuint transform_uniform_loc;
-        GLuint alpha_uniform_loc;
-        GLuint vertex_attribs_vbo;
-        GLuint texture;
-    };
-
-    Resources resources;
+    GLuint vertex_shader;
+    GLuint fragment_shader;
+    GLuint program;
+    GLuint position_attr_loc;
+    GLuint texcoord_attr_loc;
+    GLuint transform_uniform_loc;
+    GLuint alpha_uniform_loc;
+    GLuint vertex_attribs_vbo;
+    GLuint texture;
 };
 
 }
 
=== modified file 'src/server/compositor/renderer.h'
--- src/server/compositor/renderer.h	2013-12-17 18:24:51 +0000
+++ src/server/compositor/renderer.h	2014-01-02 11:14:12 +0000
@@ -34,8 +34,9 @@
 public:
     virtual ~Renderer() = default;
 
-    virtual void clear() const = 0;
+    virtual void begin() const = 0;
     virtual void render(CompositingCriteria const& info, graphics::Buffer& buffer) const = 0;
+    virtual void end() const = 0;
 
 protected:
     Renderer() = default;
 
=== modified file 'src/server/frontend/protobuf_buffer_packer.cpp'
--- src/server/frontend/protobuf_buffer_packer.cpp	2013-12-17 18:24:51 +0000
+++ src/server/frontend/protobuf_buffer_packer.cpp	2014-01-02 11:14:12 +0000
@@ -64,7 +64,7 @@
     protobuf_output.set_position_x(display_output.top_left.x.as_uint32_t());
     protobuf_output.set_position_y(display_output.top_left.y.as_uint32_t());
     protobuf_output.set_current_mode(display_output.current_mode_index);
-    protobuf_output.set_current_format(display_output.current_format_index);
+    protobuf_output.set_current_format(static_cast<uint32_t>(display_output.current_format));
     protobuf_output.set_power_mode(static_cast<uint32_t>(display_output.power_mode));
 }
 
 
=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2013-12-17 18:24:51 +0000
+++ src/server/frontend/session_mediator.cpp	2014-01-02 11:14:12 +0000
@@ -321,7 +321,9 @@
             mg::DisplayConfigurationOutputId output_id{static_cast<int>(output.output_id())};
             config->configure_output(output_id, output.used(),
                                      geom::Point{output.position_x(), output.position_y()},
-                                     output.current_mode(), static_cast<MirPowerMode>(output.power_mode()));
+                                     output.current_mode(),
+                                     static_cast<MirPixelFormat>(output.current_format()),
+                                     static_cast<MirPowerMode>(output.power_mode()));
         }
 
         display_changer->configure(session, config);
 
=== modified file 'src/server/graphics/default_display_configuration_policy.cpp'
--- src/server/graphics/default_display_configuration_policy.cpp	2013-12-17 18:24:51 +0000
+++ src/server/graphics/default_display_configuration_policy.cpp	2014-01-02 11:14:12 +0000
@@ -18,13 +18,47 @@
 
 #include "default_display_configuration_policy.h"
 #include "mir/graphics/display_configuration.h"
+#include "mir/graphics/pixel_format_utils.h"
 
 #include <unordered_map>
-
-namespace mg = mir::graphics;
-namespace geom = mir::geometry;
-
-void mg::DefaultDisplayConfigurationPolicy::apply_to(DisplayConfiguration& conf)
+#include <algorithm>
+
+namespace mir
+{
+namespace geom = geometry;
+namespace graphics
+{
+
+namespace
+{
+inline size_t select_mode_index(size_t mode_index, std::vector<DisplayConfigurationMode> const & modes)
+{
+    if (modes.empty())
+        return std::numeric_limits<size_t>::max();
+    if (mode_index > modes.size())
+        return 0;
+    return mode_index;
+}
+
+inline MirPixelFormat select_format(MirPixelFormat format, std::vector<MirPixelFormat> const& formats)
+{
+    if (formats.empty())
+        return mir_pixel_format_invalid;
+
+    if (!contains_alpha(format))
+        return format;
+
+    auto opaque_pos = std::find_if_not(formats.begin(), formats.end(), contains_alpha);
+
+    if (opaque_pos == formats.end())
+        return format;
+
+    return *opaque_pos;
+}
+
+}
+
+void DefaultDisplayConfigurationPolicy::apply_to(DisplayConfiguration& conf)
 {
     static MirPowerMode const default_power_state = mir_power_mode_on;
     std::unordered_map<DisplayConfigurationCardId, size_t> available_outputs_for_card;
@@ -38,23 +72,24 @@
     conf.for_each_output(
         [&](DisplayConfigurationOutput const& conf_output)
         {
-            if (conf_output.connected && conf_output.modes.size() > 0 &&
-                available_outputs_for_card[conf_output.card_id] > 0)
-            {
-                size_t preferred_mode_index{conf_output.preferred_mode_index};
-                if (preferred_mode_index > conf_output.modes.size())
-                    preferred_mode_index = 0;
-
-                conf.configure_output(conf_output.id, true, geom::Point(),
-                                      preferred_mode_index, default_power_state);
-
-                --available_outputs_for_card[conf_output.card_id];
-            }
-            else
+            if (!conf_output.connected || conf_output.modes.empty() ||
+                available_outputs_for_card[conf_output.card_id] == 0)
             {
                 conf.configure_output(conf_output.id, false, conf_output.top_left,
-                                      conf_output.current_mode_index, default_power_state);
+                                      conf_output.current_mode_index, conf_output.current_format,
+                                      default_power_state);
+                return;
             }
+
+            size_t preferred_mode_index{select_mode_index(conf_output.preferred_mode_index, conf_output.modes)};
+            MirPixelFormat format{select_format(conf_output.current_format, conf_output.pixel_formats)};
+
+            conf.configure_output(conf_output.id, true, geom::Point(), preferred_mode_index,
+                                  format, default_power_state);
+
+            --available_outputs_for_card[conf_output.card_id];
         });
 }
 
+} // graphics
+} // mir
 
=== modified file 'src/server/graphics/nested/nested_display.cpp'
--- src/server/graphics/nested/nested_display.cpp	2013-12-19 19:05:57 +0000
+++ src/server/graphics/nested/nested_display.cpp	2014-01-02 11:14:12 +0000
@@ -22,8 +22,10 @@
 #include "mir_api_wrappers.h"
 
 #include "mir/geometry/rectangle.h"
+#include "mir/graphics/pixel_format_utils.h"
 #include "mir/graphics/gl_context.h"
 #include "mir/graphics/surfaceless_egl_context.h"
+#include "mir/graphics/display_configuration_policy.h"
 #include "host_connection.h"
 
 #include <boost/throw_exception.hpp>
@@ -34,45 +36,8 @@
 namespace mgnw = mir::graphics::nested::mir_api_wrappers;
 namespace geom = mir::geometry;
 
-namespace
-{
-
-MirPixelFormat find_opaque_surface_format(MirConnection* connection)
-{
-    static unsigned const max_formats = 32;
-    MirPixelFormat formats[max_formats];
-    unsigned int valid_formats;
-
-    mir_connection_get_available_surface_formats(connection, formats,
-                                                 max_formats, &valid_formats);
-
-    // Find an opaque surface format
-    for (auto f = formats; f != formats+valid_formats; ++f)
-    {
-        if (*f == mir_pixel_format_xbgr_8888 ||
-            *f == mir_pixel_format_xrgb_8888)
-        {
-            return *f;
-        }
-    }
-
-    BOOST_THROW_EXCEPTION(
-        std::runtime_error("Nested Mir failed to find an opaque surface format"));
-}
-
-}
-
-EGLint const mgn::detail::nested_egl_config_attribs[] = {
-    EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
-    EGL_RED_SIZE, 8,
-    EGL_GREEN_SIZE, 8,
-    EGL_BLUE_SIZE, 8,
-    EGL_ALPHA_SIZE, 0,
-    EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-    EGL_NONE
-};
-
-EGLint const mgn::detail::nested_egl_context_attribs[] = {
+EGLint const mgn::detail::nested_egl_context_attribs[] =
+{
     EGL_CONTEXT_CLIENT_VERSION, 2,
     EGL_NONE
 };
@@ -93,6 +58,8 @@
 }
 
 mgn::detail::EGLDisplayHandle::EGLDisplayHandle(MirConnection* connection)
+    : egl_display(EGL_NO_DISPLAY),
+    egl_context_(EGL_NO_CONTEXT)
 {
     auto const native_display = (EGLNativeDisplayType) mir_connection_get_egl_native_display(connection);
     egl_display = eglGetDisplay(native_display);
@@ -100,7 +67,7 @@
         BOOST_THROW_EXCEPTION(std::runtime_error("Nested Mir Display Error: Failed to fetch EGL display."));
 }
 
-void mgn::detail::EGLDisplayHandle::initialize()
+void mgn::detail::EGLDisplayHandle::initialize(MirPixelFormat format)
 {
     int major;
     int minor;
@@ -110,17 +77,28 @@
         BOOST_THROW_EXCEPTION(std::runtime_error("Nested Mir Display Error: Failed to initialize EGL."));
     }
 
-    egl_context_ = eglCreateContext(egl_display, choose_config(detail::nested_egl_config_attribs), EGL_NO_CONTEXT, detail::nested_egl_context_attribs);
+    egl_context_ = eglCreateContext(egl_display, choose_windowed_es_config(format), EGL_NO_CONTEXT, detail::nested_egl_context_attribs);
+
     if (egl_context_ == EGL_NO_CONTEXT)
         BOOST_THROW_EXCEPTION(std::runtime_error("Failed to create shared EGL context"));
 }
 
-EGLConfig mgn::detail::EGLDisplayHandle::choose_config(const EGLint attrib_list[]) const
+EGLConfig mgn::detail::EGLDisplayHandle::choose_windowed_es_config(MirPixelFormat format) const
 {
+    EGLint const nested_egl_config_attribs[] =
+    {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+        EGL_RED_SIZE, mg::red_channel_depth(format),
+        EGL_GREEN_SIZE, mg::green_channel_depth(format),
+        EGL_BLUE_SIZE, mg::blue_channel_depth(format),
+        EGL_ALPHA_SIZE, mg::alpha_channel_depth(format),
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+        EGL_NONE
+    };
     EGLConfig result;
     int n;
 
-    int res = eglChooseConfig(egl_display, attrib_list, &result, 1, &n);
+    int res = eglChooseConfig(egl_display, nested_egl_config_attribs, &result, 1, &n);
     if ((res != EGL_TRUE) || (n != 1))
         BOOST_THROW_EXCEPTION(std::runtime_error("Nested Mir Display Error: Failed to choose EGL configuration."));
 
@@ -149,17 +127,18 @@
 mgn::NestedDisplay::NestedDisplay(
     std::shared_ptr<HostConnection> const& connection,
     std::shared_ptr<input::EventFilter> const& event_handler,
-    std::shared_ptr<mg::DisplayReport> const& display_report) :
+    std::shared_ptr<mg::DisplayReport> const& display_report,
+    std::shared_ptr<mg::DisplayConfigurationPolicy> const& initial_conf_policy) :
     connection{connection},
     event_handler{event_handler},
     display_report{display_report},
     egl_display{*connection},
-    egl_pixel_format{find_opaque_surface_format(*connection)},
     outputs{}
 {
-    egl_display.initialize();
-    eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, egl_display.egl_context());
-    configure(*configuration());
+
+    std::shared_ptr<DisplayConfiguration> conf(configuration());
+    initial_conf_policy->apply_to(*conf);
+    configure(*conf);
 }
 
 mgn::NestedDisplay::~NestedDisplay() noexcept
@@ -178,6 +157,14 @@
     return std::make_shared<NestedDisplayConfiguration>(mir_connection_create_display_config(*connection));
 }
 
+void mgn::NestedDisplay::complete_display_initialization(MirPixelFormat format)
+{
+    if (egl_display.egl_context() != EGL_NO_CONTEXT)  return;
+
+    egl_display.initialize(format);
+    eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, egl_display.egl_context());
+}
+
 void mgn::NestedDisplay::configure(mg::DisplayConfiguration const& configuration)
 {
     decltype(outputs) result;
@@ -193,13 +180,16 @@
                 geometry::Rectangle const area{output.top_left, output.modes[output.current_mode_index].size};
 
                 auto const& egl_display_mode = output.modes[output.current_mode_index];
+                auto const& egl_config_format = output.current_format;
+
+                complete_display_initialization(egl_config_format);
 
                 MirSurfaceParameters const request_params =
                     {
                         "Mir nested display",
                         egl_display_mode.size.width.as_int(),
                         egl_display_mode.size.height.as_int(),
-                        egl_pixel_format,
+                        egl_config_format,
                         mir_buffer_usage_hardware,
                         static_cast<uint32_t>(output.id.as_value())
                     };
@@ -213,7 +203,8 @@
                     egl_display,
                     mir_surface,
                     area,
-                    event_handler);
+                    event_handler,
+                    output.current_format);
             }
         });
 
@@ -274,13 +265,7 @@
     return std::weak_ptr<Cursor>();
 }
 
-namespace
-{
-}
-
 std::unique_ptr<mg::GLContext> mgn::NestedDisplay::create_gl_context()
 {
-    return std::unique_ptr<mg::GLContext>{new SurfacelessEGLContext(egl_display,
-                                                                    detail::nested_egl_config_attribs,
-                                                                    EGL_NO_CONTEXT)};
+    return std::unique_ptr<mg::GLContext>{new SurfacelessEGLContext(egl_display, EGL_NO_CONTEXT)};
 }
 
=== modified file 'src/server/graphics/nested/nested_display.h'
--- src/server/graphics/nested/nested_display.h	2013-12-17 18:24:51 +0000
+++ src/server/graphics/nested/nested_display.h	2014-01-02 11:14:12 +0000
@@ -42,6 +42,7 @@
 {
 class DisplayReport;
 class DisplayBuffer;
+class DisplayConfigurationPolicy;
 
 namespace nested
 {
@@ -67,8 +68,8 @@
     explicit EGLDisplayHandle(MirConnection* connection);
     ~EGLDisplayHandle() noexcept;
 
-    void initialize();
-    EGLConfig choose_config(const EGLint attrib_list[]) const;
+    void initialize(MirPixelFormat format);
+    EGLConfig choose_windowed_es_config (MirPixelFormat format) const;
     EGLNativeWindowType native_window(EGLConfig egl_config, MirSurface* mir_surface) const;
     EGLContext egl_context() const;
     operator EGLDisplay() const { return egl_display; }
@@ -83,7 +84,6 @@
 
 class NestedOutput;
 
-extern EGLint const nested_egl_config_attribs[];
 extern EGLint const nested_egl_context_attribs[];
 }
 
@@ -95,7 +95,8 @@
     NestedDisplay(
         std::shared_ptr<HostConnection> const& connection,
         std::shared_ptr<input::EventFilter> const& event_handler,
-        std::shared_ptr<DisplayReport> const& display_report);
+        std::shared_ptr<DisplayReport> const& display_report,
+        std::shared_ptr<DisplayConfigurationPolicy> const& conf_policy);
 
     ~NestedDisplay() noexcept;
 
@@ -124,11 +125,11 @@
     std::shared_ptr<input::EventFilter> const event_handler;
     std::shared_ptr<DisplayReport> const display_report;
     detail::EGLDisplayHandle egl_display;
-    MirPixelFormat const egl_pixel_format;
 
     std::mutex outputs_mutex;
     std::unordered_map<DisplayConfigurationOutputId, std::shared_ptr<detail::NestedOutput>> outputs;
     DisplayConfigurationChangeHandler my_conf_change_handler;
+    void complete_display_initialization(MirPixelFormat format);
 };
 
 }
 
=== modified file 'src/server/graphics/nested/nested_display_configuration.cpp'
--- src/server/graphics/nested/nested_display_configuration.cpp	2013-12-17 18:24:51 +0000
+++ src/server/graphics/nested/nested_display_configuration.cpp	2014-01-02 11:14:12 +0000
@@ -18,26 +18,40 @@
 
 #include "nested_display_configuration.h"
 
-namespace mg = mir::graphics;
-namespace mgn = mg::nested;
+#include "mir/graphics/pixel_format_utils.h"
 
 #include <boost/throw_exception.hpp>
 
 #include <stdexcept>
 #include <algorithm>
 
-namespace mgn = mir::graphics::nested;
-
-mgn::NestedDisplayConfiguration::NestedDisplayConfiguration(MirDisplayConfiguration* connection) :
+namespace mir
+{
+namespace graphics
+{
+namespace nested
+{
+
+namespace
+{
+bool format_valid_for_output(MirDisplayOutput const& output, MirPixelFormat format)
+{
+    MirPixelFormat * end = output.output_formats + output.num_output_formats;
+    return end != std::find(output.output_formats, end, format);
+}
+
+}
+
+NestedDisplayConfiguration::NestedDisplayConfiguration(MirDisplayConfiguration* connection) :
 display_config{connection}
 {
 }
 
-mgn::NestedDisplayConfiguration::~NestedDisplayConfiguration() noexcept
+NestedDisplayConfiguration::~NestedDisplayConfiguration() noexcept
 {
 }
 
-void mgn::NestedDisplayConfiguration::for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const
+void NestedDisplayConfiguration::for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const
 {
     std::for_each(
         display_config->cards,
@@ -48,7 +62,7 @@
         });
 }
 
-void mgn::NestedDisplayConfiguration::for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const
+void NestedDisplayConfiguration::for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const
 {
     std::for_each(
         display_config->outputs,
@@ -85,8 +99,8 @@
         });
 }
 
-void mgn::NestedDisplayConfiguration::configure_output(DisplayConfigurationOutputId id, bool used,
-    geometry::Point top_left, size_t mode_index, MirPowerMode power_mode)
+void NestedDisplayConfiguration::configure_output(DisplayConfigurationOutputId id, bool used,
+    geometry::Point top_left, size_t mode_index, MirPixelFormat format, MirPowerMode power_mode)
 {
     for (auto mir_output = display_config->outputs;
         mir_output != display_config->outputs+display_config->num_outputs;
@@ -97,13 +111,24 @@
             if (used && mode_index >= mir_output->num_modes)
                 BOOST_THROW_EXCEPTION(std::runtime_error("Invalid mode_index for used output"));
 
+            if (used && !valid_mir_pixel_format(format))
+                BOOST_THROW_EXCEPTION(std::runtime_error("Invalid format for used output"));
+
+            if (used && !format_valid_for_output(*mir_output, format))
+                BOOST_THROW_EXCEPTION(std::runtime_error("Format not available for used output"));
+
             mir_output->used = used;
             mir_output->position_x = top_left.x.as_uint32_t();
             mir_output->position_y = top_left.y.as_uint32_t();
             mir_output->current_mode = mode_index;
+            mir_output->current_output_format = format;
             mir_output->power_mode = static_cast<MirPowerMode>(power_mode);
             return;
         }
     }
     BOOST_THROW_EXCEPTION(std::runtime_error("Trying to configure invalid output"));
 }
+
+} // nested
+} // graphics
+} // mir
 
=== modified file 'src/server/graphics/nested/nested_display_configuration.h'
--- src/server/graphics/nested/nested_display_configuration.h	2013-09-12 21:36:55 +0000
+++ src/server/graphics/nested/nested_display_configuration.h	2014-01-02 11:14:12 +0000
@@ -38,7 +38,7 @@
     void for_each_output(std::function<void(DisplayConfigurationOutput const&)>) const;
 
     void configure_output(DisplayConfigurationOutputId id, bool used, geometry::Point top_left, size_t mode_index,
-                          MirPowerMode power_mode);
+                          MirPixelFormat format, MirPowerMode power_mode);
 
     operator MirDisplayConfiguration*() const { return display_config; }
 private:
 
=== modified file 'src/server/graphics/nested/nested_output.cpp'
--- src/server/graphics/nested/nested_output.cpp	2013-09-23 13:37:44 +0000
+++ src/server/graphics/nested/nested_output.cpp	2014-01-02 11:14:12 +0000
@@ -41,10 +41,11 @@
     EGLDisplayHandle const& egl_display,
     MirSurface* mir_surface,
     geometry::Rectangle const& area,
-    std::shared_ptr<input::EventFilter> const& event_handler) :
+    std::shared_ptr<input::EventFilter> const& event_handler,
+    MirPixelFormat preferred_format) :
     egl_display(egl_display),
     mir_surface{mir_surface},
-    egl_config{egl_display.choose_config(nested_egl_config_attribs)},
+    egl_config{egl_display.choose_windowed_es_config(preferred_format)},
     egl_context{egl_display, eglCreateContext(egl_display, egl_config, egl_display.egl_context(), nested_egl_context_attribs)},
     area{area.top_left, area.size},
     event_handler{event_handler},
 
=== modified file 'src/server/graphics/nested/nested_output.h'
--- src/server/graphics/nested/nested_output.h	2013-09-23 13:37:44 +0000
+++ src/server/graphics/nested/nested_output.h	2014-01-02 11:14:12 +0000
@@ -54,7 +54,8 @@
         EGLDisplayHandle const& egl_display,
         MirSurface* mir_surface,
         geometry::Rectangle const& area,
-        std::shared_ptr<input::EventFilter> const& event_handler);
+        std::shared_ptr<input::EventFilter> const& event_handler,
+        MirPixelFormat preferred_format);
 
     ~NestedOutput() noexcept;
 
 
=== modified file 'src/server/graphics/nested/nested_platform.cpp'
--- src/server/graphics/nested/nested_platform.cpp	2013-12-17 18:24:51 +0000
+++ src/server/graphics/nested/nested_platform.cpp	2014-01-02 11:14:12 +0000
@@ -113,9 +113,9 @@
     return native_platform->create_buffer_allocator(buffer_initializer);
 }
 
-std::shared_ptr<mg::Display> mgn::NestedPlatform::create_display(std::shared_ptr<mg::DisplayConfigurationPolicy> const& /*initial_conf_policy*/)
+std::shared_ptr<mg::Display> mgn::NestedPlatform::create_display(std::shared_ptr<mg::DisplayConfigurationPolicy> const& conf_policy)
 {
-    return std::make_shared<mgn::NestedDisplay>(connection, event_handler, display_report);
+    return std::make_shared<mgn::NestedDisplay>(connection, event_handler, display_report, conf_policy);
 }
 
 std::shared_ptr<mg::PlatformIPCPackage> mgn::NestedPlatform::get_ipc_package()
 
=== modified file 'src/server/graphics/nested/nested_platform.h'
--- src/server/graphics/nested/nested_platform.h	2013-12-17 18:24:51 +0000
+++ src/server/graphics/nested/nested_platform.h	2014-01-02 11:14:12 +0000
@@ -42,12 +42,12 @@
 
     ~NestedPlatform() noexcept;
     std::shared_ptr<GraphicBufferAllocator> create_buffer_allocator(
-            std::shared_ptr<BufferInitializer> const& buffer_initializer);
+            std::shared_ptr<BufferInitializer> const& buffer_initializer) override;
     std::shared_ptr<Display> create_display(
-            std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy);
-    std::shared_ptr<PlatformIPCPackage> get_ipc_package();
-    std::shared_ptr<InternalClient> create_internal_client();
-    void fill_ipc_package(BufferIPCPacker* packer, Buffer const* Buffer) const;
+            std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy) override;
+    std::shared_ptr<PlatformIPCPackage> get_ipc_package() override;
+    std::shared_ptr<InternalClient> create_internal_client() override;
+    void fill_ipc_package(BufferIPCPacker* packer, Buffer const* Buffer) const override;
     EGLNativeDisplayType egl_native_display() const;
 
 private:
 
=== modified file 'src/server/graphics/offscreen/display_configuration.cpp'
--- src/server/graphics/offscreen/display_configuration.cpp	2013-12-17 18:24:51 +0000
+++ src/server/graphics/offscreen/display_configuration.cpp	2014-01-02 11:14:12 +0000
@@ -31,7 +31,9 @@
                  true,
                  true,
                  geom::Point{0,0},
-                 0, 0, mir_power_mode_on},
+                 0,
+                 mir_pixel_format_xrgb_8888,
+                 mir_power_mode_on},
           card{mg::DisplayConfigurationCardId{0}, 1}
 {
 }
@@ -67,6 +69,6 @@
 }
 
 void mgo::DisplayConfiguration::configure_output(
-    mg::DisplayConfigurationOutputId, bool, geom::Point, size_t, MirPowerMode)
+    mg::DisplayConfigurationOutputId, bool, geom::Point, size_t, MirPixelFormat, MirPowerMode)
 {
 }
 
=== modified file 'src/server/graphics/offscreen/display_configuration.h'
--- src/server/graphics/offscreen/display_configuration.h	2013-11-12 17:23:53 +0000
+++ src/server/graphics/offscreen/display_configuration.h	2014-01-02 11:14:12 +0000
@@ -33,10 +33,10 @@
     DisplayConfiguration(DisplayConfiguration const& other);
     DisplayConfiguration& operator=(DisplayConfiguration const& other);
 
-    void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const;
-    void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const;
-    void configure_output(DisplayConfigurationOutputId, bool, geometry::Point,
-                          size_t, MirPowerMode power_mode);
+    void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const override;
+    void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const override;
+    virtual void configure_output(DisplayConfigurationOutputId id, bool used, geometry::Point top_left,
+                                  size_t mode_index, MirPixelFormat format, MirPowerMode power_mode) override;
 
 private:
     DisplayConfigurationOutput output;
 
=== modified file 'src/server/logging/input_report.cpp'
--- src/server/logging/input_report.cpp	2013-12-19 16:33:56 +0000
+++ src/server/logging/input_report.cpp	2014-01-02 11:14:12 +0000
@@ -18,6 +18,7 @@
 
 #include "mir/logging/input_report.h"
 #include "mir/logging/logger.h"
+#include "mir/logging/input_timestamp.h"
 
 #include "std/MirLog.h"
 #include <std/Log.h>
@@ -108,7 +109,7 @@
     std::stringstream ss;
 
     ss << "Received event"
-       << " time=" << when
+       << " time=" << ml::input_timestamp(when)
        << " type=" << type
        << " code=" << code
        << " value=" << value;
@@ -122,7 +123,7 @@
 
     ss << "Published key event"
        << " seq_id=" << seq_id
-       << " time=" << event_time
+       << " time=" << ml::input_timestamp(event_time)
        << " dest_fd=" << dest_fd;
 
     logger->log(Logger::informational, ss.str(), component());
@@ -134,7 +135,7 @@
 
     ss << "Published motion event"
        << " seq_id=" << seq_id
-       << " time=" << event_time
+       << " time=" << ml::input_timestamp(event_time)
        << " dest_fd=" << dest_fd;
 
     logger->log(Logger::informational, ss.str(), component());
 
=== modified file 'src/server/scene/mediating_display_changer.cpp'
--- src/server/scene/mediating_display_changer.cpp	2013-12-17 18:24:51 +0000
+++ src/server/scene/mediating_display_changer.cpp	2014-01-02 11:14:12 +0000
@@ -136,6 +136,7 @@
             conf->configure_output(output.id, output.used,
                                    output.top_left,
                                    output.current_mode_index,
+                                   output.current_format,
                                    mir_power_mode_on);
         }
     });
 
=== modified file 'src/shared/logging/CMakeLists.txt'
--- src/shared/logging/CMakeLists.txt	2013-12-12 07:51:12 +0000
+++ src/shared/logging/CMakeLists.txt	2014-01-02 11:14:12 +0000
@@ -16,4 +16,5 @@
 
 add_library(mirsharedlogging STATIC
   dumb_console_logger.cpp
+  input_timestamp.cpp
 )
 
=== added file 'src/shared/logging/input_timestamp.cpp'
--- src/shared/logging/input_timestamp.cpp	1970-01-01 00:00:00 +0000
+++ src/shared/logging/input_timestamp.cpp	2014-01-02 11:14:12 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2013 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: Daniel van Vugt <[e-mail]>
+ */
+
+#include "mir/logging/input_timestamp.h"
+#include <ctime>
+#include <cstdio>
+#include <string>
+
+std::string mir::logging::input_timestamp(nsecs_t when)
+{
+    // Input events use CLOCK_REALTIME, and so we must...
+    struct timespec ts;
+    clock_gettime(CLOCK_REALTIME, &ts);
+
+    nsecs_t now = ts.tv_sec * 1000000000LL + ts.tv_nsec;
+    nsecs_t age = now - when;
+
+    char str[64];
+    snprintf(str, sizeof str, "%lld (%ld.%06ld ms ago)",
+             static_cast<long long>(when),
+             static_cast<long>(age / 1000000LL),
+             static_cast<long>(age % 1000000LL));
+
+    return std::string(str);
+}
+
 
=== modified file 'tests/acceptance-tests/test_server_shutdown.cpp'
--- tests/acceptance-tests/test_server_shutdown.cpp	2013-12-17 18:24:51 +0000
+++ tests/acceptance-tests/test_server_shutdown.cpp	2014-01-02 11:14:12 +0000
@@ -48,6 +48,10 @@
 class NullRenderer : public mc::Renderer
 {
 public:
+    void begin() const override
+    {
+    }
+
     void render(mc::CompositingCriteria const&, mg::Buffer&) const override
     {
         /*
@@ -58,7 +62,7 @@
         std::this_thread::yield();
     }
 
-    void clear() const override
+    void end() const override
     {
     }
 };
 
=== modified file 'tests/integration-tests/test_session.cpp'
--- tests/integration-tests/test_session.cpp	2013-12-17 18:24:51 +0000
+++ tests/integration-tests/test_session.cpp	2014-01-02 11:14:12 +0000
@@ -87,12 +87,15 @@
     {
         struct StubRenderer : public mc::Renderer
         {
-            void clear() const override
+            void begin() const override
             {
             }
             void render(mc::CompositingCriteria const&, mg::Buffer&) const override
             {
             }
+            void end() const override
+            {
+            }
         };
 
         struct StubRendererFactory : public mc::RendererFactory
 
=== modified file 'tests/integration-tests/test_surface_first_frame_sync.cpp'
--- tests/integration-tests/test_surface_first_frame_sync.cpp	2013-12-17 18:24:51 +0000
+++ tests/integration-tests/test_surface_first_frame_sync.cpp	2014-01-02 11:14:12 +0000
@@ -96,7 +96,7 @@
     {
     }
 
-    void clear() const override
+    void begin() const override
     {
     }
 
@@ -105,6 +105,10 @@
         while (write(render_operations_fd, "a", 1) != 1) continue;
     }
 
+    void end() const override
+    {
+    }
+
 private:
     int render_operations_fd;
 };
 
=== modified file 'tests/mir_test/display_config_matchers.cpp'
--- tests/mir_test/display_config_matchers.cpp	2013-12-17 18:24:51 +0000
+++ tests/mir_test/display_config_matchers.cpp	2014-01-02 11:14:12 +0000
@@ -67,7 +67,7 @@
                 geom::Point{protobuf_output.position_x(),
                             protobuf_output.position_y()},
                 protobuf_output.current_mode(),
-                protobuf_output.current_format(),
+                static_cast<MirPixelFormat>(protobuf_output.current_format()),
                 static_cast<MirPowerMode>(protobuf_output.power_mode())
             };
 
@@ -175,7 +175,7 @@
     }
 
     void configure_output(mg::DisplayConfigurationOutputId, bool,
-                          geom::Point, size_t, MirPowerMode)
+                          geom::Point, size_t, MirPixelFormat, MirPowerMode)
     {
     }
 
 
=== modified file 'tests/mir_test_framework/stubbed_server_configuration.cpp'
--- tests/mir_test_framework/stubbed_server_configuration.cpp	2013-12-19 16:34:53 +0000
+++ tests/mir_test_framework/stubbed_server_configuration.cpp	2014-01-02 11:14:12 +0000
@@ -132,7 +132,7 @@
             mg::DisplayConfigurationCardId{0},
             mg::DisplayConfigurationOutputType::vga,
             std::vector<MirPixelFormat>{mir_pixel_format_abgr_8888},
-            modes, 0, geom::Size{}, true, true, geom::Point{0,0}, 0, 0, mir_power_mode_on};
+            modes, 0, geom::Size{}, true, true, geom::Point{0,0}, 0, mir_pixel_format_abgr_8888, mir_power_mode_on};
 
         f(dummy_output_config);
     }
@@ -201,11 +201,15 @@
 class StubRenderer : public mc::Renderer
 {
 public:
+    void begin() const override
+    {
+    }
+
     void render(mc::CompositingCriteria const&, mg::Buffer&) const override
     {
     }
 
-    void clear() const override
+    void end() const override
     {
     }
 };
 
=== modified file 'tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp'
--- tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp	2013-12-17 18:24:51 +0000
+++ tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp	2014-01-02 11:14:12 +0000
@@ -106,9 +106,9 @@
     {
     }
 
-    void clear() const override
+    void begin() const override
     {
-        renderer->clear();
+        renderer->begin();
     }
 
     void render(mc::CompositingCriteria const& criteria, mg::Buffer& buffer) const override
@@ -116,6 +116,11 @@
         renderer->render(criteria, buffer);
     }
 
+    void end() const override
+    {
+        renderer->end();
+    }
+
     mc::Renderer* const renderer;
 };
 
@@ -241,10 +246,14 @@
     renderable_vec.push_back(&small);
     renderable_vec.push_back(&fullscreen);
 
+    EXPECT_CALL(renderer_factory.mock_renderer, begin())
+        .Times(0);
     EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(small),_))
         .Times(0);
     EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(fullscreen),_))
         .Times(0);
+    EXPECT_CALL(renderer_factory.mock_renderer, end())
+        .Times(0);
 
     FakeScene scene(renderable_vec);
 
@@ -263,6 +272,58 @@
     comp->composite();
 }
 
+TEST(DefaultDisplayBufferCompositor, calls_renderer_in_sequence)
+{
+    using namespace testing;
+
+    StubRendererFactory renderer_factory;
+
+    geom::Rectangle screen{{0, 0}, {1366, 768}};
+
+    mtd::MockDisplayBuffer display_buffer;
+
+    EXPECT_CALL(display_buffer, view_area())
+        .WillRepeatedly(Return(screen));
+    EXPECT_CALL(display_buffer, can_bypass())
+        .WillRepeatedly(Return(false));
+
+    mtd::StubCompositingCriteria big(5, 10, 100, 200);
+    mtd::StubCompositingCriteria small(10, 20, 30, 40);
+
+    std::vector<mc::CompositingCriteria*> renderable_vec;
+    renderable_vec.push_back(&big);
+    renderable_vec.push_back(&small);
+
+    Sequence render_seq;
+
+    EXPECT_CALL(display_buffer, make_current())
+        .InSequence(render_seq);
+    EXPECT_CALL(renderer_factory.mock_renderer, begin())
+        .InSequence(render_seq);
+    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(big),_))
+        .InSequence(render_seq);
+    EXPECT_CALL(renderer_factory.mock_renderer, render(Ref(small),_))
+        .InSequence(render_seq);
+    EXPECT_CALL(renderer_factory.mock_renderer, end())
+        .InSequence(render_seq);
+    EXPECT_CALL(display_buffer, post_update())
+        .InSequence(render_seq);
+
+    FakeScene scene(renderable_vec);
+
+    auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
+    EXPECT_CALL(*compositor_buffer, can_bypass())
+        .Times(0);
+
+    mc::DefaultDisplayBufferCompositorFactory factory(
+        mt::fake_shared(scene),
+        mt::fake_shared(renderer_factory));
+
+    auto comp = factory.create_compositor_for(display_buffer);
+
+    comp->composite();
+}
+
 TEST(DefaultDisplayBufferCompositor, obscured_fullscreen_does_not_bypass)
 {
     using namespace testing;
 
=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2013-12-17 18:24:51 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2014-01-02 11:14:12 +0000
@@ -83,7 +83,7 @@
 {
     MOCK_CONST_METHOD1(for_each_card, void(std::function<void(mg::DisplayConfigurationCard const&)>));
     MOCK_CONST_METHOD1(for_each_output, void(std::function<void(mg::DisplayConfigurationOutput const&)>));
-    MOCK_METHOD5(configure_output, void(mg::DisplayConfigurationOutputId, bool, geom::Point, size_t, MirPowerMode));
+    MOCK_METHOD6(configure_output, void(mg::DisplayConfigurationOutputId, bool, geom::Point, size_t, MirPixelFormat, MirPowerMode));
 };
 
 }
@@ -555,6 +555,8 @@
     bool used0 = false, used1 = true;
     geom::Point pt0{44,22}, pt1{3,2};
     size_t mode_index0 = 1, mode_index1 = 3;
+    MirPixelFormat format0 = mir_pixel_format_invalid;
+    MirPixelFormat format1 = mir_pixel_format_argb_8888;
     mg::DisplayConfigurationOutputId id0{6}, id1{3};
 
     NiceMock<MockConfig> mock_display_config;
@@ -568,9 +570,9 @@
     EXPECT_CALL(*mock_display_selector, active_configuration())
         .InSequence(seq)
         .WillOnce(Return(mt::fake_shared(mock_display_config)));
-    EXPECT_CALL(mock_display_config, configure_output(id0, used0, pt0, mode_index0,  mir_power_mode_on))
+    EXPECT_CALL(mock_display_config, configure_output(id0, used0, pt0, mode_index0, format0, mir_power_mode_on))
         .InSequence(seq);
-    EXPECT_CALL(mock_display_config, configure_output(id1, used1, pt1, mode_index1, mir_power_mode_off))
+    EXPECT_CALL(mock_display_config, configure_output(id1, used1, pt1, mode_index1, format1, mir_power_mode_off))
         .InSequence(seq);
     EXPECT_CALL(*mock_display_selector, configure(_,_))
         .InSequence(seq);
@@ -593,6 +595,7 @@
     disp0->set_position_x(pt0.x.as_uint32_t());
     disp0->set_position_y(pt0.y.as_uint32_t());
     disp0->set_current_mode(mode_index0);
+    disp0->set_current_format(format0);
     disp0->set_power_mode(static_cast<uint32_t>(mir_power_mode_on));
 
     auto disp1 = configuration.add_display_output();
@@ -601,6 +604,7 @@
     disp1->set_position_x(pt1.x.as_uint32_t());
     disp1->set_position_y(pt1.y.as_uint32_t());
     disp1->set_current_mode(mode_index1);
+    disp1->set_current_format(format1);
     disp1->set_power_mode(static_cast<uint32_t>(mir_power_mode_off));
 
     session_mediator.configure_display(nullptr, &configuration,
 
=== modified file 'tests/unit-tests/graphics/CMakeLists.txt'
--- tests/unit-tests/graphics/CMakeLists.txt	2013-12-19 19:05:57 +0000
+++ tests/unit-tests/graphics/CMakeLists.txt	2014-01-02 11:14:12 +0000
@@ -6,6 +6,7 @@
     ${CMAKE_CURRENT_SOURCE_DIR}/test_default_display_configuration_policy.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_buffer_id.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_buffer_properties.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_pixel_format_utils.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_surfaceless_egl_context.cpp
 )
 
 
=== modified file 'tests/unit-tests/graphics/android/test_android_fb.cpp'
--- tests/unit-tests/graphics/android/test_android_fb.cpp	2013-12-17 18:24:51 +0000
+++ tests/unit-tests/graphics/android/test_android_fb.cpp	2014-01-02 11:14:12 +0000
@@ -256,28 +256,28 @@
     configuration->for_each_output([&](mg::DisplayConfigurationOutput const& output)
     {
         configuration->configure_output(
-            output.id, output.used, output.top_left, output.current_mode_index, mir_power_mode_on);
-    });
-    display.configure(*configuration);
-
-    configuration->for_each_output([&](mg::DisplayConfigurationOutput const& output)
-    {
-        configuration->configure_output(
-            output.id, output.used, output.top_left, output.current_mode_index, mir_power_mode_standby);
-    });
-    display.configure(*configuration);
-
-    configuration->for_each_output([&](mg::DisplayConfigurationOutput const& output)
-    {
-        configuration->configure_output(
-            output.id, output.used, output.top_left, output.current_mode_index, mir_power_mode_off);
-    });
-    display.configure(*configuration);
-
-    configuration->for_each_output([&](mg::DisplayConfigurationOutput const& output)
-    {
-        configuration->configure_output(
-            output.id, output.used, output.top_left, output.current_mode_index, mir_power_mode_suspend);
+            output.id, output.used, output.top_left, output.current_mode_index, output.current_format, mir_power_mode_on);
+    });
+    display.configure(*configuration);
+
+    configuration->for_each_output([&](mg::DisplayConfigurationOutput const& output)
+    {
+        configuration->configure_output(
+            output.id, output.used, output.top_left, output.current_mode_index, output.current_format, mir_power_mode_standby);
+    });
+    display.configure(*configuration);
+
+    configuration->for_each_output([&](mg::DisplayConfigurationOutput const& output)
+    {
+        configuration->configure_output(
+            output.id, output.used, output.top_left, output.current_mode_index, output.current_format, mir_power_mode_off);
+    });
+    display.configure(*configuration);
+
+    configuration->for_each_output([&](mg::DisplayConfigurationOutput const& output)
+    {
+        configuration->configure_output(
+            output.id, output.used, output.top_left, output.current_mode_index, output.current_format, mir_power_mode_suspend);
     });
     display.configure(*configuration);
 }
 
=== modified file 'tests/unit-tests/graphics/mesa/test_cursor.cpp'
--- tests/unit-tests/graphics/mesa/test_cursor.cpp	2013-12-17 18:24:51 +0000
+++ tests/unit-tests/graphics/mesa/test_cursor.cpp	2014-01-02 11:14:12 +0000
@@ -105,7 +105,7 @@
                 true,
                 geom::Point{0, 0},
                 1,
-                0,
+                mir_pixel_format_invalid,
                 mir_power_mode_on
             });
         outputs.push_back(
@@ -124,33 +124,33 @@
                 true,
                 geom::Point{100, 50},
                 0,
-                0,
+                mir_pixel_format_invalid,
                 mir_power_mode_on
             });
     }
 
-    void for_each_card(std::function<void(mg::DisplayConfigurationCard const&)> f) const
+    void for_each_card(std::function<void(mg::DisplayConfigurationCard const&)> f) const override
     {
         f({card_id, outputs.size()});
     }
 
-    void for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const
+    void for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const override
     {
         for (auto const& output : outputs)
             f(output);
     }
 
     void configure_output(mg::DisplayConfigurationOutputId, bool,
-                          geom::Point, size_t, MirPowerMode)
+                          geom::Point, size_t, MirPixelFormat, MirPowerMode) override
     {
     }
 
-    uint32_t get_kms_connector_id(mg::DisplayConfigurationOutputId id) const
+    uint32_t get_kms_connector_id(mg::DisplayConfigurationOutputId id) const override
     {
         return id.as_value();
     }
 
-    size_t get_kms_mode_index(mg::DisplayConfigurationOutputId, size_t conf_mode_index) const
+    size_t get_kms_mode_index(mg::DisplayConfigurationOutputId, size_t conf_mode_index) const override
     {
         return conf_mode_index;
     }
 
=== modified file 'tests/unit-tests/graphics/mesa/test_display_configuration.cpp'
--- tests/unit-tests/graphics/mesa/test_display_configuration.cpp	2013-12-17 18:24:51 +0000
+++ tests/unit-tests/graphics/mesa/test_display_configuration.cpp	2014-01-02 11:14:12 +0000
@@ -197,7 +197,7 @@
             true,
             geom::Point(),
             1,
-            0,
+            mir_pixel_format_invalid,
             mir_power_mode_on
         },
         {
@@ -212,7 +212,7 @@
             false,
             geom::Point(),
             std::numeric_limits<size_t>::max(),
-            std::numeric_limits<size_t>::max(),
+            mir_pixel_format_invalid,
             mir_power_mode_on
         },
         {
@@ -227,7 +227,7 @@
             false,
             geom::Point(),
             std::numeric_limits<size_t>::max(),
-            std::numeric_limits<size_t>::max(),
+            mir_pixel_format_invalid,
             mir_power_mode_on
         }
     };
@@ -381,7 +381,7 @@
             true,
             geom::Point(),
             1,
-            0,
+            mir_pixel_format_invalid,
             mir_power_mode_on
         },
         {
@@ -396,7 +396,7 @@
             false,
             geom::Point(),
             std::numeric_limits<size_t>::max(),
-            std::numeric_limits<size_t>::max(),
+            mir_pixel_format_invalid,
             mir_power_mode_on
         },
     };
@@ -415,7 +415,7 @@
             true,
             geom::Point(),
             std::numeric_limits<size_t>::max(),
-            std::numeric_limits<size_t>::max(),
+            mir_pixel_format_invalid,
             mir_power_mode_on
         },
         {
@@ -430,7 +430,7 @@
             false,
             geom::Point(),
             1,
-            0,
+            mir_pixel_format_invalid,
             mir_power_mode_on
         },
     };
 
=== modified file 'tests/unit-tests/graphics/mesa/test_display_multi_monitor.cpp'
--- tests/unit-tests/graphics/mesa/test_display_multi_monitor.cpp	2013-12-17 18:24:51 +0000
+++ tests/unit-tests/graphics/mesa/test_display_multi_monitor.cpp	2014-01-02 11:14:12 +0000
@@ -57,12 +57,16 @@
                 if (conf_output.connected && conf_output.modes.size() > 0)
                 {
                     conf.configure_output(conf_output.id, true, geom::Point{0, 0},
-                                          conf_output.preferred_mode_index, mir_power_mode_on);
+                                          conf_output.preferred_mode_index,
+                                          conf_output.current_format,
+                                          mir_power_mode_on);
                 }
                 else
                 {
                     conf.configure_output(conf_output.id, false, conf_output.top_left,
-                                          conf_output.current_mode_index, mir_power_mode_on);
+                                          conf_output.current_mode_index,
+                                          conf_output.current_format,
+                                          mir_power_mode_on);
                 }
             });
     }
@@ -81,13 +85,17 @@
                 if (conf_output.connected && conf_output.modes.size() > 0)
                 {
                     conf.configure_output(conf_output.id, true, geom::Point{max_x, 0},
-                                          conf_output.preferred_mode_index, mir_power_mode_on);
+                                          conf_output.preferred_mode_index,
+                                          conf_output.current_format,
+                                          mir_power_mode_on);
                     max_x += conf_output.modes[conf_output.preferred_mode_index].size.width.as_int();
                 }
                 else
                 {
                     conf.configure_output(conf_output.id, false, conf_output.top_left,
-                                          conf_output.current_mode_index, mir_power_mode_on);
+                                          conf_output.current_mode_index,
+                                          conf_output.current_format,
+                                          mir_power_mode_on);
                 }
             });
     }
@@ -472,7 +480,8 @@
         [&](mg::DisplayConfigurationOutput const& conf_output)
         {
             conf->configure_output(conf_output.id, false, conf_output.top_left,
-                                   conf_output.preferred_mode_index, mir_power_mode_on);
+                                   conf_output.preferred_mode_index, mir_pixel_format_xrgb_8888,
+                                   mir_power_mode_on);
         });
 
     display->configure(*conf);
@@ -508,7 +517,8 @@
         [&](mg::DisplayConfigurationOutput const& conf_output)
         {
             conf->configure_output(conf_output.id, false, conf_output.top_left,
-                                   conf_output.preferred_mode_index, mir_power_mode_on);
+                                   conf_output.preferred_mode_index, mir_pixel_format_xrgb_8888,
+                                   mir_power_mode_on);
         });
 
     display->configure(*conf);
 
=== modified file 'tests/unit-tests/graphics/mesa/test_overlapping_output_grouping.cpp'
--- tests/unit-tests/graphics/mesa/test_overlapping_output_grouping.cpp	2013-12-17 18:24:51 +0000
+++ tests/unit-tests/graphics/mesa/test_overlapping_output_grouping.cpp	2014-01-02 11:14:12 +0000
@@ -79,7 +79,7 @@
                 used,
                 rect.top_left,
                 i - 1,
-                0,
+                mir_pixel_format_invalid,
                 mir_power_mode_on
             };
 
@@ -89,7 +89,7 @@
     }
 
     void configure_output(mg::DisplayConfigurationOutputId, bool,
-                          geom::Point, size_t, MirPowerMode)
+                          geom::Point, size_t, MirPixelFormat, MirPowerMode)
     {
     }
 
 
=== modified file 'tests/unit-tests/graphics/nested/test_nested_display_configuration.cpp'
--- tests/unit-tests/graphics/nested/test_nested_display_configuration.cpp	2013-09-12 21:36:55 +0000
+++ tests/unit-tests/graphics/nested/test_nested_display_configuration.cpp	2014-01-02 11:14:12 +0000
@@ -36,7 +36,7 @@
 uint32_t const default_current_mode = 0;
 uint32_t const default_num_output_formats = 0;
 MirPixelFormat* const default_output_formats = nullptr;
-uint32_t const default_current_output_format = 0;
+MirPixelFormat const default_current_output_format = mir_pixel_format_abgr_8888;
 uint32_t const default_card_id = 1;
 uint32_t const second_card_id = 2;
 uint32_t const default_output_id = 0;
@@ -84,7 +84,7 @@
         output->current_mode = 0;
         output->num_output_formats = NoOfFormats;
         output->output_formats = format_tmp;
-        output->current_output_format = 0;
+        output->current_output_format = NoOfFormats > 0 ? formats[0] : mir_pixel_format_invalid;
     }
 
     template<int NoOfOutputs, int NoOfModes, int NoOfFormats>
@@ -257,7 +257,7 @@
     mgn::NestedDisplayConfiguration config(build_trivial_configuration());
 
     config.configure_output(mg::DisplayConfigurationOutputId(default_output_id), true,
-        top_left, default_current_mode, mir_power_mode_on);
+        top_left, default_current_mode, default_current_output_format, mir_power_mode_on);
 
     MockOutputVisitor ov;
     EXPECT_CALL(ov, f(_)).Times(Exactly(1));
@@ -268,6 +268,7 @@
             EXPECT_EQ(true, output.used);
             EXPECT_EQ(top_left, output.top_left);
             EXPECT_EQ(0, output.current_mode_index);
+            EXPECT_EQ(default_current_output_format, output.current_format);
         });
 }
 
@@ -278,11 +279,25 @@
     mgn::NestedDisplayConfiguration config(build_trivial_configuration());
 
     EXPECT_THROW(
-        {config.configure_output(mg::DisplayConfigurationOutputId(default_output_id), true, top_left, -1, mir_power_mode_on);},
-        std::runtime_error);
-
-    EXPECT_THROW(
-        {config.configure_output(mg::DisplayConfigurationOutputId(default_output_id), true, top_left, too_big_mode_index, mir_power_mode_on);},
+        {config.configure_output(mg::DisplayConfigurationOutputId(default_output_id), true, top_left, -1, default_current_output_format, mir_power_mode_on);},
+        std::runtime_error);
+
+    EXPECT_THROW(
+        {config.configure_output(mg::DisplayConfigurationOutputId(default_output_id), true, top_left, too_big_mode_index, default_current_output_format, mir_power_mode_on);},
+        std::runtime_error);
+}
+
+TEST_F(NestedDisplayConfiguration, configure_output_rejects_invalid_format)
+{
+    geom::Point const top_left{10,20};
+    mgn::NestedDisplayConfiguration config(build_trivial_configuration());
+
+    EXPECT_THROW(
+        {config.configure_output(mg::DisplayConfigurationOutputId(default_output_id), true, top_left, default_current_mode, mir_pixel_format_invalid, mir_power_mode_on);},
+        std::runtime_error);
+
+    EXPECT_THROW(
+        {config.configure_output(mg::DisplayConfigurationOutputId(default_output_id), true, top_left, default_current_mode, mir_pixel_formats, mir_power_mode_on);},
         std::runtime_error);
 }
 
@@ -292,11 +307,11 @@
     mgn::NestedDisplayConfiguration config(build_trivial_configuration());
 
     EXPECT_THROW(
-        {config.configure_output(mg::DisplayConfigurationOutputId(default_output_id+1), true, top_left, default_current_mode, mir_power_mode_on);},
+        {config.configure_output(mg::DisplayConfigurationOutputId(default_output_id+1), true, top_left, default_current_mode, default_current_output_format, mir_power_mode_on);},
         std::runtime_error);
 
     EXPECT_THROW(
-        {config.configure_output(mg::DisplayConfigurationOutputId(default_output_id-1), true, top_left, default_current_mode, mir_power_mode_on);},
+        {config.configure_output(mg::DisplayConfigurationOutputId(default_output_id-1), true, top_left, default_current_mode, default_current_output_format, mir_power_mode_on);},
         std::runtime_error);
 }
 
@@ -326,7 +341,7 @@
     geom::Point const top_left{100,200};
     mgn::NestedDisplayConfiguration config(build_non_trivial_configuration());
 
-    config.configure_output(id, true, top_left, 1, mir_power_mode_on);
+    config.configure_output(id, true, top_left, 1, mir_pixel_format_argb_8888, mir_power_mode_on);
 
     MockOutputVisitor ov;
     EXPECT_CALL(ov, f(_)).Times(Exactly(3));
@@ -338,6 +353,7 @@
                 EXPECT_EQ(true, output.used);
                 EXPECT_EQ(top_left, output.top_left);
                 EXPECT_EQ(1, output.current_mode_index);
+                EXPECT_EQ(mir_pixel_format_argb_8888, output.current_format);
             }
         });
 }
 
=== modified file 'tests/unit-tests/graphics/test_default_display_configuration_policy.cpp'
--- tests/unit-tests/graphics/test_default_display_configuration_policy.cpp	2013-12-17 18:24:51 +0000
+++ tests/unit-tests/graphics/test_default_display_configuration_policy.cpp	2014-01-02 11:14:12 +0000
@@ -22,149 +22,158 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
-namespace mg = mir::graphics;
-namespace geom = mir::geometry;
+using namespace mir::graphics;
+using namespace mir::geometry;
 
 namespace
 {
 
-class MockDisplayConfiguration : public mg::DisplayConfiguration
+class MockDisplayConfiguration : public DisplayConfiguration
 {
 public:
-    MockDisplayConfiguration(size_t max_simultaneous_outputs)
-        : card_id{1}, max_simultaneous_outputs{max_simultaneous_outputs}
+    MockDisplayConfiguration(MockDisplayConfiguration && m)
+        : max_simultaneous_outputs{m.max_simultaneous_outputs},
+        outputs{std::move(m.outputs)}
     {
-        /* Connected with modes */
-        outputs.push_back(
-            {
-                mg::DisplayConfigurationOutputId{10},
-                card_id,
-                mg::DisplayConfigurationOutputType::vga,
-                {
-                    mir_pixel_format_abgr_8888
-                },
-                {
-                    {geom::Size{123, 111}, 59.9},
-                    {geom::Size{123, 111}, 59.9},
-                    {geom::Size{123, 111}, 59.9}
-                },
-                2,
-                geom::Size{324, 642},
-                true,
-                false,
-                geom::Point{geom::X{123}, geom::Y{343}},
-                1,
-                0,
-                mir_power_mode_on
-            });
-        /* Connected without modes */
-        outputs.push_back(
-            {
-                mg::DisplayConfigurationOutputId{11},
-                card_id,
-                mg::DisplayConfigurationOutputType::vga,
-                {},
-                {},
-                std::numeric_limits<size_t>::max(),
-                geom::Size{566, 111},
-                true,
-                false,
-                geom::Point(),
-                std::numeric_limits<size_t>::max(),
-                std::numeric_limits<size_t>::max(),
-                mir_power_mode_on
-            });
-        /* Connected with a single mode */
-        outputs.push_back(
-            {
-                mg::DisplayConfigurationOutputId{12},
-                card_id,
-                mg::DisplayConfigurationOutputType::vga,
-                {
-                    mir_pixel_format_abgr_8888
-                },
-                {
-                    {geom::Size{523, 555}, 60.0},
-                },
-                0,
-                geom::Size{324, 642},
-                true,
-                false,
-                geom::Point(),
-                0,
-                0,
-                mir_power_mode_on
-            });
-        /* Not connected */
-        outputs.push_back(
-            {
-                mg::DisplayConfigurationOutputId{13},
-                card_id,
-                mg::DisplayConfigurationOutputType::vga,
-                {
-                    mir_pixel_format_abgr_8888
-                },
-                {},
-                0,
-                geom::Size{324, 642},
-                false,
-                false,
-                geom::Point(),
-                1,
-                0,
-                mir_power_mode_on
-            });
+    }
 
+    MockDisplayConfiguration(size_t max_simultaneous_outputs, std::vector<DisplayConfigurationOutput> && config)
+        : max_simultaneous_outputs{max_simultaneous_outputs},
+        outputs{config}
+    {
         if (max_simultaneous_outputs == max_simultaneous_outputs_all)
             max_simultaneous_outputs = outputs.size();
     }
 
-    MockDisplayConfiguration()
-        : MockDisplayConfiguration{max_simultaneous_outputs_all}
-    {
-    }
-
-    void for_each_card(std::function<void(mg::DisplayConfigurationCard const&)> f) const
-    {
-        f({card_id, max_simultaneous_outputs});
-    }
-
-    void for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const
+    MockDisplayConfiguration(std::vector<DisplayConfigurationOutput> && config)
+        : MockDisplayConfiguration(max_simultaneous_outputs_all, std::move(config))
+    {
+    }
+
+    void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const
+    {
+        f({DisplayConfigurationCardId{1}, max_simultaneous_outputs});
+    }
+
+    void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const
     {
         for (auto const& output : outputs)
             f(output);
     }
 
-    MOCK_METHOD5(configure_output, void(mg::DisplayConfigurationOutputId, bool,
-                                        geom::Point, size_t, MirPowerMode));
+    MOCK_METHOD6(configure_output, void(DisplayConfigurationOutputId, bool,
+                                        Point, size_t, MirPixelFormat, MirPowerMode));
 
+    static const size_t max_simultaneous_outputs_all{std::numeric_limits<size_t>::max()};
 private:
-    static const size_t max_simultaneous_outputs_all{std::numeric_limits<size_t>::max()};
-    mg::DisplayConfigurationCardId const card_id;
     size_t max_simultaneous_outputs;
-    std::vector<mg::DisplayConfigurationOutput> outputs;
+    std::vector<DisplayConfigurationOutput> outputs;
 };
 
 }
 
+DisplayConfigurationOutput default_output(DisplayConfigurationOutputId id)
+{
+    return { id, DisplayConfigurationCardId{1},
+        DisplayConfigurationOutputType::vga,
+        {mir_pixel_format_abgr_8888},
+        { {Size{523, 555}, 60.0} },
+        0,
+        Size{324, 642},
+        true,
+        false,
+        Point{X{123}, Y{343}},
+        0,
+        mir_pixel_format_abgr_8888,
+        mir_power_mode_on
+    };
+}
+
+DisplayConfigurationOutput connected_with_modes()
+{
+    DisplayConfigurationOutput output = default_output(DisplayConfigurationOutputId{10}) ;
+    output.modes =
+    {
+        {Size{123, 111}, 59.9},
+        {Size{123, 111}, 59.9},
+        {Size{123, 111}, 59.9}
+    };
+    output.preferred_mode_index = 2;
+    output.current_mode_index = 1;
+    return output;
+}
+DisplayConfigurationOutput connected_without_modes()
+{
+    DisplayConfigurationOutput output = default_output(DisplayConfigurationOutputId{11});
+    output.pixel_formats = {};
+    output.modes = {};
+    output.current_format = mir_pixel_format_invalid;
+    output.current_mode_index = std::numeric_limits<size_t>::max();
+    return output;
+}
+
+DisplayConfigurationOutput connected_with_single_mode()
+{
+    return default_output(DisplayConfigurationOutputId{12});
+}
+
+DisplayConfigurationOutput not_connected()
+{
+    DisplayConfigurationOutput output = default_output(DisplayConfigurationOutputId{13});
+    output.connected = false;
+    output.current_mode_index = 1;
+    return output;
+}
+
+DisplayConfigurationOutput connected_with_rgba_and_xrgb()
+{
+    DisplayConfigurationOutput output = default_output(DisplayConfigurationOutputId{14});
+    output.pixel_formats = {mir_pixel_format_argb_8888, mir_pixel_format_xrgb_8888};
+    return output;
+}
+
+DisplayConfigurationOutput connected_with_xrgb_bgr()
+{
+    DisplayConfigurationOutput output = default_output(DisplayConfigurationOutputId{15});
+    output.pixel_formats = {mir_pixel_format_xrgb_8888, mir_pixel_format_bgr_888};
+    output.current_format = mir_pixel_format_bgr_888;
+    return output;
+}
+
+MockDisplayConfiguration create_default_configuration(size_t max_outputs = MockDisplayConfiguration::max_simultaneous_outputs_all)
+{
+    return MockDisplayConfiguration
+    {
+        max_outputs,
+        {
+            connected_with_modes(),
+            connected_without_modes(),
+            connected_with_single_mode(),
+            not_connected(),
+        }
+    };
+}
+
 TEST(DefaultDisplayConfigurationPolicyTest, uses_all_connected_valid_outputs)
 {
     using namespace ::testing;
 
-    mg::DefaultDisplayConfigurationPolicy policy;
-    MockDisplayConfiguration conf;
+    DefaultDisplayConfigurationPolicy policy;
+    MockDisplayConfiguration conf{create_default_configuration()};
 
-    conf.for_each_output([&conf](mg::DisplayConfigurationOutput const& output)
+    conf.for_each_output([&conf](DisplayConfigurationOutput const& output)
     {
         if (output.connected && output.modes.size() > 0)
         {
-            EXPECT_CALL(conf, configure_output(output.id, true, geom::Point(),
-                                               output.preferred_mode_index, _));
+            EXPECT_CALL(conf, configure_output(output.id, true, Point(),
+                                               output.preferred_mode_index,
+                                               _, _));
         }
         else
         {
             EXPECT_CALL(conf, configure_output(output.id, false, output.top_left,
-                                               output.current_mode_index, _));
+                                               output.current_mode_index,
+                                               _, _));
         }
     });
 
@@ -175,12 +184,12 @@
 {
     using namespace ::testing;
 
-    mg::DefaultDisplayConfigurationPolicy policy;
-    MockDisplayConfiguration conf;
+    DefaultDisplayConfigurationPolicy policy;
+    MockDisplayConfiguration conf{create_default_configuration()};
 
-    conf.for_each_output([&conf](mg::DisplayConfigurationOutput const& output)
+    conf.for_each_output([&conf](DisplayConfigurationOutput const& output)
     {
-        EXPECT_CALL(conf, configure_output(output.id, _, _, _, mir_power_mode_on));
+        EXPECT_CALL(conf, configure_output(output.id, _, _, _, _, mir_power_mode_on));
     });
 
     policy.apply_to(conf);
@@ -191,20 +200,54 @@
     using namespace ::testing;
 
     size_t const max_simultaneous_outputs{1};
-    mg::DefaultDisplayConfigurationPolicy policy;
-    MockDisplayConfiguration conf{max_simultaneous_outputs};
+    DefaultDisplayConfigurationPolicy policy;
+    MockDisplayConfiguration conf{create_default_configuration(max_simultaneous_outputs)};
 
     size_t output_count{0};
-    conf.for_each_output([&output_count](mg::DisplayConfigurationOutput const&)
+    conf.for_each_output([&output_count](DisplayConfigurationOutput const&)
     {
         ++output_count;
     });
 
-    EXPECT_CALL(conf, configure_output(_, true, _, _, _))
+    EXPECT_CALL(conf, configure_output(_, true, _, _, _, _))
         .Times(AtMost(max_simultaneous_outputs));
 
-    EXPECT_CALL(conf, configure_output(_, false, _, _, _))
+    EXPECT_CALL(conf, configure_output(_, false, _, _, _, _))
         .Times(AtLeast(output_count - max_simultaneous_outputs));
 
     policy.apply_to(conf);
 }
+
+TEST(DefaultDisplayConfigurationPolicyTest, prefer_opaque_over_alpha)
+{
+    using namespace ::testing;
+
+    DefaultDisplayConfigurationPolicy policy;
+    MockDisplayConfiguration pick_xrgb{ { connected_with_rgba_and_xrgb() } };
+
+    EXPECT_CALL(pick_xrgb, configure_output(_, true, _, _, mir_pixel_format_xrgb_8888, _));
+    policy.apply_to(pick_xrgb);
+}
+
+TEST(DefaultDisplayConfigurationPolicyTest, preserve_opaque_selection)
+{
+    using namespace ::testing;
+
+    DefaultDisplayConfigurationPolicy policy;
+    MockDisplayConfiguration keep_bgr{ { connected_with_xrgb_bgr() } };
+
+    EXPECT_CALL(keep_bgr, configure_output(_, true, _, _, mir_pixel_format_bgr_888, _));
+    policy.apply_to(keep_bgr);
+}
+
+TEST(DefaultDisplayConfigurationPolicyTest, accept_transparency_when_only_option)
+{
+    using namespace ::testing;
+
+    DefaultDisplayConfigurationPolicy policy;
+    MockDisplayConfiguration pick_rgba{ { default_output(DisplayConfigurationOutputId{15}) } };
+
+    EXPECT_CALL(pick_rgba, configure_output(_, true, _, _, mir_pixel_format_abgr_8888, _));
+    policy.apply_to(pick_rgba);
+}
+
 
=== modified file 'tests/unit-tests/graphics/test_display_configuration.cpp'
--- tests/unit-tests/graphics/test_display_configuration.cpp	2013-12-17 18:24:51 +0000
+++ tests/unit-tests/graphics/test_display_configuration.cpp	2014-01-02 11:14:12 +0000
@@ -45,7 +45,7 @@
     true,
     geom::Point(),
     2,
-    0,
+    mir_pixel_format_abgr_8888,
     mir_power_mode_on
 };
 
 
=== added file 'tests/unit-tests/graphics/test_pixel_format_utils.cpp'
--- tests/unit-tests/graphics/test_pixel_format_utils.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/graphics/test_pixel_format_utils.cpp	2014-01-02 11:14:12 +0000
@@ -0,0 +1,90 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "mir_toolkit/common.h"
+#include "mir/graphics/pixel_format_utils.h"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using namespace mir::graphics;
+TEST(MirPixelFormatUtils, contains_alpha)
+{
+    EXPECT_FALSE(contains_alpha(mir_pixel_format_xbgr_8888));
+    EXPECT_FALSE(contains_alpha(mir_pixel_format_bgr_888));
+    EXPECT_FALSE(contains_alpha(mir_pixel_format_xrgb_8888));
+    EXPECT_FALSE(contains_alpha(mir_pixel_format_xbgr_8888));
+    EXPECT_TRUE(contains_alpha(mir_pixel_format_argb_8888));
+    EXPECT_TRUE(contains_alpha(mir_pixel_format_abgr_8888));
+    EXPECT_FALSE(contains_alpha(mir_pixel_format_invalid));
+} 
+
+TEST(MirPixelFormatUtils, red_channel_depths)
+{
+    EXPECT_EQ(8, red_channel_depth(mir_pixel_format_xbgr_8888));
+    EXPECT_EQ(8, red_channel_depth(mir_pixel_format_bgr_888));
+    EXPECT_EQ(8, red_channel_depth(mir_pixel_format_xrgb_8888));
+    EXPECT_EQ(8, red_channel_depth(mir_pixel_format_xbgr_8888));
+    EXPECT_EQ(8, red_channel_depth(mir_pixel_format_argb_8888));
+    EXPECT_EQ(8, red_channel_depth(mir_pixel_format_abgr_8888));
+    EXPECT_EQ(0, red_channel_depth(mir_pixel_format_invalid));
+}
+
+TEST(MirPixelFormatUtils, blue_channel_depths)
+{
+    EXPECT_EQ(8, blue_channel_depth(mir_pixel_format_xbgr_8888));
+    EXPECT_EQ(8, blue_channel_depth(mir_pixel_format_bgr_888));
+    EXPECT_EQ(8, blue_channel_depth(mir_pixel_format_xrgb_8888));
+    EXPECT_EQ(8, blue_channel_depth(mir_pixel_format_xbgr_8888));
+    EXPECT_EQ(8, blue_channel_depth(mir_pixel_format_argb_8888));
+    EXPECT_EQ(8, blue_channel_depth(mir_pixel_format_abgr_8888));
+    EXPECT_EQ(0, blue_channel_depth(mir_pixel_format_invalid));
+}
+
+TEST(MirPixelFormatUtils, green_channel_depths)
+{
+    EXPECT_EQ(8, green_channel_depth(mir_pixel_format_xbgr_8888));
+    EXPECT_EQ(8, green_channel_depth(mir_pixel_format_bgr_888));
+    EXPECT_EQ(8, green_channel_depth(mir_pixel_format_xrgb_8888));
+    EXPECT_EQ(8, green_channel_depth(mir_pixel_format_xbgr_8888));
+    EXPECT_EQ(8, green_channel_depth(mir_pixel_format_argb_8888));
+    EXPECT_EQ(8, green_channel_depth(mir_pixel_format_abgr_8888));
+    EXPECT_EQ(0, green_channel_depth(mir_pixel_format_invalid));
+}
+
+
+TEST(MirPixelFormatUtils, alpha_channel_depths)
+{
+    EXPECT_EQ(0, alpha_channel_depth(mir_pixel_format_xbgr_8888));
+    EXPECT_EQ(0, alpha_channel_depth(mir_pixel_format_bgr_888));
+    EXPECT_EQ(0, alpha_channel_depth(mir_pixel_format_xrgb_8888));
+    EXPECT_EQ(0, alpha_channel_depth(mir_pixel_format_xbgr_8888));
+    EXPECT_EQ(8, alpha_channel_depth(mir_pixel_format_argb_8888));
+    EXPECT_EQ(8, alpha_channel_depth(mir_pixel_format_abgr_8888));
+    EXPECT_EQ(0, alpha_channel_depth(mir_pixel_format_invalid));
+}
+
+TEST(MirPixelFormatUtils, valid_mir_pixel_format)
+{
+    EXPECT_TRUE(valid_mir_pixel_format(mir_pixel_format_xbgr_8888));
+    EXPECT_TRUE(valid_mir_pixel_format(mir_pixel_format_bgr_888));
+    EXPECT_TRUE(valid_mir_pixel_format(mir_pixel_format_xrgb_8888));
+    EXPECT_TRUE(valid_mir_pixel_format(mir_pixel_format_xbgr_8888));
+    EXPECT_TRUE(valid_mir_pixel_format(mir_pixel_format_argb_8888));
+    EXPECT_TRUE(valid_mir_pixel_format(mir_pixel_format_abgr_8888));
+    EXPECT_FALSE(valid_mir_pixel_format(mir_pixel_format_invalid));
+}