← Back to branch summary

~ubuntu-branches/ubuntu/utopic/mir/utopic-proposed

« back to all changes in this revision

Viewing changes to src/platform/graphics/android/hwc_layers.cpp

  • Committer: Package Import Robot
  • Author(s): Ubuntu daily release
  • Date: 2014-03-10 19:28:46 UTC
  • mto: This revision was merged to the branch mainline in revision 63.
  • Revision ID: package-import@ubuntu.com-20140310192846-rq9qm3ec26yrelo2
Tags: upstream-0.1.6+14.04.20140310
Import upstream version 0.1.6+14.04.20140310

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/platform/graphics/android/hwc_layers.cpp
22
22
#include "mir/graphics/android/native_buffer.h"
23
23
#include "hwc_layerlist.h"
24
24
 
 
25
#include <boost/throw_exception.hpp>
 
26
#include <stdexcept>
25
27
#include <cstring>
26
28
 
27
29
namespace mg=mir::graphics;
28
30
namespace mga=mir::graphics::android;
29
31
namespace geom=mir::geometry;
30
32
 
31
 
mga::HWCLayer& mga::HWCLayer::operator=(HWCLayer const& layer)
 
33
mga::HWCLayer& mga::HWCLayer::operator=(HWCLayer && other)
32
34
{
33
 
    memcpy(static_cast<void*>(this),
34
 
           static_cast<void const*>(&layer),
35
 
           sizeof(HWCLayer));
36
 
    this->visibleRegionScreen = {1, &this->visible_rect};
 
35
    hwc_layer = other.hwc_layer;
 
36
    hwc_list = std::move(other.hwc_list);
 
37
    visible_rect = std::move(other.visible_rect);
37
38
    return *this;
38
39
}
39
40
 
40
 
mga::HWCLayer::HWCLayer(HWCLayer const& layer)
41
 
{
42
 
    memcpy(static_cast<void*>(this),
43
 
           static_cast<void const*>(&layer),
44
 
           sizeof(HWCLayer));
45
 
    this->visibleRegionScreen = {1, &this->visible_rect};
 
41
mga::HWCLayer::HWCLayer(HWCLayer && other)
 
42
    : hwc_layer(std::move(other.hwc_layer)),
 
43
      hwc_list(std::move(other.hwc_list)),
 
44
      visible_rect(std::move(other.visible_rect))
 
45
{
 
46
}
 
47
 
 
48
mga::HWCLayer::HWCLayer(std::shared_ptr<hwc_display_contents_1_t> list, size_t layer_index)
 
49
    : hwc_layer(&list->hwLayers[layer_index]),
 
50
      hwc_list(list)
 
51
{
 
52
    memset(hwc_layer, 0, sizeof(hwc_layer_1_t));
 
53
    memset(&visible_rect, 0, sizeof(hwc_rect_t));
 
54
 
 
55
    hwc_layer->hints = 0;
 
56
    hwc_layer->transform = 0;
 
57
    hwc_layer->acquireFenceFd = -1;
 
58
    hwc_layer->releaseFenceFd = -1;
 
59
    hwc_layer->blending = HWC_BLENDING_NONE;
 
60
 
 
61
    hwc_layer->visibleRegionScreen.numRects=1;
 
62
    hwc_layer->visibleRegionScreen.rects= &visible_rect;
46
63
}
47
64
 
48
65
mga::HWCLayer::HWCLayer(
49
 
        int type,
50
 
        buffer_handle_t buffer_handle,
51
 
        geom::Rectangle position,
52
 
        geom::Size buffer_size,
53
 
        bool skip, bool alpha)
54
 
{
55
 
    (skip) ? flags = HWC_SKIP_LAYER : flags = 0;
56
 
    (alpha) ? blending = HWC_BLENDING_COVERAGE : blending = HWC_BLENDING_NONE;
57
 
    compositionType = type;
58
 
    hints = 0;
59
 
    transform = 0;
60
 
    //TODO: acquireFenceFd should be buffer.fence()
61
 
    acquireFenceFd = -1;
62
 
    releaseFenceFd = -1;
63
 
 
64
 
    sourceCrop = 
 
66
    LayerType type,
 
67
    geometry::Rectangle position,
 
68
    bool alpha_enabled,
 
69
    std::shared_ptr<hwc_display_contents_1_t> list,
 
70
    size_t layer_index)
 
71
     : HWCLayer(list, layer_index)
 
72
{
 
73
    set_layer_type(type);
 
74
    set_render_parameters(position, alpha_enabled);
 
75
}
 
76
 
 
77
bool mga::HWCLayer::needs_gl_render() const
 
78
{
 
79
    return ((hwc_layer->compositionType == HWC_FRAMEBUFFER) || (hwc_layer->flags == HWC_SKIP_LAYER));
 
80
}
 
81
 
 
82
mga::NativeFence mga::HWCLayer::release_fence() const
 
83
{
 
84
    return hwc_layer->releaseFenceFd;
 
85
}
 
86
 
 
87
void mga::HWCLayer::set_layer_type(LayerType type)
 
88
{
 
89
    hwc_layer->flags = 0;
 
90
    switch(type)
65
91
    {
66
 
        0, 0,
67
 
        buffer_size.width.as_int(),
68
 
        buffer_size.height.as_int()
69
 
    };
70
 
 
 
92
        case mga::LayerType::skip:
 
93
            hwc_layer->compositionType = HWC_FRAMEBUFFER;
 
94
            hwc_layer->flags = HWC_SKIP_LAYER;
 
95
        break;
 
96
 
 
97
        case mga::LayerType::gl_rendered:
 
98
            hwc_layer->compositionType = HWC_FRAMEBUFFER;
 
99
        break;
 
100
 
 
101
        case mga::LayerType::framebuffer_target:
 
102
            hwc_layer->compositionType = HWC_FRAMEBUFFER_TARGET;
 
103
        break;
 
104
 
 
105
        case mga::LayerType::overlay: //driver is the only one who can set to overlay
 
106
        default:
 
107
            BOOST_THROW_EXCEPTION(std::logic_error("invalid layer type"));
 
108
    }
 
109
}
 
110
 
 
111
void mga::HWCLayer::set_render_parameters(geometry::Rectangle position, bool alpha_enabled)
 
112
{
 
113
    if (alpha_enabled)
 
114
        hwc_layer->blending = HWC_BLENDING_COVERAGE;
 
115
    else
 
116
        hwc_layer->blending = HWC_BLENDING_NONE;
71
117
 
72
118
    /* note, if the sourceCrop and DisplayFrame sizes differ, the output will be linearly scaled */
73
 
    displayFrame = 
 
119
    hwc_layer->displayFrame = 
74
120
    {
75
121
        position.top_left.x.as_int(),
76
122
        position.top_left.y.as_int(),
78
124
        position.size.height.as_int()
79
125
    };
80
126
 
81
 
    visible_rect = displayFrame;
82
 
    visibleRegionScreen.numRects=1;
83
 
    visibleRegionScreen.rects= &visible_rect;
84
 
 
85
 
    handle = buffer_handle;
86
 
    memset(&reserved, 0, sizeof(reserved));
87
 
}
88
 
 
89
 
bool mga::HWCLayer::needs_gl_render() const
90
 
{
91
 
    return ((compositionType == HWC_FRAMEBUFFER) || (flags == HWC_SKIP_LAYER));
92
 
}
93
 
 
94
 
mga::FramebufferLayer::FramebufferLayer()
95
 
    : HWCLayer(HWC_FRAMEBUFFER_TARGET,
96
 
               nullptr,
97
 
               geom::Rectangle{{0,0}, {0,0}},
98
 
               geom::Size{0,0},
99
 
               false,
100
 
               false)
101
 
{
102
 
}
103
 
 
104
 
mga::FramebufferLayer::FramebufferLayer(mg::NativeBuffer const& buffer)
105
 
    : HWCLayer(HWC_FRAMEBUFFER_TARGET,
106
 
               buffer.handle(),
107
 
               geom::Rectangle{{0,0}, {buffer.anwb()->width, buffer.anwb()->height}},
108
 
               geom::Size{buffer.anwb()->width, buffer.anwb()->height},
109
 
               false,
110
 
               false)
111
 
{
112
 
}
113
 
 
114
 
mga::ForceGLLayer::ForceGLLayer()
115
 
    : HWCLayer(HWC_FRAMEBUFFER,
116
 
               nullptr,
117
 
               geom::Rectangle{{0,0}, {0,0}},
118
 
               geom::Size{0,0},
119
 
               true,
120
 
               false)
121
 
{
122
 
}
123
 
 
124
 
mga::ForceGLLayer::ForceGLLayer(mg::NativeBuffer const& buffer)
125
 
    : HWCLayer(HWC_FRAMEBUFFER,
126
 
               buffer.handle(),
127
 
               geom::Rectangle{{0,0}, {buffer.anwb()->width, buffer.anwb()->height}},
128
 
               geom::Size{buffer.anwb()->width, buffer.anwb()->height},
129
 
               true,
130
 
               false)
131
 
{
132
 
}
133
 
 
134
 
mga::CompositionLayer::CompositionLayer(mg::Renderable const& renderable)
135
 
    : HWCLayer(HWC_FRAMEBUFFER,
136
 
               renderable.buffer()->native_buffer_handle()->handle(),
137
 
               renderable.screen_position(),
138
 
               renderable.buffer()->size(),
139
 
               false,
140
 
               renderable.alpha_enabled())
141
 
{
 
127
    visible_rect = hwc_layer->displayFrame;
 
128
}
 
129
 
 
130
void mga::HWCLayer::set_buffer(Buffer const& buffer)
 
131
{
 
132
    auto size = buffer.size();
 
133
    auto native_buffer = buffer.native_buffer_handle();
 
134
    hwc_layer->handle = native_buffer->handle();
 
135
    if (!needs_gl_render())
 
136
        hwc_layer->acquireFenceFd = native_buffer->copy_fence();
 
137
    hwc_layer->releaseFenceFd = -1;
 
138
    hwc_layer->sourceCrop = 
 
139
    {
 
140
        0, 0,
 
141
        size.width.as_int(),
 
142
        size.height.as_int()
 
143
    };
142
144
}