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

Commit f52b2284 authored by Lajos Molnar's avatar Lajos Molnar Committed by Android (Google) Code Review
Browse files

Merge changes from topic 'codec-setsurface' into mnc-dev 

* changes:
  stagefright: support push-blank-buffers-on-shutdown for SW renderer
  ACodec: blank surface when switching to another surface
  stagefright: move native window helpers into SurfaceUtils
parents 3b7084c6 8b237597

include/media/stagefright/ACodec.h

+0 −5
Original line number Diff line number Diff line
@@ -236,9 +236,6 @@ private: 
    status_t freeBuffer(OMX_U32 portIndex, size_t i);



    status_t handleSetSurface(const sp<Surface> &surface);

    status_t setNativeWindowSizeFormatAndUsage(

            ANativeWindow *nativeWindow /* nonnull */,

            int width, int height, int format, int rotation, int usage);

    status_t setupNativeWindowSizeFormatAndUsage(ANativeWindow *nativeWindow /* nonnull */);



    status_t configureOutputBuffersFromNativeWindow(
@@ -332,8 +329,6 @@ private: 


    status_t initNativeWindow();



    status_t pushBlankBuffersToNativeWindow();



    // Returns true iff all buffers on the given port have status

    // OWNED_BY_US or OWNED_BY_NATIVE_WINDOW.

    bool allYourBuffersAreBelongToUs(OMX_U32 portIndex);

include/media/stagefright/MediaCodec.h

+1 −0
Original line number Diff line number Diff line
@@ -224,6 +224,7 @@ private: 
        kFlagGatherCodecSpecificData    = 512,

        kFlagIsAsync                    = 1024,

        kFlagIsComponentAllocated       = 2048,

        kFlagPushBlankBuffersOnShutdown = 4096,

    };



    struct BufferInfo {

include/media/stagefright/OMXCodec.h

+0 −2
Original line number Diff line number Diff line
@@ -298,7 +298,6 @@ private: 
    status_t queueBufferToNativeWindow(BufferInfo *info);

    status_t cancelBufferToNativeWindow(BufferInfo *info);

    BufferInfo* dequeueBufferFromNativeWindow();

    status_t pushBlankBuffersToNativeWindow();



    status_t freeBuffersOnPort(

            OMX_U32 portIndex, bool onlyThoseWeOwn = false);
@@ -347,7 +346,6 @@ private: 


    status_t configureCodec(const sp<MetaData> &meta);



    status_t applyRotation();

    status_t waitForBufferFilled_l();



    int64_t getDecodingTimeUs();

include/media/stagefright/SurfaceUtils.h

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

 * Copyright 2015 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 SURFACE_UTILS_H_



#define SURFACE_UTILS_H_



#include <utils/Errors.h>



struct ANativeWindow;



namespace android {



status_t setNativeWindowSizeFormatAndUsage(

        ANativeWindow *nativeWindow /* nonnull */,

        int width, int height, int format, int rotation, int usage);

status_t pushBlankBuffersToNativeWindow(ANativeWindow *nativeWindow /* nonnull */);



} // namespace android



#endif  // SURFACE_UTILS_H_

media/libstagefright/ACodec.cpp

+9 −208
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ 
#include <media/stagefright/OMXClient.h>

#include <media/stagefright/OMXCodec.h>

#include <media/stagefright/PersistentSurface.h>

#include <media/stagefright/SurfaceUtils.h>

#include <media/hardware/HardwareAPI.h>



#include <OMX_AudioExt.h>
@@ -650,6 +651,11 @@ status_t ACodec::handleSetSurface(const sp<Surface> &surface) { 
        (void)surface->getIGraphicBufferProducer()->allowAllocation(false);

    }



    // push blank buffers to previous window if requested

    if (mFlags & kFlagPushBlankBuffersToNativeWindowOnShutdown) {

        pushBlankBuffersToNativeWindow(mNativeWindow.get());

    }



    mNativeWindow = nativeWindow;

    return OK;

}
@@ -748,82 +754,6 @@ status_t ACodec::allocateBuffersOnPort(OMX_U32 portIndex) { 
    return OK;

}



status_t ACodec::setNativeWindowSizeFormatAndUsage(

        ANativeWindow *nativeWindow /* nonnull */,

        int width, int height, int format, int rotation, int usage) {

    status_t err = native_window_set_buffers_dimensions(nativeWindow, width, height);

    if (err != 0) {

        ALOGE("native_window_set_buffers_dimensions failed: %s (%d)", strerror(-err), -err);

        return err;

    }



    err = native_window_set_buffers_format(nativeWindow, format);

    if (err != 0) {

        ALOGE("native_window_set_buffers_format failed: %s (%d)", strerror(-err), -err);

        return err;

    }



    int transform = 0;

    if ((rotation % 90) == 0) {

        switch ((rotation / 90) & 3) {

            case 1:  transform = HAL_TRANSFORM_ROT_90;  break;

            case 2:  transform = HAL_TRANSFORM_ROT_180; break;

            case 3:  transform = HAL_TRANSFORM_ROT_270; break;

            default: transform = 0;                     break;

        }

    }



    err = native_window_set_buffers_transform(nativeWindow, transform);

    if (err != 0) {

        ALOGE("native_window_set_buffers_transform failed: %s (%d)", strerror(-err), -err);

        return err;

    }



    // Make sure to check whether either Stagefright or the video decoder

    // requested protected buffers.

    if (usage & GRALLOC_USAGE_PROTECTED) {

        // Verify that the ANativeWindow sends images directly to

        // SurfaceFlinger.

        int queuesToNativeWindow = 0;

        err = nativeWindow->query(

                nativeWindow, NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER, &queuesToNativeWindow);

        if (err != 0) {

            ALOGE("error authenticating native window: %s (%d)", strerror(-err), -err);

            return err;

        }

        if (queuesToNativeWindow != 1) {

            ALOGE("native window could not be authenticated");

            return PERMISSION_DENIED;

        }

    }



    int consumerUsage = 0;

    err = nativeWindow->query(nativeWindow, NATIVE_WINDOW_CONSUMER_USAGE_BITS, &consumerUsage);

    if (err != 0) {

        ALOGW("failed to get consumer usage bits. ignoring");

        err = 0;

    }



    int finalUsage = usage | consumerUsage | GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_EXTERNAL_DISP;

    ALOGV("gralloc usage: %#x(ACodec) + %#x(Consumer) = %#x", usage, consumerUsage, finalUsage);

    err = native_window_set_usage(nativeWindow, finalUsage);

    if (err != 0) {

        ALOGE("native_window_set_usage failed: %s (%d)", strerror(-err), -err);

        return err;

    }



    err = native_window_set_scaling_mode(

            nativeWindow, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);

    if (err != 0) {

        ALOGE("native_window_set_scaling_mode failed: %s (%d)", strerror(-err), -err);

        return err;

    }



    ALOGD("set up nativeWindow %p for %dx%d, color %#x, rotation %d, usage %#x",

            nativeWindow, width, height, format, rotation, finalUsage);

    return OK;

}



status_t ACodec::setupNativeWindowSizeFormatAndUsage(ANativeWindow *nativeWindow /* nonnull */) {

    OMX_PARAM_PORTDEFINITIONTYPE def;

    InitOMXParams(&def);
@@ -849,6 +779,8 @@ status_t ACodec::setupNativeWindowSizeFormatAndUsage(ANativeWindow *nativeWindow 
        usage |= GRALLOC_USAGE_PROTECTED;

    }



    usage |= GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_EXTERNAL_DISP;



    ALOGV("gralloc usage: %#x(OMX) => %#x(ACodec)", omxUsage, usage);

    return setNativeWindowSizeFormatAndUsage(

            nativeWindow,
@@ -4123,137 +4055,6 @@ void ACodec::signalError(OMX_ERRORTYPE error, status_t internalError) { 
    notify->post();

}



status_t ACodec::pushBlankBuffersToNativeWindow() {

    status_t err = NO_ERROR;

    ANativeWindowBuffer* anb = NULL;

    int numBufs = 0;

    int minUndequeuedBufs = 0;



    // We need to reconnect to the ANativeWindow as a CPU client to ensure that

    // no frames get dropped by SurfaceFlinger assuming that these are video

    // frames.

    err = native_window_api_disconnect(mNativeWindow.get(),

            NATIVE_WINDOW_API_MEDIA);

    if (err != NO_ERROR) {

        ALOGE("error pushing blank frames: api_disconnect failed: %s (%d)",

                strerror(-err), -err);

        return err;

    }



    err = native_window_api_connect(mNativeWindow.get(),

            NATIVE_WINDOW_API_CPU);

    if (err != NO_ERROR) {

        ALOGE("error pushing blank frames: api_connect failed: %s (%d)",

                strerror(-err), -err);

        return err;

    }



    err = setNativeWindowSizeFormatAndUsage(

            mNativeWindow.get(), 1, 1, HAL_PIXEL_FORMAT_RGBX_8888, 0, GRALLOC_USAGE_SW_WRITE_OFTEN);

    if (err != NO_ERROR) {

        ALOGE("error pushing blank frames: set format failed: %s (%d)",

                strerror(-err), -err);

        goto error;

    }



    static_cast<Surface*>(mNativeWindow.get())

            ->getIGraphicBufferProducer()->allowAllocation(true);



    err = mNativeWindow->query(mNativeWindow.get(),

            NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &minUndequeuedBufs);

    if (err != NO_ERROR) {

        ALOGE("error pushing blank frames: MIN_UNDEQUEUED_BUFFERS query "

                "failed: %s (%d)", strerror(-err), -err);

        goto error;

    }



    numBufs = minUndequeuedBufs + 1;

    err = native_window_set_buffer_count(mNativeWindow.get(), numBufs);

    if (err != NO_ERROR) {

        ALOGE("error pushing blank frames: set_buffer_count failed: %s (%d)",

                strerror(-err), -err);

        goto error;

    }



    // We  push numBufs + 1 buffers to ensure that we've drawn into the same

    // buffer twice.  This should guarantee that the buffer has been displayed

    // on the screen and then been replaced, so an previous video frames are

    // guaranteed NOT to be currently displayed.

    for (int i = 0; i < numBufs + 1; i++) {

        err = native_window_dequeue_buffer_and_wait(mNativeWindow.get(), &anb);

        if (err != NO_ERROR) {

            ALOGE("error pushing blank frames: dequeueBuffer failed: %s (%d)",

                    strerror(-err), -err);

            goto error;

        }



        sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));



        // Fill the buffer with the a 1x1 checkerboard pattern ;)

        uint32_t* img = NULL;

        err = buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));

        if (err != NO_ERROR) {

            ALOGE("error pushing blank frames: lock failed: %s (%d)",

                    strerror(-err), -err);

            goto error;

        }



        *img = 0;



        err = buf->unlock();

        if (err != NO_ERROR) {

            ALOGE("error pushing blank frames: unlock failed: %s (%d)",

                    strerror(-err), -err);

            goto error;

        }



        err = mNativeWindow->queueBuffer(mNativeWindow.get(),

                buf->getNativeBuffer(), -1);

        if (err != NO_ERROR) {

            ALOGE("error pushing blank frames: queueBuffer failed: %s (%d)",

                    strerror(-err), -err);

            goto error;

        }



        anb = NULL;

    }



error:



    if (err != NO_ERROR) {

        // Clean up after an error.

        if (anb != NULL) {

            mNativeWindow->cancelBuffer(mNativeWindow.get(), anb, -1);

        }



        native_window_api_disconnect(mNativeWindow.get(),

                NATIVE_WINDOW_API_CPU);

        native_window_api_connect(mNativeWindow.get(),

                NATIVE_WINDOW_API_MEDIA);



        return err;

    } else {

        // Clean up after success.

        err = native_window_api_disconnect(mNativeWindow.get(),

                NATIVE_WINDOW_API_CPU);

        if (err != NO_ERROR) {

            ALOGE("error pushing blank frames: api_disconnect failed: %s (%d)",

                    strerror(-err), -err);

            return err;

        }



        err = native_window_api_connect(mNativeWindow.get(),

                NATIVE_WINDOW_API_MEDIA);

        if (err != NO_ERROR) {

            ALOGE("error pushing blank frames: api_connect failed: %s (%d)",

                    strerror(-err), -err);

            return err;

        }



        return NO_ERROR;

    }

}



////////////////////////////////////////////////////////////////////////////////



ACodec::PortDescription::PortDescription() {
@@ -6148,7 +5949,7 @@ void ACodec::ExecutingToIdleState::changeStateIfWeOwnAllBuffers() { 
            // them has made it to the display.  This allows the OMX

            // component teardown to zero out any protected buffers

            // without the risk of scanning out one of those buffers.

            mCodec->pushBlankBuffersToNativeWindow();

            pushBlankBuffersToNativeWindow(mCodec->mNativeWindow.get());

        }



        mCodec->changeState(mCodec->mIdleToLoadedState);