Home | History | Annotate | Download | only in mpeg2ts
      1 /*
      2  * Copyright (C) 2010 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 //#define LOG_NDEBUG 0
     18 #define LOG_TAG "ATSParser"
     19 #include <utils/Log.h>
     20 
     21 #include "ATSParser.h"
     22 
     23 #include "AnotherPacketSource.h"
     24 #include "ESQueue.h"
     25 #include "include/avc_utils.h"
     26 
     27 #include <media/stagefright/foundation/ABitReader.h>
     28 #include <media/stagefright/foundation/ABuffer.h>
     29 #include <media/stagefright/foundation/ADebug.h>
     30 #include <media/stagefright/foundation/AMessage.h>
     31 #include <media/stagefright/foundation/hexdump.h>
     32 #include <media/stagefright/MediaDefs.h>
     33 #include <media/stagefright/MediaErrors.h>
     34 #include <media/stagefright/MetaData.h>
     35 #include <media/stagefright/Utils.h>
     36 #include <media/IStreamSource.h>
     37 #include <utils/KeyedVector.h>
     38 
     39 namespace android {
     40 
     41 // I want the expression "y" evaluated even if verbose logging is off.
     42 #define MY_LOGV(x, y) \
     43     do { unsigned tmp = y; ALOGV(x, tmp); } while (0)
     44 
     45 static const size_t kTSPacketSize = 188;
     46 
     47 struct ATSParser::Program : public RefBase {
     48     Program(ATSParser *parser, unsigned programNumber, unsigned programMapPID);
     49 
     50     bool parsePSISection(
     51             unsigned pid, ABitReader *br, status_t *err);
     52 
     53     bool parsePID(
     54             unsigned pid, unsigned continuity_counter,
     55             unsigned payload_unit_start_indicator,
     56             ABitReader *br, status_t *err);
     57 
     58     void signalDiscontinuity(
     59             DiscontinuityType type, const sp<AMessage> &extra);
     60 
     61     void signalEOS(status_t finalResult);
     62 
     63     sp<MediaSource> getSource(SourceType type);
     64 
     65     int64_t convertPTSToTimestamp(uint64_t PTS);
     66 
     67     bool PTSTimeDeltaEstablished() const {
     68         return mFirstPTSValid;
     69     }
     70 
     71     unsigned number() const { return mProgramNumber; }
     72 
     73     void updateProgramMapPID(unsigned programMapPID) {
     74         mProgramMapPID = programMapPID;
     75     }
     76 
     77     unsigned programMapPID() const {
     78         return mProgramMapPID;
     79     }
     80 
     81     uint32_t parserFlags() const {
     82         return mParser->mFlags;
     83     }
     84 
     85 private:
     86     ATSParser *mParser;
     87     unsigned mProgramNumber;
     88     unsigned mProgramMapPID;
     89     KeyedVector<unsigned, sp<Stream> > mStreams;
     90     bool mFirstPTSValid;
     91     uint64_t mFirstPTS;
     92 
     93     status_t parseProgramMap(ABitReader *br);
     94 
     95     DISALLOW_EVIL_CONSTRUCTORS(Program);
     96 };
     97 
     98 struct ATSParser::Stream : public RefBase {
     99     Stream(Program *program,
    100            unsigned elementaryPID,
    101            unsigned streamType,
    102            unsigned PCR_PID);
    103 
    104     unsigned type() const { return mStreamType; }
    105     unsigned pid() const { return mElementaryPID; }
    106     void setPID(unsigned pid) { mElementaryPID = pid; }
    107 
    108     status_t parse(
    109             unsigned continuity_counter,
    110             unsigned payload_unit_start_indicator,
    111             ABitReader *br);
    112 
    113     void signalDiscontinuity(
    114             DiscontinuityType type, const sp<AMessage> &extra);
    115 
    116     void signalEOS(status_t finalResult);
    117 
    118     sp<MediaSource> getSource(SourceType type);
    119 
    120 protected:
    121     virtual ~Stream();
    122 
    123 private:
    124     Program *mProgram;
    125     unsigned mElementaryPID;
    126     unsigned mStreamType;
    127     unsigned mPCR_PID;
    128     int32_t mExpectedContinuityCounter;
    129 
    130     sp<ABuffer> mBuffer;
    131     sp<AnotherPacketSource> mSource;
    132     bool mPayloadStarted;
    133 
    134     uint64_t mPrevPTS;
    135 
    136     ElementaryStreamQueue *mQueue;
    137 
    138     status_t flush();
    139     status_t parsePES(ABitReader *br);
    140 
    141     void onPayloadData(
    142             unsigned PTS_DTS_flags, uint64_t PTS, uint64_t DTS,
    143             const uint8_t *data, size_t size);
    144 
    145     void extractAACFrames(const sp<ABuffer> &buffer);
    146 
    147     bool isAudio() const;
    148     bool isVideo() const;
    149 
    150     DISALLOW_EVIL_CONSTRUCTORS(Stream);
    151 };
    152 
    153 struct ATSParser::PSISection : public RefBase {
    154     PSISection();
    155 
    156     status_t append(const void *data, size_t size);
    157     void clear();
    158 
    159     bool isComplete() const;
    160     bool isEmpty() const;
    161 
    162     const uint8_t *data() const;
    163     size_t size() const;
    164 
    165 protected:
    166     virtual ~PSISection();
    167 
    168 private:
    169     sp<ABuffer> mBuffer;
    170 
    171     DISALLOW_EVIL_CONSTRUCTORS(PSISection);
    172 };
    173 
    174 ////////////////////////////////////////////////////////////////////////////////
    175 
    176 ATSParser::Program::Program(
    177         ATSParser *parser, unsigned programNumber, unsigned programMapPID)
    178     : mParser(parser),
    179       mProgramNumber(programNumber),
    180       mProgramMapPID(programMapPID),
    181       mFirstPTSValid(false),
    182       mFirstPTS(0) {
    183     ALOGV("new program number %u", programNumber);
    184 }
    185 
    186 bool ATSParser::Program::parsePSISection(
    187         unsigned pid, ABitReader *br, status_t *err) {
    188     *err = OK;
    189 
    190     if (pid != mProgramMapPID) {
    191         return false;
    192     }
    193 
    194     *err = parseProgramMap(br);
    195 
    196     return true;
    197 }
    198 
    199 bool ATSParser::Program::parsePID(
    200         unsigned pid, unsigned continuity_counter,
    201         unsigned payload_unit_start_indicator,
    202         ABitReader *br, status_t *err) {
    203     *err = OK;
    204 
    205     ssize_t index = mStreams.indexOfKey(pid);
    206     if (index < 0) {
    207         return false;
    208     }
    209 
    210     *err = mStreams.editValueAt(index)->parse(
    211             continuity_counter, payload_unit_start_indicator, br);
    212 
    213     return true;
    214 }
    215 
    216 void ATSParser::Program::signalDiscontinuity(
    217         DiscontinuityType type, const sp<AMessage> &extra) {
    218     int64_t mediaTimeUs;
    219     if ((type & DISCONTINUITY_TIME)
    220             && extra != NULL
    221             && extra->findInt64(
    222                 IStreamListener::kKeyMediaTimeUs, &mediaTimeUs)) {
    223         mFirstPTSValid = false;
    224     }
    225 
    226     for (size_t i = 0; i < mStreams.size(); ++i) {
    227         mStreams.editValueAt(i)->signalDiscontinuity(type, extra);
    228     }
    229 }
    230 
    231 void ATSParser::Program::signalEOS(status_t finalResult) {
    232     for (size_t i = 0; i < mStreams.size(); ++i) {
    233         mStreams.editValueAt(i)->signalEOS(finalResult);
    234     }
    235 }
    236 
    237 struct StreamInfo {
    238     unsigned mType;
    239     unsigned mPID;
    240 };
    241 
    242 status_t ATSParser::Program::parseProgramMap(ABitReader *br) {
    243     unsigned table_id = br->getBits(8);
    244     ALOGV("  table_id = %u", table_id);
    245     CHECK_EQ(table_id, 0x02u);
    246 
    247     unsigned section_syntax_indicator = br->getBits(1);
    248     ALOGV("  section_syntax_indicator = %u", section_syntax_indicator);
    249     CHECK_EQ(section_syntax_indicator, 1u);
    250 
    251     CHECK_EQ(br->getBits(1), 0u);
    252     MY_LOGV("  reserved = %u", br->getBits(2));
    253 
    254     unsigned section_length = br->getBits(12);
    255     ALOGV("  section_length = %u", section_length);
    256     CHECK_EQ(section_length & 0xc00, 0u);
    257     CHECK_LE(section_length, 1021u);
    258 
    259     MY_LOGV("  program_number = %u", br->getBits(16));
    260     MY_LOGV("  reserved = %u", br->getBits(2));
    261     MY_LOGV("  version_number = %u", br->getBits(5));
    262     MY_LOGV("  current_next_indicator = %u", br->getBits(1));
    263     MY_LOGV("  section_number = %u", br->getBits(8));
    264     MY_LOGV("  last_section_number = %u", br->getBits(8));
    265     MY_LOGV("  reserved = %u", br->getBits(3));
    266 
    267     unsigned PCR_PID = br->getBits(13);
    268     ALOGV("  PCR_PID = 0x%04x", PCR_PID);
    269 
    270     MY_LOGV("  reserved = %u", br->getBits(4));
    271 
    272     unsigned program_info_length = br->getBits(12);
    273     ALOGV("  program_info_length = %u", program_info_length);
    274     CHECK_EQ(program_info_length & 0xc00, 0u);
    275 
    276     br->skipBits(program_info_length * 8);  // skip descriptors
    277 
    278     Vector<StreamInfo> infos;
    279 
    280     // infoBytesRemaining is the number of bytes that make up the
    281     // variable length section of ES_infos. It does not include the
    282     // final CRC.
    283     size_t infoBytesRemaining = section_length - 9 - program_info_length - 4;
    284 
    285     while (infoBytesRemaining > 0) {
    286         CHECK_GE(infoBytesRemaining, 5u);
    287 
    288         unsigned streamType = br->getBits(8);
    289         ALOGV("    stream_type = 0x%02x", streamType);
    290 
    291         MY_LOGV("    reserved = %u", br->getBits(3));
    292 
    293         unsigned elementaryPID = br->getBits(13);
    294         ALOGV("    elementary_PID = 0x%04x", elementaryPID);
    295 
    296         MY_LOGV("    reserved = %u", br->getBits(4));
    297 
    298         unsigned ES_info_length = br->getBits(12);
    299         ALOGV("    ES_info_length = %u", ES_info_length);
    300         CHECK_EQ(ES_info_length & 0xc00, 0u);
    301 
    302         CHECK_GE(infoBytesRemaining - 5, ES_info_length);
    303 
    304 #if 0
    305         br->skipBits(ES_info_length * 8);  // skip descriptors
    306 #else
    307         unsigned info_bytes_remaining = ES_info_length;
    308         while (info_bytes_remaining >= 2) {
    309             MY_LOGV("      tag = 0x%02x", br->getBits(8));
    310 
    311             unsigned descLength = br->getBits(8);
    312             ALOGV("      len = %u", descLength);
    313 
    314             CHECK_GE(info_bytes_remaining, 2 + descLength);
    315 
    316             br->skipBits(descLength * 8);
    317 
    318             info_bytes_remaining -= descLength + 2;
    319         }
    320         CHECK_EQ(info_bytes_remaining, 0u);
    321 #endif
    322 
    323         StreamInfo info;
    324         info.mType = streamType;
    325         info.mPID = elementaryPID;
    326         infos.push(info);
    327 
    328         infoBytesRemaining -= 5 + ES_info_length;
    329     }
    330 
    331     CHECK_EQ(infoBytesRemaining, 0u);
    332     MY_LOGV("  CRC = 0x%08x", br->getBits(32));
    333 
    334     bool PIDsChanged = false;
    335     for (size_t i = 0; i < infos.size(); ++i) {
    336         StreamInfo &info = infos.editItemAt(i);
    337 
    338         ssize_t index = mStreams.indexOfKey(info.mPID);
    339 
    340         if (index >= 0 && mStreams.editValueAt(index)->type() != info.mType) {
    341             ALOGI("uh oh. stream PIDs have changed.");
    342             PIDsChanged = true;
    343             break;
    344         }
    345     }
    346 
    347     if (PIDsChanged) {
    348 #if 0
    349         ALOGI("before:");
    350         for (size_t i = 0; i < mStreams.size(); ++i) {
    351             sp<Stream> stream = mStreams.editValueAt(i);
    352 
    353             ALOGI("PID 0x%08x => type 0x%02x", stream->pid(), stream->type());
    354         }
    355 
    356         ALOGI("after:");
    357         for (size_t i = 0; i < infos.size(); ++i) {
    358             StreamInfo &info = infos.editItemAt(i);
    359 
    360             ALOGI("PID 0x%08x => type 0x%02x", info.mPID, info.mType);
    361         }
    362 #endif
    363 
    364         // The only case we can recover from is if we have two streams
    365         // and they switched PIDs.
    366 
    367         bool success = false;
    368 
    369         if (mStreams.size() == 2 && infos.size() == 2) {
    370             const StreamInfo &info1 = infos.itemAt(0);
    371             const StreamInfo &info2 = infos.itemAt(1);
    372 
    373             sp<Stream> s1 = mStreams.editValueAt(0);
    374             sp<Stream> s2 = mStreams.editValueAt(1);
    375 
    376             bool caseA =
    377                 info1.mPID == s1->pid() && info1.mType == s2->type()
    378                     && info2.mPID == s2->pid() && info2.mType == s1->type();
    379 
    380             bool caseB =
    381                 info1.mPID == s2->pid() && info1.mType == s1->type()
    382                     && info2.mPID == s1->pid() && info2.mType == s2->type();
    383 
    384             if (caseA || caseB) {
    385                 unsigned pid1 = s1->pid();
    386                 unsigned pid2 = s2->pid();
    387                 s1->setPID(pid2);
    388                 s2->setPID(pid1);
    389 
    390                 mStreams.clear();
    391                 mStreams.add(s1->pid(), s1);
    392                 mStreams.add(s2->pid(), s2);
    393 
    394                 success = true;
    395             }
    396         }
    397 
    398         if (!success) {
    399             ALOGI("Stream PIDs changed and we cannot recover.");
    400             return ERROR_MALFORMED;
    401         }
    402     }
    403 
    404     for (size_t i = 0; i < infos.size(); ++i) {
    405         StreamInfo &info = infos.editItemAt(i);
    406 
    407         ssize_t index = mStreams.indexOfKey(info.mPID);
    408 
    409         if (index < 0) {
    410             sp<Stream> stream = new Stream(
    411                     this, info.mPID, info.mType, PCR_PID);
    412 
    413             mStreams.add(info.mPID, stream);
    414         }
    415     }
    416 
    417     return OK;
    418 }
    419 
    420 sp<MediaSource> ATSParser::Program::getSource(SourceType type) {
    421     size_t index = (type == AUDIO) ? 0 : 0;
    422 
    423     for (size_t i = 0; i < mStreams.size(); ++i) {
    424         sp<MediaSource> source = mStreams.editValueAt(i)->getSource(type);
    425         if (source != NULL) {
    426             if (index == 0) {
    427                 return source;
    428             }
    429             --index;
    430         }
    431     }
    432 
    433     return NULL;
    434 }
    435 
    436 int64_t ATSParser::Program::convertPTSToTimestamp(uint64_t PTS) {
    437     if (!(mParser->mFlags & TS_TIMESTAMPS_ARE_ABSOLUTE)) {
    438         if (!mFirstPTSValid) {
    439             mFirstPTSValid = true;
    440             mFirstPTS = PTS;
    441             PTS = 0;
    442         } else if (PTS < mFirstPTS) {
    443             PTS = 0;
    444         } else {
    445             PTS -= mFirstPTS;
    446         }
    447     }
    448 
    449     int64_t timeUs = (PTS * 100) / 9;
    450 
    451     if (mParser->mAbsoluteTimeAnchorUs >= 0ll) {
    452         timeUs += mParser->mAbsoluteTimeAnchorUs;
    453     }
    454 
    455     if (mParser->mTimeOffsetValid) {
    456         timeUs += mParser->mTimeOffsetUs;
    457     }
    458 
    459     return timeUs;
    460 }
    461 
    462 ////////////////////////////////////////////////////////////////////////////////
    463 
    464 ATSParser::Stream::Stream(
    465         Program *program,
    466         unsigned elementaryPID,
    467         unsigned streamType,
    468         unsigned PCR_PID)
    469     : mProgram(program),
    470       mElementaryPID(elementaryPID),
    471       mStreamType(streamType),
    472       mPCR_PID(PCR_PID),
    473       mExpectedContinuityCounter(-1),
    474       mPayloadStarted(false),
    475       mPrevPTS(0),
    476       mQueue(NULL) {
    477     switch (mStreamType) {
    478         case STREAMTYPE_H264:
    479             mQueue = new ElementaryStreamQueue(
    480                     ElementaryStreamQueue::H264,
    481                     (mProgram->parserFlags() & ALIGNED_VIDEO_DATA)
    482                         ? ElementaryStreamQueue::kFlag_AlignedData : 0);
    483             break;
    484         case STREAMTYPE_MPEG2_AUDIO_ADTS:
    485             mQueue = new ElementaryStreamQueue(ElementaryStreamQueue::AAC);
    486             break;
    487         case STREAMTYPE_MPEG1_AUDIO:
    488         case STREAMTYPE_MPEG2_AUDIO:
    489             mQueue = new ElementaryStreamQueue(
    490                     ElementaryStreamQueue::MPEG_AUDIO);
    491             break;
    492 
    493         case STREAMTYPE_MPEG1_VIDEO:
    494         case STREAMTYPE_MPEG2_VIDEO:
    495             mQueue = new ElementaryStreamQueue(
    496                     ElementaryStreamQueue::MPEG_VIDEO);
    497             break;
    498 
    499         case STREAMTYPE_MPEG4_VIDEO:
    500             mQueue = new ElementaryStreamQueue(
    501                     ElementaryStreamQueue::MPEG4_VIDEO);
    502             break;
    503 
    504         case STREAMTYPE_PCM_AUDIO:
    505             mQueue = new ElementaryStreamQueue(
    506                     ElementaryStreamQueue::PCM_AUDIO);
    507             break;
    508 
    509         default:
    510             break;
    511     }
    512 
    513     ALOGV("new stream PID 0x%02x, type 0x%02x", elementaryPID, streamType);
    514 
    515     if (mQueue != NULL) {
    516         mBuffer = new ABuffer(192 * 1024);
    517         mBuffer->setRange(0, 0);
    518     }
    519 }
    520 
    521 ATSParser::Stream::~Stream() {
    522     delete mQueue;
    523     mQueue = NULL;
    524 }
    525 
    526 status_t ATSParser::Stream::parse(
    527         unsigned continuity_counter,
    528         unsigned payload_unit_start_indicator, ABitReader *br) {
    529     if (mQueue == NULL) {
    530         return OK;
    531     }
    532 
    533     if (mExpectedContinuityCounter >= 0
    534             && (unsigned)mExpectedContinuityCounter != continuity_counter) {
    535         ALOGI("discontinuity on stream pid 0x%04x", mElementaryPID);
    536 
    537         mPayloadStarted = false;
    538         mBuffer->setRange(0, 0);
    539         mExpectedContinuityCounter = -1;
    540 
    541 #if 0
    542         // Uncomment this if you'd rather see no corruption whatsoever on
    543         // screen and suspend updates until we come across another IDR frame.
    544 
    545         if (mStreamType == STREAMTYPE_H264) {
    546             ALOGI("clearing video queue");
    547             mQueue->clear(true /* clearFormat */);
    548         }
    549 #endif
    550 
    551         return OK;
    552     }
    553 
    554     mExpectedContinuityCounter = (continuity_counter + 1) & 0x0f;
    555 
    556     if (payload_unit_start_indicator) {
    557         if (mPayloadStarted) {
    558             // Otherwise we run the danger of receiving the trailing bytes
    559             // of a PES packet that we never saw the start of and assuming
    560             // we have a a complete PES packet.
    561 
    562             status_t err = flush();
    563 
    564             if (err != OK) {
    565                 return err;
    566             }
    567         }
    568 
    569         mPayloadStarted = true;
    570     }
    571 
    572     if (!mPayloadStarted) {
    573         return OK;
    574     }
    575 
    576     size_t payloadSizeBits = br->numBitsLeft();
    577     CHECK_EQ(payloadSizeBits % 8, 0u);
    578 
    579     size_t neededSize = mBuffer->size() + payloadSizeBits / 8;
    580     if (mBuffer->capacity() < neededSize) {
    581         // Increment in multiples of 64K.
    582         neededSize = (neededSize + 65535) & ~65535;
    583 
    584         ALOGI("resizing buffer to %d bytes", neededSize);
    585 
    586         sp<ABuffer> newBuffer = new ABuffer(neededSize);
    587         memcpy(newBuffer->data(), mBuffer->data(), mBuffer->size());
    588         newBuffer->setRange(0, mBuffer->size());
    589         mBuffer = newBuffer;
    590     }
    591 
    592     memcpy(mBuffer->data() + mBuffer->size(), br->data(), payloadSizeBits / 8);
    593     mBuffer->setRange(0, mBuffer->size() + payloadSizeBits / 8);
    594 
    595     return OK;
    596 }
    597 
    598 bool ATSParser::Stream::isVideo() const {
    599     switch (mStreamType) {
    600         case STREAMTYPE_H264:
    601         case STREAMTYPE_MPEG1_VIDEO:
    602         case STREAMTYPE_MPEG2_VIDEO:
    603         case STREAMTYPE_MPEG4_VIDEO:
    604             return true;
    605 
    606         default:
    607             return false;
    608     }
    609 }
    610 
    611 bool ATSParser::Stream::isAudio() const {
    612     switch (mStreamType) {
    613         case STREAMTYPE_MPEG1_AUDIO:
    614         case STREAMTYPE_MPEG2_AUDIO:
    615         case STREAMTYPE_MPEG2_AUDIO_ADTS:
    616         case STREAMTYPE_PCM_AUDIO:
    617             return true;
    618 
    619         default:
    620             return false;
    621     }
    622 }
    623 
    624 void ATSParser::Stream::signalDiscontinuity(
    625         DiscontinuityType type, const sp<AMessage> &extra) {
    626     mExpectedContinuityCounter = -1;
    627 
    628     if (mQueue == NULL) {
    629         return;
    630     }
    631 
    632     mPayloadStarted = false;
    633     mBuffer->setRange(0, 0);
    634 
    635     bool clearFormat = false;
    636     if (isAudio()) {
    637         if (type & DISCONTINUITY_AUDIO_FORMAT) {
    638             clearFormat = true;
    639         }
    640     } else {
    641         if (type & DISCONTINUITY_VIDEO_FORMAT) {
    642             clearFormat = true;
    643         }
    644     }
    645 
    646     mQueue->clear(clearFormat);
    647 
    648     if (type & DISCONTINUITY_TIME) {
    649         uint64_t resumeAtPTS;
    650         if (extra != NULL
    651                 && extra->findInt64(
    652                     IStreamListener::kKeyResumeAtPTS,
    653                     (int64_t *)&resumeAtPTS)) {
    654             int64_t resumeAtMediaTimeUs =
    655                 mProgram->convertPTSToTimestamp(resumeAtPTS);
    656 
    657             extra->setInt64("resume-at-mediatimeUs", resumeAtMediaTimeUs);
    658         }
    659     }
    660 
    661     if (mSource != NULL) {
    662         mSource->queueDiscontinuity(type, extra);
    663     }
    664 }
    665 
    666 void ATSParser::Stream::signalEOS(status_t finalResult) {
    667     if (mSource != NULL) {
    668         mSource->signalEOS(finalResult);
    669     }
    670 }
    671 
    672 status_t ATSParser::Stream::parsePES(ABitReader *br) {
    673     unsigned packet_startcode_prefix = br->getBits(24);
    674 
    675     ALOGV("packet_startcode_prefix = 0x%08x", packet_startcode_prefix);
    676 
    677     if (packet_startcode_prefix != 1) {
    678         ALOGV("Supposedly payload_unit_start=1 unit does not start "
    679              "with startcode.");
    680 
    681         return ERROR_MALFORMED;
    682     }
    683 
    684     CHECK_EQ(packet_startcode_prefix, 0x000001u);
    685 
    686     unsigned stream_id = br->getBits(8);
    687     ALOGV("stream_id = 0x%02x", stream_id);
    688 
    689     unsigned PES_packet_length = br->getBits(16);
    690     ALOGV("PES_packet_length = %u", PES_packet_length);
    691 
    692     if (stream_id != 0xbc  // program_stream_map
    693             && stream_id != 0xbe  // padding_stream
    694             && stream_id != 0xbf  // private_stream_2
    695             && stream_id != 0xf0  // ECM
    696             && stream_id != 0xf1  // EMM
    697             && stream_id != 0xff  // program_stream_directory
    698             && stream_id != 0xf2  // DSMCC
    699             && stream_id != 0xf8) {  // H.222.1 type E
    700         CHECK_EQ(br->getBits(2), 2u);
    701 
    702         MY_LOGV("PES_scrambling_control = %u", br->getBits(2));
    703         MY_LOGV("PES_priority = %u", br->getBits(1));
    704         MY_LOGV("data_alignment_indicator = %u", br->getBits(1));
    705         MY_LOGV("copyright = %u", br->getBits(1));
    706         MY_LOGV("original_or_copy = %u", br->getBits(1));
    707 
    708         unsigned PTS_DTS_flags = br->getBits(2);
    709         ALOGV("PTS_DTS_flags = %u", PTS_DTS_flags);
    710 
    711         unsigned ESCR_flag = br->getBits(1);
    712         ALOGV("ESCR_flag = %u", ESCR_flag);
    713 
    714         unsigned ES_rate_flag = br->getBits(1);
    715         ALOGV("ES_rate_flag = %u", ES_rate_flag);
    716 
    717         unsigned DSM_trick_mode_flag = br->getBits(1);
    718         ALOGV("DSM_trick_mode_flag = %u", DSM_trick_mode_flag);
    719 
    720         unsigned additional_copy_info_flag = br->getBits(1);
    721         ALOGV("additional_copy_info_flag = %u", additional_copy_info_flag);
    722 
    723         MY_LOGV("PES_CRC_flag = %u", br->getBits(1));
    724         MY_LOGV("PES_extension_flag = %u", br->getBits(1));
    725 
    726         unsigned PES_header_data_length = br->getBits(8);
    727         ALOGV("PES_header_data_length = %u", PES_header_data_length);
    728 
    729         unsigned optional_bytes_remaining = PES_header_data_length;
    730 
    731         uint64_t PTS = 0, DTS = 0;
    732 
    733         if (PTS_DTS_flags == 2 || PTS_DTS_flags == 3) {
    734             CHECK_GE(optional_bytes_remaining, 5u);
    735 
    736             CHECK_EQ(br->getBits(4), PTS_DTS_flags);
    737 
    738             PTS = ((uint64_t)br->getBits(3)) << 30;
    739             CHECK_EQ(br->getBits(1), 1u);
    740             PTS |= ((uint64_t)br->getBits(15)) << 15;
    741             CHECK_EQ(br->getBits(1), 1u);
    742             PTS |= br->getBits(15);
    743             CHECK_EQ(br->getBits(1), 1u);
    744 
    745             ALOGV("PTS = 0x%016llx (%.2f)", PTS, PTS / 90000.0);
    746 
    747             optional_bytes_remaining -= 5;
    748 
    749             if (PTS_DTS_flags == 3) {
    750                 CHECK_GE(optional_bytes_remaining, 5u);
    751 
    752                 CHECK_EQ(br->getBits(4), 1u);
    753 
    754                 DTS = ((uint64_t)br->getBits(3)) << 30;
    755                 CHECK_EQ(br->getBits(1), 1u);
    756                 DTS |= ((uint64_t)br->getBits(15)) << 15;
    757                 CHECK_EQ(br->getBits(1), 1u);
    758                 DTS |= br->getBits(15);
    759                 CHECK_EQ(br->getBits(1), 1u);
    760 
    761                 ALOGV("DTS = %llu", DTS);
    762 
    763                 optional_bytes_remaining -= 5;
    764             }
    765         }
    766 
    767         if (ESCR_flag) {
    768             CHECK_GE(optional_bytes_remaining, 6u);
    769 
    770             br->getBits(2);
    771 
    772             uint64_t ESCR = ((uint64_t)br->getBits(3)) << 30;
    773             CHECK_EQ(br->getBits(1), 1u);
    774             ESCR |= ((uint64_t)br->getBits(15)) << 15;
    775             CHECK_EQ(br->getBits(1), 1u);
    776             ESCR |= br->getBits(15);
    777             CHECK_EQ(br->getBits(1), 1u);
    778 
    779             ALOGV("ESCR = %llu", ESCR);
    780             MY_LOGV("ESCR_extension = %u", br->getBits(9));
    781 
    782             CHECK_EQ(br->getBits(1), 1u);
    783 
    784             optional_bytes_remaining -= 6;
    785         }
    786 
    787         if (ES_rate_flag) {
    788             CHECK_GE(optional_bytes_remaining, 3u);
    789 
    790             CHECK_EQ(br->getBits(1), 1u);
    791             MY_LOGV("ES_rate = %u", br->getBits(22));
    792             CHECK_EQ(br->getBits(1), 1u);
    793 
    794             optional_bytes_remaining -= 3;
    795         }
    796 
    797         br->skipBits(optional_bytes_remaining * 8);
    798 
    799         // ES data follows.
    800 
    801         if (PES_packet_length != 0) {
    802             CHECK_GE(PES_packet_length, PES_header_data_length + 3);
    803 
    804             unsigned dataLength =
    805                 PES_packet_length - 3 - PES_header_data_length;
    806 
    807             if (br->numBitsLeft() < dataLength * 8) {
    808                 ALOGE("PES packet does not carry enough data to contain "
    809                      "payload. (numBitsLeft = %d, required = %d)",
    810                      br->numBitsLeft(), dataLength * 8);
    811 
    812                 return ERROR_MALFORMED;
    813             }
    814 
    815             CHECK_GE(br->numBitsLeft(), dataLength * 8);
    816 
    817             onPayloadData(
    818                     PTS_DTS_flags, PTS, DTS, br->data(), dataLength);
    819 
    820             br->skipBits(dataLength * 8);
    821         } else {
    822             onPayloadData(
    823                     PTS_DTS_flags, PTS, DTS,
    824                     br->data(), br->numBitsLeft() / 8);
    825 
    826             size_t payloadSizeBits = br->numBitsLeft();
    827             CHECK_EQ(payloadSizeBits % 8, 0u);
    828 
    829             ALOGV("There's %d bytes of payload.", payloadSizeBits / 8);
    830         }
    831     } else if (stream_id == 0xbe) {  // padding_stream
    832         CHECK_NE(PES_packet_length, 0u);
    833         br->skipBits(PES_packet_length * 8);
    834     } else {
    835         CHECK_NE(PES_packet_length, 0u);
    836         br->skipBits(PES_packet_length * 8);
    837     }
    838 
    839     return OK;
    840 }
    841 
    842 status_t ATSParser::Stream::flush() {
    843     if (mBuffer->size() == 0) {
    844         return OK;
    845     }
    846 
    847     ALOGV("flushing stream 0x%04x size = %d", mElementaryPID, mBuffer->size());
    848 
    849     ABitReader br(mBuffer->data(), mBuffer->size());
    850 
    851     status_t err = parsePES(&br);
    852 
    853     mBuffer->setRange(0, 0);
    854 
    855     return err;
    856 }
    857 
    858 void ATSParser::Stream::onPayloadData(
    859         unsigned PTS_DTS_flags, uint64_t PTS, uint64_t DTS,
    860         const uint8_t *data, size_t size) {
    861 #if 0
    862     ALOGI("payload streamType 0x%02x, PTS = 0x%016llx, dPTS = %lld",
    863           mStreamType,
    864           PTS,
    865           (int64_t)PTS - mPrevPTS);
    866     mPrevPTS = PTS;
    867 #endif
    868 
    869     ALOGV("onPayloadData mStreamType=0x%02x", mStreamType);
    870 
    871     int64_t timeUs = 0ll;  // no presentation timestamp available.
    872     if (PTS_DTS_flags == 2 || PTS_DTS_flags == 3) {
    873         timeUs = mProgram->convertPTSToTimestamp(PTS);
    874     }
    875 
    876     status_t err = mQueue->appendData(data, size, timeUs);
    877 
    878     if (err != OK) {
    879         return;
    880     }
    881 
    882     sp<ABuffer> accessUnit;
    883     while ((accessUnit = mQueue->dequeueAccessUnit()) != NULL) {
    884         if (mSource == NULL) {
    885             sp<MetaData> meta = mQueue->getFormat();
    886 
    887             if (meta != NULL) {
    888                 ALOGV("Stream PID 0x%08x of type 0x%02x now has data.",
    889                      mElementaryPID, mStreamType);
    890 
    891                 mSource = new AnotherPacketSource(meta);
    892                 mSource->queueAccessUnit(accessUnit);
    893             }
    894         } else if (mQueue->getFormat() != NULL) {
    895             // After a discontinuity we invalidate the queue's format
    896             // and won't enqueue any access units to the source until
    897             // the queue has reestablished the new format.
    898 
    899             if (mSource->getFormat() == NULL) {
    900                 mSource->setFormat(mQueue->getFormat());
    901             }
    902             mSource->queueAccessUnit(accessUnit);
    903         }
    904     }
    905 }
    906 
    907 sp<MediaSource> ATSParser::Stream::getSource(SourceType type) {
    908     switch (type) {
    909         case VIDEO:
    910         {
    911             if (isVideo()) {
    912                 return mSource;
    913             }
    914             break;
    915         }
    916 
    917         case AUDIO:
    918         {
    919             if (isAudio()) {
    920                 return mSource;
    921             }
    922             break;
    923         }
    924 
    925         default:
    926             break;
    927     }
    928 
    929     return NULL;
    930 }
    931 
    932 ////////////////////////////////////////////////////////////////////////////////
    933 
    934 ATSParser::ATSParser(uint32_t flags)
    935     : mFlags(flags),
    936       mAbsoluteTimeAnchorUs(-1ll),
    937       mTimeOffsetValid(false),
    938       mTimeOffsetUs(0ll),
    939       mNumTSPacketsParsed(0),
    940       mNumPCRs(0) {
    941     mPSISections.add(0 /* PID */, new PSISection);
    942 }
    943 
    944 ATSParser::~ATSParser() {
    945 }
    946 
    947 status_t ATSParser::feedTSPacket(const void *data, size_t size) {
    948     CHECK_EQ(size, kTSPacketSize);
    949 
    950     ABitReader br((const uint8_t *)data, kTSPacketSize);
    951     return parseTS(&br);
    952 }
    953 
    954 void ATSParser::signalDiscontinuity(
    955         DiscontinuityType type, const sp<AMessage> &extra) {
    956     int64_t mediaTimeUs;
    957     if ((type & DISCONTINUITY_TIME)
    958             && extra != NULL
    959             && extra->findInt64(
    960                 IStreamListener::kKeyMediaTimeUs, &mediaTimeUs)) {
    961         mAbsoluteTimeAnchorUs = mediaTimeUs;
    962     } else if (type == DISCONTINUITY_ABSOLUTE_TIME) {
    963         int64_t timeUs;
    964         CHECK(extra->findInt64("timeUs", &timeUs));
    965 
    966         CHECK(mPrograms.empty());
    967         mAbsoluteTimeAnchorUs = timeUs;
    968         return;
    969     } else if (type == DISCONTINUITY_TIME_OFFSET) {
    970         int64_t offset;
    971         CHECK(extra->findInt64("offset", &offset));
    972 
    973         mTimeOffsetValid = true;
    974         mTimeOffsetUs = offset;
    975         return;
    976     }
    977 
    978     for (size_t i = 0; i < mPrograms.size(); ++i) {
    979         mPrograms.editItemAt(i)->signalDiscontinuity(type, extra);
    980     }
    981 }
    982 
    983 void ATSParser::signalEOS(status_t finalResult) {
    984     CHECK_NE(finalResult, (status_t)OK);
    985 
    986     for (size_t i = 0; i < mPrograms.size(); ++i) {
    987         mPrograms.editItemAt(i)->signalEOS(finalResult);
    988     }
    989 }
    990 
    991 void ATSParser::parseProgramAssociationTable(ABitReader *br) {
    992     unsigned table_id = br->getBits(8);
    993     ALOGV("  table_id = %u", table_id);
    994     CHECK_EQ(table_id, 0x00u);
    995 
    996     unsigned section_syntax_indictor = br->getBits(1);
    997     ALOGV("  section_syntax_indictor = %u", section_syntax_indictor);
    998     CHECK_EQ(section_syntax_indictor, 1u);
    999 
   1000     CHECK_EQ(br->getBits(1), 0u);
   1001     MY_LOGV("  reserved = %u", br->getBits(2));
   1002 
   1003     unsigned section_length = br->getBits(12);
   1004     ALOGV("  section_length = %u", section_length);
   1005     CHECK_EQ(section_length & 0xc00, 0u);
   1006 
   1007     MY_LOGV("  transport_stream_id = %u", br->getBits(16));
   1008     MY_LOGV("  reserved = %u", br->getBits(2));
   1009     MY_LOGV("  version_number = %u", br->getBits(5));
   1010     MY_LOGV("  current_next_indicator = %u", br->getBits(1));
   1011     MY_LOGV("  section_number = %u", br->getBits(8));
   1012     MY_LOGV("  last_section_number = %u", br->getBits(8));
   1013 
   1014     size_t numProgramBytes = (section_length - 5 /* header */ - 4 /* crc */);
   1015     CHECK_EQ((numProgramBytes % 4), 0u);
   1016 
   1017     for (size_t i = 0; i < numProgramBytes / 4; ++i) {
   1018         unsigned program_number = br->getBits(16);
   1019         ALOGV("    program_number = %u", program_number);
   1020 
   1021         MY_LOGV("    reserved = %u", br->getBits(3));
   1022 
   1023         if (program_number == 0) {
   1024             MY_LOGV("    network_PID = 0x%04x", br->getBits(13));
   1025         } else {
   1026             unsigned programMapPID = br->getBits(13);
   1027 
   1028             ALOGV("    program_map_PID = 0x%04x", programMapPID);
   1029 
   1030             bool found = false;
   1031             for (size_t index = 0; index < mPrograms.size(); ++index) {
   1032                 const sp<Program> &program = mPrograms.itemAt(index);
   1033 
   1034                 if (program->number() == program_number) {
   1035                     program->updateProgramMapPID(programMapPID);
   1036                     found = true;
   1037                     break;
   1038                 }
   1039             }
   1040 
   1041             if (!found) {
   1042                 mPrograms.push(
   1043                         new Program(this, program_number, programMapPID));
   1044             }
   1045 
   1046             if (mPSISections.indexOfKey(programMapPID) < 0) {
   1047                 mPSISections.add(programMapPID, new PSISection);
   1048             }
   1049         }
   1050     }
   1051 
   1052     MY_LOGV("  CRC = 0x%08x", br->getBits(32));
   1053 }
   1054 
   1055 status_t ATSParser::parsePID(
   1056         ABitReader *br, unsigned PID,
   1057         unsigned continuity_counter,
   1058         unsigned payload_unit_start_indicator) {
   1059     ssize_t sectionIndex = mPSISections.indexOfKey(PID);
   1060 
   1061     if (sectionIndex >= 0) {
   1062         sp<PSISection> section = mPSISections.valueAt(sectionIndex);
   1063 
   1064         if (payload_unit_start_indicator) {
   1065             CHECK(section->isEmpty());
   1066 
   1067             unsigned skip = br->getBits(8);
   1068             br->skipBits(skip * 8);
   1069         }
   1070 
   1071         CHECK((br->numBitsLeft() % 8) == 0);
   1072         status_t err = section->append(br->data(), br->numBitsLeft() / 8);
   1073 
   1074         if (err != OK) {
   1075             return err;
   1076         }
   1077 
   1078         if (!section->isComplete()) {
   1079             return OK;
   1080         }
   1081 
   1082         ABitReader sectionBits(section->data(), section->size());
   1083 
   1084         if (PID == 0) {
   1085             parseProgramAssociationTable(&sectionBits);
   1086         } else {
   1087             bool handled = false;
   1088             for (size_t i = 0; i < mPrograms.size(); ++i) {
   1089                 status_t err;
   1090                 if (!mPrograms.editItemAt(i)->parsePSISection(
   1091                             PID, &sectionBits, &err)) {
   1092                     continue;
   1093                 }
   1094 
   1095                 if (err != OK) {
   1096                     return err;
   1097                 }
   1098 
   1099                 handled = true;
   1100                 break;
   1101             }
   1102 
   1103             if (!handled) {
   1104                 mPSISections.removeItem(PID);
   1105                 section.clear();
   1106             }
   1107         }
   1108 
   1109         if (section != NULL) {
   1110             section->clear();
   1111         }
   1112 
   1113         return OK;
   1114     }
   1115 
   1116     bool handled = false;
   1117     for (size_t i = 0; i < mPrograms.size(); ++i) {
   1118         status_t err;
   1119         if (mPrograms.editItemAt(i)->parsePID(
   1120                     PID, continuity_counter, payload_unit_start_indicator,
   1121                     br, &err)) {
   1122             if (err != OK) {
   1123                 return err;
   1124             }
   1125 
   1126             handled = true;
   1127             break;
   1128         }
   1129     }
   1130 
   1131     if (!handled) {
   1132         ALOGV("PID 0x%04x not handled.", PID);
   1133     }
   1134 
   1135     return OK;
   1136 }
   1137 
   1138 void ATSParser::parseAdaptationField(ABitReader *br, unsigned PID) {
   1139     unsigned adaptation_field_length = br->getBits(8);
   1140 
   1141     if (adaptation_field_length > 0) {
   1142         unsigned discontinuity_indicator = br->getBits(1);
   1143 
   1144         if (discontinuity_indicator) {
   1145             ALOGV("PID 0x%04x: discontinuity_indicator = 1 (!!!)", PID);
   1146         }
   1147 
   1148         br->skipBits(2);
   1149         unsigned PCR_flag = br->getBits(1);
   1150 
   1151         size_t numBitsRead = 4;
   1152 
   1153         if (PCR_flag) {
   1154             br->skipBits(4);
   1155             uint64_t PCR_base = br->getBits(32);
   1156             PCR_base = (PCR_base << 1) | br->getBits(1);
   1157 
   1158             br->skipBits(6);
   1159             unsigned PCR_ext = br->getBits(9);
   1160 
   1161             // The number of bytes from the start of the current
   1162             // MPEG2 transport stream packet up and including
   1163             // the final byte of this PCR_ext field.
   1164             size_t byteOffsetFromStartOfTSPacket =
   1165                 (188 - br->numBitsLeft() / 8);
   1166 
   1167             uint64_t PCR = PCR_base * 300 + PCR_ext;
   1168 
   1169             ALOGV("PID 0x%04x: PCR = 0x%016llx (%.2f)",
   1170                   PID, PCR, PCR / 27E6);
   1171 
   1172             // The number of bytes received by this parser up to and
   1173             // including the final byte of this PCR_ext field.
   1174             size_t byteOffsetFromStart =
   1175                 mNumTSPacketsParsed * 188 + byteOffsetFromStartOfTSPacket;
   1176 
   1177             for (size_t i = 0; i < mPrograms.size(); ++i) {
   1178                 updatePCR(PID, PCR, byteOffsetFromStart);
   1179             }
   1180 
   1181             numBitsRead += 52;
   1182         }
   1183 
   1184         CHECK_GE(adaptation_field_length * 8, numBitsRead);
   1185 
   1186         br->skipBits(adaptation_field_length * 8 - numBitsRead);
   1187     }
   1188 }
   1189 
   1190 status_t ATSParser::parseTS(ABitReader *br) {
   1191     ALOGV("---");
   1192 
   1193     unsigned sync_byte = br->getBits(8);
   1194     CHECK_EQ(sync_byte, 0x47u);
   1195 
   1196     if (br->getBits(1)) {  // transport_error_indicator
   1197         // silently ignore.
   1198         return OK;
   1199     }
   1200 
   1201     unsigned payload_unit_start_indicator = br->getBits(1);
   1202     ALOGV("payload_unit_start_indicator = %u", payload_unit_start_indicator);
   1203 
   1204     MY_LOGV("transport_priority = %u", br->getBits(1));
   1205 
   1206     unsigned PID = br->getBits(13);
   1207     ALOGV("PID = 0x%04x", PID);
   1208 
   1209     MY_LOGV("transport_scrambling_control = %u", br->getBits(2));
   1210 
   1211     unsigned adaptation_field_control = br->getBits(2);
   1212     ALOGV("adaptation_field_control = %u", adaptation_field_control);
   1213 
   1214     unsigned continuity_counter = br->getBits(4);
   1215     ALOGV("PID = 0x%04x, continuity_counter = %u", PID, continuity_counter);
   1216 
   1217     // ALOGI("PID = 0x%04x, continuity_counter = %u", PID, continuity_counter);
   1218 
   1219     if (adaptation_field_control == 2 || adaptation_field_control == 3) {
   1220         parseAdaptationField(br, PID);
   1221     }
   1222 
   1223     status_t err = OK;
   1224 
   1225     if (adaptation_field_control == 1 || adaptation_field_control == 3) {
   1226         err = parsePID(
   1227                 br, PID, continuity_counter, payload_unit_start_indicator);
   1228     }
   1229 
   1230     ++mNumTSPacketsParsed;
   1231 
   1232     return err;
   1233 }
   1234 
   1235 sp<MediaSource> ATSParser::getSource(SourceType type) {
   1236     int which = -1;  // any
   1237 
   1238     for (size_t i = 0; i < mPrograms.size(); ++i) {
   1239         const sp<Program> &program = mPrograms.editItemAt(i);
   1240 
   1241         if (which >= 0 && (int)program->number() != which) {
   1242             continue;
   1243         }
   1244 
   1245         sp<MediaSource> source = program->getSource(type);
   1246 
   1247         if (source != NULL) {
   1248             return source;
   1249         }
   1250     }
   1251 
   1252     return NULL;
   1253 }
   1254 
   1255 bool ATSParser::PTSTimeDeltaEstablished() {
   1256     if (mPrograms.isEmpty()) {
   1257         return false;
   1258     }
   1259 
   1260     return mPrograms.editItemAt(0)->PTSTimeDeltaEstablished();
   1261 }
   1262 
   1263 void ATSParser::updatePCR(
   1264         unsigned PID, uint64_t PCR, size_t byteOffsetFromStart) {
   1265     ALOGV("PCR 0x%016llx @ %d", PCR, byteOffsetFromStart);
   1266 
   1267     if (mNumPCRs == 2) {
   1268         mPCR[0] = mPCR[1];
   1269         mPCRBytes[0] = mPCRBytes[1];
   1270         mSystemTimeUs[0] = mSystemTimeUs[1];
   1271         mNumPCRs = 1;
   1272     }
   1273 
   1274     mPCR[mNumPCRs] = PCR;
   1275     mPCRBytes[mNumPCRs] = byteOffsetFromStart;
   1276     mSystemTimeUs[mNumPCRs] = ALooper::GetNowUs();
   1277 
   1278     ++mNumPCRs;
   1279 
   1280     if (mNumPCRs == 2) {
   1281         double transportRate =
   1282             (mPCRBytes[1] - mPCRBytes[0]) * 27E6 / (mPCR[1] - mPCR[0]);
   1283 
   1284         ALOGV("transportRate = %.2f bytes/sec", transportRate);
   1285     }
   1286 }
   1287 
   1288 ////////////////////////////////////////////////////////////////////////////////
   1289 
   1290 ATSParser::PSISection::PSISection() {
   1291 }
   1292 
   1293 ATSParser::PSISection::~PSISection() {
   1294 }
   1295 
   1296 status_t ATSParser::PSISection::append(const void *data, size_t size) {
   1297     if (mBuffer == NULL || mBuffer->size() + size > mBuffer->capacity()) {
   1298         size_t newCapacity =
   1299             (mBuffer == NULL) ? size : mBuffer->capacity() + size;
   1300 
   1301         newCapacity = (newCapacity + 1023) & ~1023;
   1302 
   1303         sp<ABuffer> newBuffer = new ABuffer(newCapacity);
   1304 
   1305         if (mBuffer != NULL) {
   1306             memcpy(newBuffer->data(), mBuffer->data(), mBuffer->size());
   1307             newBuffer->setRange(0, mBuffer->size());
   1308         } else {
   1309             newBuffer->setRange(0, 0);
   1310         }
   1311 
   1312         mBuffer = newBuffer;
   1313     }
   1314 
   1315     memcpy(mBuffer->data() + mBuffer->size(), data, size);
   1316     mBuffer->setRange(0, mBuffer->size() + size);
   1317 
   1318     return OK;
   1319 }
   1320 
   1321 void ATSParser::PSISection::clear() {
   1322     if (mBuffer != NULL) {
   1323         mBuffer->setRange(0, 0);
   1324     }
   1325 }
   1326 
   1327 bool ATSParser::PSISection::isComplete() const {
   1328     if (mBuffer == NULL || mBuffer->size() < 3) {
   1329         return false;
   1330     }
   1331 
   1332     unsigned sectionLength = U16_AT(mBuffer->data() + 1) & 0xfff;
   1333     return mBuffer->size() >= sectionLength + 3;
   1334 }
   1335 
   1336 bool ATSParser::PSISection::isEmpty() const {
   1337     return mBuffer == NULL || mBuffer->size() == 0;
   1338 }
   1339 
   1340 const uint8_t *ATSParser::PSISection::data() const {
   1341     return mBuffer == NULL ? NULL : mBuffer->data();
   1342 }
   1343 
   1344 size_t ATSParser::PSISection::size() const {
   1345     return mBuffer == NULL ? 0 : mBuffer->size();
   1346 }
   1347 
   1348 }  // namespace android
   1349