1 /* 2 * Copyright (C) 2007 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_LAYER_BUFFER_H 18 #define ANDROID_LAYER_BUFFER_H 19 20 #include <stdint.h> 21 #include <sys/types.h> 22 23 #include "LayerBase.h" 24 #include "TextureManager.h" 25 26 struct copybit_device_t; 27 28 namespace android { 29 30 // --------------------------------------------------------------------------- 31 32 class Buffer; 33 class Region; 34 class OverlayRef; 35 36 // --------------------------------------------------------------------------- 37 38 class LayerBuffer : public LayerBaseClient 39 { 40 class Source : public LightRefBase<Source> { 41 public: 42 Source(LayerBuffer& layer); 43 virtual ~Source(); 44 virtual void onDraw(const Region& clip) const; 45 virtual void onTransaction(uint32_t flags); 46 virtual void onVisibilityResolved(const Transform& planeTransform); 47 virtual void onvalidateVisibility(const Transform& globalTransform) { } 48 virtual void postBuffer(ssize_t offset); 49 virtual void unregisterBuffers(); 50 virtual void destroy() { } 51 SurfaceFlinger* getFlinger() const { return mLayer.mFlinger.get(); } 52 protected: 53 LayerBuffer& mLayer; 54 }; 55 56 public: 57 LayerBuffer(SurfaceFlinger* flinger, DisplayID display, 58 const sp<Client>& client); 59 virtual ~LayerBuffer(); 60 61 virtual void onFirstRef(); 62 virtual bool needsBlending() const; 63 virtual const char* getTypeId() const { return "LayerBuffer"; } 64 65 virtual sp<LayerBaseClient::Surface> createSurface() const; 66 virtual status_t ditch(); 67 virtual void onDraw(const Region& clip) const; 68 virtual void drawForSreenShot() const; 69 virtual uint32_t doTransaction(uint32_t flags); 70 virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion); 71 virtual void validateVisibility(const Transform& globalTransform); 72 73 status_t registerBuffers(const ISurface::BufferHeap& buffers); 74 void postBuffer(ssize_t offset); 75 void unregisterBuffers(); 76 sp<OverlayRef> createOverlay(uint32_t w, uint32_t h, int32_t format, 77 int32_t orientation); 78 79 sp<Source> getSource() const; 80 sp<Source> clearSource(); 81 void setNeedsBlending(bool blending); 82 Rect getTransformedBounds() const { 83 return mTransformedBounds; 84 } 85 86 void serverDestroy(); 87 88 private: 89 struct NativeBuffer { 90 copybit_image_t img; 91 copybit_rect_t crop; 92 }; 93 94 static gralloc_module_t const* sGrallocModule; 95 static gralloc_module_t const* getGrallocModule() { 96 return sGrallocModule; 97 } 98 99 class Buffer : public LightRefBase<Buffer> { 100 public: 101 Buffer(const ISurface::BufferHeap& buffers, 102 ssize_t offset, size_t bufferSize); 103 inline bool supportsCopybit() const { 104 return mSupportsCopybit; 105 } 106 inline status_t getStatus() const { 107 return mBufferHeap.heap!=0 ? NO_ERROR : NO_INIT; 108 } 109 inline const NativeBuffer& getBuffer() const { 110 return mNativeBuffer; 111 } 112 protected: 113 friend class LightRefBase<Buffer>; 114 Buffer& operator = (const Buffer& rhs); 115 Buffer(const Buffer& rhs); 116 ~Buffer(); 117 private: 118 ISurface::BufferHeap mBufferHeap; 119 NativeBuffer mNativeBuffer; 120 bool mSupportsCopybit; 121 }; 122 123 class BufferSource : public Source { 124 public: 125 BufferSource(LayerBuffer& layer, const ISurface::BufferHeap& buffers); 126 virtual ~BufferSource(); 127 128 status_t getStatus() const { return mStatus; } 129 sp<Buffer> getBuffer() const; 130 void setBuffer(const sp<Buffer>& buffer); 131 132 virtual void onDraw(const Region& clip) const; 133 virtual void postBuffer(ssize_t offset); 134 virtual void unregisterBuffers(); 135 virtual void destroy() { } 136 private: 137 status_t initTempBuffer() const; 138 void clearTempBufferImage() const; 139 mutable Mutex mBufferSourceLock; 140 sp<Buffer> mBuffer; 141 status_t mStatus; 142 ISurface::BufferHeap mBufferHeap; 143 size_t mBufferSize; 144 mutable Texture mTexture; 145 mutable NativeBuffer mTempBuffer; 146 mutable TextureManager mTextureManager; 147 }; 148 149 class OverlaySource : public Source { 150 public: 151 OverlaySource(LayerBuffer& layer, 152 sp<OverlayRef>* overlayRef, 153 uint32_t w, uint32_t h, int32_t format, int32_t orientation); 154 virtual ~OverlaySource(); 155 virtual void onDraw(const Region& clip) const; 156 virtual void onTransaction(uint32_t flags); 157 virtual void onVisibilityResolved(const Transform& planeTransform); 158 virtual void onvalidateVisibility(const Transform& globalTransform); 159 virtual void destroy(); 160 private: 161 162 class OverlayChannel : public BnOverlay { 163 wp<LayerBuffer> mLayer; 164 virtual void destroy() { 165 sp<LayerBuffer> layer(mLayer.promote()); 166 if (layer != 0) { 167 layer->serverDestroy(); 168 } 169 } 170 public: 171 OverlayChannel(const sp<LayerBuffer>& layer) 172 : mLayer(layer) { 173 } 174 }; 175 176 friend class OverlayChannel; 177 bool mVisibilityChanged; 178 179 overlay_t* mOverlay; 180 overlay_handle_t mOverlayHandle; 181 overlay_control_device_t* mOverlayDevice; 182 uint32_t mWidth; 183 uint32_t mHeight; 184 int32_t mFormat; 185 int32_t mWidthStride; 186 int32_t mHeightStride; 187 int32_t mOrientation; 188 mutable Mutex mOverlaySourceLock; 189 bool mInitialized; 190 }; 191 192 193 class SurfaceLayerBuffer : public LayerBaseClient::Surface 194 { 195 public: 196 SurfaceLayerBuffer(const sp<SurfaceFlinger>& flinger, 197 const sp<LayerBuffer>& owner); 198 virtual ~SurfaceLayerBuffer(); 199 200 virtual status_t registerBuffers(const ISurface::BufferHeap& buffers); 201 virtual void postBuffer(ssize_t offset); 202 virtual void unregisterBuffers(); 203 204 virtual sp<OverlayRef> createOverlay( 205 uint32_t w, uint32_t h, int32_t format, int32_t orientation); 206 private: 207 sp<LayerBuffer> getOwner() const { 208 return static_cast<LayerBuffer*>(Surface::getOwner().get()); 209 } 210 }; 211 212 mutable Mutex mLock; 213 sp<Source> mSource; 214 sp<Surface> mSurface; 215 bool mInvalidate; 216 bool mNeedsBlending; 217 copybit_device_t* mBlitEngine; 218 }; 219 220 // --------------------------------------------------------------------------- 221 222 }; // namespace android 223 224 #endif // ANDROID_LAYER_BUFFER_H 225
