~alan-griffiths/mir/fix-1654023

#include "client_buffer.h"

#include "perf_report.h"

#include "logging/perf_report.h"

void null_callback(MirSurface*, void*) {}

mp::DisplayServer::Stub null_server{nullptr};

 

    : server{null_server},

      connection{nullptr}

    mp::DisplayServer::Stub & server,

    std::shared_ptr<mcl::ClientBufferFactory> const& factory,

    std::shared_ptr<mircv::InputPlatform> const& input_platform,

    MirSurfaceParameters const & params,

    mir_surface_callback callback, void * context)

    : MirSurface(allocating_connection,

                 server,

                 nullptr,

                 factory,

                 input_platform,

                 params,

                 callback, context)

{

}

 

 

MirSurface::MirSurface(

    MirConnection *allocating_connection,

    mp::DisplayServer::Stub & server,

    std::shared_ptr<mcl::ClientBufferFactory> const& factory,

    MirSurfaceParameters const & params,

    : server(server),

      buffer_depository(std::make_shared<mcl::ClientBufferDepository>(factory, mir::frontend::client_buffer_cache_size)),

    const char* report_target = getenv("MIR_CLIENT_PERF_REPORT");

    if (report_target && !strcmp(report_target, "log"))

    {

        auto& logger = connection->the_logger();

        perf_report = std::make_shared<mir::client::logging::PerfReport>(logger);

    }

    else

    {

        perf_report = std::make_shared<mir::client::NullPerfReport>();

    }

    perf_report->name_surface(params.name);

 

    mir::protobuf::SurfaceParameters message;

    message.set_surface_name(params.name ? params.name : std::string());

    message.set_width(params.width);

    message.set_height(params.height);

    message.set_pixel_format(params.pixel_format);

    message.set_buffer_usage(params.buffer_usage);

    message.set_output_id(params.output_id);

 

    server.create_surface(0, &message, &surface, gp::NewCallback(this, &MirSurface::created, callback, context));

 

    release_cpu_region();

    return MirSurfaceParameters {

        0,

        surface.width(),

        surface.height(),

        static_cast<MirPixelFormat>(surface.pixel_format()),

        static_cast<MirBufferUsage>(surface.buffer_usage()),

        mir_display_output_id_invalid};

void MirSurface::get_cpu_region(MirGraphicsRegion& region_out)

{

    std::lock_guard<decltype(mutex)> lock(mutex);

 

    auto buffer = buffer_depository->current_buffer();

 

    secured_region = buffer->secure_for_cpu_write();

    region_out.width = secured_region->width.as_uint32_t();

    region_out.height = secured_region->height.as_uint32_t();

    region_out.stride = secured_region->stride.as_uint32_t();

    region_out.pixel_format = secured_region->format;

    region_out.vaddr = secured_region->vaddr.get();

}

 

void MirSurface::release_cpu_region()

{

    secured_region.reset();

}

 

MirWaitHandle* MirSurface::next_buffer(mir_surface_callback callback, void * context)

{

    std::unique_lock<decltype(mutex)> lock(mutex);

    release_cpu_region();

 

    //TODO: we have extract the per-message information from the buffer

    *buffer_request.mutable_id() = surface.id();

    buffer_request.mutable_buffer()->set_buffer_id(surface.buffer().buffer_id());

    perf_report->end_frame(surface.buffer().buffer_id());

    lock.unlock();

 

    next_buffer_wait_handle.expect_result();

    server.exchange_buffer(

        0,

        &buffer_request,

        surface.mutable_buffer(),

        google::protobuf::NewCallback(this, &MirSurface::new_buffer, callback, context));

 

    return &next_buffer_wait_handle;

}

 

MirPixelFormat MirSurface::convert_ipc_pf_to_geometry(gp::int32 pf)

void MirSurface::process_incoming_buffer()

{

    auto const& buffer = surface.buffer();

 

    /*

     * On most frames when the properties aren't changing, the server won't

     * fill in the width and height. I think this is an intentional

     * protocol optimization ("need_full_ipc").

     */

    if (buffer.has_width() && buffer.has_height())

    {

        surface.set_width(buffer.width());

        surface.set_height(buffer.height());

    }

 

    auto surface_size = geom::Size{surface.width(), surface.height()};

    auto surface_pf = convert_ipc_pf_to_geometry(surface.pixel_format());

 

    auto ipc_package = std::make_shared<MirBufferPackage>();

    populate(*ipc_package);

 

    try

    {

        buffer_depository->deposit_package(std::move(ipc_package),

                                           buffer.buffer_id(),

                                           surface_size, surface_pf);

        perf_report->begin_frame(buffer.buffer_id());

    }

    catch (const std::runtime_error& err)

    {

        // TODO: Report the error

    }

}

 

    auto platform = connection->get_client_platform();

            process_incoming_buffer();

            accelerated_window = platform->create_egl_native_window(this);

void MirSurface::new_buffer(mir_surface_callback callback, void * context)

{

    {

        std::lock_guard<decltype(mutex)> lock(mutex);

        process_incoming_buffer();

    }

 

    callback(this, context);

    next_buffer_wait_handle.result_received();

}

 

    if (connection)

MirNativeBuffer* MirSurface::get_current_buffer_package()

{

    auto platform = connection->get_client_platform();

    auto buffer = get_current_buffer();

    auto handle = buffer->native_buffer_handle();

    return platform->convert_native_buffer(handle.get());

}

 

std::shared_ptr<mcl::ClientBuffer> MirSurface::get_current_buffer()

{

    std::lock_guard<decltype(mutex)> lock(mutex);

 

    return buffer_depository->current_buffer();

}

 

uint32_t MirSurface::get_current_buffer_id() const

{

    std::lock_guard<decltype(mutex)> lock(mutex);

 

    return buffer_depository->current_buffer_id();

}

 

void MirSurface::populate(MirBufferPackage& buffer_package)

{

    if (!surface.has_error() && surface.has_buffer())

    {

        auto const& buffer = surface.buffer();

 

        buffer_package.data_items = buffer.data_size();

        for (int i = 0; i != buffer.data_size(); ++i)

        {

            buffer_package.data[i] = buffer.data(i);

        }

 

        buffer_package.fd_items = buffer.fd_size();

 

        for (int i = 0; i != buffer.fd_size(); ++i)

        {

            buffer_package.fd[i] = buffer.fd(i);

        }

 

        buffer_package.stride = buffer.stride();

        buffer_package.flags = buffer.flags();

        buffer_package.width = buffer.width();

        buffer_package.height = buffer.height();

    }

    else

    {

        buffer_package.data_items = 0;

        buffer_package.fd_items = 0;

        buffer_package.stride = 0;

    }

}

 

EGLNativeWindowType MirSurface::generate_native_window()

{

    std::lock_guard<decltype(mutex)> lock(mutex);

 

    return *accelerated_window;

}

 

    server.configure_cursor(0, &setting, &void_response,

    server.configure_surface(0, &setting, &configure_result,

        case mir_surface_attrib_swapinterval:

    switch (e.type)

        MirSurfaceAttrib a = e.surface.attrib;

            attrib_cache[a] = e.surface.value;

        orientation = e.orientation.direction;

 

MirPlatformType MirSurface::platform_type()

{

    std::lock_guard<decltype(mutex)> lock(mutex);

 

    auto platform = connection->get_client_platform();

    return platform->platform_type();

}

 

void MirSurface::request_and_wait_for_next_buffer()

{

    next_buffer(null_callback, nullptr)->wait_for_all();

}