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

Commit 9bb3803a authored by Wei Jia's avatar Wei Jia
Browse files

BufferingSettings: simplify buffering control. 

Now only 2 marks, initialMarkMs and resumPlaybackMarkMs, remain.
Test: pass cts tests
Bug: 36280094
Change-Id: I03c8e2a0db9f7e845f57e76f51874cd8715a48d4
parent 63ca9630

media/libmedia/BufferingSettings.cpp

+9 −45
Original line number Diff line number Diff line
@@ -23,43 +23,16 @@ 


namespace android {



// static

bool BufferingSettings::IsValidBufferingMode(int mode) {

    return (mode >= BUFFERING_MODE_NONE && mode < BUFFERING_MODE_COUNT);

}



// static

bool BufferingSettings::IsTimeBasedBufferingMode(int mode) {

    return (mode == BUFFERING_MODE_TIME_ONLY || mode == BUFFERING_MODE_TIME_THEN_SIZE);

}



// static

bool BufferingSettings::IsSizeBasedBufferingMode(int mode) {

    return (mode == BUFFERING_MODE_SIZE_ONLY || mode == BUFFERING_MODE_TIME_THEN_SIZE);

}



BufferingSettings::BufferingSettings()

        : mInitialBufferingMode(BUFFERING_MODE_NONE),

          mRebufferingMode(BUFFERING_MODE_NONE),

          mInitialWatermarkMs(kNoWatermark),

          mInitialWatermarkKB(kNoWatermark),

          mRebufferingWatermarkLowMs(kNoWatermark),

          mRebufferingWatermarkHighMs(kNoWatermark),

          mRebufferingWatermarkLowKB(kNoWatermark),

          mRebufferingWatermarkHighKB(kNoWatermark) { }

        : mInitialMarkMs(kNoMark),

          mResumePlaybackMarkMs(kNoMark) { }



status_t BufferingSettings::readFromParcel(const Parcel* parcel) {

    if (parcel == nullptr) {

        return BAD_VALUE;

    }

    mInitialBufferingMode = (BufferingMode)parcel->readInt32();

    mRebufferingMode = (BufferingMode)parcel->readInt32();

    mInitialWatermarkMs = parcel->readInt32();

    mInitialWatermarkKB = parcel->readInt32();

    mRebufferingWatermarkLowMs = parcel->readInt32();

    mRebufferingWatermarkHighMs = parcel->readInt32();

    mRebufferingWatermarkLowKB = parcel->readInt32();

    mRebufferingWatermarkHighKB = parcel->readInt32();

    mInitialMarkMs = parcel->readInt32();

    mResumePlaybackMarkMs = parcel->readInt32();



    return OK;

}
@@ -68,26 +41,17 @@ status_t BufferingSettings::writeToParcel(Parcel* parcel) const { 
    if (parcel == nullptr) {

        return BAD_VALUE;

    }

    parcel->writeInt32(mInitialBufferingMode);

    parcel->writeInt32(mRebufferingMode);

    parcel->writeInt32(mInitialWatermarkMs);

    parcel->writeInt32(mInitialWatermarkKB);

    parcel->writeInt32(mRebufferingWatermarkLowMs);

    parcel->writeInt32(mRebufferingWatermarkHighMs);

    parcel->writeInt32(mRebufferingWatermarkLowKB);

    parcel->writeInt32(mRebufferingWatermarkHighKB);

    parcel->writeInt32(mInitialMarkMs);

    parcel->writeInt32(mResumePlaybackMarkMs);



    return OK;

}



String8 BufferingSettings::toString() const {

    String8 s;

    s.appendFormat("initialMode(%d), rebufferingMode(%d), "

            "initialMarks(%d ms, %d KB), rebufferingMarks(%d, %d)ms, (%d, %d)KB",

            mInitialBufferingMode, mRebufferingMode,

            mInitialWatermarkMs, mInitialWatermarkKB,

            mRebufferingWatermarkLowMs, mRebufferingWatermarkHighMs,

            mRebufferingWatermarkLowKB, mRebufferingWatermarkHighKB);

    s.appendFormat(

            "initialMarks(%d ms), resumePlaybackMarks(%d ms)",

            mInitialMarkMs, mResumePlaybackMarkMs);

    return s;

}

media/libmedia/IMediaPlayer.cpp

+5 −5
Original line number Diff line number Diff line
@@ -44,7 +44,7 @@ enum { 
    SET_DATA_SOURCE_STREAM,

    SET_DATA_SOURCE_CALLBACK,

    SET_BUFFERING_SETTINGS,

    GET_DEFAULT_BUFFERING_SETTINGS,

    GET_BUFFERING_SETTINGS,

    PREPARE_ASYNC,

    START,

    STOP,
@@ -184,14 +184,14 @@ public: 
        return reply.readInt32();

    }



    status_t getDefaultBufferingSettings(BufferingSettings* buffering /* nonnull */)

    status_t getBufferingSettings(BufferingSettings* buffering /* nonnull */)

    {

        if (buffering == nullptr) {

            return BAD_VALUE;

        }

        Parcel data, reply;

        data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());

        remote()->transact(GET_DEFAULT_BUFFERING_SETTINGS, data, &reply);

        remote()->transact(GET_BUFFERING_SETTINGS, data, &reply);

        status_t err = reply.readInt32();

        if (err == OK) {

            err = buffering->readFromParcel(&reply);
@@ -700,10 +700,10 @@ status_t BnMediaPlayer::onTransact( 
            reply->writeInt32(setBufferingSettings(buffering));

            return NO_ERROR;

        } break;

        case GET_DEFAULT_BUFFERING_SETTINGS: {

        case GET_BUFFERING_SETTINGS: {

            CHECK_INTERFACE(IMediaPlayer, data, reply);

            BufferingSettings buffering;

            status_t err = getDefaultBufferingSettings(&buffering);

            status_t err = getBufferingSettings(&buffering);

            reply->writeInt32(err);

            if (err == OK) {

                buffering.writeToParcel(reply);

media/libmedia/include/media/BufferingSettings.h

+5 −36
Original line number Diff line number Diff line
@@ -21,45 +21,14 @@ 


namespace android {



enum BufferingMode : int {

    // Do not support buffering.

    BUFFERING_MODE_NONE             = 0,

    // Support only time based buffering.

    BUFFERING_MODE_TIME_ONLY        = 1,

    // Support only size based buffering.

    BUFFERING_MODE_SIZE_ONLY        = 2,

    // Support both time and size based buffering, time based calculation precedes size based.

    // Size based calculation will be used only when time information is not available for

    // the stream.

    BUFFERING_MODE_TIME_THEN_SIZE   = 3,

    // Number of modes.

    BUFFERING_MODE_COUNT            = 4,

};



struct BufferingSettings : public Parcelable {

    static const int kNoWatermark = -1;



    static bool IsValidBufferingMode(int mode);

    static bool IsTimeBasedBufferingMode(int mode);

    static bool IsSizeBasedBufferingMode(int mode);



    BufferingMode mInitialBufferingMode;  // for prepare

    BufferingMode mRebufferingMode;  // for playback



    int mInitialWatermarkMs;  // time based

    int mInitialWatermarkKB;  // size based

    static const int kNoMark = -1;



    // When cached data is below this mark, playback will be paused for buffering

    // till data reach |mRebufferingWatermarkHighMs| or end of stream.

    int mRebufferingWatermarkLowMs;

    // When cached data is above this mark, buffering will be paused.

    int mRebufferingWatermarkHighMs;

    int mInitialMarkMs;



    // When cached data is below this mark, playback will be paused for buffering

    // till data reach |mRebufferingWatermarkHighKB| or end of stream.

    int mRebufferingWatermarkLowKB;

    // When cached data is above this mark, buffering will be paused.

    int mRebufferingWatermarkHighKB;

    // When cached data is above this mark, playback will be resumed if it has been paused

    // due to low cached data.

    int mResumePlaybackMarkMs;



    BufferingSettings();

media/libmedia/include/media/IMediaPlayer.h

+1 −1
Original line number Diff line number Diff line
@@ -61,7 +61,7 @@ public: 
    virtual status_t        setDataSource(const sp<IDataSource>& source) = 0;

    virtual status_t        setVideoSurfaceTexture(

                                    const sp<IGraphicBufferProducer>& bufferProducer) = 0;

    virtual status_t        getDefaultBufferingSettings(

    virtual status_t        getBufferingSettings(

                                    BufferingSettings* buffering /* nonnull */) = 0;

    virtual status_t        setBufferingSettings(const BufferingSettings& buffering) = 0;

    virtual status_t        prepareAsync() = 0;

media/libmedia/include/media/mediaplayer.h

+0 −2
Original line number Diff line number Diff line
@@ -227,7 +227,6 @@ public: 
            status_t        setVideoSurfaceTexture(

                                    const sp<IGraphicBufferProducer>& bufferProducer);

            status_t        setListener(const sp<MediaPlayerListener>& listener);

            status_t        getDefaultBufferingSettings(BufferingSettings* buffering /* nonnull */);

            status_t        getBufferingSettings(BufferingSettings* buffering /* nonnull */);

            status_t        setBufferingSettings(const BufferingSettings& buffering);

            status_t        prepare();
@@ -316,7 +315,6 @@ private: 
    float                       mSendLevel;

    struct sockaddr_in          mRetransmitEndpoint;

    bool                        mRetransmitEndpointValid;

    BufferingSettings           mCurrentBufferingSettings;

};



}; // namespace android