• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  /*
2   * Copyright (C) 2010 The Android Open Source Project
3   * Copyright (C) 2012-2014, The Linux Foundation. All rights reserved.
4   *
5   * Not a Contribution, Apache license notifications and license are retained
6   * for attribution purposes only.
7   *
8   * Licensed under the Apache License, Version 2.0 (the "License");
9   * you may not use this file except in compliance with the License.
10   * You may obtain a copy of the License at
11   *
12   *      http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing, software
15   * distributed under the License is distributed on an "AS IS" BASIS,
16   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17   * See the License for the specific language governing permissions and
18   * limitations under the License.
19   */
20  #ifndef HWC_COPYBIT_H
21  #define HWC_COPYBIT_H
22  #include "hwc_utils.h"
23  
24  #define NUM_RENDER_BUFFERS 3
25  //These scaling factors are specific for MDP3. Normally scaling factor
26  //is only 4, but copybit will create temp buffer to let it run through
27  //twice
28  #define MAX_SCALE_FACTOR 16
29  #define MIN_SCALE_FACTOR 0.0625
30  #define MAX_LAYERS_FOR_ABC 2
31  namespace qhwc {
32  
33  class CopyBit {
34  public:
35      CopyBit(hwc_context_t *ctx, const int& dpy);
36      ~CopyBit();
37      // API to get copybit engine(non static)
38      struct copybit_device_t *getCopyBitDevice();
39      //Sets up members and prepares copybit if conditions are met
40      bool prepare(hwc_context_t *ctx, hwc_display_contents_1_t *list,
41                                                                     int dpy);
42      //Draws layer if the layer is set for copybit in prepare
43      bool draw(hwc_context_t *ctx, hwc_display_contents_1_t *list,
44                                                          int dpy, int* fd);
45      // resets the values
46      void reset();
47  
48      private_handle_t * getCurrentRenderBuffer();
49  
50      void setReleaseFd(int fd);
51  
52      void setReleaseFdSync(int fd);
53  
54      bool prepareOverlap(hwc_context_t *ctx, hwc_display_contents_1_t *list);
55  
56      int drawOverlap(hwc_context_t *ctx, hwc_display_contents_1_t *list);
57  
58  private:
59      /* cached data */
60      struct LayerCache {
61        int layerCount;
62        buffer_handle_t hnd[MAX_NUM_APP_LAYERS];
63        /* c'tor */
64        LayerCache();
65        /* clear caching info*/
66        void reset();
67        void updateCounts(hwc_context_t *ctx, hwc_display_contents_1_t *list,
68                int dpy);
69      };
70      /* framebuffer cache*/
71      struct FbCache {
72        hwc_rect_t  FbdirtyRect[NUM_RENDER_BUFFERS];
73        int FbIndex;
74        FbCache();
75        void reset();
76        void insertAndUpdateFbCache(hwc_rect_t dirtyRect);
77        int getUnchangedFbDRCount(hwc_rect_t dirtyRect);
78      };
79  
80      // holds the copybit device
81      struct copybit_device_t *mEngine;
82      bool drawUsingAppBufferComposition(hwc_context_t *ctx,
83                                  hwc_display_contents_1_t *list,
84                                  int dpy, int *fd);
85      // Helper functions for copybit composition
86      int  drawLayerUsingCopybit(hwc_context_t *dev, hwc_layer_1_t *layer,
87                            private_handle_t *renderBuffer, bool isFG);
88      // Helper function to draw copybit layer for PTOR comp
89      int drawRectUsingCopybit(hwc_context_t *dev, hwc_layer_1_t *layer,
90                            private_handle_t *renderBuffer, hwc_rect_t overlap,
91                            hwc_rect_t destRect);
92      int fillColorUsingCopybit(hwc_layer_1_t *layer,
93                            private_handle_t *renderBuffer);
94      bool canUseCopybitForYUV (hwc_context_t *ctx);
95      bool canUseCopybitForRGB (hwc_context_t *ctx,
96                                       hwc_display_contents_1_t *list, int dpy);
97      bool validateParams (hwc_context_t *ctx,
98                                  const hwc_display_contents_1_t *list);
99      //Flags if this feature is on.
100      bool mIsModeOn;
101      // flag that indicates whether CopyBit composition is enabled for this cycle
102      bool mCopyBitDraw;
103  
104      unsigned int getRGBRenderingArea (const hwc_context_t *ctx,
105                                           const hwc_display_contents_1_t *list);
106  
107      void getLayerResolution(const hwc_layer_1_t* layer,
108                                     unsigned int &width, unsigned int& height);
109  
110      int allocRenderBuffers(int w, int h, int f);
111  
112      void freeRenderBuffers();
113  
114      int clear (private_handle_t* hnd, hwc_rect_t& rect);
115  
116      private_handle_t* mRenderBuffer[NUM_RENDER_BUFFERS];
117  
118      // Index of the current intermediate render buffer
119      int mCurRenderBufferIndex;
120  
121      // Release FDs of the intermediate render buffer
122      int mRelFd[NUM_RENDER_BUFFERS];
123  
124      //Dynamic composition threshold for deciding copybit usage.
125      double mDynThreshold;
126      bool mSwapRectEnable;
127      int mAlignedWidth;
128      int mAlignedHeight;
129      int mDirtyLayerIndex;
130      LayerCache mLayerCache;
131      FbCache mFbCache;
132      int getLayersChanging(hwc_context_t *ctx, hwc_display_contents_1_t *list,
133                    int dpy);
134      int checkDirtyRect(hwc_context_t *ctx, hwc_display_contents_1_t *list,
135                    int dpy);
136  };
137  
138  }; //namespace qhwc
139  
140  #endif //HWC_COPYBIT_H
141