android graphic(2)—EGL和OpenGL ES

http://blog.csdn.net/lewif/article/details/50532011

目录(?)[+]

• Android的本地窗口
• FramebufferNativeWindow
• Surface

前面提到Android EGL库的主要作用就是将OpenGL ES和本地窗口系统结合起来。OpenGL ES就像是一个打印机，各个厂商打印机的内部实现不同(不同的OpenGL ES的实现，软件、硬件等，实现的库由EGL加载)，但是只要打印的文档内容相同，按下打印键，其输出的结果都是相同的。当然打印机可以在不同种类的纸张上打印，A4，A5或者牛皮纸、塑料纸等等，打印机对这些都需要支持。OpenGL ES和打印机一样，需要兼容windows、塞班、android等多个不同的系统，所以它的实现是平台无关的，而windows、android等系统需要给OpenGL ES提供纸，这个纸就是本地窗口，而不同系统的实现肯定是不同的。打印机打印的最终内容需要呈现在纸上，对软件来说本地窗口里面肯定有buffer的存在来保存OpenGL ES画的图。

2016/03/25 注：android 4.4中已经不使用FramebufferNativeWindow了，而是使用FramebufferSurface和hwcomposer去做composer。

Android的本地窗口

上面提到，如果需要使用OpenGL ES就需要本地窗口的加入，而在前面文章中提到有两处使用OpenGL ES的地方：一是上层的3D绘图，二是SurfaceFlinger对layer的合成（先不考虑Canvas和overlay）。那么我们可以想象下面这幅图画：

我们需要两种本地窗口，一种是面对app的，一种是面对SurfaceFlinger。那么本地窗口在android中到底是什么？我们从EGL函数的调用开始，在eglCreateWindowSurface函数中，有个和平台无关的结构体为NativeWindowType，

EGLSurface eglCreateWindowSurface(  EGLDisplay dpy, EGLConfig config,

                                   NativeWindowType window,

                                    const EGLint*attrib_list)

{

    return createWindowSurface(dpy, config, window, attrib_list);

}

而

typedefEGLNativeWindowType  NativeWindowType;

从下面的定义可以看到，在系统为android的宏下，本地窗口其实为ANativeWindow。

#elifdefined(__ANDROID__) || defined(ANDROID)

struct ANativeWindow;

structegl_native_pixmap_t;

typedefstructANativeWindow*          EGLNativeWindowType;

typedefstructegl_native_pixmap_t*    EGLNativePixmapType;

typedefvoid*                          EGLNativeDisplayType;

下面是ANativeWindow结构体，里面有一组函数指针，我们能够猜到，两个本地窗口都是继承了ANativeWindow，然后对函数进行赋值，“实现协议”。

struct ANativeWindow

{

    structandroid_native_base_t common;

    const uint32_t flags;

    constint   minSwapInterval;

    constint   maxSwapInterval;

    constfloat xdpi;

    constfloat ydpi;

    intptr_t    oem[4];

    int     (*setSwapInterval)(struct ANativeWindow*window,

                int interval);

    int     (*query)(conststruct ANativeWindow*window,

                int what, int* value);

    int     (*perform)(struct ANativeWindow*window,

                int operation, ...);

    int     (*cancelBuffer_DEPRECATED)(struct ANativeWindow*window,

                structANativeWindowBuffer* buffer);

    int     (*dequeueBuffer)(struct ANativeWindow*window,

                structANativeWindowBuffer** buffer, int* fenceFd);

    int     (*queueBuffer)(struct ANativeWindow*window,

                structANativeWindowBuffer* buffer, int fenceFd);

    int     (*cancelBuffer)(struct ANativeWindow*window,

                structANativeWindowBuffer* buffer, int fenceFd);

};

最终找到的两个本地窗口为FramebufferNativeWindow和Surface。

FramebufferNativeWindow

SurfaceFlinger对应的本地窗口为FramebufferNativeWindow，继承了ANativeWindow，里面有个sp<NativeBuffer>buffers[MAX_NUM_FRAME_BUFFERS];，这应该就是“本地的纸”，而且还有和ANativeWindow对应的函数实现。

class FramebufferNativeWindow

    : publicANativeObjectBase<

       ANativeWindow,

        FramebufferNativeWindow,

       LightRefBase<FramebufferNativeWindow> >

{

public:

    FramebufferNativeWindow();

   framebuffer_device_t const * getDevice() const { return fbDev; }

    boolisUpdateOnDemand() const { returnmUpdateOnDemand; }

    status_tsetUpdateRectangle(const Rect&updateRect);

    status_tcompositionComplete();

    voiddump(String8& result);

    // for debugging only

    intgetCurrentBufferIndex() const;

private:

    friend classLightRefBase<FramebufferNativeWindow>;   

   ~FramebufferNativeWindow(); // this class cannot be overloaded

    staticintsetSwapInterval(ANativeWindow* window, int interval);

    staticintdequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer, int* fenceFd);

    staticint queueBuffer(ANativeWindow*window, ANativeWindowBuffer* buffer, int fenceFd);

    staticint query(const ANativeWindow*window, int what, int* value);

    staticintperform(ANativeWindow* window, int operation, ...);

    staticint dequeueBuffer_DEPRECATED(ANativeWindow*window, ANativeWindowBuffer** buffer);

    staticintqueueBuffer_DEPRECATED(ANativeWindow* window, ANativeWindowBuffer* buffer);

    staticintlockBuffer_DEPRECATED(ANativeWindow* window, ANativeWindowBuffer* buffer);

   framebuffer_device_t* fbDev;

    alloc_device_t*grDev;

   sp<NativeBuffer> buffers[MAX_NUM_FRAME_BUFFERS];

   sp<NativeBuffer> front;

    mutable Mutexmutex;

    ConditionmCondition;

    int32_tmNumBuffers;

    int32_tmNumFreeBuffers;

    int32_t mBufferHead;

    int32_tmCurrentBufferIndex;

    boolmUpdateOnDemand;

};

Surface

众多App对应的本地窗口为Surface，继承了ANativeWindow，类似的也有个BufferSlot mSlots[NUM_BUFFER_SLOTS];，是App的“本地的纸”，而且还有和ANativeWindow对应的函数实现。

class Surface

    : public ANativeObjectBase<ANativeWindow,Surface, RefBase>

{

public:

    Surface(constsp<IGraphicBufferProducer>& bufferProducer, bool controlledByApp= false);

   sp<IGraphicBufferProducer> getIGraphicBufferProducer() const;

    staticbool isValid(constsp<Surface>& surface) {

        return surface != NULL&& surface->getIGraphicBufferProducer() != NULL;

    }

protected:

    virtual ~Surface();

private:

    // can't becopied

    Surface& operator = (const Surface&rhs);

    Surface(const Surface&rhs);

    // ANativeWindow hooks

    staticinthook_cancelBuffer(ANativeWindow* window,

           ANativeWindowBuffer* buffer, int fenceFd);

    staticint hook_dequeueBuffer(ANativeWindow*window,

           ANativeWindowBuffer** buffer, int* fenceFd);

    staticinthook_perform(ANativeWindow* window, int operation, ...);

    staticint hook_query(const ANativeWindow*window, int what, int* value);

    staticinthook_queueBuffer(ANativeWindow* window,

           ANativeWindowBuffer* buffer, int fenceFd);

    staticinthook_setSwapInterval(ANativeWindow* window, int interval);

    staticinthook_cancelBuffer_DEPRECATED(ANativeWindow* window,

            ANativeWindowBuffer* buffer);

    staticinthook_dequeueBuffer_DEPRECATED(ANativeWindow* window,

           ANativeWindowBuffer** buffer);

    staticinthook_lockBuffer_DEPRECATED(ANativeWindow* window,

           ANativeWindowBuffer* buffer);

    staticinthook_queueBuffer_DEPRECATED(ANativeWindow* window,

           ANativeWindowBuffer* buffer);

    intdispatchConnect(va_list args);

    intdispatchDisconnect(va_list args);

    intdispatchSetBufferCount(va_list args);

    intdispatchSetBuffersGeometry(va_list args);

    intdispatchSetBuffersDimensions(va_list args);

    intdispatchSetBuffersUserDimensions(va_list args);

    intdispatchSetBuffersFormat(va_list args);

    intdispatchSetScalingMode(va_list args);

    int dispatchSetBuffersTransform(va_listargs);

    intdispatchSetBuffersTimestamp(va_list args);

    intdispatchSetCrop(va_list args);

    intdispatchSetPostTransformCrop(va_list args);

    intdispatchSetUsage(va_list args);

    intdispatchLock(va_list args);

    intdispatchUnlockAndPost(va_list args);

protected:

    virtualintdequeueBuffer(ANativeWindowBuffer**buffer, int* fenceFd);

    virtualintcancelBuffer(ANativeWindowBuffer* buffer, int fenceFd);

    virtualintqueueBuffer(ANativeWindowBuffer* buffer, int fenceFd);

    virtualint perform(int operation,va_list args);

    virtualint query(int what, int* value) const;

    virtualintsetSwapInterval(int interval);

    virtualintlockBuffer_DEPRECATED(ANativeWindowBuffer* buffer);

    virtualint connect(int api);

    virtualint disconnect(int api);

    virtualint setBufferCount(int bufferCount);

    virtualintsetBuffersDimensions(int w, int h);

    virtualintsetBuffersUserDimensions(int w, int h);

    virtualintsetBuffersFormat(int format);

    virtualint setScalingMode(int mode);

    virtualintsetBuffersTransform(int transform);

    virtualintsetBuffersTimestamp(int64_t timestamp);

    virtualint setCrop(Rect const* rect);

    virtualintsetUsage(uint32_t reqUsage);

public:

    virtualintlock(ANativeWindow_Buffer*outBuffer, ARect* inOutDirtyBounds);

    virtualintunlockAndPost();

protected:

    enum {NUM_BUFFER_SLOTS = BufferQueue::NUM_BUFFER_SLOTS };

    enum {DEFAULT_FORMAT = PIXEL_FORMAT_RGBA_8888 };

private:

    voidfreeAllBuffers();

    intgetSlotFromBufferLocked(android_native_buffer_t* buffer) const;

    struct BufferSlot {

       sp<GraphicBuffer> buffer;

        RegiondirtyRegion;

    };

    // mSurfaceTexture is the interface tothe surface texture server. All

    // operations on the surface textureclient ultimately translate into

    // interactions with the server usingthis interface.

    // TODO: rename to mBufferProducer

   sp<IGraphicBufferProducer> mGraphicBufferProducer;

    // mSlots stores the buffers that havebeen allocated for each buffer slot.

    // It is initialized to null pointers,and gets filled in with the result of

    // IGraphicBufferProducer::requestBufferwhen the client dequeues a buffer from a

    // slot that has not yet been used. Thebuffer allocated to a slot will also

    // be replaced if the requested bufferusage or geometry differs from that

    // of the buffer allocated to a slot.

    BufferSlotmSlots[NUM_BUFFER_SLOTS];

    // mReqWidth is the buffer width thatwill be requested at the next dequeue

    // operation. It is initialized to 1.

    uint32_tmReqWidth;

    // mReqHeight is the buffer height thatwill be requested at the next

    // dequeue operation. It is initializedto 1.

    uint32_tmReqHeight;

    // mReqFormat is the buffer pixel formatthat will be requested at the next

    // deuque operation. It is initializedto PIXEL_FORMAT_RGBA_8888.

    uint32_tmReqFormat;

    // mReqUsage is the set of buffer usageflags that will be requested

    // at the next deuque operation. It isinitialized to 0.

    uint32_tmReqUsage;

    // mTimestamp is the timestamp that willbe used for the next buffer queue

    // operation. It defaults toNATIVE_WINDOW_TIMESTAMP_AUTO, which means that

    // a timestamp is auto-generated whenqueueBuffer is called.

    int64_tmTimestamp;

    // mCrop is the crop rectangle that willbe used for the next buffer

    // that gets queued. It is set bycalling setCrop.

    Rect mCrop;

    // mScalingMode is the scaling mode that will be used forthe next

    // buffers that get queued. It is set bycalling setScalingMode.

    int mScalingMode;

    // mTransform is the transformidentifier that will be used for the next

    // buffer that gets queued. It is set bycalling setTransform.

    uint32_tmTransform;

     // mDefaultWidth is default width of thebuffers, regardless of the

     // native_window_set_buffers_dimensionscall.

     uint32_tmDefaultWidth;

     // mDefaultHeight is default height ofthe buffers, regardless of the

     // native_window_set_buffers_dimensionscall.

     uint32_tmDefaultHeight;

     // mUserWidth, if non-zero, is anapplication-specified override

     // of mDefaultWidth.  This is lower priority than the width set by

     // native_window_set_buffers_dimensions.

     uint32_tmUserWidth;

     // mUserHeight, if non-zero, is anapplication-specified override

     // of mDefaultHeight.  This is lower priority than the height set

     // by native_window_set_buffers_dimensions.

     uint32_tmUserHeight;

    // mTransformHint is the transformprobably applied to buffers of this

    // window. this is only a hint, actualtransform may differ.

    uint32_tmTransformHint;

    // mProducerControlledByApp whether thisbuffer producer is controlled

    // by the application

    boolmProducerControlledByApp;

    // mSwapIntervalZero set if we shoulddrop buffers at queue() time to

    // achieve an asynchronous swap interval

    boolmSwapIntervalZero;

    // mConsumerRunningBehind whether theconsumer is running more than

    // one buffer behind the producer.

    mutable boolmConsumerRunningBehind;

    // mMutex is the mutex used to preventconcurrent access to the member

    // variables of Surface objects. It must be locked whenever the

    // member variables are accessed.

    mutable MutexmMutex;

    // must be used from the lock/unlockthread

   sp<GraphicBuffer>          mLockedBuffer;

   sp<GraphicBuffer>           mPostedBuffer;

    bool                        mConnectedToCpu;

    // must be accessed from lock/unlockthread only

    RegionmDirtyRegion;

};