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

Commit 813869b7 authored by Brian Lindahl's avatar Brian Lindahl Committed by Android (Google) Code Review
Browse files

Merge changes from topic "peek-default-mode" into tm-dev 

* changes:
  Allow the default mode for video peek to be undefined
  Allow the default mode for video peek to be undefined
  Allow the default mode for video peek to be undefined
  Allow the default mode for video peek to be undefined
parents 9f1b1863 22441854

media/codec2/core/include/C2Config.h

+26 −0
Original line number Diff line number Diff line
@@ -79,6 +79,7 @@ struct C2Config { 


struct C2PlatformConfig {

    enum encoding_quality_level_t : uint32_t; ///< encoding quality level

    enum tunnel_peek_mode_t: uint32_t;      ///< tunnel peek mode

};



namespace {
@@ -280,6 +281,9 @@ enum C2ParamIndexKind : C2Param::type_index_t { 


    // channel mask for decoded audio

    kParamIndexAndroidChannelMask, // uint32



    // allow tunnel peek behavior to be unspecified for app compatibility

    kParamIndexTunnelPeekMode, // tunnel mode, enum

};



}
@@ -2482,6 +2486,28 @@ typedef C2StreamParam<C2Info, C2EasyBoolValue, kParamIndexTunnelStartRender> 
        C2StreamTunnelStartRender;

constexpr char C2_PARAMKEY_TUNNEL_START_RENDER[] = "output.tunnel-start-render";



/** Tunnel Peek Mode. */

C2ENUM(C2PlatformConfig::tunnel_peek_mode_t, uint32_t,

    UNSPECIFIED_PEEK = 0,

    SPECIFIED_PEEK = 1

);



/**

 * Tunnel Peek Mode Tuning parameter.

 *

 * If set to UNSPECIFIED_PEEK_MODE, the decoder is free to ignore the

 * C2StreamTunnelHoldRender and C2StreamTunnelStartRender flags and associated

 * features. Additionally, it becomes up to the decoder to display any frame

 * before receiving synchronization information.

 *

 * Note: This parameter allows a decoder to ignore the video peek machinery and

 * to revert to its preferred behavior.

 */

typedef C2StreamParam<C2Tuning, C2EasyEnum<C2PlatformConfig::tunnel_peek_mode_t>,

        kParamIndexTunnelPeekMode> C2StreamTunnelPeekModeTuning;

constexpr char C2_PARAMKEY_TUNNEL_PEEK_MODE[] =

        "output.tunnel-peek-mode";



/**

 * Encoding quality level signaling.

 *

media/codec2/sfplugin/CCodecConfig.cpp

+10 −0
Original line number Diff line number Diff line
@@ -965,6 +965,16 @@ void CCodecConfig::initializeStandardParams() { 
            return value == 0 ? C2_FALSE : C2_TRUE;

        }));



    add(ConfigMapper("android._tunnel-peek-set-legacy", C2_PARAMKEY_TUNNEL_PEEK_MODE, "value")

        .limitTo(D::PARAM & D::VIDEO & D::DECODER)

        .withMapper([](C2Value v) -> C2Value {

          int32_t value = 0;

          (void)v.get(&value);

          return value == 0

              ? C2Value(C2PlatformConfig::SPECIFIED_PEEK)

              : C2Value(C2PlatformConfig::UNSPECIFIED_PEEK);

        }));



    add(ConfigMapper(KEY_VIDEO_QP_AVERAGE, C2_PARAMKEY_AVERAGE_QP, "value")

        .limitTo(D::ENCODER & D::VIDEO & D::READ));

media/libstagefright/ACodec.cpp

+44 −10
Original line number Diff line number Diff line
@@ -77,6 +77,7 @@ enum { 
namespace {



constexpr char TUNNEL_PEEK_KEY[] = "android._trigger-tunnel-peek";

constexpr char TUNNEL_PEEK_SET_LEGACY_KEY[] = "android._tunnel-peek-set-legacy";



}
@@ -2483,17 +2484,39 @@ status_t ACodec::setTunnelPeek(int32_t tunnelPeek) { 
        return BAD_VALUE;

    }



    OMX_CONFIG_BOOLEANTYPE config;

    InitOMXParams(&config);

    config.bEnabled = (OMX_BOOL)(tunnelPeek != 0);

    OMX_CONFIG_BOOLEANTYPE tunnelPeekConfig;

    InitOMXParams(&tunnelPeekConfig);

    tunnelPeekConfig.bEnabled = (OMX_BOOL)(tunnelPeek != 0);

    status_t err = mOMXNode->setConfig(

            (OMX_INDEXTYPE)OMX_IndexConfigAndroidTunnelPeek,

            &config, sizeof(config));

            &tunnelPeekConfig, sizeof(tunnelPeekConfig));

    if (err != OK) {

        ALOGE("decoder cannot set %s to %d (err %d)",

                TUNNEL_PEEK_KEY, tunnelPeek, err);

    }

    return err;

}



status_t ACodec::setTunnelPeekLegacy(int32_t isLegacy) {

    if (mIsEncoder) {

        ALOGE("encoder does not support %s", TUNNEL_PEEK_SET_LEGACY_KEY);

        return BAD_VALUE;

    }

    if (!mTunneled) {

        ALOGE("%s is only supported in tunnel mode", TUNNEL_PEEK_SET_LEGACY_KEY);

        return BAD_VALUE;

    }



    OMX_CONFIG_BOOLEANTYPE tunnelPeekLegacyModeConfig;

    InitOMXParams(&tunnelPeekLegacyModeConfig);

    tunnelPeekLegacyModeConfig.bEnabled = (OMX_BOOL)(isLegacy != 0);

    status_t err = mOMXNode->setConfig(

            (OMX_INDEXTYPE)OMX_IndexConfigAndroidTunnelPeekLegacyMode,

            &tunnelPeekLegacyModeConfig, sizeof(tunnelPeekLegacyModeConfig));

    if (err != OK) {

        ALOGE("decoder cannot set video peek legacy mode to %d (err %d)",

                isLegacy,  err);

    }

    return err;

}
@@ -7934,6 +7957,7 @@ status_t ACodec::setParameters(const sp<AMessage> &params) { 
        }

    }



    {

        int32_t tunnelPeek = 0;

        if (params->findInt32(TUNNEL_PEEK_KEY, &tunnelPeek)) {

            status_t err = setTunnelPeek(tunnelPeek);
@@ -7941,6 +7965,16 @@ status_t ACodec::setParameters(const sp<AMessage> &params) { 
                return err;

            }

        }

    }

    {

        int32_t tunnelPeekSetLegacy = 0;

        if (params->findInt32(TUNNEL_PEEK_SET_LEGACY_KEY, &tunnelPeekSetLegacy)) {

            status_t err = setTunnelPeekLegacy(tunnelPeekSetLegacy);

            if (err != OK) {

                return err;

            }

        }

    }



    return setVendorParameters(params);

}

media/libstagefright/MediaCodec.cpp

+35 −13
Original line number Diff line number Diff line
@@ -817,7 +817,7 @@ MediaCodec::MediaCodec( 
      mTunneledInputWidth(0),

      mTunneledInputHeight(0),

      mTunneled(false),

      mTunnelPeekState(TunnelPeekState::kEnabledNoBuffer),

      mTunnelPeekState(TunnelPeekState::kLegacyMode),

      mHaveInputSurface(false),

      mHavePendingInputBuffers(false),

      mCpuBoostRequested(false),
@@ -1087,6 +1087,8 @@ void MediaCodec::updateLowLatency(const sp<AMessage> &msg) { 


constexpr const char *MediaCodec::asString(TunnelPeekState state, const char *default_string){

    switch(state) {

        case TunnelPeekState::kLegacyMode:

            return "LegacyMode";

        case TunnelPeekState::kEnabledNoBuffer:

            return "EnabledNoBuffer";

        case TunnelPeekState::kDisabledNoBuffer:
@@ -1113,6 +1115,9 @@ void MediaCodec::updateTunnelPeek(const sp<AMessage> &msg) { 
    TunnelPeekState previousState = mTunnelPeekState;

    if(tunnelPeek == 0){

        switch (mTunnelPeekState) {

            case TunnelPeekState::kLegacyMode:

                msg->setInt32("android._tunnel-peek-set-legacy", 0);

                [[fallthrough]];

            case TunnelPeekState::kEnabledNoBuffer:

                mTunnelPeekState = TunnelPeekState::kDisabledNoBuffer;

                break;
@@ -1125,6 +1130,9 @@ void MediaCodec::updateTunnelPeek(const sp<AMessage> &msg) { 
        }

    } else {

        switch (mTunnelPeekState) {

            case TunnelPeekState::kLegacyMode:

                msg->setInt32("android._tunnel-peek-set-legacy", 0);

                [[fallthrough]];

            case TunnelPeekState::kDisabledNoBuffer:

                mTunnelPeekState = TunnelPeekState::kEnabledNoBuffer;

                break;
@@ -3539,10 +3547,12 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) { 
                        break;

                    }

                    TunnelPeekState previousState = mTunnelPeekState;

                    if (mTunnelPeekState != TunnelPeekState::kLegacyMode) {

                        mTunnelPeekState = TunnelPeekState::kBufferRendered;

                        ALOGV("TunnelPeekState: %s -> %s",

                                asString(previousState),

                                asString(TunnelPeekState::kBufferRendered));

                    }

                    updatePlaybackDuration(msg);

                    // check that we have a notification set

                    if (mOnFrameRenderedNotification != NULL) {
@@ -3959,6 +3969,14 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) { 
                mTunneled = false;

            }



            // If mTunnelPeekState is still in kLegacyMode at this point,

            // configure the codec in legacy mode

            if (mTunneled && (mTunnelPeekState == TunnelPeekState::kLegacyMode)) {

                sp<AMessage> params = new AMessage;

                params->setInt32("android._tunnel-peek-set-legacy", 1);

                setParameters(params);

            }



            int32_t background = 0;

            if (format->findInt32("android._background-mode", &background) && background) {

                androidSetThreadPriority(gettid(), ANDROID_PRIORITY_BACKGROUND);
@@ -4077,10 +4095,12 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) { 
            sp<AReplyToken> replyID;

            CHECK(msg->senderAwaitsResponse(&replyID));

            TunnelPeekState previousState = mTunnelPeekState;

            if (previousState != TunnelPeekState::kLegacyMode) {

                mTunnelPeekState = TunnelPeekState::kEnabledNoBuffer;

                ALOGV("TunnelPeekState: %s -> %s",

                        asString(previousState),

                        asString(TunnelPeekState::kEnabledNoBuffer));

            }



            mReplyID = replyID;

            setState(STARTING);
@@ -4521,10 +4541,12 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) { 
            mCodec->signalFlush();

            returnBuffersToCodec();

            TunnelPeekState previousState = mTunnelPeekState;

            if (previousState != TunnelPeekState::kLegacyMode) {

                mTunnelPeekState = TunnelPeekState::kEnabledNoBuffer;

                ALOGV("TunnelPeekState: %s -> %s",

                        asString(previousState),

                        asString(TunnelPeekState::kEnabledNoBuffer));

            }

            break;

        }

media/libstagefright/include/media/stagefright/ACodec.h

+1 −0
Original line number Diff line number Diff line
@@ -522,6 +522,7 @@ private: 
    status_t setLatency(uint32_t latency);

    status_t getLatency(uint32_t *latency);

    status_t setTunnelPeek(int32_t tunnelPeek);

    status_t setTunnelPeekLegacy(int32_t isLegacy);

    status_t setAudioPresentation(int32_t presentationId, int32_t programId);

    status_t setOperatingRate(float rateFloat, bool isVideo);

    status_t getIntraRefreshPeriod(uint32_t *intraRefreshPeriod);