【stagefrightplayer】3 MediaExtractor介绍

概述

---

本篇介绍播放器结构中的第一部分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 构造函数

AwesomePlayer::AwesomePlayer(){
*************
DataSource::RegisterDefaultSniffers();
*************
}

AwesomePlayer::AwesomePlayer(){
    *************
    DataSource::RegisterDefaultSniffers();
    *************
}

看下RegisterDefaultSniffers实现

// 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);
}

// static
void DataSource::RegisterSniffer(SnifferFunc func) {
    Mutex::Autolock autoLock(gSnifferMutex);
 
    for (List::iterator it = gSniffers.begin();
         it != gSniffers.end(); ++it) {
        if (*it == func) {
            return;
        }
    }
 
    gSniffers.push_back(func);
}

void DataSource::RegisterDefaultSniffers() {

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);
}

    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

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);
}

status_t AwesomePlayer::setDataSource(
        int fd, int64_t offset, int64_t length) {
    Mutex::Autolock autoLock(mLock);
 
    reset_l();
 
    sp 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类的定义

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 &);
};

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 DrmInitialization(const char *mime);
 
    virtual void getDrmInfo(sp &handle, DrmManagerClient **client);
 
protected:
    virtual ~FileSource();
 
private:
    int mFd;
    int64_t mOffset;
    int64_t mLength;
    Mutex mLock;
 
    /*for DRM*/
    sp 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功能。其构造函数如下

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));
}
}

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对应起来，这里看下流程

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);
}

status_t AwesomePlayer::setDataSource_l(
        const sp &dataSource) {
    sp 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等实现

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);
}

sp MediaExtractor::Create(
        const sp &source, const char *mime) {
    sp 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实现

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;
}

bool DataSource::sniff(
        String8 *mimeType, float *confidence, sp *meta) {
    *mimeType = "";
    *confidence = 0.0f;
    meta->clear();
 
    Mutex::Autolock autoLock(gSnifferMutex);
    for (List::iterator it = gSniffers.begin();
         it != gSniffers.end(); ++it) {
        String8 newMimeType;
        float newConfidence;
        sp newMeta;
        if ((*it)(this, &newMimeType, &newConfidence, &newMeta)) {
            if (newConfidence > *confidence) {
                *mimeType = newMimeType;
                *confidence = newConfidence;
                *meta = newMeta;
            }
        }
    }
 
    return *confidence > 0.0;
}

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

下面继续

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;
}

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函数。具体实现如下：

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;
}

bool SniffMPEG2TS(
        const sp &source, String8 *mimeType, float *confidence,
        sp *) {
    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函数主要作用是解析文件头信息，获取文件中的具体流信息及参数

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

MPEG2TSExtractor::MPEG2TSExtractor(const sp<DataSource> &source)
: mDataSource(source),
mParser(new ATSParser),
mOffset(0) {
init();
}

MPEG2TSExtractor::MPEG2TSExtractor(const sp &source)
    : mDataSource(source),
      mParser(new ATSParser),
      mOffset(0) {
    init();
}

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

看下其构造函数

ATSParser::ATSParser(uint32_t flags)
: mFlags(flags),
mAbsoluteTimeAnchorUs(-1ll),
mNumTSPacketsParsed(0),
mNumPCRs(0) {
mPSISections.add(0 /* PID */, new PSISection);
}

ATSParser::ATSParser(uint32_t flags)
    : mFlags(flags),
      mAbsoluteTimeAnchorUs(-1ll),
      mNumTSPacketsParsed(0),
      mNumPCRs(0) {
    mPSISections.add(0 /* PID */, new PSISection);
}

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

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);
}

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 impl =
                (AnotherPacketSource *)mParser->getSource(
                        ATSParser::VIDEO).get();
 
            if (impl != NULL) {
                haveVideo = true;
                mSourceImpls.push(impl);
            }
        }
 
        if (!haveAudio) {
            sp 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中。看下具体实现

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);
}

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类方法中

status_t ATSParser::feedTSPacket(const void *data, size_t size) {
CHECK_EQ(size, kTSPacketSize);

ABitReader br((const uint8_t *)data, kTSPacketSize);
return parseTS(&br);
}

status_t ATSParser::feedTSPacket(const void *data, size_t size) {
    CHECK_EQ(size, kTSPacketSize);
 
    ABitReader br((const uint8_t *)data, kTSPacketSize);
    return parseTS(&br);
}

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;
}

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来处理。

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;
}

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的具体实现

sp<MediaSource> MPEG2TSExtractor::getTrack(size_t index) {


************

return new MPEG2TSSource(this, mSourceImpls.editItemAt(index), seekable);
}

sp MPEG2TSExtractor::getTrack(size_t index) {
 
 
    ************
 
    return new MPEG2TSSource(this, mSourceImpls.editItemAt(index), seekable);
}

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

其构造函数如下：

MPEG2TSSource::MPEG2TSSource(
const sp<MPEG2TSExtractor> &extractor,
const sp<AnotherPacketSource> &impl,
bool seekable)
: mExtractor(extractor),
mImpl(impl),
mSeekable(seekable) {
}

MPEG2TSSource::MPEG2TSSource(
        const sp &extractor,
        const sp &impl,
        bool seekable)
    : mExtractor(extractor),
      mImpl(impl),
      mSeekable(seekable) {
}

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

看下实际的读包方法：

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

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);
}

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实现

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);
}

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,代码如下

status_t AwesomePlayer::seekTo(int64_t timeUs) {
ATRACE_CALL();

if (mExtractorFlags & MediaExtractor::CAN_SEEK) {
Mutex::Autolock autoLock(mLock);
return seekTo_l(timeUs);
}

return OK;
}

status_t AwesomePlayer::seekTo(int64_t timeUs) {
    ATRACE_CALL();
 
    if (mExtractorFlags & MediaExtractor::CAN_SEEK) {
        Mutex::Autolock autoLock(mLock);
        return seekTo_l(timeUs);
    }
 
    return OK;
}

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;
}

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，看下实现

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);
}
}
}

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

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;
}

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中读取数据时便会设置要读取的时间的数据，具体代码如下

size_t AudioPlayer::fillBuffer(void *data, size_t size) {
*************
MediaSource::ReadOptions options;
options.setSeekTo(mSeekTimeUs);
err = mSource->read(&mInputBuffer, &options);
*************
}

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中

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);

********

}

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方法读取数据代码如下：

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);
}

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

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;
}

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 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就分析完了。