parcelable_composer_layer.cpp revision b42f171a5a76985fde2689d90fd6d2d7e4920564 
1#include "aidl/android/dvr/parcelable_composer_layer.h"
2
3#include <binder/Parcel.h>
4#include <ui/Fence.h>
5#include <ui/GraphicBuffer.h>
6#include <ui/GraphicBufferMapper.h>
7
8namespace android {
9namespace dvr {
10namespace {
11
12sp<GraphicBuffer> GetBufferFromHandle(native_handle_t* handle) {
13  uint32_t width = 0, height = 0, stride = 0, layer_count = 1;
14  uint64_t producer_usage = 0, consumer_usage = 0;
15  int32_t format = 0;
16
17  GraphicBufferMapper& mapper = GraphicBufferMapper::get();
18  // Need to register |handle| otherwise we can't read its properties.
19  if (mapper.registerBuffer(handle) != OK) {
20    ALOGE("Failed to register buffer");
21    return nullptr;
22  }
23
24  if (mapper.getDimensions(handle, &width, &height) ||
25      mapper.getStride(handle, &stride) ||
26      mapper.getFormat(handle, &format) ||
27      mapper.getProducerUsage(handle, &producer_usage) ||
28      mapper.getConsumerUsage(handle, &consumer_usage)) {
29    ALOGE("Failed to read handle properties");
30    return nullptr;
31  }
32
33  // This will only succeed if gralloc has GRALLOC1_CAPABILITY_LAYERED_BUFFERS
34  // capability. Otherwise assume a count of 1.
35  mapper.getLayerCount(handle, &layer_count);
36
37  sp<GraphicBuffer> buffer = new GraphicBuffer(handle,
38      GraphicBuffer::TAKE_HANDLE, width, height, format, layer_count,
39      producer_usage, consumer_usage, stride);
40
41  return buffer;
42}
43
44}  // namespace
45
46ParcelableComposerLayer::ParcelableComposerLayer() {}
47
48ParcelableComposerLayer::ParcelableComposerLayer(
49    const ComposerView::ComposerLayer& layer) : layer_(layer) {}
50
51ParcelableComposerLayer::~ParcelableComposerLayer() {}
52
53status_t ParcelableComposerLayer::writeToParcel(Parcel* parcel) const {
54  status_t ret = parcel->writeUint64(layer_.id);
55  if (ret != OK) return ret;
56
57  ret = parcel->writeNativeHandle(layer_.buffer->getNativeBuffer()->handle);
58  if (ret != OK) return ret;
59
60  ret = parcel->writeBool(layer_.fence->isValid());
61  if (ret != OK) return ret;
62
63  if (layer_.fence->isValid()) {
64    ret = parcel->writeFileDescriptor(layer_.fence->dup(), true);
65    if (ret != OK) return ret;
66  }
67
68  ret = parcel->writeInt32(layer_.display_frame.left);
69  if (ret != OK) return ret;
70
71  ret = parcel->writeInt32(layer_.display_frame.top);
72  if (ret != OK) return ret;
73
74  ret = parcel->writeInt32(layer_.display_frame.right);
75  if (ret != OK) return ret;
76
77  ret = parcel->writeInt32(layer_.display_frame.bottom);
78  if (ret != OK) return ret;
79
80  ret = parcel->writeFloat(layer_.crop.left);
81  if (ret != OK) return ret;
82
83  ret = parcel->writeFloat(layer_.crop.top);
84  if (ret != OK) return ret;
85
86  ret = parcel->writeFloat(layer_.crop.right);
87  if (ret != OK) return ret;
88
89  ret = parcel->writeFloat(layer_.crop.bottom);
90  if (ret != OK) return ret;
91
92  ret = parcel->writeInt32(static_cast<int32_t>(layer_.blend_mode));
93  if (ret != OK) return ret;
94
95  ret = parcel->writeFloat(layer_.alpha);
96  if (ret != OK) return ret;
97
98  ret = parcel->writeUint32(layer_.type);
99  if (ret != OK) return ret;
100
101  ret = parcel->writeUint32(layer_.app_id);
102  if (ret != OK) return ret;
103
104  return OK;
105}
106
107status_t ParcelableComposerLayer::readFromParcel(const Parcel* parcel) {
108  status_t ret = parcel->readUint64(&layer_.id);
109  if (ret != OK) return ret;
110
111  native_handle* handle = parcel->readNativeHandle();
112  if (!handle) return BAD_VALUE;
113
114  layer_.buffer = GetBufferFromHandle(handle);
115  if (!layer_.buffer.get()) return BAD_VALUE;
116
117  bool has_fence = 0;
118  ret = parcel->readBool(&has_fence);
119  if (ret != OK) return ret;
120
121  if (has_fence)
122    layer_.fence = new Fence(dup(parcel->readFileDescriptor()));
123  else
124    layer_.fence = new Fence();
125
126  ret = parcel->readInt32(&layer_.display_frame.left);
127  if (ret != OK) return ret;
128
129  ret = parcel->readInt32(&layer_.display_frame.top);
130  if (ret != OK) return ret;
131
132  ret = parcel->readInt32(&layer_.display_frame.right);
133  if (ret != OK) return ret;
134
135  ret = parcel->readInt32(&layer_.display_frame.bottom);
136  if (ret != OK) return ret;
137
138  ret = parcel->readFloat(&layer_.crop.left);
139  if (ret != OK) return ret;
140
141  ret = parcel->readFloat(&layer_.crop.top);
142  if (ret != OK) return ret;
143
144  ret = parcel->readFloat(&layer_.crop.right);
145  if (ret != OK) return ret;
146
147  ret = parcel->readFloat(&layer_.crop.bottom);
148  if (ret != OK) return ret;
149
150  ret = parcel->readInt32(reinterpret_cast<int32_t*>(&layer_.blend_mode));
151  if (ret != OK) return ret;
152
153  ret = parcel->readFloat(&layer_.alpha);
154  if (ret != OK) return ret;
155
156  ret = parcel->readUint32(&layer_.type);
157  if (ret != OK) return ret;
158
159  ret = parcel->readUint32(&layer_.app_id);
160  if (ret != OK) return ret;
161
162  return OK;
163}
164
165}  // namespace dvr
166}  // namespace android
167