libs/surfaceflinger/Layer.h

/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * 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_H
#define ANDROID_LAYER_H

#include <stdint.h>
#include <sys/types.h>

#include <ui/GraphicBuffer.h>
#include <ui/PixelFormat.h>
#include <pixelflinger/pixelflinger.h>

#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GLES/gl.h>
#include <GLES/glext.h>

#include "LayerBase.h"
#include "Transform.h"
#include "TextureManager.h"

namespace android {

// ---------------------------------------------------------------------------

class Client;
class UserClient;
class FreezeLock;

// ---------------------------------------------------------------------------

class Layer : public LayerBaseClient
{
public:
            Layer(SurfaceFlinger* flinger, DisplayID display,
                    const sp<Client>& client);

    virtual ~Layer();

    virtual const char* getTypeId() const { return "Layer"; }

    // the this layer's size and format
    status_t setBuffers(uint32_t w, uint32_t h, 
            PixelFormat format, uint32_t flags=0);

    // associate a UserClient to this Layer
    status_t setToken(const sp<UserClient>& uc, SharedClient* sc, int32_t idx);
    int32_t getToken() const;
    sp<UserClient> getClient() const;

    // Set this Layer's buffers size
    void setBufferSize(uint32_t w, uint32_t h);
    bool isFixedSize() const;

    // LayerBase interface
    virtual void onDraw(const Region& clip) const;
    virtual uint32_t doTransaction(uint32_t transactionFlags);
    virtual void lockPageFlip(bool& recomputeVisibleRegions);
    virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion);
    virtual void finishPageFlip();
    virtual bool needsBlending() const      { return mNeedsBlending; }
    virtual bool needsDithering() const     { return mNeedsDithering; }
    virtual bool needsFiltering() const;
    virtual bool isSecure() const           { return mSecure; }
    virtual sp<Surface> createSurface() const;
    virtual status_t ditch();
    virtual void onRemoved();

    // only for debugging
    inline sp<GraphicBuffer> getBuffer(int i) const {
        return mBufferManager.getBuffer(i); }
    // only for debugging
    inline const sp<FreezeLock>&  getFreezeLock() const {
        return mFreezeLock; }

protected:
    virtual void dump(String8& result, char* scratch, size_t size) const;

private:
    void reloadTexture(const Region& dirty);
    uint32_t getEffectiveUsage(uint32_t usage) const;
    sp<GraphicBuffer> requestBuffer(int bufferIdx,
            uint32_t w, uint32_t h, uint32_t format, uint32_t usage);
    status_t setBufferCount(int bufferCount);

    // -----------------------------------------------------------------------

    class SurfaceLayer : public LayerBaseClient::Surface {
    public:
        SurfaceLayer(const sp<SurfaceFlinger>& flinger, const sp<Layer>& owner);
        ~SurfaceLayer();
    private:
        virtual sp<GraphicBuffer> requestBuffer(int bufferIdx,
                uint32_t w, uint32_t h, uint32_t format, uint32_t usage);
        virtual status_t setBufferCount(int bufferCount);
        sp<Layer> getOwner() const {
            return static_cast<Layer*>(Surface::getOwner().get());
        }
    };
    friend class SurfaceLayer;

    // -----------------------------------------------------------------------

    class ClientRef {
        ClientRef(const ClientRef& rhs);
        ClientRef& operator = (const ClientRef& rhs);
        mutable Mutex mLock;
        // binder thread, page-flip thread
        sp<SharedBufferServer> mControlBlock;
        wp<UserClient> mUserClient;
        int32_t mToken;
    public:
        ClientRef();
        ~ClientRef();
        int32_t getToken() const;
        sp<UserClient> getClient() const;
        status_t setToken(const sp<UserClient>& uc,
                const sp<SharedBufferServer>& sharedClient, int32_t token);
        sp<UserClient> getUserClientUnsafe() const;
        class Access {
            Access(const Access& rhs);
            Access& operator = (const Access& rhs);
            sp<UserClient> mUserClientStrongRef;
            sp<SharedBufferServer> mControlBlock;
        public:
            Access(const ClientRef& ref);
            ~Access();
            inline SharedBufferServer* get() const { return mControlBlock.get(); }
        };
        friend class Access;
    };

    // -----------------------------------------------------------------------

    class BufferManager {
        static const size_t NUM_BUFFERS = 2;
        struct BufferData {
            sp<GraphicBuffer>   buffer;
            Image               texture;
        };
        // this lock protect mBufferData[].buffer but since there
        // is very little contention, we have only one like for
        // the whole array, we also use it to protect mNumBuffers.
        mutable Mutex mLock;
        BufferData          mBufferData[SharedBufferStack::NUM_BUFFER_MAX];
        size_t              mNumBuffers;
        Texture             mFailoverTexture;
        TextureManager&     mTextureManager;
        ssize_t             mActiveBuffer;
        bool                mFailover;
        static status_t destroyTexture(Image* tex, EGLDisplay dpy);

    public:
        static size_t getDefaultBufferCount() { return NUM_BUFFERS; }
        BufferManager(TextureManager& tm);
        ~BufferManager();

        // detach/attach buffer from/to given index
        sp<GraphicBuffer> detachBuffer(size_t index);
        status_t attachBuffer(size_t index, const sp<GraphicBuffer>& buffer);
        // resize the number of active buffers
        status_t resize(size_t size);

        // ----------------------------------------------
        // must be called from GL thread

        // set/get active buffer index
        status_t setActiveBufferIndex(size_t index);
        size_t getActiveBufferIndex() const;
        // return the active buffer
        sp<GraphicBuffer> getActiveBuffer() const;
        // return the active texture (or fail-over)
        Texture getActiveTexture() const;
        // frees resources associated with all buffers
        status_t destroy(EGLDisplay dpy);
        // load bitmap data into the active buffer
        status_t loadTexture(const Region& dirty, const GGLSurface& t);
        // make active buffer an EGLImage if needed
        status_t initEglImage(EGLDisplay dpy,
                const sp<GraphicBuffer>& buffer);

        // ----------------------------------------------
        // only for debugging
        sp<GraphicBuffer> getBuffer(size_t index) const;
    };

    // -----------------------------------------------------------------------

    // thread-safe
    ClientRef mUserClientRef;

    // constants
    sp<Surface> mSurface;
    PixelFormat mFormat;
    bool mNeedsBlending;
    bool mNeedsDithering;

    // page-flip thread (currently main thread)
    bool mSecure;
    Region mPostedDirtyRegion;

    // page-flip thread and transaction thread (currently main thread)
    sp<FreezeLock>  mFreezeLock;

    // see threading usage in declaration
    TextureManager mTextureManager;
    BufferManager mBufferManager;

    // binder thread, transaction thread
    mutable Mutex mLock;
    uint32_t mWidth;
    uint32_t mHeight;
    uint32_t mReqWidth;
    uint32_t mReqHeight;
    uint32_t mReqFormat;
    bool mFixedSize;
};

// ---------------------------------------------------------------------------

}; // namespace android

#endif // ANDROID_LAYER_H