Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8ba32fad authored by Jamie Gennis's avatar Jamie Gennis
Browse files

Add the SurfaceTexture C++ implementation. 

This change adds the C++ implementation of SurfaceTexture and related
classes. The goal of this is for a SurfaceTexture to be passed to
camera service or Stagefright in place of a Surface to allow camera
preview or decoded video frames to be streamed to an OpenGL ES texture
that an application can use.

Change-Id: I55c83a7017f1ecb81c9c9e3252cbd118b914296c
parent 49563340

include/gui/ISurfaceTexture.h

0 → 100644
+91 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2010 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_GUI_ISURFACETEXTURE_H

#define ANDROID_GUI_ISURFACETEXTURE_H



#include <stdint.h>

#include <sys/types.h>



#include <utils/Errors.h>

#include <utils/RefBase.h>



#include <binder/IInterface.h>



#include <ui/GraphicBuffer.h>

#include <ui/Rect.h>



namespace android {

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



class ISurfaceTexture : public IInterface

{

public:

    DECLARE_META_INTERFACE(SurfaceTexture);



    // requestBuffer requests a new buffer for the given index. The server (i.e.

    // the ISurfaceTexture implementation) assigns the newly created buffer to

    // the given slot index, and the client is expected to mirror the

    // slot->buffer mapping so that it's not necessary to transfer a

    // GraphicBuffer for every dequeue operation.

    virtual sp<GraphicBuffer> requestBuffer(int slot, uint32_t w, uint32_t h,

            uint32_t format, uint32_t usage) = 0;



    // setBufferCount sets the number of buffer slots available. Calling this

    // will also cause all buffer slots to be emptied. The caller should empty

    // its mirrored copy of the buffer slots when calling this method.

    virtual status_t setBufferCount(int bufferCount) = 0;



    // dequeueBuffer requests a new buffer slot for the client to use. Ownership

    // of the slot is transfered to the client, meaning that the server will not

    // use the contents of the buffer associated with that slot. The slot index

    // returned may or may not contain a buffer. If the slot is empty the client

    // should call requestBuffer to assign a new buffer to that slot. The client

    // is expected to either call cancelBuffer on the dequeued slot or to fill

    // in the contents of its associated buffer contents and call queueBuffer.

    virtual status_t dequeueBuffer(int *slot) = 0;



    // queueBuffer indicates that the client has finished filling in the

    // contents of the buffer associated with slot and transfers ownership of

    // that slot back to the server. It is not valid to call queueBuffer on a

    // slot that is not owned by the client or one for which a buffer associated

    // via requestBuffer.

    virtual status_t queueBuffer(int slot) = 0;



    // cancelBuffer indicates that the client does not wish to fill in the

    // buffer associated with slot and transfers ownership of the slot back to

    // the server.

    virtual void cancelBuffer(int slot) = 0;



    virtual status_t setCrop(const Rect& reg) = 0;

    virtual status_t setTransform(uint32_t transform) = 0;

};



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



class BnSurfaceTexture : public BnInterface<ISurfaceTexture>

{

public:

    virtual status_t    onTransact( uint32_t code,

                                    const Parcel& data,

                                    Parcel* reply,

                                    uint32_t flags = 0);

};



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

}; // namespace android



#endif // ANDROID_GUI_ISURFACETEXTURE_H

include/gui/SurfaceTexture.h

0 → 100644
+139 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2010 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_GUI_SURFACETEXTURE_H

#define ANDROID_GUI_SURFACETEXTURE_H



#include <EGL/egl.h>

#include <EGL/eglext.h>

#include <GLES2/gl2.h>



#include <gui/ISurfaceTexture.h>



#include <ui/GraphicBuffer.h>



#include <utils/threads.h>



#define ANDROID_GRAPHICS_SURFACETEXTURE_JNI_ID "mSurfaceTexture"



namespace android {

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



class SurfaceTexture : public BnSurfaceTexture {

public:

    enum { MIN_BUFFER_SLOTS = 3 };

    enum { NUM_BUFFER_SLOTS = 32 };



    // tex indicates the name OpenGL texture to which images are to be streamed.

    // This texture name cannot be changed once the SurfaceTexture is created.

    SurfaceTexture(GLuint tex);



    virtual ~SurfaceTexture();



    // setBufferCount updates the number of available buffer slots.  After

    // calling this all buffer slots are both unallocated and owned by the

    // SurfaceTexture object (i.e. they are not owned by the client).

    virtual status_t setBufferCount(int bufferCount);



    virtual sp<GraphicBuffer> requestBuffer(int buf, uint32_t w, uint32_t h,

            uint32_t format, uint32_t usage);



    // dequeueBuffer gets the next buffer slot index for the client to use. If a

    // buffer slot is available then that slot index is written to the location

    // pointed to by the buf argument and a status of OK is returned.  If no

    // slot is available then a status of -EBUSY is returned and buf is

    // unmodified.

    virtual status_t dequeueBuffer(int *buf);



    virtual status_t queueBuffer(int buf);

    virtual void cancelBuffer(int buf);

    virtual status_t setCrop(const Rect& reg);

    virtual status_t setTransform(uint32_t transform);



    // updateTexImage sets the image contents of the target texture to that of

    // the most recently queued buffer.

    //

    // This call may only be made while the OpenGL ES context to which the

    // target texture belongs is bound to the calling thread.

    status_t updateTexImage();



private:



    // freeAllBuffers frees the resources (both GraphicBuffer and EGLImage) for

    // all slots.

    void freeAllBuffers();



    // createImage creates a new EGLImage from a GraphicBuffer.

    EGLImageKHR createImage(EGLDisplay dpy,

            const sp<GraphicBuffer>& graphicBuffer);



    enum { INVALID_BUFFER_SLOT = -1 };



    struct BufferSlot {

        // mGraphicBuffer points to the buffer allocated for this slot or is NULL

        // if no buffer has been allocated.

        sp<GraphicBuffer> mGraphicBuffer;



        // mEglImage is the EGLImage created from mGraphicBuffer.

        EGLImageKHR mEglImage;



        // mEglDisplay is the EGLDisplay used to create mEglImage.

        EGLDisplay mEglDisplay;



        // mOwnedByClient indicates whether the slot is currently accessible to a

        // client and should not be used by the SurfaceTexture object. It gets

        // set to true when dequeueBuffer returns the slot and is reset to false

        // when the client calls either queueBuffer or cancelBuffer on the slot.

        bool mOwnedByClient;

    };



    // mSlots is the array of buffer slots that must be mirrored on the client

    // side. This allows buffer ownership to be transferred between the client

    // and server without sending a GraphicBuffer over binder. The entire array

    // is initialized to NULL at construction time, and buffers are allocated

    // for a slot when requestBuffer is called with that slot's index.

    BufferSlot mSlots[NUM_BUFFER_SLOTS];



    // mBufferCount is the number of buffer slots that the client and server

    // must maintain. It defaults to MIN_BUFFER_SLOTS and can be changed by

    // calling setBufferCount.

    int mBufferCount;



    // mCurrentTexture is the buffer slot index of the buffer that is currently

    // bound to the OpenGL texture. A value of INVALID_BUFFER_SLOT, indicating

    // that no buffer is currently bound to the texture.

    int mCurrentTexture;



    // mLastQueued is the buffer slot index of the most recently enqueued buffer.

    // At construction time it is initialized to INVALID_BUFFER_SLOT, and is

    // updated each time queueBuffer is called.

    int mLastQueued;



    // mTexName is the name of the OpenGL texture to which streamed images will

    // be bound when updateTexImage is called. It is set at construction time 

    // changed with a call to setTexName.

    const GLuint mTexName;



    // mMutex is the mutex used to prevent concurrent access to the member

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

    // member variables are accessed.

    Mutex mMutex;

};



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

}; // namespace android



#endif // ANDROID_GUI_SURFACETEXTURE_H

include/gui/SurfaceTextureClient.h

0 → 100644
+118 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2010 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_GUI_SURFACETEXTURECLIENT_H

#define ANDROID_GUI_SURFACETEXTURECLIENT_H



#include <gui/ISurfaceTexture.h>

#include <gui/SurfaceTexture.h>



#include <ui/egl/android_natives.h>



#include <utils/RefBase.h>

#include <utils/threads.h>



namespace android {



class SurfaceTextureClient

    : public EGLNativeBase<ANativeWindow, SurfaceTextureClient, RefBase>

{

public:

    SurfaceTextureClient(const sp<ISurfaceTexture>& surfaceTexture);



private:



    // can't be copied

    SurfaceTextureClient& operator = (const SurfaceTextureClient& rhs);

    SurfaceTextureClient(const SurfaceTextureClient& rhs);



    // ANativeWindow hooks

    static int setSwapInterval(ANativeWindow* window, int interval);

    static int dequeueBuffer(ANativeWindow* window, android_native_buffer_t** buffer);

    static int cancelBuffer(ANativeWindow* window, android_native_buffer_t* buffer);

    static int lockBuffer(ANativeWindow* window, android_native_buffer_t* buffer);

    static int queueBuffer(ANativeWindow* window, android_native_buffer_t* buffer);

    static int query(ANativeWindow* window, int what, int* value);

    static int perform(ANativeWindow* window, int operation, ...);



    int setSwapInterval(int interval);

    int dequeueBuffer(android_native_buffer_t** buffer);

    int lockBuffer(android_native_buffer_t* buffer);

    int queueBuffer(android_native_buffer_t* buffer);

    int cancelBuffer(android_native_buffer_t* buffer);

    int query(int what, int* value);

    int perform(int operation, va_list args);



    int dispatchSetUsage(va_list args);

    int dispatchConnect(va_list args);

    int dispatchDisconnect(va_list args);

    int dispatchSetCrop(va_list args);

    int dispatchSetBufferCount(va_list args);

    int dispatchSetBuffersGeometry(va_list args);

    int dispatchSetBuffersTransform(va_list args);



    int connect(int api);

    int disconnect(int api);

    int setUsage(uint32_t reqUsage);

    int setCrop(Rect const* rect);

    int setBufferCount(int bufferCount);

    int setBuffersGeometry(int w, int h, int format);

    int setBuffersTransform(int transform);



    void freeAllBuffers();



    enum { MIN_BUFFER_SLOTS = SurfaceTexture::MIN_BUFFER_SLOTS };

    enum { NUM_BUFFER_SLOTS = SurfaceTexture::NUM_BUFFER_SLOTS };

    enum { DEFAULT_FORMAT = PIXEL_FORMAT_RGBA_8888 };



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

    // operations on the surface texture client ultimately translate into

    // interactions with the server using this interface.

    sp<ISurfaceTexture> mSurfaceTexture;



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

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

    // ISurfaceTexture::requestBuffer when the client dequeues a buffer from a

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

    // be replaced if the requested buffer usage or geometry differs from that

    // of the buffer allocated to a slot.

    sp<GraphicBuffer> mSlots[NUM_BUFFER_SLOTS];



    // mReqWidth is the buffer width that will be requested at the next dequeue

    // operation. It is initialized to 1.

    uint32_t mReqWidth;



    // mReqHeight is the buffer height that will be requested at the next deuque

    // operation. It is initialized to 1.

    uint32_t mReqHeight;



    // mReqFormat is the buffer pixel format that will be requested at the next

    // deuque operation. It is initialized to PIXEL_FORMAT_RGBA_8888.

    uint32_t mReqFormat;



    // mReqUsage is the set of buffer usage flags that will be requested

    // at the next deuque operation. It is initialized to 0.

    uint32_t mReqUsage;



    // mMutex is the mutex used to prevent concurrent access to the member

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

    // member variables are accessed.

    Mutex mMutex;

};



}; // namespace android



#endif  // ANDROID_GUI_SURFACETEXTURECLIENT_H

include/ui/GraphicBuffer.h

+1 −0
Original line number Diff line number Diff line
@@ -121,6 +121,7 @@ private: 
    friend class Surface;

    friend class BpSurface;

    friend class BnSurface;

    friend class SurfaceTextureClient;

    friend class LightRefBase<GraphicBuffer>;

    GraphicBuffer(const GraphicBuffer& rhs);

    GraphicBuffer& operator = (const GraphicBuffer& rhs);

libs/gui/Android.mk

+10 −2
Original line number Diff line number Diff line
@@ -4,17 +4,25 @@ include $(CLEAR_VARS) 
LOCAL_SRC_FILES:= \

	ISensorEventConnection.cpp \

	ISensorServer.cpp \

	ISurfaceTexture.cpp \

	Sensor.cpp \

	SensorChannel.cpp \

	SensorEventQueue.cpp \

	SensorManager.cpp

	SensorManager.cpp \

	SurfaceTexture.cpp \

	SurfaceTextureClient.cpp



LOCAL_SHARED_LIBRARIES := \

	libcutils \

	libutils \

	libbinder \

	libhardware \

	libhardware_legacy

	libhardware_legacy \

	libui \

	libEGL \

	libGLESv2 \

	libsurfaceflinger_client





LOCAL_MODULE:= libgui