1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <utils/Errors.h>
18 #include <binder/Parcel.h>
19 #include <gui/ISurfaceComposerClient.h>
20 #include <gui/IGraphicBufferProducer.h>
21 #include <gui/LayerState.h>
22
23 namespace android {
24
write(Parcel & output) const25 status_t layer_state_t::write(Parcel& output) const
26 {
27 output.writeStrongBinder(surface);
28 output.writeUint32(what);
29 output.writeFloat(x);
30 output.writeFloat(y);
31 output.writeInt32(z);
32 output.writeUint32(w);
33 output.writeUint32(h);
34 output.writeUint32(layerStack);
35 output.writeFloat(alpha);
36 output.writeUint32(flags);
37 output.writeUint32(mask);
38 *reinterpret_cast<layer_state_t::matrix22_t *>(
39 output.writeInplace(sizeof(layer_state_t::matrix22_t))) = matrix;
40 output.write(crop);
41 output.write(finalCrop);
42 output.writeStrongBinder(barrierHandle);
43 output.writeStrongBinder(reparentHandle);
44 output.writeUint64(frameNumber);
45 output.writeInt32(overrideScalingMode);
46 output.writeStrongBinder(IInterface::asBinder(barrierGbp));
47 output.writeStrongBinder(relativeLayerHandle);
48 output.writeStrongBinder(parentHandleForChild);
49 output.writeFloat(color.r);
50 output.writeFloat(color.g);
51 output.writeFloat(color.b);
52 output.write(transparentRegion);
53 return NO_ERROR;
54 }
55
read(const Parcel & input)56 status_t layer_state_t::read(const Parcel& input)
57 {
58 surface = input.readStrongBinder();
59 what = input.readUint32();
60 x = input.readFloat();
61 y = input.readFloat();
62 z = input.readInt32();
63 w = input.readUint32();
64 h = input.readUint32();
65 layerStack = input.readUint32();
66 alpha = input.readFloat();
67 flags = static_cast<uint8_t>(input.readUint32());
68 mask = static_cast<uint8_t>(input.readUint32());
69 const void* matrix_data = input.readInplace(sizeof(layer_state_t::matrix22_t));
70 if (matrix_data) {
71 matrix = *reinterpret_cast<layer_state_t::matrix22_t const *>(matrix_data);
72 } else {
73 return BAD_VALUE;
74 }
75 input.read(crop);
76 input.read(finalCrop);
77 barrierHandle = input.readStrongBinder();
78 reparentHandle = input.readStrongBinder();
79 frameNumber = input.readUint64();
80 overrideScalingMode = input.readInt32();
81 barrierGbp =
82 interface_cast<IGraphicBufferProducer>(input.readStrongBinder());
83 relativeLayerHandle = input.readStrongBinder();
84 parentHandleForChild = input.readStrongBinder();
85 color.r = input.readFloat();
86 color.g = input.readFloat();
87 color.b = input.readFloat();
88 input.read(transparentRegion);
89 return NO_ERROR;
90 }
91
write(Parcel & output) const92 status_t ComposerState::write(Parcel& output) const {
93 output.writeStrongBinder(IInterface::asBinder(client));
94 return state.write(output);
95 }
96
read(const Parcel & input)97 status_t ComposerState::read(const Parcel& input) {
98 client = interface_cast<ISurfaceComposerClient>(input.readStrongBinder());
99 return state.read(input);
100 }
101
102
DisplayState()103 DisplayState::DisplayState() :
104 what(0),
105 layerStack(0),
106 orientation(eOrientationDefault),
107 viewport(Rect::EMPTY_RECT),
108 frame(Rect::EMPTY_RECT),
109 width(0),
110 height(0) {
111 }
112
write(Parcel & output) const113 status_t DisplayState::write(Parcel& output) const {
114 output.writeStrongBinder(token);
115 output.writeStrongBinder(IInterface::asBinder(surface));
116 output.writeUint32(what);
117 output.writeUint32(layerStack);
118 output.writeUint32(orientation);
119 output.write(viewport);
120 output.write(frame);
121 output.writeUint32(width);
122 output.writeUint32(height);
123 return NO_ERROR;
124 }
125
read(const Parcel & input)126 status_t DisplayState::read(const Parcel& input) {
127 token = input.readStrongBinder();
128 surface = interface_cast<IGraphicBufferProducer>(input.readStrongBinder());
129 what = input.readUint32();
130 layerStack = input.readUint32();
131 orientation = input.readUint32();
132 input.read(viewport);
133 input.read(frame);
134 width = input.readUint32();
135 height = input.readUint32();
136 return NO_ERROR;
137 }
138
merge(const DisplayState & other)139 void DisplayState::merge(const DisplayState& other) {
140 if (other.what & eSurfaceChanged) {
141 what |= eSurfaceChanged;
142 surface = other.surface;
143 }
144 if (other.what & eLayerStackChanged) {
145 what |= eLayerStackChanged;
146 layerStack = other.layerStack;
147 }
148 if (other.what & eDisplayProjectionChanged) {
149 what |= eDisplayProjectionChanged;
150 orientation = other.orientation;
151 viewport = other.viewport;
152 frame = other.frame;
153 }
154 if (other.what & eDisplaySizeChanged) {
155 what |= eDisplaySizeChanged;
156 width = other.width;
157 height = other.height;
158 }
159 }
160
merge(const layer_state_t & other)161 void layer_state_t::merge(const layer_state_t& other) {
162 if (other.what & ePositionChanged) {
163 what |= ePositionChanged;
164 x = other.x;
165 y = other.y;
166 }
167 if (other.what & eLayerChanged) {
168 what |= eLayerChanged;
169 z = other.z;
170 }
171 if (other.what & eSizeChanged) {
172 what |= eSizeChanged;
173 w = other.w;
174 h = other.h;
175 }
176 if (other.what & eAlphaChanged) {
177 what |= eAlphaChanged;
178 alpha = other.alpha;
179 }
180 if (other.what & eMatrixChanged) {
181 what |= eMatrixChanged;
182 matrix = other.matrix;
183 }
184 if (other.what & eTransparentRegionChanged) {
185 what |= eTransparentRegionChanged;
186 transparentRegion = other.transparentRegion;
187 }
188 if (other.what & eFlagsChanged) {
189 what |= eFlagsChanged;
190 flags = other.flags;
191 mask = other.mask;
192 }
193 if (other.what & eLayerStackChanged) {
194 what |= eLayerStackChanged;
195 layerStack = other.layerStack;
196 }
197 if (other.what & eCropChanged) {
198 what |= eCropChanged;
199 crop = other.crop;
200 }
201 if (other.what & eDeferTransaction) {
202 what |= eDeferTransaction;
203 barrierHandle = other.barrierHandle;
204 barrierGbp = other.barrierGbp;
205 frameNumber = other.frameNumber;
206 }
207 if (other.what & eFinalCropChanged) {
208 what |= eFinalCropChanged;
209 finalCrop = other.finalCrop;
210 }
211 if (other.what & eOverrideScalingModeChanged) {
212 what |= eOverrideScalingModeChanged;
213 overrideScalingMode = other.overrideScalingMode;
214 }
215 if (other.what & eGeometryAppliesWithResize) {
216 what |= eGeometryAppliesWithResize;
217 }
218 if (other.what & eReparentChildren) {
219 what |= eReparentChildren;
220 reparentHandle = other.reparentHandle;
221 }
222 if (other.what & eDetachChildren) {
223 what |= eDetachChildren;
224 }
225 if (other.what & eRelativeLayerChanged) {
226 what |= eRelativeLayerChanged;
227 z = other.z;
228 relativeLayerHandle = other.relativeLayerHandle;
229 }
230 if (other.what & eReparent) {
231 what |= eReparent;
232 parentHandleForChild = other.parentHandleForChild;
233 }
234 if (other.what & eDestroySurface) {
235 what |= eDestroySurface;
236 }
237 }
238
239 }; // namespace android
240