← Back to branch summary

~robertcarr/mir/send-clients-input

« back to all changes in this revision

Viewing changes to src/client/gbm/gbm_client_buffer.cpp

  • Committer: Kevin DuBois
  • Date: 2012-11-13 01:36:29 UTC
  • mfrom: (245 trunk)
  • mto: This revision was merged to the branch mainline in revision 246.
  • Revision ID: kevin.dubois@canonical.com-20121113013629-q4496w4mp5e33auk
merge in base branch. move the demo clients to a new directory, examples/

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/client/gbm/gbm_client_buffer.cpp
18
18
 
19
19
#include "mir_client/mir_client_library.h"
20
20
#include "mir_client/gbm/gbm_client_buffer.h"
 
21
#include "mir_client/gbm/drm_fd_handler.h"
 
22
#include "mir/exception.h"
 
23
 
 
24
#include <stdexcept>
 
25
 
 
26
#include <xf86drm.h>
 
27
#include <string.h>
 
28
#include <errno.h>
 
29
#include <sys/mman.h>
21
30
 
22
31
namespace mcl=mir::client;
 
32
namespace mclg=mir::client::gbm;
23
33
namespace geom=mir::geometry;
24
34
 
25
 
mcl::GBMClientBuffer::GBMClientBuffer(
26
 
                        std::shared_ptr<MirBufferPackage> && package,
27
 
                        geom::Size size, geom::PixelFormat pf)
28
 
 : creation_package(std::move(package)),
29
 
   rect({{geom::X(0),geom::Y(0)}, size}),
30
 
   buffer_pf(pf)
31
 
{
32
 
}
33
 
 
34
 
std::shared_ptr<mcl::MemoryRegion> mcl::GBMClientBuffer::secure_for_cpu_write()
35
 
{
36
 
    return std::shared_ptr<mcl::MemoryRegion>();
37
 
}
38
 
 
39
 
geom::Size mcl::GBMClientBuffer::size() const
 
35
namespace
 
36
{
 
37
 
 
38
struct GEMHandle
 
39
{
 
40
    GEMHandle(std::shared_ptr<mclg::DRMFDHandler> const& drm_fd_handler,
 
41
              uint32_t gem_name)
 
42
        : drm_fd_handler{drm_fd_handler}
 
43
    {
 
44
        struct drm_gem_open gem_open;
 
45
        memset(&gem_open, 0, sizeof(gem_open));
 
46
        gem_open.name = gem_name;
 
47
 
 
48
        int ret = drm_fd_handler->ioctl(DRM_IOCTL_GEM_OPEN, &gem_open);
 
49
        if (ret)
 
50
        {
 
51
            std::string msg("Failed to open GEM handle for DRM buffer");
 
52
            BOOST_THROW_EXCEPTION(
 
53
                boost::enable_error_info(
 
54
                    std::runtime_error(msg)) << boost::errinfo_errno(errno));
 
55
        }
 
56
 
 
57
        handle = gem_open.handle;
 
58
    }
 
59
 
 
60
    ~GEMHandle()
 
61
    {
 
62
        static const uint32_t pad{0};
 
63
        struct drm_gem_close gem_close = {handle, pad};
 
64
        drm_fd_handler->ioctl(DRM_IOCTL_GEM_CLOSE, &gem_close);
 
65
    }
 
66
 
 
67
    std::shared_ptr<mclg::DRMFDHandler> const drm_fd_handler;
 
68
    uint32_t handle;
 
69
};
 
70
 
 
71
struct NullDeleter
 
72
{
 
73
    void operator()(char *) const {}
 
74
};
 
75
 
 
76
struct GBMMemoryRegion : mcl::MemoryRegion
 
77
{
 
78
    GBMMemoryRegion(std::shared_ptr<mclg::DRMFDHandler> const& drm_fd_handler,
 
79
                    uint32_t gem_name, geom::Size const& size_param,
 
80
                    geom::Stride stride_param, geom::PixelFormat format_param)
 
81
        : drm_fd_handler{drm_fd_handler},
 
82
          gem_handle{drm_fd_handler, gem_name},
 
83
          size_in_bytes{size_param.height.as_uint32_t() * stride_param.as_uint32_t()}
 
84
    {
 
85
        width = size_param.width;
 
86
        height = size_param.height;
 
87
        stride = stride_param;
 
88
        format = format_param;
 
89
 
 
90
        struct drm_mode_map_dumb map_dumb;
 
91
        memset(&map_dumb, 0, sizeof(map_dumb));
 
92
        map_dumb.handle = gem_handle.handle;
 
93
 
 
94
        int ret = drm_fd_handler->ioctl(DRM_IOCTL_MODE_MAP_DUMB, &map_dumb);
 
95
        if (ret)
 
96
        {
 
97
            std::string msg("Failed to map dumb DRM buffer");
 
98
            BOOST_THROW_EXCEPTION(
 
99
                boost::enable_error_info(
 
100
                    std::runtime_error(msg)) << boost::errinfo_errno(errno));
 
101
        }
 
102
 
 
103
        void* map = drm_fd_handler->map(size_in_bytes, map_dumb.offset);
 
104
        if (map == MAP_FAILED)
 
105
        {
 
106
            std::string msg("Failed to mmap DRM buffer");
 
107
            BOOST_THROW_EXCEPTION(
 
108
                boost::enable_error_info(
 
109
                    std::runtime_error(msg)) << boost::errinfo_errno(errno));
 
110
        }
 
111
 
 
112
        vaddr = std::shared_ptr<char>(static_cast<char*>(map), NullDeleter());
 
113
    }
 
114
 
 
115
    ~GBMMemoryRegion()
 
116
    {
 
117
        drm_fd_handler->unmap(vaddr.get(), size_in_bytes);
 
118
    }
 
119
 
 
120
    std::shared_ptr<mclg::DRMFDHandler> const drm_fd_handler;
 
121
    GEMHandle const gem_handle;
 
122
    size_t const size_in_bytes;
 
123
};
 
124
 
 
125
}
 
126
 
 
127
mclg::GBMClientBuffer::GBMClientBuffer(
 
128
        std::shared_ptr<mclg::DRMFDHandler> const& drm_fd_handler,
 
129
        std::shared_ptr<MirBufferPackage> && package,
 
130
        geom::Size size, geom::PixelFormat pf)
 
131
    : drm_fd_handler{drm_fd_handler},
 
132
      creation_package(std::move(package)),
 
133
      rect({{geom::X(0),geom::Y(0)}, size}),
 
134
      buffer_pf{pf}
 
135
{
 
136
}
 
137
 
 
138
std::shared_ptr<mcl::MemoryRegion> mclg::GBMClientBuffer::secure_for_cpu_write()
 
139
{
 
140
    const uint32_t gem_name = creation_package->data[0];
 
141
 
 
142
    return std::make_shared<GBMMemoryRegion>(drm_fd_handler,
 
143
                                             gem_name,
 
144
                                             size(),
 
145
                                             stride(),
 
146
                                             pixel_format());
 
147
}
 
148
 
 
149
geom::Size mclg::GBMClientBuffer::size() const
40
150
{
41
151
    return rect.size;
42
152
}
43
153
 
44
 
geom::Stride mcl::GBMClientBuffer::stride() const
 
154
geom::Stride mclg::GBMClientBuffer::stride() const
45
155
{
46
156
    return geom::Stride{creation_package->stride};
47
157
}
48
158
 
49
 
geom::PixelFormat mcl::GBMClientBuffer::pixel_format() const
 
159
geom::PixelFormat mclg::GBMClientBuffer::pixel_format() const
50
160
{
51
161
    return buffer_pf;
52
162
}
53
163
 
54
 
std::shared_ptr<MirBufferPackage> mcl::GBMClientBuffer::get_buffer_package() const
 
164
std::shared_ptr<MirBufferPackage> mclg::GBMClientBuffer::get_buffer_package() const
55
165
{
56
166
    return creation_package;
57
167
}
58
168
 
59
 
MirNativeBuffer mcl::GBMClientBuffer::get_native_handle()
 
169
MirNativeBuffer mclg::GBMClientBuffer::get_native_handle()
60
170
{
61
171
    return NULL;
62
172
}