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

Commit 08b82bdd authored by Chih-Chung Chang's avatar Chih-Chung Chang
Browse files

Add connect calls for SurfaceTexture. Clean PreviewRenderer. 

Now connect() is necessary for SurfaceTexture.
Also cleaned unused code in PreviewRenderer.

Change-Id: Ic49df01e79f38a48a8c2cf194d13ee575660c834
parent 7b0a960e

libvideoeditor/lvpp/NativeWindowRenderer.cpp

+3 −0
Original line number Diff line number Diff line
@@ -572,6 +572,9 @@ RenderInput::RenderInput(NativeWindowRenderer* renderer, GLuint textureId) 
    : mRenderer(renderer)

    , mTextureId(textureId) {

    mST = new SurfaceTexture(mTextureId);

    uint32_t outWidth, outHeight, outTransform;

    mST->connect(NATIVE_WINDOW_API_MEDIA, &outWidth, &outHeight, &outTransform);



    mSTC = new SurfaceTextureClient(mST);

}

libvideoeditor/lvpp/PreviewRenderer.cpp

+44 −108
Original line number Diff line number Diff line
@@ -21,120 +21,61 @@ 


#include "PreviewRenderer.h"



#include <binder/MemoryHeapBase.h>

#include <binder/MemoryHeapPmem.h>

#include <media/stagefright/MediaDebug.h>

#include <surfaceflinger/Surface.h>



namespace android {



PreviewRenderer* PreviewRenderer::CreatePreviewRenderer (OMX_COLOR_FORMATTYPE colorFormat,

        const sp<Surface> &surface,

        size_t displayWidth, size_t displayHeight,

        size_t decodedWidth, size_t decodedHeight,

        int32_t rotationDegrees) {



        PreviewRenderer* returnCtx =

            new PreviewRenderer(colorFormat,

            surface,

            displayWidth, displayHeight,

            decodedWidth, decodedHeight,

            rotationDegrees);



        int result = 0;



        int halFormat;

        switch (returnCtx->mColorFormat) {

            case OMX_COLOR_FormatYUV420Planar:

            {

                halFormat = HAL_PIXEL_FORMAT_YV12;

                returnCtx->mYUVMode = None;

                break;

            }

            default:

                halFormat = HAL_PIXEL_FORMAT_RGB_565;



                returnCtx->mConverter = new ColorConverter(

                        returnCtx->mColorFormat, OMX_COLOR_Format16bitRGB565);

                CHECK(returnCtx->mConverter->isValid());

                break;

        }



        CHECK(returnCtx->mSurface.get() != NULL);

        CHECK(returnCtx->mDecodedWidth > 0);

        CHECK(returnCtx->mDecodedHeight > 0);

        CHECK(returnCtx->mConverter == NULL || returnCtx->mConverter->isValid());



        result = native_window_set_usage(

                    returnCtx->mSurface.get(),

                    GRALLOC_USAGE_SW_READ_NEVER | GRALLOC_USAGE_SW_WRITE_OFTEN

                    | GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_EXTERNAL_DISP);



        if ( result == 0 ) {

            result = native_window_set_buffer_count(returnCtx->mSurface.get(), 3);

            if ( result == 0 ) {

                result = native_window_set_scaling_mode(returnCtx->mSurface.get(),

                        NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);

                if ( result == 0 ) {

                    result = native_window_set_buffers_geometry(

                            returnCtx->mSurface.get(),

                            returnCtx->mDecodedWidth, returnCtx->mDecodedHeight,

                            halFormat);

                    if ( result == 0) {

                        uint32_t transform;

                        switch (rotationDegrees) {

                            case 0: transform = 0; break;

                            case 90: transform = HAL_TRANSFORM_ROT_90; break;

                            case 180: transform = HAL_TRANSFORM_ROT_180; break;

                            case 270: transform = HAL_TRANSFORM_ROT_270; break;

                            default: transform = 0; break;

                        }

                        if (transform) {

                            result = native_window_set_buffers_transform(

                                    returnCtx->mSurface.get(), transform);

PreviewRenderer* PreviewRenderer::CreatePreviewRenderer (

        const sp<Surface> &surface, size_t width, size_t height) {



                        }

                    }

                }

            }

        }

    PreviewRenderer* renderer = new PreviewRenderer(surface, width, height);



        if ( result != 0 )

        {

            /* free the ctx */

            returnCtx->~PreviewRenderer();

    if (renderer->init() != 0) {

        delete renderer;

        return NULL;

    }



        return returnCtx;

    return renderer;

}



PreviewRenderer::PreviewRenderer(

        OMX_COLOR_FORMATTYPE colorFormat,

        const sp<Surface> &surface,

        size_t displayWidth, size_t displayHeight,

        size_t decodedWidth, size_t decodedHeight,

        int32_t rotationDegrees)

    : mColorFormat(colorFormat),

      mConverter(NULL),

      mYUVMode(None),

      mSurface(surface),

      mDisplayWidth(displayWidth),

      mDisplayHeight(displayHeight),

      mDecodedWidth(decodedWidth),

      mDecodedHeight(decodedHeight) {



    LOGV("input format = %d", mColorFormat);

    LOGV("display = %d x %d, decoded = %d x %d",

            mDisplayWidth, mDisplayHeight, mDecodedWidth, mDecodedHeight);



    mDecodedWidth = mDisplayWidth;

    mDecodedHeight = mDisplayHeight;

        size_t width, size_t height)

    : mSurface(surface),

      mWidth(width),

      mHeight(height) {

}



int PreviewRenderer::init() {

    int err = 0;



    err = native_window_api_connect(mSurface.get(), NATIVE_WINDOW_API_CPU);

    if (err) goto fail;



    err = native_window_set_usage(mSurface.get(),

            GRALLOC_USAGE_SW_READ_NEVER | GRALLOC_USAGE_SW_WRITE_OFTEN);

    if (err) goto fail;



    err = native_window_set_buffer_count(mSurface.get(), 3);

    if (err) goto fail;



    err = native_window_set_scaling_mode(

            mSurface.get(), NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);

    if (err) goto fail;



    err = native_window_set_buffers_geometry(

            mSurface.get(),

            mWidth, mHeight,

            HAL_PIXEL_FORMAT_YV12);

    if (err) goto fail;



fail:

    return err;

}



PreviewRenderer::~PreviewRenderer() {

    delete mConverter;

    mConverter = NULL;

    native_window_api_disconnect(mSurface.get(), NATIVE_WINDOW_API_CPU);

}
@@ -153,7 +94,6 @@ PreviewRenderer::~PreviewRenderer() { 
//

void PreviewRenderer::getBufferYV12(uint8_t **data, size_t *stride) {

    int err = OK;

    LOGV("getBuffer START");



    if ((err = mSurface->ANativeWindow::dequeueBuffer(mSurface.get(), &mBuf)) != 0) {

        LOGW("Surface::dequeueBuffer returned error %d", err);
@@ -164,17 +104,15 @@ void PreviewRenderer::getBufferYV12(uint8_t **data, size_t *stride) { 


    GraphicBufferMapper &mapper = GraphicBufferMapper::get();



    Rect bounds(mDecodedWidth, mDecodedHeight);

    Rect bounds(mWidth, mHeight);



    void *dst;

    CHECK_EQ(0, mapper.lock(

                mBuf->handle, GRALLOC_USAGE_SW_WRITE_OFTEN, bounds, &dst));

    LOGV("Buffer locked");

    CHECK_EQ(0, mapper.lock(mBuf->handle,

            GRALLOC_USAGE_SW_READ_NEVER | GRALLOC_USAGE_SW_WRITE_OFTEN,

            bounds, &dst));



    *data   = (uint8_t*)dst;

    *stride = mBuf->stride;



    LOGV("getBuffer END %p %d", dst, mBuf->stride);

}
@@ -184,7 +122,6 @@ void PreviewRenderer::getBufferYV12(uint8_t **data, size_t *stride) { 
// See getBufferYV12() for details.

//

void PreviewRenderer::renderYV12() {

    LOGV("renderYV12() START");

    int err = OK;



    GraphicBufferMapper &mapper = GraphicBufferMapper::get();
@@ -197,7 +134,6 @@ void PreviewRenderer::renderYV12() { 
        }

    }

    mBuf = NULL;

    LOGV("renderYV12() END");

}



}  // namespace android

libvideoeditor/lvpp/PreviewRenderer.h

+7 −19
Original line number Diff line number Diff line
@@ -32,11 +32,9 @@ class Surface; 
class PreviewRenderer {

public:



static PreviewRenderer* CreatePreviewRenderer (OMX_COLOR_FORMATTYPE colorFormat,

static PreviewRenderer* CreatePreviewRenderer (

        const sp<Surface> &surface,

        size_t displayWidth, size_t displayHeight,

        size_t decodedWidth, size_t decodedHeight,

        int32_t rotationDegrees);

        size_t width, size_t height);



    ~PreviewRenderer();
@@ -50,23 +48,13 @@ static PreviewRenderer* CreatePreviewRenderer (OMX_COLOR_FORMATTYPE colorFormat, 


private:

    PreviewRenderer(

            OMX_COLOR_FORMATTYPE colorFormat,

            const sp<Surface> &surface,

            size_t displayWidth, size_t displayHeight,

            size_t decodedWidth, size_t decodedHeight,

            int32_t rotationDegrees);

    enum YUVMode {

        None,

        YUV420ToYUV420sp,

        YUV420spToYUV420sp,

    };

            size_t width, size_t height);



    int init();



    OMX_COLOR_FORMATTYPE mColorFormat;

    ColorConverter *mConverter;

    YUVMode mYUVMode;

    sp<Surface> mSurface;

    size_t mDisplayWidth, mDisplayHeight;

    size_t mDecodedWidth, mDecodedHeight;

    size_t mWidth, mHeight;



    ANativeWindowBuffer *mBuf;

libvideoeditor/lvpp/VideoEditorPreviewController.cpp

+4 −8
Original line number Diff line number Diff line
@@ -747,8 +747,8 @@ M4OSA_ERR VideoEditorPreviewController::clearSurface( 
    if(mTarget == NULL) {



        mTarget = PreviewRenderer::CreatePreviewRenderer(

            OMX_COLOR_FormatYUV420Planar, surface, outputBufferWidth, outputBufferHeight,

            outputBufferWidth, outputBufferHeight, 0);

            surface,

            outputBufferWidth, outputBufferHeight);



        if(mTarget == NULL) {

            LOGE("renderPreviewFrame: cannot create PreviewRenderer");
@@ -813,13 +813,9 @@ M4OSA_ERR VideoEditorPreviewController::renderPreviewFrame( 


    // Initialize the renderer

    if(mTarget == NULL) {

        /*mTarget = new PreviewRenderer(

            OMX_COLOR_FormatYUV420Planar, surface, mOutputVideoWidth, mOutputVideoHeight,

            mOutputVideoWidth, mOutputVideoHeight, 0);*/



         mTarget = PreviewRenderer::CreatePreviewRenderer(

            OMX_COLOR_FormatYUV420Planar, surface, mOutputVideoWidth, mOutputVideoHeight,

            mOutputVideoWidth, mOutputVideoHeight, 0);

            surface,

            mOutputVideoWidth, mOutputVideoHeight);



        if(mTarget == NULL) {

            LOGE("renderPreviewFrame: cannot create PreviewRenderer");