/* * Copyright (C) 2007 The Android Open Source Project * Copyright (C) 2010, The Linux Foundation. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef ANDROID_LAYER_BASE_H #define ANDROID_LAYER_BASE_H #include #include #include #include #include #include #include #include #include #include #include #include #include "DisplayHardware/DisplayHardware.h" #include "Transform.h" namespace android { // --------------------------------------------------------------------------- class DisplayHardware; class Client; class GraphicBuffer; class GraphicPlane; class LayerBaseClient; class SurfaceFlinger; class Texture; // --------------------------------------------------------------------------- class LayerBase : public RefBase { static int32_t sSequence; int mLayerInitFlags; int mS3DFormat; bool mUseOrigSurfRes; public: virtual int getLayerInitFlags() const { return mLayerInitFlags; } LayerBase(SurfaceFlinger* flinger, DisplayID display); virtual status_t setStereoscopic3DFormat(int format) { mS3DFormat = format; return 0; } virtual int getStereoscopic3DFormat() const { return mS3DFormat; } //Marks the layer to be displayed in original resolution. virtual void useOriginalSurfaceResolution(bool flag) { mUseOrigSurfRes = flag; } //Getter to check for original resolution layer. virtual bool getUseOriginalSurfaceResolution() const { return mUseOrigSurfRes; } DisplayID dpy; mutable bool contentDirty; Region visibleRegionScreen; Region transparentRegionScreen; Region coveredRegionScreen; int32_t sequence; struct State { uint32_t w; uint32_t h; uint32_t requested_w; uint32_t requested_h; uint32_t z; uint8_t alpha; uint8_t flags; uint8_t reserved[2]; int32_t sequence; // changes when visible regions can change uint32_t tint; Transform transform; Region transparentRegion; }; void setName(const String8& name); String8 getName() const; // modify current state bool setPosition(int32_t x, int32_t y); bool setLayer(uint32_t z); bool setSize(uint32_t w, uint32_t h); bool setAlpha(uint8_t alpha); bool setMatrix(const layer_state_t::matrix22_t& matrix); bool setTransparentRegionHint(const Region& opaque); bool setFlags(uint8_t flags, uint8_t mask); void commitTransaction(); bool requestTransaction(); void forceVisibilityTransaction(); uint32_t getTransactionFlags(uint32_t flags); uint32_t setTransactionFlags(uint32_t flags); Rect visibleBounds() const; void drawRegion(const Region& reg) const; void invalidate(); virtual sp getLayerBaseClient() const { return 0; } virtual const char* getTypeId() const { return "LayerBase"; } /** * draw - performs some global clipping optimizations * and calls onDraw(). * Typically this method is not overridden, instead implement onDraw() * to perform the actual drawing. */ virtual void draw(const Region& clip) const; virtual void drawForSreenShot() const; virtual status_t drawWithOverlay(const Region& clip, bool hdmiConnected, bool ignoreFB = true) const { return INVALID_OPERATION; } virtual status_t setBufferInUse() const { return INVALID_OPERATION; }; virtual status_t freeBypassBuffers() const { return INVALID_OPERATION; }; virtual status_t clearFreezeLock() { return INVALID_OPERATION; }; /** * bypass mode */ virtual bool setBypass(bool enable) { return false; } virtual void resetReconfigStatus() {} virtual bool isReconfiguring() const { return false; } /** * onDraw - draws the surface. */ virtual void onDraw(const Region& clip) const = 0; /** * initStates - called just after construction */ virtual void initStates(uint32_t w, uint32_t h, uint32_t flags); /** * doTransaction - process the transaction. This is a good place to figure * out which attributes of the surface have changed. */ virtual uint32_t doTransaction(uint32_t transactionFlags); /** * setVisibleRegion - called to set the new visible region. This gives * a chance to update the new visible region or record the fact it changed. */ virtual void setVisibleRegion(const Region& visibleRegion); /** * setCoveredRegion - called when the covered region changes. The covered * region corresponds to any area of the surface that is covered * (transparently or not) by another surface. */ virtual void setCoveredRegion(const Region& coveredRegion); /** * validateVisibility - cache a bunch of things */ virtual void validateVisibility(const Transform& globalTransform); /** * lockPageFlip - called each time the screen is redrawn and returns whether * the visible regions need to be recomputed (this is a fairly heavy * operation, so this should be set only if needed). Typically this is used * to figure out if the content or size of a surface has changed. */ virtual void lockPageFlip(bool& recomputeVisibleRegions); /** * unlockPageFlip - called each time the screen is redrawn. updates the * final dirty region wrt the planeTransform. * At this point, all visible regions, surface position and size, etc... are * correct. */ virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion); /** * needsBlending - true if this surface needs blending */ virtual bool needsBlending() const { return false; } virtual bool isNothingToUpdate() const {return false; } virtual void setNothingToUpdate(bool) {} /** * needsDithering - true if this surface needs dithering */ virtual bool needsDithering() const { return false; } /** * needsLinearFiltering - true if this surface needs filtering */ virtual bool needsFiltering() const { return (!(mFlags & DisplayHardware::SLOW_CONFIG)) && mNeedsFiltering; } #ifdef AVOID_DRAW_TEXTURE /** * transformed -- true is this surface needs a to be transformed */ virtual bool transformed() const { return mTransformed; } #endif /** * isSecure - true if this surface is secure, that is if it prevents * screenshots or VNC servers. */ virtual bool isSecure() const { return false; } /** called with the state lock when the surface is removed from the * current list */ virtual void onRemoved() { }; /** always call base class first */ virtual void dump(String8& result, char* scratch, size_t size) const; enum { // flags for doTransaction() eVisibleRegion = 0x00000002, }; inline const State& drawingState() const { return mDrawingState; } inline const State& currentState() const { return mCurrentState; } inline State& currentState() { return mCurrentState; } int32_t getOrientation() const { return mOrientation; } int tx() const { return mLeft; } int ty() const { return mTop; } protected: const GraphicPlane& graphicPlane(int dpy) const; GraphicPlane& graphicPlane(int dpy); void clearWithOpenGL(const Region& clip, GLclampf r, GLclampf g, GLclampf b, GLclampf alpha) const; void clearWithOpenGL(const Region& clip) const; void drawWithOpenGL(const Region& clip, const Texture& texture) const; void drawWithOpenGLOptimized(const Region& clip, const Texture& texture) const; enum { QUAD_WIDTH = 16, TEXTURE_MIN_WIDTH = 480 }; int getQuadWidth() const { return QUAD_WIDTH; } int getTexMinWidth() const { return TEXTURE_MIN_WIDTH; } // these must be called from the post/drawing thread void setBufferCrop(const Rect& crop); void setBufferTransform(uint32_t transform); sp mFlinger; uint32_t mFlags; // post/drawing thread Rect mBufferCrop; uint32_t mBufferTransform; // cached during validateVisibility() bool mNeedsFiltering; int32_t mOrientation; GLfloat mVertices[4][2]; Rect mTransformedBounds; int mLeft; int mTop; // these are protected by an external lock State mCurrentState; State mDrawingState; volatile int32_t mTransactionFlags; // don't change, don't need a lock bool mPremultipliedAlpha; String8 mName; mutable bool mDebug; // atomic volatile int32_t mInvalidate; #ifdef AVOID_DRAW_TEXTURE bool mTransformed; #endif public: // called from class SurfaceFlinger virtual ~LayerBase(); private: LayerBase(const LayerBase& rhs); private: mutable bool mOverlayUsed; public: bool isOverlayUsed() const { return mOverlayUsed; } void setOverlayUsed(bool val) const { mOverlayUsed = val; } }; // --------------------------------------------------------------------------- class LayerBaseClient : public LayerBase { public: class Surface; LayerBaseClient(SurfaceFlinger* flinger, DisplayID display, const sp& client); virtual ~LayerBaseClient(); sp getSurface(); bool isSurface() const; virtual sp createSurface() const; virtual sp getLayerBaseClient() const { return const_cast(this); } virtual const char* getTypeId() const { return "LayerBaseClient"; } virtual void setVisualParam(int8_t paramType, float paramValue); uint32_t getIdentity() const { return mIdentity; } class Surface : public BnSurface { public: int32_t getIdentity() const { return mIdentity; } protected: Surface(const sp& flinger, int identity, const sp& owner); virtual ~Surface(); virtual status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); sp getOwner() const; private: virtual sp requestBuffer(int bufferIdx, uint32_t w, uint32_t h, uint32_t format, uint32_t usage); virtual status_t setBufferCount(int bufferCount); virtual status_t setStereoscopic3DFormat(int format); virtual status_t useOriginalSurfaceResolution(bool flag); virtual status_t registerBuffers(const ISurface::BufferHeap& buffers); virtual void postBuffer(ssize_t offset); virtual void reconfigureBuffers(); virtual void unregisterBuffers(); virtual sp createOverlay(uint32_t w, uint32_t h, int32_t format, int32_t orientation); protected: friend class LayerBaseClient; sp mFlinger; int32_t mIdentity; wp mOwner; }; friend class Surface; protected: virtual void dump(String8& result, char* scratch, size_t size) const; private: mutable Mutex mLock; mutable wp mClientSurface; const wp mClientRef; // only read const uint32_t mIdentity; static int32_t sIdentity; }; // --------------------------------------------------------------------------- }; // namespace android #endif // ANDROID_LAYER_BASE_H