We can show the boot screen, but we need a ton of cleanup

Author: mattkae

src/platform/graphics/cpu_buffers.cpp

@@ -192,7 +192,6 @@ auto mrs::alloc_buffer_with_content(
     MirPixelFormat src_format) -> std::shared_ptr<graphics::Buffer>
 {
     auto const buffer = allocator.alloc_software_buffer(size, src_format);
-
     auto mapping = as_write_mappable_buffer(buffer)->map_writeable();
     if (mapping->stride() == src_stride)
     {

src/platforms/common/server/shm_buffer.cpp

@@ -99,6 +99,7 @@ mgc::ShmBuffer::ShmBuffer(
       pixel_format_{format},
       egl_delegate{std::move(egl_delegate)}
 {
+    mir::log_info("Constructed A");
 }
 
 mgc::MemoryBackedShmBuffer::MemoryBackedShmBuffer(
@@ -109,6 +110,7 @@ mgc::MemoryBackedShmBuffer::MemoryBackedShmBuffer(
       stride_{MIR_BYTES_PER_PIXEL(pixel_format) * size.width.as_uint32_t()},
       pixels{new unsigned char[stride_.as_int() * size.height.as_int()]}
 {
+    mir::log_info("Constructed B");
 }
 
 mgc::ShmBuffer::~ShmBuffer() noexcept

src/platforms/gbm-kms/server/buffer_allocator.cpp

@@ -160,13 +160,15 @@ mgg::BufferAllocator::BufferAllocator(EGLDisplay dpy, EGLContext share_with)
 std::shared_ptr<mg::Buffer> mgg::BufferAllocator::alloc_software_buffer(
     geom::Size size, MirPixelFormat format)
 {
+    mir::log_info("Before format");
     if (!mgc::MemoryBackedShmBuffer::supports(format))
     {
         BOOST_THROW_EXCEPTION(
             std::runtime_error(
                 "Trying to create SHM buffer with unsupported pixel format"));
     }
 
+    mir::log_info("After format");
     return std::make_shared<mgc::MemoryBackedShmBuffer>(size, format, egl_delegate);
 }
 

src/platforms/gbm-kms/server/kms/display.cpp

@@ -313,7 +313,33 @@ auto mgg::Display::create_hardware_cursor() -> std::shared_ptr<graphics::Cursor>
 
 std::shared_ptr<mg::InitialRender> mgg::Display::create_initial_render()
 {
-    return nullptr;
+    class GbmKmsInitialRender : public mg::InitialRender
+    {
+    public:
+        void add_renderable(std::shared_ptr<Renderable> renderable)
+        {
+            if (renderable == nullptr)
+                return;
+
+            renderables.push_back(renderable);
+        }
+
+        auto get_renderables() const -> std::vector<std::shared_ptr<Renderable>> override
+        {
+            return renderables;
+        }
+
+    private:
+        std::vector<std::shared_ptr<Renderable>> renderables;
+    };
+
+    auto initial_render = std::make_shared<GbmKmsInitialRender>();
+    for (auto const& buffer : display_buffers)
+    {
+        initial_render->add_renderable(buffer->copy_to_buffer());
+    }
+
+    return initial_render;
 }
 
 void mgg::Display::clear_connected_unused_outputs()

src/platforms/gbm-kms/server/kms/display_buffer.cpp

@@ -72,7 +72,7 @@ struct SmoothTransitionRenderable : public mg::Renderable
     auto screen_position() const -> geom::Rectangle override
     {
         return {
-            {-size.width.as_int() / 2, -size.height.as_value() / 2},
+            {0, 0},
             {size.width.as_int(), size.height.as_int()}
         };
     }
@@ -110,7 +110,7 @@ mgg::DisplayBuffer::DisplayBuffer(
     std::vector<std::shared_ptr<KMSOutput>> const& outputs,
     geom::Rectangle const& area,
     glm::mat2 const& transformation,
-    std::shared_ptr<graphics::GraphicBufferAllocator> const& buffer_allocator,
+    std::shared_ptr<graphics::GraphicBufferAllocator> const& allocator,
     std::shared_ptr<input::Scene> const&,
     bool smooth_transition)
     : provider{std::move(provider)},
@@ -119,7 +119,9 @@ mgg::DisplayBuffer::DisplayBuffer(
       area(area),
       transform{transformation},
       needs_set_crtc{false},
-      page_flips_pending{false}
+      page_flips_pending{false},
+      allocator{allocator},
+      smooth_transition{smooth_transition}
 {
     listener->report_successful_setup_of_native_resources();
 
@@ -138,22 +140,6 @@ mgg::DisplayBuffer::DisplayBuffer(
             output->set_crtc(*visible_fb);
         }
     }
-    else
-    {
-        auto output = outputs[0];
-        auto mapping = output->map_content();
-
-        if (mapping)
-        {
-            auto pixel_format = mapping->get_pixel_format().as_mir_format();
-            auto buffer = mir::renderer::software::alloc_buffer_with_content(
-                *buffer_allocator,
-                reinterpret_cast<const unsigned char *>(mapping->get_data()),
-                mapping->get_size(),
-                mapping->get_stride(),
-                pixel_format.value());
-        }
-    }
 
     listener->report_successful_drm_mode_set_crtc_on_construction();
     listener->report_successful_display_construction();
@@ -391,9 +377,11 @@ void mir::graphics::gbm::DisplayBuffer::set_next_image(std::unique_ptr<Framebuff
     }
 }
 
-auto mgg::DisplayBuffer::copy_to_buffer(std::shared_ptr<graphics::common::EGLContextExecutor>& egl_delegate) const
-    -> std::unique_ptr<common::MemoryBackedShmBuffer>
+auto mgg::DisplayBuffer::copy_to_buffer() const -> std::unique_ptr<mg::Renderable>
 {
+    if (!smooth_transition)
+        return nullptr;
+
     if (outputs.empty())
     {
         mir::log_error("Unable to copy the contents of the buffer: No outputs available");
@@ -402,14 +390,21 @@ auto mgg::DisplayBuffer::copy_to_buffer(std::shared_ptr<graphics::common::EGLCon
 
     auto output = outputs[0];
     auto mapping = output->map_content();
+
     if (!mapping)
         return nullptr;
 
-    auto const pixel_format = mapping->get_pixel_format().as_mir_format();
-    auto buffer = new common::MemoryBackedShmBuffer(
-        mapping->get_size(),
-        pixel_format.value(),
-        egl_delegate);
-    (void)buffer;
-    return nullptr;
-}
+    auto pixel_format = mapping->get_pixel_format().as_mir_format();
+    auto data = mapping->get_data();
+    auto size = mapping->get_size();
+    auto stride = mapping->get_stride();
+    auto format = pixel_format.value();
+
+    auto buffer = mir::renderer::software::alloc_buffer_with_content(
+        *allocator,
+        data,
+        size,
+        stride,
+        format);
+    return std::make_unique<SmoothTransitionRenderable>(buffer, mapping->get_size());
+}

src/platforms/gbm-kms/server/kms/display_buffer.h

@@ -97,8 +97,7 @@ class DisplayBuffer : public graphics::DisplayBuffer,
     /// Creates a Buffer from the current contents of the first output.
     /// TODO: What do we do about the other outputs?
     /// \returns A buffer
-    auto copy_to_buffer(std::shared_ptr<graphics::common::EGLContextExecutor>&) const
-        -> std::unique_ptr<common::MemoryBackedShmBuffer>;
+    auto copy_to_buffer() const -> std::unique_ptr<graphics::Renderable>;
 private:
     bool schedule_page_flip(FBHandle const& bufobj);
     void set_crtc(FBHandle const&);
@@ -122,6 +121,8 @@ class DisplayBuffer : public graphics::DisplayBuffer,
     std::atomic<bool> needs_set_crtc;
     std::chrono::milliseconds recommend_sleep{0};
     bool page_flips_pending;
+    std::shared_ptr<graphics::GraphicBufferAllocator> const allocator;
+    bool smooth_transition;
 };
 
 }

src/platforms/gbm-kms/server/kms/kms_output.h

@@ -48,7 +48,7 @@ class KMSOutputContentMap
     virtual auto get_size() -> mir::geometry::Size const& = 0;
     virtual auto get_stride() -> mir::geometry::Stride const& = 0;
     virtual auto get_pixel_format() -> mir::graphics::DRMFormat const& = 0;
-    virtual auto get_data() -> const char* = 0;
+    virtual auto get_data() -> const unsigned char* = 0;
 };
 
 class KMSOutput

src/platforms/gbm-kms/server/kms/real_kms_output.cpp

@@ -46,7 +46,7 @@ class RealKMSOutputContentMap : public mgg::KMSOutputContentMap
         mir::geometry::Size size,
         mir::geometry::Stride stride,
         uint32_t pixel_format,
-        char* data)
+        unsigned char* data)
         : mapping_size{mapping_size},
           size{size},
           stride{stride},
@@ -76,7 +76,7 @@ class RealKMSOutputContentMap : public mgg::KMSOutputContentMap
         return pixel_format;
     }
 
-    virtual auto get_data() -> const char* override
+    virtual auto get_data() -> const unsigned char* override
     {
         return data;
     }
@@ -107,7 +107,7 @@ class RealKMSOutputContentMap : public mgg::KMSOutputContentMap
 
         // Establish a memory map.
         uint32_t size = height * stride;
-        auto map = static_cast<char *>(mmap(
+        auto map = static_cast<unsigned char *>(mmap(
             0,
             size,
             PROT_READ,
@@ -133,7 +133,7 @@ class RealKMSOutputContentMap : public mgg::KMSOutputContentMap
     mir::geometry::Size size;
     mir::geometry::Stride stride;
     mir::graphics::DRMFormat pixel_format;
-    char* data = nullptr;
+    unsigned char* data = nullptr;
 };
 }
 
@@ -732,6 +732,7 @@ std::shared_ptr<mgg::KMSOutputContentMap> mgg::RealKMSOutput::map_content() cons
         if (!map)
             continue;
 
+        mir::log_info("Got one!");
         return map;
     }
 

src/server/graphics/default_configuration.cpp

@@ -507,23 +507,16 @@ mir::DefaultServerConfiguration::the_initial_render(std::shared_ptr<mg::Display>
     return initial_render(
         [display = in_display, input_scene = the_input_scene()]
         {
-            class NoInitialRender : public mg::InitialRender
+            auto initial = display->create_initial_render();
+            if (initial)
             {
-                virtual auto get_renderables() const -> std::vector<std::shared_ptr<mg::Renderable>> override
+                for (auto const& renderable : initial->get_renderables())
                 {
-                    return {};
+                    input_scene->add_input_visualization(renderable);
                 }
-            };
-
-            auto initial = display->create_initial_render();
-            if (!initial)
-                initial = std::make_shared<NoInitialRender>();
-
-            for (auto const& renderable : initial->get_renderables())
-            {
-                input_scene->add_input_visualization(renderable);
             }
 
+
             return initial;
         });
 }