MediaPlayer的核心-NuPlayer-六虎

MediaPlayer的中心-NuPlayer

之前整理过Android MediaPlayer源码剖析，知道MediaPlayer的中心是NuPlayer完成视频的解码、烘托、同步、输出，这篇深入剖析NuPlayer相关的常识体系

整体规划架构

下图是MediaPlayer在Android架构中的作业流程

下图是NuPlayer的作业流程

可以看到Android傍边选用NuPlayer作为主流播映器，NuPlayer选用StageFright引擎，StageFright内部集成了OpenMAX编解码器，会话管理、时刻同步、烘托、传输操控和DRM(Digital Rights Management)

AHandler机制

在NuPlayer源码傍边处处能看到AHandler的影子，NuPlayer便是经过AHandler建立各个成员之间的通信和交互，相似Android Java层中的Handler一样，AHandler是Android native层完成的一个异步音讯机制，在这个机制中所有的处理都是异步的，将变量封装到一个音讯AMessage结构体中，然后放到行列中去，后台专门有一个线程会从这个行列中取出音讯然后履行，履行函数便是onMessageReceived。原理如下图：

AHandler机制包括以下几个中心类

AMessage

音讯类，用于构造音讯，经过deliver()办法运用AHandler发送出去，经过post办法运用ALooper投递给AHandler处理

//运用AHandler发送音讯
void AMessage::deliver() {
    sp<AHandler> handler = mHandler.promote();
    if (handler == NULL) {
        ALOGW("failed to deliver message as target handler %d is gone.", mTarget);
        return;
    }
    handler->deliverMessage(this);
}
//运用ALooper投递给AHandler处理
status_t AMessage::post(int64_t delayUs) {
    sp<ALooper> looper = mLooper.promote();
    if (looper == NULL) {
        ALOGW("failed to post message as target looper for handler %d is gone.", mTarget);
        return -ENOENT;
    }
    looper->post(this, delayUs);
    return OK;
}

AHandler

音讯处理类，一般当做父类，继承该类的子类需求完成onMessageReceived办法，相似于java层Handler中的handleMessage(msg)办法

void AHandler::deliverMessage(const sp<AMessage> &msg) {
    //交由该办法处理，该办法是一个虚函数，由AHandler的子类来完成该办法，NuPlayer继承自AHandler，里边完成了该办法的功用
    onMessageReceived(msg);
    mMessageCounter++;
//省掉部分代码
}

ALooper

与Ahander一一对应，担任存储音讯并分发Ahandler的音讯，与AMessage一对多关系

// posts a message on this looper with the given timeout
void ALooper::post(const sp<AMessage> &msg, int64_t delayUs) {
    Mutex::Autolock autoLock(mLock);
    int64_t whenUs;
    if (delayUs > 0) {
        whenUs = GetNowUs() + delayUs;
    } else {
        whenUs = GetNowUs();
    }
    List<Event>::iterator it = mEventQueue.begin();
    while (it != mEventQueue.end() && (*it).mWhenUs <= whenUs) {
        ++it;
    }
    Event event;
    event.mWhenUs = whenUs;
    event.mMessage = msg;
    if (it == mEventQueue.begin()) {
        mQueueChangedCondition.signal();
    }
    //将音讯插入到音讯行列傍边，mEventQueue是一个List<Event>调集
    mEventQueue.insert(it, event);
}
status_t ALooper::start(
        bool runOnCallingThread, bool canCallJava, int32_t priority) {
    if (runOnCallingThread) {
        {
            Mutex::Autolock autoLock(mLock);
            if (mThread != NULL || mRunningLocally) {
                return INVALID_OPERATION;
            }
            mRunningLocally = true;
        }
        //循环取出音讯，办法体为空，取音讯动作在loop()办法中
        do {
        } while (loop());
        return OK;
    }
    Mutex::Autolock autoLock(mLock);
    if (mThread != NULL || mRunningLocally) {
        return INVALID_OPERATION;
    }
    mThread = new LooperThread(this, canCallJava);
    status_t err = mThread->run(
            mName.empty() ? "ALooper" : mName.c_str(), priority);
    if (err != OK) {
        mThread.clear();
    }
    return err;
}
bool ALooper::loop() {
    Event event;
    {
        Mutex::Autolock autoLock(mLock);
        if (mThread == NULL && !mRunningLocally) {
            return false;
        }
        if (mEventQueue.empty()) {
            mQueueChangedCondition.wait(mLock);
            return true;
        }
        int64_t whenUs = (*mEventQueue.begin()).mWhenUs;
        int64_t nowUs = GetNowUs();
        if (whenUs > nowUs) {
            int64_t delayUs = whenUs - nowUs;
            mQueueChangedCondition.waitRelative(mLock, delayUs * 1000ll);
            return true;
        }
        event = *mEventQueue.begin();
        mEventQueue.erase(mEventQueue.begin());
    }
    event.mMessage->deliver();
//省掉部分代码    
}

NuPlayer

NuPlayer自身继承自AHandler，具有发送/处理音讯的才能

struct NuPlayer : public AHandler {
    explicit NuPlayer(pid_t pid, const sp<MediaClock> &mediaClock);
    void setUID(uid_t uid);
    void init(const wp<NuPlayerDriver> &driver);
    void setDataSourceAsync(const sp<IStreamSource> &source);
    virtual void setDataSourceAsync(
            const sp<IMediaHTTPService> &httpService,
            const char *url,
            const KeyedVector<String8, String8> *headers);
    void setDataSourceAsync(int fd, int64_t offset, int64_t length);
    void setDataSourceAsync(const sp<DataSource> &source);
//省掉部分代码
}

下图是正常播映器的履行流程

下图是NuPlayer的架构规划

NuPlayer的创立进程在之前的文章中已经整理过了，见Android MediaPlayer源码剖析，创立进程中涉及到几个重要的成员，逐一剖析下

NuPlayerDriver

NuPlayerDriver是对NuPlayer的封装，继承MediaPlayerInterface接口。经过NuPlayer来完成播映的功用。看这部分代码的办法便是先看NuPlayerDriver里边干了啥，回头就去找NuPlayer里边的完成，一般都要再去NuPlayer的onMessageReceive中看音讯的响应，最终回到NuPlayerDriver的各种notify中看流程的周转，下面是播映器状态机流通图

struct NuPlayerDriver : public MediaPlayerInterface {
    explicit NuPlayerDriver(pid_t pid);
    virtual status_t initCheck();
    virtual status_t setUID(uid_t uid);
    virtual status_t setDataSource(
            const sp<IMediaHTTPService> &httpService,
            const char *url,
            const KeyedVector<String8, String8> *headers);
    virtual status_t setDataSource(int fd, int64_t offset, int64_t length);
    virtual status_t setDataSource(const sp<IStreamSource> &source);
    virtual status_t setDataSource(const sp<DataSource>& dataSource);
    virtual status_t setVideoSurfaceTexture(
            const sp<IGraphicBufferProducer> &bufferProducer);
    virtual status_t getBufferingSettings(
            BufferingSettings* buffering /* nonnull */) override;
    virtual status_t setBufferingSettings(const BufferingSettings& buffering) override;
    virtual status_t prepare();
    virtual status_t prepareAsync();
    virtual status_t start();
    virtual status_t stop();
    virtual status_t pause();
    virtual bool isPlaying();
    virtual status_t setPlaybackSettings(const AudioPlaybackRate &rate);
    virtual status_t getPlaybackSettings(AudioPlaybackRate *rate);
    virtual status_t setSyncSettings(const AVSyncSettings &sync, float videoFpsHint);
    virtual status_t getSyncSettings(AVSyncSettings *sync, float *videoFps);
    virtual status_t seekTo(
            int msec, MediaPlayerSeekMode mode = MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC);
    virtual status_t getCurrentPosition(int *msec);
    virtual status_t getDuration(int *msec);
    virtual status_t reset();
    virtual status_t notifyAt(int64_t mediaTimeUs) override;
    virtual status_t setLooping(int loop);
    virtual player_type playerType();
    virtual status_t invoke(const Parcel &request, Parcel *reply);
    virtual void setAudioSink(const sp<AudioSink> &audioSink);
    virtual status_t setParameter(int key, const Parcel &request);
    virtual status_t getParameter(int key, Parcel *reply);
    virtual status_t getMetadata(
            const media::Metadata::Filter& ids, Parcel *records);
    virtual status_t dump(int fd, const Vector<String16> &args) const;
    void notifySetDataSourceCompleted(status_t err);
    void notifyPrepareCompleted(status_t err);
    void notifyResetComplete();
    void notifySetSurfaceComplete();
    void notifyDuration(int64_t durationUs);
    void notifyMorePlayingTimeUs(int64_t timeUs);
    void notifyMoreRebufferingTimeUs(int64_t timeUs);
    void notifyRebufferingWhenExit(bool status);
    void notifySeekComplete();
    void notifySeekComplete_l();
    void notifyListener(int msg, int ext1 = 0, int ext2 = 0, const Parcel *in = NULL);
    void notifyFlagsChanged(uint32_t flags);
    // Modular DRM
    virtual status_t prepareDrm(const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId);
    virtual status_t releaseDrm();
//省掉部分代码
}

AVNuFactory

担任要害组件的创立，包括decoder，renderer，经过它能看到数据流从Source-Decoder-Renderer，中心由AMessages驱动

struct AVNuFactory {
    virtual sp<NuPlayer> createNuPlayer(pid_t pid, const sp<MediaClock> &mediaClock);
    virtual sp<NuPlayer::DecoderBase> createPassThruDecoder(
            const sp<AMessage> &notify,
            const sp<NuPlayer::Source> &source,
            const sp<NuPlayer::Renderer> &renderer);
    virtual sp<NuPlayer::DecoderBase> createDecoder(
            const sp<AMessage> &notify,
            const sp<NuPlayer::Source> &source,
            pid_t pid,
            uid_t uid,
            const sp<NuPlayer::Renderer> &renderer);
    virtual sp<NuPlayer::Renderer> createRenderer(
            const sp<MediaPlayerBase::AudioSink> &sink,
            const sp<MediaClock> &mediaClock,
            const sp<AMessage> &notify,
            uint32_t flags);
    // ----- NO TRESSPASSING BEYOND THIS LINE ------
    DECLARE_LOADABLE_SINGLETON(AVNuFactory);
};

Source

表明数据源，同时里边包括解析模块MediaExtractor，功用相似FFmpeg的avformat，并且Source继承自AHandler，同样拥有发送/处理音讯的才能

struct NuPlayer::Source : public AHandler {
    enum Flags {
        FLAG_CAN_PAUSE          = 1,
        FLAG_CAN_SEEK_BACKWARD  = 2,  // the "10 sec back button"
        FLAG_CAN_SEEK_FORWARD   = 4,  // the "10 sec forward button"
        FLAG_CAN_SEEK           = 8,  // the "seek bar"
        FLAG_DYNAMIC_DURATION   = 16,
        FLAG_SECURE             = 32, // Secure codec is required.
        FLAG_PROTECTED          = 64, // The screen needs to be protected (screenshot is disabled).
    };
//省掉部分代码
}

数据源一般分三种，在NuPlayer::setDataSourceAsync()中会对数据源进行判别区别，不同的数据源需求用到对应的解析模块

void NuPlayer::setDataSourceAsync(
        const sp<IMediaHTTPService> &httpService,
        const char *url,
        const KeyedVector<String8, String8> *headers) {
    sp<AMessage> msg = new AMessage(kWhatSetDataSource, this);
    size_t len = strlen(url);
    sp<AMessage> notify = new AMessage(kWhatSourceNotify, this);
    sp<Source> source;
    //判别数据源的类型
    if (IsHTTPLiveURL(url)) {
        //流媒体
        source = new HTTPLiveSource(notify, httpService, url, headers);
        ALOGV("setDataSourceAsync HTTPLiveSource %s", url);
        mDataSourceType = DATA_SOURCE_TYPE_HTTP_LIVE;
    } else if (!strncasecmp(url, "rtsp://", 7)) {
        //直播
        source = new RTSPSource(
                notify, httpService, url, headers, mUIDValid, mUID);
        ALOGV("setDataSourceAsync RTSPSource %s", url);
        mDataSourceType = DATA_SOURCE_TYPE_RTSP;
    } else if ((!strncasecmp(url, "http://", 7)
                || !strncasecmp(url, "https://", 8))
                    && ((len >= 4 && !strcasecmp(".sdp", &url[len - 4]))
                    || strstr(url, ".sdp?"))) {
        //直播
        source = new RTSPSource(
                notify, httpService, url, headers, mUIDValid, mUID, true);
        ALOGV("setDataSourceAsync RTSPSource http/https/.sdp %s", url);
        mDataSourceType = DATA_SOURCE_TYPE_RTSP;
    } else {
        //本地视频
        ALOGV("setDataSourceAsync GenericSource %s", url);
        sp<GenericSource> genericSource =
                new GenericSource(notify, mUIDValid, mUID, mMediaClock);
        status_t err = genericSource->setDataSource(httpService, url, headers);
        if (err == OK) {
            source = genericSource;
        } else {
            ALOGE("Failed to set data source!");
        }
        // regardless of success/failure
        mDataSourceType = DATA_SOURCE_TYPE_GENERIC_URL;
    }
    msg->setObject("source", source);
    msg->post();
}

GenericSource：表明本地数据源

struct NuPlayer::GenericSource : public NuPlayer::Source,
                                 public MediaBufferObserver // Modular DRM
{
    GenericSource(const sp<AMessage> &notify, bool uidValid, uid_t uid,
                  const sp<MediaClock> &mediaClock);
    status_t setDataSource(
            const sp<IMediaHTTPService> &httpService,
            const char *url,
            const KeyedVector<String8, String8> *headers);
    status_t setDataSource(int fd, int64_t offset, int64_t length);
    status_t setDataSource(const sp<DataSource>& dataSource);
    virtual status_t getBufferingSettings(
            BufferingSettings* buffering /* nonnull */) override;
    virtual status_t setBufferingSettings(const BufferingSettings& buffering) override;
    virtual void prepareAsync();
    virtual void start();
    virtual void stop();
    virtual void pause();
    virtual void resume();
    virtual void disconnect();
    virtual status_t feedMoreTSData();
    virtual sp<MetaData> getFileFormatMeta() const;
    virtual status_t dequeueAccessUnit(bool audio, sp<ABuffer> *accessUnit);
    virtual status_t getDuration(int64_t *durationUs);
    virtual size_t getTrackCount() const;
    virtual sp<AMessage> getTrackInfo(size_t trackIndex) const;
    virtual ssize_t getSelectedTrack(media_track_type type) const;
    virtual status_t selectTrack(size_t trackIndex, bool select, int64_t timeUs);
    virtual status_t seekTo(
        int64_t seekTimeUs,
        MediaPlayerSeekMode mode = MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC) override;
//省掉部分代码
}

HTTPLiveSource：表明网络数据源，一般指流媒体

struct NuPlayer::HTTPLiveSource : public NuPlayer::Source {
    HTTPLiveSource(
            const sp<AMessage> &notify,
            const sp<IMediaHTTPService> &httpService,
            const char *url,
            const KeyedVector<String8, String8> *headers);
    virtual status_t getBufferingSettings(
            BufferingSettings* buffering /* nonnull */) override;
    virtual status_t setBufferingSettings(const BufferingSettings& buffering) override;
    virtual void prepareAsync();
    virtual void start();
    virtual status_t dequeueAccessUnit(bool audio, sp<ABuffer> *accessUnit);
    virtual sp<MetaData> getFormatMeta(bool audio);
    virtual sp<AMessage> getFormat(bool audio);
    virtual status_t feedMoreTSData();
    virtual status_t getDuration(int64_t *durationUs);
    virtual size_t getTrackCount() const;
    virtual sp<AMessage> getTrackInfo(size_t trackIndex) const;
    virtual ssize_t getSelectedTrack(media_track_type /* type */) const;
    virtual status_t selectTrack(size_t trackIndex, bool select, int64_t timeUs);
    virtual status_t seekTo(
            int64_t seekTimeUs,
            MediaPlayerSeekMode mode = MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC) override;
 //省掉部分代码
}

RTSPSource：表明直播数据源

struct NuPlayer::RTSPSource : public NuPlayer::Source {
    RTSPSource(
            const sp<AMessage> &notify,
            const sp<IMediaHTTPService> &httpService,
            const char *url,
            const KeyedVector<String8, String8> *headers,
            bool uidValid = false,
            uid_t uid = 0,
            bool isSDP = false);
    virtual status_t getBufferingSettings(
            BufferingSettings* buffering /* nonnull */) override;
    virtual status_t setBufferingSettings(const BufferingSettings& buffering) override;
    virtual void prepareAsync();
    virtual void start();
    virtual void stop();
    virtual status_t feedMoreTSData();
    virtual status_t dequeueAccessUnit(bool audio, sp<ABuffer> *accessUnit);
    virtual status_t getDuration(int64_t *durationUs);
    virtual status_t seekTo(
            int64_t seekTimeUs,
            MediaPlayerSeekMode mode = MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC) override;
    void onMessageReceived(const sp<AMessage> &msg);
//省掉部分代码
}

Decoder

解码器，功用相似FFmpeg的avcodec，封装了用于AVC、AAC解码的接口，经过ACodec完成解码（包括OMX硬解码和软解码），它的初始化在NuPlayer::onMessageReceived()办法中

void NuPlayer::onMessageReceived(const sp<AMessage> &msg) {
//省掉部分代码
 case kWhatPause:
        {
            onPause();
            mPausedByClient = true;
            break;
        }
        case kWhatSourceNotify:
        {
            //在此处创立Decoder
            onSourceNotify(msg);
            break;
        }
        case kWhatClosedCaptionNotify:
        {
            onClosedCaptionNotify(msg);
            break;
        }
//省掉部分代码
}
---------------------------------------------------------------
void NuPlayer::onSourceNotify(const sp<AMessage> &msg) {
//省掉部分代码
    switch (what) {
        case Source::kWhatInstantiateSecureDecoders:
        {
            if (mSource == NULL) {
                // This is a stale notification from a source that was
                // asynchronously preparing when the client called reset().
                // We handled the reset, the source is gone.
                break;
            }
            sp<AMessage> reply;
            CHECK(msg->findMessage("reply", &reply));
            //此处创立decoder
            status_t err = onInstantiateSecureDecoders();
            reply->setInt32("err", err);
            reply->post();
            break;
        }
//省掉部分代码
}
---------------------------------------------------------------
status_t NuPlayer::onInstantiateSecureDecoders() {
    status_t err;
    if (!(mSourceFlags & Source::FLAG_SECURE)) {
        return BAD_TYPE;
    }
    if (mRenderer != NULL) {
        ALOGE("renderer should not be set when instantiating secure decoders");
        return UNKNOWN_ERROR;
    }
    // TRICKY: We rely on mRenderer being null, so that decoder does not start requesting
    // data on instantiation.
    if (mSurface != NULL) {
        //创立VideoDecoder
        err = instantiateDecoder(false, &mVideoDecoder);
        if (err != OK) {
            return err;
        }
    }
    if (mAudioSink != NULL) {
         //创立AudioDecoder
        err = instantiateDecoder(true, &mAudioDecoder);
        if (err != OK) {
            return err;
        }
    }
    return OK;
}
---------------------------------------------------------------
status_t NuPlayer::instantiateDecoder(
        bool audio, sp<DecoderBase> *decoder, bool checkAudioModeChange) {
//省掉部分代码
    if (audio) {
        //创立音频解码器
        sp<AMessage> notify = new AMessage(kWhatAudioNotify, this);
        ++mAudioDecoderGeneration;
        notify->setInt32("generation", mAudioDecoderGeneration);
        if (checkAudioModeChange) {
            determineAudioModeChange(format);
        }
        if (mOffloadAudio) {
            mSource->setOffloadAudio(true /* offload */);
            const bool hasVideo = (mSource->getFormat(false /*audio */) != NULL);
            format->setInt32("has-video", hasVideo);
            *decoder = AVNuFactory::get()->createPassThruDecoder(notify, mSource, mRenderer);
            ALOGV("instantiateDecoder audio DecoderPassThrough hasVideo: %d", hasVideo);
        } else {
            AVNuUtils::get()->setCodecOutputFormat(format);
            mSource->setOffloadAudio(false /* offload */);
            *decoder = AVNuFactory::get()->createDecoder(notify, mSource, mPID, mUID, mRenderer);
            ALOGV("instantiateDecoder audio Decoder");
        }
        mAudioDecoderError = false;
    } else {
        //创立视频解码器
        sp<AMessage> notify = new AMessage(kWhatVideoNotify, this);
        ++mVideoDecoderGeneration;
        notify->setInt32("generation", mVideoDecoderGeneration);
        *decoder = new Decoder(
                notify, mSource, mPID, mUID, mRenderer, mSurface, mCCDecoder);
        mVideoDecoderError = false;
        // enable FRC if high-quality AV sync is requested, even if not
        // directly queuing to display, as this will even improve textureview
        // playback.
        {
            if (property_get_bool("persist.sys.media.avsync", false)) {
                format->setInt32("auto-frc", 1);
            }
        }
    }
    (*decoder)->init();
//省掉部分代码
}

Renderer

烘托器，功用相似声卡驱动和显卡驱动，首要用于音视频烘托和同步，与NativeWindow有关，创立进程在NuPlayer::onStart()中

void NuPlayer::onStart(int64_t startPositionUs, MediaPlayerSeekMode mode) {
//省掉部分代码
    sp<AMessage> notify = new AMessage(kWhatRendererNotify, this);
    ++mRendererGeneration;
    notify->setInt32("generation", mRendererGeneration);
    //创立renderer
    mRenderer = AVNuFactory::get()->createRenderer(mAudioSink, mMediaClock, notify, flags);
    mRendererLooper = new ALooper;
    mRendererLooper->setName("NuPlayerRenderer");
    mRendererLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
    mRendererLooper->registerHandler(mRenderer);
//省掉部分代码
}

数据的输入在NuPlayer:Decoder::handleAnOutputBuffer()中

bool NuPlayer::Decoder::handleAnOutputBuffer(
        size_t index,
        size_t offset,
        size_t size,
        int64_t timeUs,
        int32_t flags) {
//省掉部分代码
if (mRenderer != NULL) {
        // send the buffer to renderer.把Buffer送到Renderer
        mRenderer->queueBuffer(mIsAudio, buffer, reply);
        if (eos && !isDiscontinuityPending()) {
            mRenderer->queueEOS(mIsAudio, ERROR_END_OF_STREAM);
        }
    }
//省掉部分代码
}

数据的输出在NuPlayer::Renderer::postDrainVideoQueue()中

void NuPlayer::Renderer::postDrainVideoQueue() {
//省掉部分代码
    sp<AMessage> msg = new AMessage(kWhatDrainVideoQueue, this);
    msg->setInt32("drainGeneration", getDrainGeneration(false /* audio */));
//省掉部分代码
}
--------------------------------------------------------
case kWhatDrainVideoQueue:
        {
            int32_t generation;
            CHECK(msg->findInt32("drainGeneration", &generation));
            if (generation != getDrainGeneration(false /* audio */)) {
                break;
            }
            mDrainVideoQueuePending = false;
            //输出视频缓冲行列的内容
            onDrainVideoQueue();
            postDrainVideoQueue();
            break;
        }
--------------------------------------------------------
 void NuPlayer::Renderer::onDrainVideoQueue() {
    //省掉部分代码
   mVideoSampleReceived = true;
    if (!mPaused) {
        if (!mVideoRenderingStarted) {
            mVideoRenderingStarted = true;
          //告诉Renderer开始烘托
            notifyVideoRenderingStart();
        }
        Mutex::Autolock autoLock(mLock);
        notifyIfMediaRenderingStarted_l();
    }
}
--------------------------------------------------------
void NuPlayer::Renderer::notifyVideoRenderingStart() {
    sp<AMessage> notify = mNotify->dup();
    notify->setInt32("what", kWhatVideoRenderingStart);
    notify->post();
}

void NuPlayer::onMessageReceived(const sp<AMessage> &msg) {
    switch (msg->what()) {
    //省掉部分代码
    case kWhatRendererNotify:
        //处理Renderer发送过来的音讯
        {
            int32_t requesterGeneration = mRendererGeneration - 1;
            CHECK(msg->findInt32("generation", &requesterGeneration));
            if (requesterGeneration != mRendererGeneration) {
                ALOGV("got message from old renderer, generation(%d:%d)",
                        requesterGeneration, mRendererGeneration);
                return;
            }
            int32_t what;
            CHECK(msg->findInt32("what", &what));
            if (what == Renderer::kWhatEOS) {
               //省掉部分代码
            } else if (what == Renderer::kWhatFlushComplete) {
          //省掉部分代码
            } else if (what == Renderer::kWhatVideoRenderingStart) {
                //这儿处理kWhatVideoRenderingStart音讯
                notifyListener(MEDIA_INFO, MEDIA_INFO_RENDERING_START, 0);
            } else if (what == Renderer::kWhatMediaRenderingStart) {
                ALOGV("media rendering started");
                notifyListener(MEDIA_STARTED, 0, 0);
            } else if (!mPaused && what == Renderer::kWhatVideoPrerollComplete) {
                // If NuPlayer is paused too, don't resume renderer. The pause may be called by
                // client, wait for client to resume NuPlayer
                ALOGI("NOTE: Video preroll complete.. resume renderer..");
                mRenderer->resume();
            } else if (what == Renderer::kWhatAudioTearDown) {
          //省掉部分代码
            }
            break;
        }
    }
}

MediaPlayer的核心-NuPlayer

MediaPlayer的中心-NuPlayer

整体规划架构

AHandler机制

NuPlayer

作者信息

推广

MediaPlayer的核心-NuPlayer

MediaPlayer的中心-NuPlayer

整体规划架构

AHandler机制

NuPlayer

相关文章

刷题神器！把LeetCode题目生成卡片；苏黎世联邦理工『数据科学数学基础』课程；深度学习实例锦囊(含代码) ；前沿论文 | ShowMeAI资讯日报

Android 系统报告收集和查看

Swift编译特性和条件编译

Android事件冲突解决-悬浮窗拖拽处理

作者信息

推广