【stagefrightplayer】3 MediaExtractor介绍

最新推荐文章于 2024-03-08 23:56:29 发布
最新推荐文章于 2024-03-08 23:56:29 发布
阅读量6.8k 收藏 7
点赞数
分类专栏： android

概述

本篇介绍播放器结构中的第一部分Stream+Demuxer.

Awesomeplayer中对应的数据结构主要有DataSource，MediaExtractor，MediaSource。

其中DataSource 主要负责提供原始数据，MediaSource负责提供demux后的数据（即实际的audio 或者 video 数据包）

而MediaExtractor则负责中间的过程，即将从DataSource得到的原始数据解析成解码器需要的es数据，并通过MediaSource的接口输出。

以ts为例，extractor在awesomeplayer中的位置图如下：


我们按照一个demux的基本结构结合ts的实例来分析整个结构

其中demuxer的部分我们按照ffmpeg demuxer的结构中的主要成员来分析

1 stream -- 功能

2 extractor 创建流程

3 extractor 结构介绍（ts为例）

3.1 demuxer -- read_probe

3.2 demuxer -- read_header

3.3 demuxer -- read_packet

3.4 demuxer -- read_seek

下面通过实际的代码来分析

1 stream -- 功能

stream的主要功能是，从外部介质（本地磁盘或者网络等）获取待播放的原始数据。

对应的数据结构为：DataSource

看下awesomeplayer中对应的代码

a 构造函数

[html] view plain copy print ?
  1. AwesomePlayer::AwesomePlayer(){
  2. *************
  3. DataSource::RegisterDefaultSniffers();
  4. *************
  5. } 
AwesomePlayer::AwesomePlayer(){
    *************
    DataSource::RegisterDefaultSniffers();
    *************
}

看下RegisterDefaultSniffers实现

[html] view plain copy print ?
  1. // static
  2. void DataSource::RegisterSniffer(SnifferFunc func) {
  3. Mutex::Autolock autoLock(gSnifferMutex);
  5. for (List<SnifferFunc>::iterator it = gSniffers.begin();
  6. it != gSniffers.end(); ++it) {
  7. if (*it == func) {
  8. return;
  9. }
  10. }
  12. gSniffers.push_back(func);
  13. } 
// static
void DataSource::RegisterSniffer(SnifferFunc func) {
    Mutex::Autolock autoLock(gSnifferMutex);
 
    for (List<SnifferFunc>::iterator it = gSniffers.begin();
         it != gSniffers.end(); ++it) {
        if (*it == func) {
            return;
        }
    }
 
    gSniffers.push_back(func);
}

void DataSource::RegisterDefaultSniffers() {

[html] view plain copy print ?
  1. RegisterSniffer(SniffMPEG4);
  2. RegisterSniffer(SniffFragmentedMP4);
  3. RegisterSniffer(SniffMatroska);
  4. RegisterSniffer(SniffOgg);
  5. RegisterSniffer(SniffWAV);
  6. RegisterSniffer(SniffFLAC);
  7. RegisterSniffer(SniffAMR);
  8. RegisterSniffer(SniffMPEG2TS);
  9. RegisterSniffer(SniffMP3);
  10. RegisterSniffer(SniffAAC);
  11. RegisterSniffer(SniffMPEG2PS);
  12. RegisterSniffer(SniffWVM);
  14. char value[PROPERTY_VALUE_MAX];
  15. if (property_get("drm.service.enabled", value, NULL)
  16. && (!strcmp(value, "1") || !strcasecmp(value, "true"))) {
  17. RegisterSniffer(SniffDRM);
  18. } 
    RegisterSniffer(SniffMPEG4);
    RegisterSniffer(SniffFragmentedMP4);
    RegisterSniffer(SniffMatroska);
    RegisterSniffer(SniffOgg);
    RegisterSniffer(SniffWAV);
    RegisterSniffer(SniffFLAC);
    RegisterSniffer(SniffAMR);
    RegisterSniffer(SniffMPEG2TS);
    RegisterSniffer(SniffMP3);
    RegisterSniffer(SniffAAC);
    RegisterSniffer(SniffMPEG2PS);
    RegisterSniffer(SniffWVM);
 
    char value[PROPERTY_VALUE_MAX];
    if (property_get("drm.service.enabled", value, NULL)
            && (!strcmp(value, "1") || !strcasecmp(value, "true"))) {
        RegisterSniffer(SniffDRM);
    }
}

从代码可以看出RegisterDefaultSniffers的主要作用既是注册Sniffer函数

将所有的sniffer函数都挂在全局链表gSniffers中。

sniffer函数的主要作用就是用于探测文件的类型，每种类型的媒体文件都对应一个sniffer函数。

这里从代码可以看出原生的android播放器支持的格式还比较少

这里主要作用就是注册完成后 demuxer在read_probe阶段便可以通过调用sniffer函数来探测文件类型，具体等讲解probe的时候结合实际的例子（mpegts）分析

b setDataSource

[html] view plain copy print ?
  1. status_t AwesomePlayer::setDataSource(
  2. int fd, int64_t offset, int64_t length) {
  3. Mutex::Autolock autoLock(mLock);
  5. reset_l();
  7. sp<DataSource> dataSource = new FileSource(fd, offset, length);
  9. status_t err = dataSource->initCheck();
  11. if (err != OK) {
  12. return err;
  13. }
  15. mFileSource = dataSource;
  17. {
  18. Mutex::Autolock autoLock(mStatsLock);
  19. mStats.mFd = fd;
  20. mStats.mURI = String8();
  21. }
  23. return setDataSource_l(dataSource);
  24. } 
status_t AwesomePlayer::setDataSource(
        int fd, int64_t offset, int64_t length) {
    Mutex::Autolock autoLock(mLock);
 
    reset_l();
 
    sp<DataSource> dataSource = new FileSource(fd, offset, length);
 
    status_t err = dataSource->initCheck();
 
    if (err != OK) {
        return err;
    }
 
    mFileSource = dataSource;
 
    {
        Mutex::Autolock autoLock(mStatsLock);
        mStats.mFd = fd;
        mStats.mURI = String8();
    }
 
    return setDataSource_l(dataSource);
}

代码中构造了FileSource对象赋值给mFileSource，这里FileSource继承自DataSource，提供stream功能。

下面列出filesource类的定义

[html] view plain copy print ?
  1. class FileSource : public DataSource {
  2. public:
  3. FileSource(const char *filename);
  4. FileSource(int fd, int64_t offset, int64_t length);
  6. virtual status_t initCheck() const;
  8. virtual ssize_t readAt(off64_t offset, void *data, size_t size);
  10. virtual status_t getSize(off64_t *size);
  12. virtual sp<DecryptHandle> DrmInitialization(const char *mime);
  14. virtual void getDrmInfo(sp<DecryptHandle> &handle, DrmManagerClient **client);
  16. protected:
  17. virtual ~FileSource();
  19. private:
  20. int mFd;
  21. int64_t mOffset;
  22. int64_t mLength;
  23. Mutex mLock;
  25. /*for DRM*/
  26. sp<DecryptHandle> mDecryptHandle;
  27. DrmManagerClient *mDrmManagerClient;
  28. int64_t mDrmBufOffset;
  29. int64_t mDrmBufSize;
  30. unsigned char *mDrmBuf;
  32. ssize_t readAtDRM(off64_t offset, void *data, size_t size);
  34. FileSource(const FileSource &);
  35. FileSource &operator=(const FileSource &);
  36. }; 
class FileSource : public DataSource {
public:
    FileSource(const char *filename);
    FileSource(int fd, int64_t offset, int64_t length);
 
    virtual status_t initCheck() const;
 
    virtual ssize_t readAt(off64_t offset, void *data, size_t size);
 
    virtual status_t getSize(off64_t *size);
 
    virtual sp<DecryptHandle> DrmInitialization(const char *mime);
 
    virtual void getDrmInfo(sp<DecryptHandle> &handle, DrmManagerClient **client);
 
protected:
    virtual ~FileSource();
 
private:
    int mFd;
    int64_t mOffset;
    int64_t mLength;
    Mutex mLock;
 
    /*for DRM*/
    sp<DecryptHandle> mDecryptHandle;
    DrmManagerClient *mDrmManagerClient;
    int64_t mDrmBufOffset;
    int64_t mDrmBufSize;
    unsigned char *mDrmBuf;
 
    ssize_t readAtDRM(off64_t offset, void *data, size_t size);
 
    FileSource(const FileSource &);
    FileSource &operator=(const FileSource &);
};

这里filesource提供了readAt方法提供原始数据获取，由于其参数有offset，则支持随机存取，支持seek功能。其构造函数如下

[html] view plain copy print ?
  1. FileSource::FileSource(const char *filename)
  2. : mFd(-1),
  3. mOffset(0),
  4. mLength(-1),
  5. mDecryptHandle(NULL),
  6. mDrmManagerClient(NULL),
  7. mDrmBufOffset(0),
  8. mDrmBufSize(0),
  9. mDrmBuf(NULL){
  11. mFd = open(filename, O_LARGEFILE | O_RDONLY);
  13. if (mFd >= 0) {
  14. mLength = lseek64(mFd, 0, SEEK_END);
  15. } else {
  16. ALOGE("Failed to open file '%s'. (%s)", filename, strerror(errno));
  17. }
  18. } 
FileSource::FileSource(const char *filename)
    : mFd(-1),
      mOffset(0),
      mLength(-1),
      mDecryptHandle(NULL),
      mDrmManagerClient(NULL),
      mDrmBufOffset(0),
      mDrmBufSize(0),
      mDrmBuf(NULL){
 
    mFd = open(filename, O_LARGEFILE | O_RDONLY);
 
    if (mFd >= 0) {
        mLength = lseek64(mFd, 0, SEEK_END);
    } else {
        ALOGE("Failed to open file '%s'. (%s)", filename, strerror(errno));
    }
}

构造函数的主要功能就是open给定的文件名，并将句柄存储在mFd中，后面读取数据可以直接使用Linux标准方法读取。

2 awesomeplayer中extractor 创建流程

在setDataSource的最后，会调用setDataSource_l(dataSource);将datasource和对应的extractor对应起来，这里看下流程

[html] view plain copy print ?
  1. status_t AwesomePlayer::setDataSource_l(
  2. const sp<DataSource> &dataSource) {
  3. sp<MediaExtractor> extractor = MediaExtractor::Create(dataSource);
  5. if (extractor == NULL) {
  6. return UNKNOWN_ERROR;
  7. }
  9. if (extractor->getDrmFlag()) {
  10. checkDrmStatus(dataSource);
  11. }
  13. return setDataSource_l(extractor);
  14. } 
status_t AwesomePlayer::setDataSource_l(
        const sp<DataSource> &dataSource) {
    sp<MediaExtractor> extractor = MediaExtractor::Create(dataSource);
 
    if (extractor == NULL) {
        return UNKNOWN_ERROR;
    }
 
    if (extractor->getDrmFlag()) {
        checkDrmStatus(dataSource);
    }
 
    return setDataSource_l(extractor);
}

2.1 MediaExtractor::Create

这里通过MediaExtractor::Create创建extractor ，分段来看代码实现。这里还是忽略drm等实现

[html] view plain copy print ?
  1. sp<MediaExtractor> MediaExtractor::Create(
  2. const sp<DataSource> &source, const char *mime) {
  3. sp<AMessage> meta;
  5. String8 tmp;
  6. if (mime == NULL) {
  7. float confidence;
  8. if (!source->sniff(&tmp, &confidence, &meta)) {
  9. ALOGV("FAILED to autodetect media content.");
  11. return NULL;
  12. }
  14. mime = tmp.string();
  15. ALOGV("Autodetected media content as '%s' with confidence %.2f",
  16. mime, confidence);
  17. } 
sp<MediaExtractor> MediaExtractor::Create(
        const sp<DataSource> &source, const char *mime) {
    sp<AMessage> meta;
 
    String8 tmp;
    if (mime == NULL) {
        float confidence;
        if (!source->sniff(&tmp, &confidence, &meta)) {
            ALOGV("FAILED to autodetect media content.");
 
            return NULL;
        }
 
        mime = tmp.string();
        ALOGV("Autodetected media content as '%s' with confidence %.2f",
             mime, confidence);
    }

这里第一步是通过调用datasource的siniff函数探测文件类型。

看下sniff实现

[html] view plain copy print ?
  1. bool DataSource::sniff(
  2. String8 *mimeType, float *confidence, sp<AMessage> *meta) {
  3. *mimeType = "";
  4. *confidence = 0.0f;
  5. meta->clear();
  7. Mutex::Autolock autoLock(gSnifferMutex);
  8. for (List<SnifferFunc>::iterator it = gSniffers.begin();
  9. it != gSniffers.end(); ++it) {
  10. String8 newMimeType;
  11. float newConfidence;
  12. sp<AMessage> newMeta;
  13. if ((*it)(this, &newMimeType, &newConfidence, &newMeta)) {
  14. if (newConfidence > *confidence) {
  15. *mimeType = newMimeType;
  16. *confidence = newConfidence;
  17. *meta = newMeta;
  18. }
  19. }
  20. }
  22. return *confidence > 0.0;
  23. } 
bool DataSource::sniff(
        String8 *mimeType, float *confidence, sp<AMessage> *meta) {
    *mimeType = "";
    *confidence = 0.0f;
    meta->clear();
 
    Mutex::Autolock autoLock(gSnifferMutex);
    for (List<SnifferFunc>::iterator it = gSniffers.begin();
         it != gSniffers.end(); ++it) {
        String8 newMimeType;
        float newConfidence;
        sp<AMessage> newMeta;
        if ((*it)(this, &newMimeType, &newConfidence, &newMeta)) {
            if (newConfidence > *confidence) {
                *mimeType = newMimeType;
                *confidence = newConfidence;
                *meta = newMeta;
            }
        }
    }
 
    return *confidence > 0.0;
}

主要是将gSniffers链表中的每种格式的函数调用一遍，选取最高的confidence作为选中的文件格式。后面会以ts为例讲解具体细节。

下面继续

[html] view plain copy print ?
  1. MediaExtractor *ret = NULL;
  2. if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG4)
  3. || !strcasecmp(mime, "audio/mp4")) {
  4. int fragmented = 0;
  5. if (meta != NULL && meta->findInt32("fragmented", &fragmented) && fragmented) {
  6. ret = new FragmentedMP4Extractor(source);
  7. } else {
  8. ret = new MPEG4Extractor(source);
  9. }
  10. } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_MPEG)) {
  11. ret = new MP3Extractor(source, meta);
  12. } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_NB)
  13. || !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_WB)) {
  14. ret = new AMRExtractor(source);
  15. } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_FLAC)) {
  16. ret = new FLACExtractor(source);
  17. } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WAV)) {
  18. ret = new WAVExtractor(source);
  19. } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_OGG)) {
  20. ret = new OggExtractor(source);
  21. } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MATROSKA)) {
  22. ret = new MatroskaExtractor(source);
  23. } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2TS)) {
  24. ret = new MPEG2TSExtractor(source);
  25. } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WVM)) {
  26. // Return now. WVExtractor should not have the DrmFlag set in the block below.
  27. return new WVMExtractor(source);
  28. } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC_ADTS)) {
  29. ret = new AACExtractor(source, meta);
  30. } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2PS)) {
  31. ret = new MPEG2PSExtractor(source);
  32. }
  34. if (ret != NULL) {
  35. if (isDrm) {
  36. ret->setDrmFlag(true);
  37. } else {
  38. ret->setDrmFlag(false);
  39. }
  40. }
  42. return ret;
  43. } 
MediaExtractor *ret = NULL;
    if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG4)
            || !strcasecmp(mime, "audio/mp4")) {
        int fragmented = 0;
        if (meta != NULL && meta->findInt32("fragmented", &fragmented) && fragmented) {
            ret = new FragmentedMP4Extractor(source);
        } else {
            ret = new MPEG4Extractor(source);
        }
    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_MPEG)) {
        ret = new MP3Extractor(source, meta);
    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_NB)
            || !strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AMR_WB)) {
        ret = new AMRExtractor(source);
    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_FLAC)) {
        ret = new FLACExtractor(source);
    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WAV)) {
        ret = new WAVExtractor(source);
    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_OGG)) {
        ret = new OggExtractor(source);
    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MATROSKA)) {
        ret = new MatroskaExtractor(source);
    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2TS)) {
        ret = new MPEG2TSExtractor(source);
    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_WVM)) {
        // Return now.  WVExtractor should not have the DrmFlag set in the block below.
        return new WVMExtractor(source);
    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC_ADTS)) {
        ret = new AACExtractor(source, meta);
    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2PS)) {
        ret = new MPEG2PSExtractor(source);
    }
 
    if (ret != NULL) {
       if (isDrm) {
           ret->setDrmFlag(true);
       } else {
           ret->setDrmFlag(false);
       }
    }
 
    return ret;
}

成功的通过sniff函数确定了文件的格式之后，就可以构造extractor对象了。

例如：如果文件格式是ts格式，则会调用ret = new MPEG2TSExtractor(source);

具体的构造函数就完成了文件头的解析获取了流信息。

2.2 setDataSource_l(extractor)

创建了extractor对象之后，setDataSource_l(extractor) 的主要作用就是使用上面得到的信息来构造播放器框架了。

这里只将重要的语句列出

setVideoSource(extractor->getTrack(i));

setAudioSource(extractor->getTrack(i));

addTextSource_l(i, extractor->getTrack(i));

主要是将文件中的各个流通过上面三个方法，存放在mVideoTrack、mAudioTrack，之后作为参数传递给解码器。便建立了解码器与extractor的关联

3 MediaExtractor的结构介绍（ts为例）

这里主要是以ts为例，按照一个demuxer的具体功能组件（仿照ffmpeg结构）来介绍，extractor是如何实现一个demuxer的功能。

ts相关的代码文件是：frameworks/media/libstagefrightplayer/mpeg2ts/MPEG2TSExtractor.cpp

下面是一张MPEG2TSExtractor 的总体结构图：

 

 

下面的很多介绍都会引用此图

解释下这张图：MPEG2TSExtractor是总入口，负责解析文件头信息，提供原始数据包。在功能上讲，MPEG2TSExtractor 是ATSParser的封装，而ATSParser负责实际的解析工作，

即：MPEG2TSExtractor 从FileSource中获取数据，提供给ATSParser 进行解析。而MPEG2TSExtractor 对外提供的各种接口及文件信息都是借由ATSParser 来完成的。

比如图中：getTrack接口提供的MediaSource也就是awesomeplayer中的mAudioTrack和mVideoTrack，是MPEG2TSSource结构，而MPEG2TSSource的工作由AnotherPacketSource（mSourceImpls）完成

而实际上AnotherPacketSource 是在ATSParser中的Stream中生成的，每个Stream对应一个实际的流。后面分析代码时可以依据上面解释来理解。

3.1 demuxer -- read_probe

这里的probe主要是对应datasource的sniffer函数。具体实现如下：

[html] view plain copy print ?
  1. bool SniffMPEG2TS(
  2. const sp<DataSource> &source, String8 *mimeType, float *confidence,
  3. sp<AMessage> *) {
  4. for (int i = 0; i < 5; ++i) {
  5. char header;
  6. if (source->readAt(kTSPacketSize * i, &header, 1) != 1
  7. || header != 0x47) {
  8. return false;
  9. }
  10. }
  12. *confidence = 0.1f;
  13. mimeType->setTo(MEDIA_MIMETYPE_CONTAINER_MPEG2TS);
  15. return true;
  16. } 
bool SniffMPEG2TS(
        const sp<DataSource> &source, String8 *mimeType, float *confidence,
        sp<AMessage> *) {
    for (int i = 0; i < 5; ++i) {
        char header;
        if (source->readAt(kTSPacketSize * i, &header, 1) != 1
                || header != 0x47) {
            return false;
        }
    }
 
    *confidence = 0.1f;
    mimeType->setTo(MEDIA_MIMETYPE_CONTAINER_MPEG2TS);
 
    return true;
}

基本思路很简单，对于ts文件 每个ts包为188字节，每个包的同步字为0x47

这里主要通过datasource的readAt接口读取一个字节，判断是否是0x47，主要是间隔kTSPacketSize=188读取一个字节判断5次

如果全部通过则确定此文件为mpegts文件。设置*confidence = 0.1f;返回。

3.2 demuxer -- read_header

ffmpeg中的read_header函数主要作用是解析文件头信息，获取文件中的具体流信息及参数

这里主要是通过构造函数来完成，具体看下

[html] view plain copy print ?
  1. MPEG2TSExtractor::MPEG2TSExtractor(const sp<DataSource> &source)
  2. : mDataSource(source),
  3. mParser(new ATSParser),
  4. mOffset(0) {
  5. init();
  6. } 
MPEG2TSExtractor::MPEG2TSExtractor(const sp<DataSource> &source)
    : mDataSource(source),
      mParser(new ATSParser),
      mOffset(0) {
    init();
}

这里将datasource参数存放在mDataSource中，并构造了ATSParser对象，这里可以这样认定：MPEG2TSExtractor是ATSParser的封装，具体的工作都是ATSParser完成的

看下其构造函数

[html] view plain copy print ?
  1. ATSParser::ATSParser(uint32_t flags)
  2. : mFlags(flags),
  3. mAbsoluteTimeAnchorUs(-1ll),
  4. mNumTSPacketsParsed(0),
  5. mNumPCRs(0) {
  6. mPSISections.add(0 /* PID */, new PSISection);
  7. } 
ATSParser::ATSParser(uint32_t flags)
    : mFlags(flags),
      mAbsoluteTimeAnchorUs(-1ll),
      mNumTSPacketsParsed(0),
      mNumPCRs(0) {
    mPSISections.add(0 /* PID */, new PSISection);
}

构造好ATSParser对象之后，调用了init()函数

[html] view plain copy print ?
  1. void MPEG2TSExtractor::init() {
  2. bool haveAudio = false;
  3. bool haveVideo = false;
  4. int numPacketsParsed = 0;
  6. while (feedMore() == OK) {
  7. ATSParser::SourceType type;
  8. if (haveAudio && haveVideo) {
  9. break;
  10. }
  11. if (!haveVideo) {
  12. sp<AnotherPacketSource> impl =
  13. (AnotherPacketSource *)mParser->getSource(
  14. ATSParser::VIDEO).get();
  16. if (impl != NULL) {
  17. haveVideo = true;
  18. mSourceImpls.push(impl);
  19. }
  20. }
  22. if (!haveAudio) {
  23. sp<AnotherPacketSource> impl =
  24. (AnotherPacketSource *)mParser->getSource(
  25. ATSParser::AUDIO).get();
  27. if (impl != NULL) {
  28. haveAudio = true;
  29. mSourceImpls.push(impl);
  30. }
  31. }
  33. if (++numPacketsParsed > 10000) {
  34. break;
  35. }
  36. }
  38. ALOGI("haveAudio=%d, haveVideo=%d", haveAudio, haveVideo);
  39. } 
void MPEG2TSExtractor::init() {
    bool haveAudio = false;
    bool haveVideo = false;
    int numPacketsParsed = 0;
 
    while (feedMore() == OK) {
        ATSParser::SourceType type;
        if (haveAudio && haveVideo) {
            break;
        }
        if (!haveVideo) {
            sp<AnotherPacketSource> impl =
                (AnotherPacketSource *)mParser->getSource(
                        ATSParser::VIDEO).get();
 
            if (impl != NULL) {
                haveVideo = true;
                mSourceImpls.push(impl);
            }
        }
 
        if (!haveAudio) {
            sp<AnotherPacketSource> impl =
                (AnotherPacketSource *)mParser->getSource(
                        ATSParser::AUDIO).get();
 
            if (impl != NULL) {
                haveAudio = true;
                mSourceImpls.push(impl);
            }
        }
 
        if (++numPacketsParsed > 10000) {
            break;
        }
    }
 
    ALOGI("haveAudio=%d, haveVideo=%d", haveAudio, haveVideo);
}

这里feedMore便是解析文件头的具体实现，代码的后半部分主要是当解析成功即feedMore() == OK

feedmore作用有两个：解析头信息+缓冲数据

将audio video的source存放在栈mSourceImpls中。看下具体实现

[html] view plain copy print ?
  1. status_t MPEG2TSExtractor::feedMore() {
  2. Mutex::Autolock autoLock(mLock);
  4. uint8_t packet[kTSPacketSize];
  5. ssize_t n = mDataSource->readAt(mOffset, packet, kTSPacketSize);
  7. if (n < (ssize_t)kTSPacketSize) {
  8. return (n < 0) ? (status_t)n : ERROR_END_OF_STREAM;
  9. }
  11. mOffset += n;
  12. return mParser->feedTSPacket(packet, kTSPacketSize);
  13. } 
status_t MPEG2TSExtractor::feedMore() {
    Mutex::Autolock autoLock(mLock);
 
    uint8_t packet[kTSPacketSize];
    ssize_t n = mDataSource->readAt(mOffset, packet, kTSPacketSize);
 
    if (n < (ssize_t)kTSPacketSize) {
        return (n < 0) ? (status_t)n : ERROR_END_OF_STREAM;
    }
 
    mOffset += n;
    return mParser->feedTSPacket(packet, kTSPacketSize);
}

从代码中可以看出mParser并不与datasource直接联系，而是mExtractor读取一个ts包，传递给mParser来分析

具体分析过程通过调用mParser->feedTSPacket方法完成，进入ATParser类方法中

[html] view plain copy print ?
  1. status_t ATSParser::feedTSPacket(const void *data, size_t size) {
  2. CHECK_EQ(size, kTSPacketSize);
  4. ABitReader br((const uint8_t *)data, kTSPacketSize);
  5. return parseTS(&br);
  6. } 
status_t ATSParser::feedTSPacket(const void *data, size_t size) {
    CHECK_EQ(size, kTSPacketSize);
 
    ABitReader br((const uint8_t *)data, kTSPacketSize);
    return parseTS(&br);
}

[html] view plain copy print ?
  1. status_t ATSParser::parseTS(ABitReader *br) {
  3. *****************
  5. if (adaptation_field_control == 1 || adaptation_field_control == 3) {
  6. err = parsePID(
  7. br, PID, continuity_counter, payload_unit_start_indicator);
  8. }
  10. ++mNumTSPacketsParsed;
  12. return err;
  13. } 
status_t ATSParser::parseTS(ABitReader *br) {
 
    *****************
 
    if (adaptation_field_control == 1 || adaptation_field_control == 3) {
        err = parsePID(
                br, PID, continuity_counter, payload_unit_start_indicator);
    }
 
    ++mNumTSPacketsParsed;
 
    return err;
}


省略部分无关代码

如果对ts文件格式不了解，网上有很多资料。这里解析ts头主要就是解析几个表，如PAT(pid==0) PMT(pid通过解析pat获取) 以及通过上面两步获取实际流pid号之后解析实际数据获取参数。

这里获取pid之后通过调用parsePID来处理。

[html] view plain copy print ?
  1. status_t ATSParser::parsePID(
  2. ABitReader *br, unsigned PID,
  3. unsigned continuity_counter,
  4. unsigned payload_unit_start_indicator) {
  6. if (PID == 0) {
  7. parseProgramAssociationTable(§ionBits);
  8. } else {
  10. bool handled = false;
  11. for (size_t i = 0; i < mPrograms.size(); ++i) {
  12. status_t err;
  13. if (!mPrograms.editItemAt(i)->parsePSISection(
  14. PID, §ionBits, &err)) {
  15. continue;
  16. }
  17. section->clear();
  19. return OK;
  20. }
  22. bool handled = false;
  23. for (size_t i = 0; i < mPrograms.size(); ++i) {
  24. status_t err;
  25. if (mPrograms.editItemAt(i)->parsePID(
  26. PID, continuity_counter, payload_unit_start_indicator,
  27. br, &err)) {
  28. if (err != OK) {
  29. return err;
  30. }
  32. handled = true;
  33. break;
  34. }
  35. }
  37. if (!handled) {
  38. ALOGV("PID 0x%04x not handled.", PID);
  39. }
  41. return OK;
  42. } 
status_t ATSParser::parsePID(
        ABitReader *br, unsigned PID,
        unsigned continuity_counter,
        unsigned payload_unit_start_indicator) {
 
        if (PID == 0) {
            parseProgramAssociationTable(§ionBits);
        } else {
 
             bool handled = false;
            for (size_t i = 0; i < mPrograms.size(); ++i) {
                status_t err;
                if (!mPrograms.editItemAt(i)->parsePSISection(
                            PID, §ionBits, &err)) {
                    continue;
                }
        section->clear();
 
        return OK;
    }
 
bool handled = false;
    for (size_t i = 0; i < mPrograms.size(); ++i) {
        status_t err;
        if (mPrograms.editItemAt(i)->parsePID(
                    PID, continuity_counter, payload_unit_start_indicator,
                    br, &err)) {
            if (err != OK) {
                return err;
            }
 
            handled = true;
            break;
        }
    }
 
    if (!handled) {
        ALOGV("PID 0x%04x not handled.", PID);
    }
 
    return OK;
}


 

这里主要是根据pid的不同来分别处理，如parseProgramAssociationTable用来处理pat表，此时pid==0

如果不是，则调用mPrograms.editItemAt(i)->parsePSISection来处理pmt表

这里如果没有处理过pat表，则 mPrograms.size()==0 会进入下一循环直到找到pat为止

这里不再深入了，解析完pmt表，就知道了文件中有几个流，几路audio 几路video等信息都得到了

后面会调用每个流的parsePID -- >调用每个流的parse函数，后续调用顺序为

mStreams.editValueAt(index)->parse->flush();->parsePES->onPayloadData等

这里简单总结下：在ATSParser中有几个内嵌类，

Program类负责解析pmt表

Stream类负责解析每个流的具体信息

具体代码不再列举了，总归都是按照ts的标准来解析，若读者不熟悉ts强烈建议仔细阅读下ffmpeg或者ATSParser中的实现方式。

重点注释：

每个Stream代表一个流，可以是音频流或者是视频流，读包的操作主要就是通过Stream接口来完成的。当在extractor中的feedmore方法中读取一个ts包传递给mParser解析时，

如果是实际的数据包，则最终都会存储在Stream的buffer中，而stream中的成员mSource(AnotherPacketSource)则是最终传递上去的保存在MPEG2TSExtractor中保存在全局变量中mSourceImpl中

而实际的mAudioTrack mVideoTrack则是通过getTrack返回MPEG2TSSource，而MPEG2TSSource 封装了AnotherPacketSource ，也就和实际的stream关联起来，

最终可以通过MPEG2TSSource 读取保存在stream中的数据包

【说明】请仔细消化上面这段话，并结合代码及上面的图来理解

3.3 demuxer -- read_packet

之前分析过，在awesomeplayer中有如下语句

mAudioTrack = extractor->getTrack(*);

mVideoTrack = extractor->getTrack(*);

这里getTrack便是建立awesomeplayer与extractor连接的地方（参考上面的黑体部分）

这里分析下ts的具体实现

[html] view plain copy print ?
  1. sp<MediaSource> MPEG2TSExtractor::getTrack(size_t index) {
  4. ************
  6. return new MPEG2TSSource(this, mSourceImpls.editItemAt(index), seekable);
  7. } 
sp<MediaSource> MPEG2TSExtractor::getTrack(size_t index) {
 
 
    ************
 
    return new MPEG2TSSource(this, mSourceImpls.editItemAt(index), seekable);
}

这里在MPEG2TSExtractor定义了一个新的继承自MediaSource的类MPEG2TSSource，返回给上层

其构造函数如下：

[html] view plain copy print ?
  1. MPEG2TSSource::MPEG2TSSource(
  2. const sp<MPEG2TSExtractor> &extractor,
  3. const sp<AnotherPacketSource> &impl,
  4. bool seekable)
  5. : mExtractor(extractor),
  6. mImpl(impl),
  7. mSeekable(seekable) {
  8. } 
MPEG2TSSource::MPEG2TSSource(
        const sp<MPEG2TSExtractor> &extractor,
        const sp<AnotherPacketSource> &impl,
        bool seekable)
    : mExtractor(extractor),
      mImpl(impl),
      mSeekable(seekable) {
}

这里传入的参数mSourceImpls.editItemAt(index)是一个AnotherPacketSource对象（实际生成是在ATSParser中的Stream类中），主要负责缓存数据包，等上层解码器需要数据的时候会从此处读取

看下实际的读包方法：

在awesomeplayer中会调用mAudioTrack->read(*)方法，由于mAudioTrack == mVideoTrack == MPEG2TSSource ，因此调用的是MPEG2TSSource 的read方法

[html] view plain copy print ?
  1. status_t MPEG2TSSource::read(
  2. MediaBuffer **out, const ReadOptions *options) {
  3. *out = NULL;
  5. int64_t seekTimeUs;
  6. ReadOptions::SeekMode seekMode;
  7. if (mSeekable && options && options->getSeekTo(&seekTimeUs, &seekMode)) {
  8. mExtractor->seekTo(seekTimeUs);
  9. }
  11. status_t finalResult;
  12. while (!mImpl->hasBufferAvailable(&finalResult)) {
  13. if (finalResult != OK) {
  14. return ERROR_END_OF_STREAM;
  15. }
  17. status_t err = mExtractor->feedMore();
  18. if (err != OK) {
  19. mImpl->signalEOS(err);
  20. }
  21. }
  23. return mImpl->read(out, options);
  24. } 
status_t MPEG2TSSource::read(
        MediaBuffer **out, const ReadOptions *options) {
    *out = NULL;
 
    int64_t seekTimeUs;
    ReadOptions::SeekMode seekMode;
    if (mSeekable && options && options->getSeekTo(&seekTimeUs, &seekMode)) {
        mExtractor->seekTo(seekTimeUs);
    }
 
    status_t finalResult;
    while (!mImpl->hasBufferAvailable(&finalResult)) {
        if (finalResult != OK) {
            return ERROR_END_OF_STREAM;
        }
 
        status_t err = mExtractor->feedMore();
        if (err != OK) {
            mImpl->signalEOS(err);
        }
    }
 
    return mImpl->read(out, options);
}


 

这里首先判断是否需要seek，若不需要。则通过mImpl->hasBufferAvailable看是否有缓存数据包，此处mImpl == mSourceImpls.editItemAt(index),（见上面构造函数参数列表）

如果没有则通过feedMore()读取包

最后通过 mImpl->read(out, options)返回给上层。

这里再解释下：首先每个流都对应一个MPEG2TSSource 对象，而每个MPEG2TSSource 对象都有一个AnotherPacketSource 对象，对应一个缓存列表。一开始extractor通过feedMore解析数据后将数据存储在各个AnotherPacketSource 的缓存列表中

举例来讲：如果某一时刻 audio 缓存类表为空，而video 缓存列表为 4 ， 此时读取audio包会导致mImpl->hasBufferAvailable ==0，此时会通过mExtractor->feedMore 继续缓存数据，若下一包为video则挂在到video缓存（此处video包+1=5）

直到解析到一个audio包，则返回。此处的实现保证了不会因为包分布不合理导致解码阻塞等情况

看下feedMore实现

[html] view plain copy print ?
  1. status_t MPEG2TSExtractor::feedMore() {
  2. Mutex::Autolock autoLock(mLock);
  4. uint8_t packet[kTSPacketSize];
  5. ssize_t n = mDataSource->readAt(mOffset, packet, kTSPacketSize);
  7. if (n < (ssize_t)kTSPacketSize) {
  8. return (n < 0) ? (status_t)n : ERROR_END_OF_STREAM;
  9. }
  11. mOffset += n;
  12. return mParser->feedTSPacket(packet, kTSPacketSize);
  13. } 
status_t MPEG2TSExtractor::feedMore() {
    Mutex::Autolock autoLock(mLock);
 
    uint8_t packet[kTSPacketSize];
    ssize_t n = mDataSource->readAt(mOffset, packet, kTSPacketSize);
 
    if (n < (ssize_t)kTSPacketSize) {
        return (n < 0) ? (status_t)n : ERROR_END_OF_STREAM;
    }
 
    mOffset += n;
    return mParser->feedTSPacket(packet, kTSPacketSize);
}

主要是读取一包，然后解析,调用顺序如下

feedMore->mParser->feedTSPacket->parseTS->ATSParser::parsePID->ATSParser::Program::parsePID->ATSParser::Stream::parse

在ATSParser::Stream::parse 最终会将数据包缓存起来（具体实现方式：将数据全部缓存起来，放在mBuffer中，当此包数据都完成时，即得到了一个完整的audio或者video包，调用flush解析好了存在AnotherPacketSource的缓存中。）

3.4 demuxer -- read_seek

当需要seek的时候，入口在awesomeplayer的seekto,代码如下

[html] view plain copy print ?
  1. status_t AwesomePlayer::seekTo(int64_t timeUs) {
  2. ATRACE_CALL();
  4. if (mExtractorFlags & MediaExtractor::CAN_SEEK) {
  5. Mutex::Autolock autoLock(mLock);
  6. return seekTo_l(timeUs);
  7. }
  9. return OK;
  10. } 
status_t AwesomePlayer::seekTo(int64_t timeUs) {
    ATRACE_CALL();
 
    if (mExtractorFlags & MediaExtractor::CAN_SEEK) {
        Mutex::Autolock autoLock(mLock);
        return seekTo_l(timeUs);
    }
 
    return OK;
}

[html] view plain copy print ?
  1. status_t AwesomePlayer::seekTo_l(int64_t timeUs) {
  2. *********************
  3. mSeeking = SEEK;
  4. mSeekNotificationSent = false;
  5. mSeekTimeUs = timeUs;
  6. modifyFlags((AT_EOS | AUDIO_AT_EOS | VIDEO_AT_EOS), CLEAR);
  7. seekAudioIfNecessary_l();
  8. if (!(mFlags & PLAYING)) {
  9. ALOGV("seeking while paused, sending SEEK_COMPLETE notification"
  10. " immediately.");
  11. notifyListener_l(MEDIA_SEEK_COMPLETE);
  12. mSeekNotificationSent = true;
  13. if ((mFlags & PREPARED) && mVideoSource != NULL) {
  14. modifyFlags(SEEK_PREVIEW, SET);
  15. postVideoEvent_l();
  16. }
  17. }
  19. return OK;
  20. } 
status_t AwesomePlayer::seekTo_l(int64_t timeUs) {
    *********************
    mSeeking = SEEK;
    mSeekNotificationSent = false;
    mSeekTimeUs = timeUs;
    modifyFlags((AT_EOS | AUDIO_AT_EOS | VIDEO_AT_EOS), CLEAR);
    seekAudioIfNecessary_l();
    if (!(mFlags & PLAYING)) {
        ALOGV("seeking while paused, sending SEEK_COMPLETE notification"
             " immediately.");
        notifyListener_l(MEDIA_SEEK_COMPLETE);
        mSeekNotificationSent = true;
        if ((mFlags & PREPARED) && mVideoSource != NULL) {
            modifyFlags(SEEK_PREVIEW, SET);
            postVideoEvent_l();
        }
    }
 
    return OK;
}


首先设置seek标志，mSeeking = SEEK，然后设置seek到的位置 mSeekTimeUs = timeUs;清空标志位。

调用seekAudioIfNecessary_l，看下实现

[html] view plain copy print ?
  1. void AwesomePlayer::seekAudioIfNecessary_l() {
  2. if (mSeeking != NO_SEEK && mVideoSource == NULL && mAudioPlayer != NULL) {
  3. mAudioPlayer->seekTo(mSeekTimeUs);
  5. mWatchForAudioSeekComplete = true;
  6. mWatchForAudioEOS = true;
  8. if (mDecryptHandle != NULL) {
  9. mDrmManagerClient->setPlaybackStatus(mDecryptHandle,
  10. Playback::PAUSE, 0);
  11. mDrmManagerClient->setPlaybackStatus(mDecryptHandle,
  12. Playback::START, mSeekTimeUs / 1000);
  13. }
  14. }
  15. } 
void AwesomePlayer::seekAudioIfNecessary_l() {
    if (mSeeking != NO_SEEK && mVideoSource == NULL && mAudioPlayer != NULL) {
        mAudioPlayer->seekTo(mSeekTimeUs);
 
        mWatchForAudioSeekComplete = true;
        mWatchForAudioEOS = true;
 
        if (mDecryptHandle != NULL) {
            mDrmManagerClient->setPlaybackStatus(mDecryptHandle,
                    Playback::PAUSE, 0);
            mDrmManagerClient->setPlaybackStatus(mDecryptHandle,
                    Playback::START, mSeekTimeUs / 1000);
        }
    }
}


 

比较简单，调用mAudioPlayer->seekTo

[html] view plain copy print ?
  1. status_t AudioPlayer::seekTo(int64_t time_us) {
  2. Mutex::Autolock autoLock(mLock);
  4. mSeeking = true;
  5. mPositionTimeRealUs = mPositionTimeMediaUs = -1;
  6. mReachedEOS = false;
  7. mSeekTimeUs = time_us;
  9. // Flush resets the number of played frames
  10. mNumFramesPlayed = 0;
  11. mNumFramesPlayedSysTimeUs = ALooper::GetNowUs();
  13. if (mAudioSink != NULL) {
  14. mAudioSink->flush();
  15. } else {
  16. mAudioTrack->flush();
  17. }
  19. return OK;
  20. } 
status_t AudioPlayer::seekTo(int64_t time_us) {
    Mutex::Autolock autoLock(mLock);
 
    mSeeking = true;
    mPositionTimeRealUs = mPositionTimeMediaUs = -1;
    mReachedEOS = false;
    mSeekTimeUs = time_us;
 
    // Flush resets the number of played frames
    mNumFramesPlayed = 0;
    mNumFramesPlayedSysTimeUs = ALooper::GetNowUs();
 
    if (mAudioSink != NULL) {
        mAudioSink->flush();
    } else {
        mAudioTrack->flush();
    }
 
    return OK;
}


 

从代码中看主要是设置标志位

mSeeking = true;

mSeekTimeUs = time_us;

然后清空audioplayer中的pcm数据，而设置好seek标志之后，在audioplayer的fill buffer中读取数据时便会设置要读取的时间的数据，具体代码如下

[html] view plain copy print ?
  1. size_t AudioPlayer::fillBuffer(void *data, size_t size) {
  2. *************
  3. MediaSource::ReadOptions options;
  4. options.setSeekTo(mSeekTimeUs);
  5. err = mSource->read(&mInputBuffer, &options);
  6. *************
  7. } 
size_t AudioPlayer::fillBuffer(void *data, size_t size) {
    *************
    MediaSource::ReadOptions options;
    options.setSeekTo(mSeekTimeUs);
    err = mSource->read(&mInputBuffer, &options);     
    *************
}

只列出了关键语句。

通过上面分析得出：当收到seek命令时，对于audio来讲就是清空audioplayer的pcm数据，设置下次要读取的位置MediaSource::ReadOptions options，其他工作由上层完成（指的是decoder，具体在分析decoder的时候介绍）

audio的seek完成之后，看下video的seek

具体代码在onVideoEvent中

[html] view plain copy print ?
  1. void AwesomePlayer::onVideoEvent() {
  3. ********
  5. MediaSource::ReadOptions options;
  6. if (mSeeking != NO_SEEK) {
  7. options.setSeekTo(
  8. mSeekTimeUs,
  9. mSeeking == SEEK_VIDEO_ONLY
  10. ? MediaSource::ReadOptions::SEEK_NEXT_SYNC
  11. : MediaSource::ReadOptions::SEEK_CLOSEST_SYNC);
  12. } ​​
  14. status_t err = mVideoSource->read(&mVideoBuffer, &options);
  16. ********
  18. } 
void AwesomePlayer::onVideoEvent() {
 
    ********
 
    MediaSource::ReadOptions options;
    if (mSeeking != NO_SEEK) {
            options.setSeekTo(
             mSeekTimeUs,
             mSeeking == SEEK_VIDEO_ONLY
                ? MediaSource::ReadOptions::SEEK_NEXT_SYNC
                : MediaSource::ReadOptions::SEEK_CLOSEST_SYNC);
   }    ​​
 
   status_t err = mVideoSource->read(&mVideoBuffer, &options);
 
    ********
 
}


 

这里的处理方式与audio类似，都是设置好seek后的位置 MediaSource::ReadOptions options ，然后再从mVideoSource读取数据时作为参数传递进去（decoder后面介绍）。

但这里可以想到，最终decoder都会设置MediaExtractor 读取位置来达到seek的效果，这里看些ts的case

这里在ts extractor中调用read方法读取数据代码如下：

[html] view plain copy print ?
  1. status_t MPEG2TSSource::read(
  2. MediaBuffer **out, const ReadOptions *options) {
  3. *out = NULL;
  5. int64_t seekTimeUs;
  6. ReadOptions::SeekMode seekMode;
  7. if (mSeekable && options && options->getSeekTo(&seekTimeUs, &seekMode)) {
  8. mExtractor->seekTo(seekTimeUs);
  9. }
  11. status_t finalResult;
  12. while (!mImpl->hasBufferAvailable(&finalResult)) {
  13. if (finalResult != OK) {
  14. return ERROR_END_OF_STREAM;
  15. }
  17. status_t err = mExtractor->feedMore();
  18. if (err != OK) {
  19. mImpl->signalEOS(err);
  20. }
  21. }
  23. return mImpl->read(out, options);
  24. } 
status_t MPEG2TSSource::read(
        MediaBuffer **out, const ReadOptions *options) {
    *out = NULL;
 
    int64_t seekTimeUs;
    ReadOptions::SeekMode seekMode;
    if (mSeekable && options && options->getSeekTo(&seekTimeUs, &seekMode)) {
        mExtractor->seekTo(seekTimeUs);
    }
 
    status_t finalResult;
    while (!mImpl->hasBufferAvailable(&finalResult)) {
        if (finalResult != OK) {
            return ERROR_END_OF_STREAM;
        }
 
        status_t err = mExtractor->feedMore();
        if (err != OK) {
            mImpl->signalEOS(err);
        }
    }
 
    return mImpl->read(out, options);
}



 

可以看到option已经传递进来，继续跟进mImpl->read

[html] view plain copy print ?
  1. status_t AnotherPacketSource::read(
  2. MediaBuffer **out, const ReadOptions *) {
  3. *out = NULL;
  5. Mutex::Autolock autoLock(mLock);
  6. while (mEOSResult == OK && mBuffers.empty()) {
  7. mCondition.wait(mLock);
  8. }
  10. if (!mBuffers.empty()) {
  11. const sp<ABuffer> buffer = *mBuffers.begin();
  12. mBuffers.erase(mBuffers.begin());
  14. int32_t discontinuity;
  15. if (buffer->meta()->findInt32("discontinuity", &discontinuity)) {
  16. if (wasFormatChange(discontinuity)) {
  17. mFormat.clear();
  18. }
  20. return INFO_DISCONTINUITY;
  21. } else {
  22. int64_t timeUs;
  23. CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
  25. MediaBuffer *mediaBuffer = new MediaBuffer(buffer);
  27. mediaBuffer->meta_data()->setInt64(kKeyTime, timeUs);
  29. *out = mediaBuffer;
  30. return OK;
  31. }
  32. }
  34. return mEOSResult;
  35. } 
status_t AnotherPacketSource::read(
        MediaBuffer **out, const ReadOptions *) {
    *out = NULL;
 
    Mutex::Autolock autoLock(mLock);
    while (mEOSResult == OK && mBuffers.empty()) {
        mCondition.wait(mLock);
    }
 
    if (!mBuffers.empty()) {
        const sp<ABuffer> buffer = *mBuffers.begin();
        mBuffers.erase(mBuffers.begin());
 
        int32_t discontinuity;
        if (buffer->meta()->findInt32("discontinuity", &discontinuity)) {
            if (wasFormatChange(discontinuity)) {
                mFormat.clear();
            }
 
            return INFO_DISCONTINUITY;
        } else {
            int64_t timeUs;
            CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
 
            MediaBuffer *mediaBuffer = new MediaBuffer(buffer);
 
            mediaBuffer->meta_data()->setInt64(kKeyTime, timeUs);
 
            *out = mediaBuffer;
            return OK;
        }
    }
 
    return mEOSResult;
}



 

从代码里看并没有使用传递进来的 ReadOptions ，预计seek动作实在decoder中解决的。等分析decoder的时候再详细看。

到此，extractor就分析完了。

cosmoslhf
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android多媒体框架服务之StagefrightPlayer和OMXCodec实现原理.pdf
04-22
扎根科技 191文章 22万总阅读 查看TA的文章> 评论 分享 微信分享 ...移动安全是指保护移动设备和移动应用程序免受安全威胁和攻击的一系列措施和技术。随着移动设备的普及和移动应用的快速发展，移动安全变得...
音视频开发系列(5)——全面了解Android MediaExtractor
一个码农的博客
03-05 1805
MediaExtractor的主要API如下：setDataSource(String path): 设置媒体文件的路径。setDataSource(FileDescriptor fd): 设置媒体文件的FileDescriptor。setDataSource(Context context, Uri uri, Map headers): 设置媒体文件的Uri和headers。getTrackCount(): 获取媒体文件中的音视频轨道数量。
音视频从入门到精通——MediaExtractor API 简介
e891377的专栏
08-24 2596
顾名思义，MediaExtractor 可以从数据源中提取经过编码的媒体数据。MediaExtractor 不仅可以解析本地媒体文件，还可以解析网络媒体资源。
在 Android 上使用 MediaExtractor 和 MediaMuxer 提取视频\提取音频\转封装\添加音频等操作
记录学习的过程
01-02 2377
之前我们介绍了 FFmpeg 并利用它解封装、编解码的能力完成了一款简易的视频播放器。额外的 so 文件。你需要将多个 so 文件集成至你的 app 中，使得 app 整体体积增加。额外的复杂性。这里的复杂性包括多个方面：集成的复杂性。为了引入 ffmpeg，你在编译脚本需要额外对这些库进行维护；此外，通常你不需要 FFmpeg 的全部能力，因此在编译 FFmpeg 库时你需要对其进行裁剪，这部分也需要额外的付出。编程的复杂性。
音视频开发之旅（五）MediaExtractor MediaMuxer 实现视频的解封装与合成
yabin的专栏
10-21 1429
目录 MediaExtractor MediaMuxer 能做什么 视频解封装和合成的API以及流程介绍 三个实践（视频解封装提取纯音轨和视频轨文件、再合成新视频、给视频换个背景音） 遇到的问题 收获 一、有什么实际应用 在我们日常使用短视频软件的时候，对视频的裁剪，拼凑，加入背景是很常用的操作，这些功能是如何实现的呐？其实是将视频多信道的分离出来，比如音轨和视频轨道分隔出来，可以做到二次合成。 今天我们通过对来MediaExtractor和MediaM
Android音视频开发（三）——MediaExtractor和MediaMuxer的使用
indeedes的博客
05-23 4696
了解了音视频的编解码过程，我们接下来使用一下经常跟MediaCodec一起搭配的MediaExtractor和MediaMuxer。最后会使用一个简单的demo来了解具体了解这两个工具类的使用过程。这一节我们就先不讲MediaCodec了，放到下节的demo。 一、MediaExtractor Android提供了一个MediaExtractor类，可以用来分离容器中的视频track和音频track。 主要API介绍： setDataSource(String path)：即可以设置本地文件又
TS和M3U8的解析
04-12
3. **下载TS片段**：根据M3U8文件中的信息，客户端会按需下载TS文件，这些文件通常包含几秒的视频或音频数据。 4. **解码和播放**：下载的TS文件会被送入解码器进行解码，然后由播放器进行播放。在Android中，流...
android-stagefright处理httplivestreaming缓冲机制
06-17
在Native层，这会触发StagefrightPlayer的创建，它内部持有一个AwesomePlayer类型的mPlayer成员。这个过程涉及了跨进程的数据传递和对象的实例化。 三、Prepare过程 在prepare过程中，主要涉及了一个名为...
Android 音视频开发(五) -- 使用 MediaExtractor 分离音视频，并使用 MediaMuxer合成新视频(音视频同步)
夏至的稻穗的博客
07-14 5918
音视频学习demo,正在升级打怪，加油鸭~ Android 音视频开发(一) – 使用AudioRecord 录制PCM(录音)；AudioTrack播放音频 Android 音视频开发(二) – Camera1 实现预览、拍照功能 Android 音视频开发(三) – Camera2 实现预览、拍照功能 Android 音视频开发(四) – CameraX 实现预览、拍照功能 工程：音视频demo 前几章，我们已经为音视频学习打下了一定的基础。 这一章，我们来学习如何使用 MediaExtractor.
MediaExtractor介绍
baidu_15408405的专栏
03-24 4463
概述 本篇介绍播放器结构中的第一部分Stream+Demuxer. Awesomeplayer中对应的数据结构主要有DataSource，MediaExtractor，MediaSource。 其中DataSource 主要负责提供原始数据，MediaSource负责提供demux后的数据（即实际的audio 或者 video 数据包） 而MediaExtractor则
基于 FFmpeg 的自定义 Media Extractor（1）：播放器基本原理及 Extractor 框架简析
最新发布
汽车行业，专注于座舱多媒体功能开发。欢迎大家在此共享想法，学习知识，探索新的技术。
03-08 1222
在 Android 多媒体框架中，Media Extractor 扮演着十分重要的角色。本文作为自定义 Media Extractor 系列的第一篇文章，将对播放器的一些基本原理进行普及，然后简要介绍 Android 系统中 Media Extractor 的框架结构，以及 Extractor 组件加载流程。本文基于 Android 11，主要目的为普及 Android Extractor 的基本框架以及工作原理，不对 Android 源代码展开过多的分析。
MediaExtractor浅析
qq_38076413的博客
01-07 2428
1. JAVA层 file: frameworks/base/media/java/android/media/MediaExtractor.java  class: MediaExtractor MediaExtractor上层接口。  其中有3个调用JNI的接口： private static native final void native_init();
Android RTSP IPC的使用
weixin_40437029的博客
01-11 438
RTSP(Real Time Streaming Protocol)简介 https://baike.baidu.com/item/RTSP/1276768?fr=aladdin Android支持 APP Process=>VideoView=>MediaPlayer=> mediaserver Process=>NuPlayerDriver=>NuPlayer=>RTSPSource=>AnotherPacketSource frameworks\av\med
Android 9.0 MediaPlayer播放流程分析
zjy764219923的专栏
11-28 2778
MediaPlayer流程分析
【五】Android MediaPlayer整体架构源码分析 -【prepareAsync/prepare数据准备处理流程】【Part 3】
CloverLHao的博客
04-09 1257
承接上一章节分析：【五】Android MediaPlayer整体架构源码分析 -【prepareAsync/prepare数据准备处理流程】【Part 2】 本系列文章分析的安卓源码版本：【Android 10.0 版本】 【此章节小节编号就接着上一章节排列】 3.5、getFormatMeta_l(false /* audio */)实现分析： 获取video track信息的元数据。 其实也就是通过video track对象（source）的getFormat()方法来获取video track信息的
Multimedia框架解析之MediaExtractor源码分析（一）
06-08 1883
Multimedia框架解析之MediaExtractor源码分析
android mpeg2ts 流媒体打包MediaMuxer 和 录制MPEG2TSWriter 以及抽帧MPEG2TSExtractor
xuhui_7810的专栏
04-01 2738
目前android上，录相大多是mp4的视频，这在一般情况下，已经够用了。但是在一些特定的场景，比如远程临控录相或者行车记录仪上，用mp4录相，就不太理想了。为什么呢？因为远程录相，或者行车记录仪上都有一个共同的问题，那就是录相有可能中断。比如突然撞车了，或者是远程监控断电了，如果这时录的是Mp4的视频，那么就会导致，没有来得及写和mp4的文件头信息，而打不开视频。所以在远程监控录相...
Miracast技术详解（四）：Sink源码解析
Venus 的博客
07-06 2645
Miracast Sink端源码最早出现在上，通过可以很方便的查看： https://android.googlesource.com/platform/frameworks/av/+/android-4.2.2_r1.2/media/libstagefright/wifi-display/sink/ 但是在以后，Google却移除掉了这部分源码，详细的commit记录在： https://android.googlesource.com/platform/frameworks/av/+/c4bd06130
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值