Home | History | Annotate | Download | only in camera2 
      1 /*
      2  * Copyright (C) 2015 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 #ifndef ANDROID_HARDWARE_CAMERA2_OUTPUTCONFIGURATION_H
     18 #define ANDROID_HARDWARE_CAMERA2_OUTPUTCONFIGURATION_H
     19 
     20 #include <gui/IGraphicBufferProducer.h>
     21 #include <binder/Parcelable.h>
     22 
     23 namespace android {
     24 
     25 class Surface;
     26 
     27 namespace hardware {
     28 namespace camera2 {
     29 namespace params {
     30 
     31 class OutputConfiguration : public android::Parcelable {
     32 public:
     33 
     34     static const int INVALID_ROTATION;
     35     static const int INVALID_SET_ID;
     36     enum SurfaceType{
     37         SURFACE_TYPE_UNKNOWN = -1,
     38         SURFACE_TYPE_SURFACE_VIEW = 0,
     39         SURFACE_TYPE_SURFACE_TEXTURE = 1
     40     };
     41     const std::vector<sp<IGraphicBufferProducer>>& getGraphicBufferProducers() const;
     42     int                        getRotation() const;
     43     int                        getSurfaceSetID() const;
     44     int                        getSurfaceType() const;
     45     int                        getWidth() const;
     46     int                        getHeight() const;
     47     bool                       isDeferred() const;
     48     bool                       isShared() const;
     49     /**
     50      * Keep impl up-to-date with OutputConfiguration.java in frameworks/base
     51      */
     52     virtual status_t           writeToParcel(android::Parcel* parcel) const override;
     53 
     54     virtual status_t           readFromParcel(const android::Parcel* parcel) override;
     55 
     56     // getGraphicBufferProducer will be NULL
     57     // getRotation will be INVALID_ROTATION
     58     // getSurfaceSetID will be INVALID_SET_ID
     59     OutputConfiguration();
     60 
     61     // getGraphicBufferProducer will be NULL if error occurred
     62     // getRotation will be INVALID_ROTATION if error occurred
     63     // getSurfaceSetID will be INVALID_SET_ID if error occurred
     64     OutputConfiguration(const android::Parcel& parcel);
     65 
     66     OutputConfiguration(sp<IGraphicBufferProducer>& gbp, int rotation,
     67             int surfaceSetID = INVALID_SET_ID);
     68 
     69     bool operator == (const OutputConfiguration& other) const {
     70         return ( mRotation == other.mRotation &&
     71                 mSurfaceSetID == other.mSurfaceSetID &&
     72                 mSurfaceType == other.mSurfaceType &&
     73                 mWidth == other.mWidth &&
     74                 mHeight == other.mHeight &&
     75                 mIsDeferred == other.mIsDeferred &&
     76                 mIsShared == other.mIsShared &&
     77                 gbpsEqual(other));
     78     }
     79     bool operator != (const OutputConfiguration& other) const {
     80         return !(*this == other);
     81     }
     82     bool operator < (const OutputConfiguration& other) const {
     83         if (*this == other) return false;
     84         if (mSurfaceSetID != other.mSurfaceSetID) {
     85             return mSurfaceSetID < other.mSurfaceSetID;
     86         }
     87         if (mSurfaceType != other.mSurfaceType) {
     88             return mSurfaceType < other.mSurfaceType;
     89         }
     90         if (mWidth != other.mWidth) {
     91             return mWidth < other.mWidth;
     92         }
     93         if (mHeight != other.mHeight) {
     94             return mHeight < other.mHeight;
     95         }
     96         if (mRotation != other.mRotation) {
     97             return mRotation < other.mRotation;
     98         }
     99         if (mIsDeferred != other.mIsDeferred) {
    100             return mIsDeferred < other.mIsDeferred;
    101         }
    102         if (mIsShared != other.mIsShared) {
    103             return mIsShared < other.mIsShared;
    104         }
    105         return gbpsLessThan(other);
    106     }
    107     bool operator > (const OutputConfiguration& other) const {
    108         return (*this != other && !(*this < other));
    109     }
    110 
    111     bool gbpsEqual(const OutputConfiguration& other) const;
    112     bool gbpsLessThan(const OutputConfiguration& other) const;
    113 private:
    114     std::vector<sp<IGraphicBufferProducer>> mGbps;
    115     int                        mRotation;
    116     int                        mSurfaceSetID;
    117     int                        mSurfaceType;
    118     int                        mWidth;
    119     int                        mHeight;
    120     bool                       mIsDeferred;
    121     bool                       mIsShared;
    122     // helper function
    123     static String16 readMaybeEmptyString16(const android::Parcel* parcel);
    124 };
    125 } // namespace params
    126 } // namespace camera2
    127 } // namespace hardware
    128 
    129 
    130 using hardware::camera2::params::OutputConfiguration;
    131 
    132 }; // namespace android
    133 
    134 #endif
    135