Home | History | Annotate | Download | only in gui 
      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 
     25 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 
     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 
     92 status_t ComposerState::write(Parcel& output) const {
     93     output.writeStrongBinder(IInterface::asBinder(client));
     94     return state.write(output);
     95 }
     96 
     97 status_t ComposerState::read(const Parcel& input) {
     98     client = interface_cast<ISurfaceComposerClient>(input.readStrongBinder());
     99     return state.read(input);
    100 }
    101 
    102 
    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 
    113 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 
    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 
    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 
    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