ATSParser.cpp revision 43c3e6ce02215ca99d506458f596cb1211639f29 
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 <utils/KeyedVector.h>
36
37namespace android {
38
39// I want the expression "y" evaluated even if verbose logging is off.
40#define MY_LOGV(x, y) \
41    do { unsigned tmp = y; LOGV(x, tmp); } while (0)
42
43static const size_t kTSPacketSize = 188;
44
45struct ATSParser::Program : public RefBase {
46    Program(ATSParser *parser, unsigned programMapPID);
47
48    bool parsePID(
49            unsigned pid, unsigned payload_unit_start_indicator,
50            ABitReader *br);
51
52    void signalDiscontinuity(DiscontinuityType type);
53    void signalEOS(status_t finalResult);
54
55    sp<MediaSource> getSource(SourceType type);
56
57    int64_t convertPTSToTimestamp(uint64_t PTS);
58
59    bool PTSTimeDeltaEstablished() const {
60        return mFirstPTSValid;
61    }
62
63private:
64    ATSParser *mParser;
65    unsigned mProgramMapPID;
66    KeyedVector<unsigned, sp<Stream> > mStreams;
67    bool mFirstPTSValid;
68    uint64_t mFirstPTS;
69
70    void parseProgramMap(ABitReader *br);
71
72    DISALLOW_EVIL_CONSTRUCTORS(Program);
73};
74
75struct ATSParser::Stream : public RefBase {
76    Stream(Program *program, unsigned elementaryPID, unsigned streamType);
77
78    void parse(
79            unsigned payload_unit_start_indicator,
80            ABitReader *br);
81
82    void signalDiscontinuity(DiscontinuityType type);
83    void signalEOS(status_t finalResult);
84
85    sp<MediaSource> getSource(SourceType type);
86
87protected:
88    virtual ~Stream();
89
90private:
91    Program *mProgram;
92    unsigned mElementaryPID;
93    unsigned mStreamType;
94
95    sp<ABuffer> mBuffer;
96    sp<AnotherPacketSource> mSource;
97    bool mPayloadStarted;
98
99    ElementaryStreamQueue mQueue;
100
101    void flush();
102    void parsePES(ABitReader *br);
103
104    void onPayloadData(
105            unsigned PTS_DTS_flags, uint64_t PTS, uint64_t DTS,
106            const uint8_t *data, size_t size);
107
108    void extractAACFrames(const sp<ABuffer> &buffer);
109
110    DISALLOW_EVIL_CONSTRUCTORS(Stream);
111};
112
113////////////////////////////////////////////////////////////////////////////////
114
115ATSParser::Program::Program(ATSParser *parser, unsigned programMapPID)
116    : mParser(parser),
117      mProgramMapPID(programMapPID),
118      mFirstPTSValid(false),
119      mFirstPTS(0) {
120}
121
122bool ATSParser::Program::parsePID(
123        unsigned pid, unsigned payload_unit_start_indicator,
124        ABitReader *br) {
125    if (pid == mProgramMapPID) {
126        if (payload_unit_start_indicator) {
127            unsigned skip = br->getBits(8);
128            br->skipBits(skip * 8);
129        }
130
131        parseProgramMap(br);
132        return true;
133    }
134
135    ssize_t index = mStreams.indexOfKey(pid);
136    if (index < 0) {
137        return false;
138    }
139
140    mStreams.editValueAt(index)->parse(
141            payload_unit_start_indicator, br);
142
143    return true;
144}
145
146void ATSParser::Program::signalDiscontinuity(DiscontinuityType type) {
147    for (size_t i = 0; i < mStreams.size(); ++i) {
148        mStreams.editValueAt(i)->signalDiscontinuity(type);
149    }
150}
151
152void ATSParser::Program::signalEOS(status_t finalResult) {
153    for (size_t i = 0; i < mStreams.size(); ++i) {
154        mStreams.editValueAt(i)->signalEOS(finalResult);
155    }
156}
157
158void ATSParser::Program::parseProgramMap(ABitReader *br) {
159    unsigned table_id = br->getBits(8);
160    LOGV("  table_id = %u", table_id);
161    CHECK_EQ(table_id, 0x02u);
162
163    unsigned section_syntax_indicator = br->getBits(1);
164    LOGV("  section_syntax_indicator = %u", section_syntax_indicator);
165    CHECK_EQ(section_syntax_indicator, 1u);
166
167    CHECK_EQ(br->getBits(1), 0u);
168    MY_LOGV("  reserved = %u", br->getBits(2));
169
170    unsigned section_length = br->getBits(12);
171    LOGV("  section_length = %u", section_length);
172    CHECK_EQ(section_length & 0xc00, 0u);
173    CHECK_LE(section_length, 1021u);
174
175    MY_LOGV("  program_number = %u", br->getBits(16));
176    MY_LOGV("  reserved = %u", br->getBits(2));
177    MY_LOGV("  version_number = %u", br->getBits(5));
178    MY_LOGV("  current_next_indicator = %u", br->getBits(1));
179    MY_LOGV("  section_number = %u", br->getBits(8));
180    MY_LOGV("  last_section_number = %u", br->getBits(8));
181    MY_LOGV("  reserved = %u", br->getBits(3));
182    MY_LOGV("  PCR_PID = 0x%04x", br->getBits(13));
183    MY_LOGV("  reserved = %u", br->getBits(4));
184
185    unsigned program_info_length = br->getBits(12);
186    LOGV("  program_info_length = %u", program_info_length);
187    CHECK_EQ(program_info_length & 0xc00, 0u);
188
189    br->skipBits(program_info_length * 8);  // skip descriptors
190
191    // infoBytesRemaining is the number of bytes that make up the
192    // variable length section of ES_infos. It does not include the
193    // final CRC.
194    size_t infoBytesRemaining = section_length - 9 - program_info_length - 4;
195
196    while (infoBytesRemaining > 0) {
197        CHECK_GE(infoBytesRemaining, 5u);
198
199        unsigned streamType = br->getBits(8);
200        LOGV("    stream_type = 0x%02x", streamType);
201
202        MY_LOGV("    reserved = %u", br->getBits(3));
203
204        unsigned elementaryPID = br->getBits(13);
205        LOGV("    elementary_PID = 0x%04x", elementaryPID);
206
207        MY_LOGV("    reserved = %u", br->getBits(4));
208
209        unsigned ES_info_length = br->getBits(12);
210        LOGV("    ES_info_length = %u", ES_info_length);
211        CHECK_EQ(ES_info_length & 0xc00, 0u);
212
213        CHECK_GE(infoBytesRemaining - 5, ES_info_length);
214
215#if 0
216        br->skipBits(ES_info_length * 8);  // skip descriptors
217#else
218        unsigned info_bytes_remaining = ES_info_length;
219        while (info_bytes_remaining >= 2) {
220            MY_LOGV("      tag = 0x%02x", br->getBits(8));
221
222            unsigned descLength = br->getBits(8);
223            LOGV("      len = %u", descLength);
224
225            CHECK_GE(info_bytes_remaining, 2 + descLength);
226
227            br->skipBits(descLength * 8);
228
229            info_bytes_remaining -= descLength + 2;
230        }
231        CHECK_EQ(info_bytes_remaining, 0u);
232#endif
233
234        ssize_t index = mStreams.indexOfKey(elementaryPID);
235#if 0  // XXX revisit
236        CHECK_LT(index, 0);
237        mStreams.add(elementaryPID,
238                     new Stream(this, elementaryPID, streamType));
239#else
240        if (index < 0) {
241            mStreams.add(elementaryPID,
242                         new Stream(this, elementaryPID, streamType));
243        }
244#endif
245
246        infoBytesRemaining -= 5 + ES_info_length;
247    }
248
249    CHECK_EQ(infoBytesRemaining, 0u);
250
251    MY_LOGV("  CRC = 0x%08x", br->getBits(32));
252}
253
254sp<MediaSource> ATSParser::Program::getSource(SourceType type) {
255    size_t index = (type == MPEG2ADTS_AUDIO) ? 0 : 0;
256
257    for (size_t i = 0; i < mStreams.size(); ++i) {
258        sp<MediaSource> source = mStreams.editValueAt(i)->getSource(type);
259        if (source != NULL) {
260            if (index == 0) {
261                return source;
262            }
263            --index;
264        }
265    }
266
267    return NULL;
268}
269
270int64_t ATSParser::Program::convertPTSToTimestamp(uint64_t PTS) {
271    if (!mFirstPTSValid) {
272        mFirstPTSValid = true;
273        mFirstPTS = PTS;
274        PTS = 0;
275    } else if (PTS < mFirstPTS) {
276        PTS = 0;
277    } else {
278        PTS -= mFirstPTS;
279    }
280
281    return (PTS * 100) / 9;
282}
283
284////////////////////////////////////////////////////////////////////////////////
285
286ATSParser::Stream::Stream(
287        Program *program, unsigned elementaryPID, unsigned streamType)
288    : mProgram(program),
289      mElementaryPID(elementaryPID),
290      mStreamType(streamType),
291      mBuffer(new ABuffer(192 * 1024)),
292      mPayloadStarted(false),
293      mQueue(streamType == 0x1b
294              ? ElementaryStreamQueue::H264 : ElementaryStreamQueue::AAC) {
295    mBuffer->setRange(0, 0);
296
297    LOGV("new stream PID 0x%02x, type 0x%02x", elementaryPID, streamType);
298}
299
300ATSParser::Stream::~Stream() {
301}
302
303void ATSParser::Stream::parse(
304        unsigned payload_unit_start_indicator, ABitReader *br) {
305    if (payload_unit_start_indicator) {
306        if (mPayloadStarted) {
307            // Otherwise we run the danger of receiving the trailing bytes
308            // of a PES packet that we never saw the start of and assuming
309            // we have a a complete PES packet.
310
311            flush();
312        }
313
314        mPayloadStarted = true;
315    }
316
317    if (!mPayloadStarted) {
318        return;
319    }
320
321    size_t payloadSizeBits = br->numBitsLeft();
322    CHECK_EQ(payloadSizeBits % 8, 0u);
323
324    CHECK_LE(mBuffer->size() + payloadSizeBits / 8, mBuffer->capacity());
325
326    memcpy(mBuffer->data() + mBuffer->size(), br->data(), payloadSizeBits / 8);
327    mBuffer->setRange(0, mBuffer->size() + payloadSizeBits / 8);
328}
329
330void ATSParser::Stream::signalDiscontinuity(DiscontinuityType type) {
331    mPayloadStarted = false;
332    mBuffer->setRange(0, 0);
333
334    switch (type) {
335        case DISCONTINUITY_HTTPLIVE:
336        {
337            mQueue.clear(true);
338
339            if (mStreamType == 0x1b && mSource != NULL) {
340                // Don't signal discontinuities on audio streams.
341                mSource->queueDiscontinuity(type);
342            }
343            break;
344        }
345
346        case DISCONTINUITY_SEEK:
347        case DISCONTINUITY_FORMATCHANGE:
348        {
349            bool isASeek = (type == DISCONTINUITY_SEEK);
350
351            mQueue.clear(!isASeek);
352
353            if (mSource != NULL) {
354                mSource->clear();
355                mSource->queueDiscontinuity(type);
356            }
357            break;
358        }
359
360        default:
361            TRESPASS();
362            break;
363    }
364}
365
366void ATSParser::Stream::signalEOS(status_t finalResult) {
367    if (mSource != NULL) {
368        mSource->signalEOS(finalResult);
369    }
370}
371
372void ATSParser::Stream::parsePES(ABitReader *br) {
373    unsigned packet_startcode_prefix = br->getBits(24);
374
375    LOGV("packet_startcode_prefix = 0x%08x", packet_startcode_prefix);
376
377    CHECK_EQ(packet_startcode_prefix, 0x000001u);
378
379    unsigned stream_id = br->getBits(8);
380    LOGV("stream_id = 0x%02x", stream_id);
381
382    unsigned PES_packet_length = br->getBits(16);
383    LOGV("PES_packet_length = %u", PES_packet_length);
384
385    if (stream_id != 0xbc  // program_stream_map
386            && stream_id != 0xbe  // padding_stream
387            && stream_id != 0xbf  // private_stream_2
388            && stream_id != 0xf0  // ECM
389            && stream_id != 0xf1  // EMM
390            && stream_id != 0xff  // program_stream_directory
391            && stream_id != 0xf2  // DSMCC
392            && stream_id != 0xf8) {  // H.222.1 type E
393        CHECK_EQ(br->getBits(2), 2u);
394
395        MY_LOGV("PES_scrambling_control = %u", br->getBits(2));
396        MY_LOGV("PES_priority = %u", br->getBits(1));
397        MY_LOGV("data_alignment_indicator = %u", br->getBits(1));
398        MY_LOGV("copyright = %u", br->getBits(1));
399        MY_LOGV("original_or_copy = %u", br->getBits(1));
400
401        unsigned PTS_DTS_flags = br->getBits(2);
402        LOGV("PTS_DTS_flags = %u", PTS_DTS_flags);
403
404        unsigned ESCR_flag = br->getBits(1);
405        LOGV("ESCR_flag = %u", ESCR_flag);
406
407        unsigned ES_rate_flag = br->getBits(1);
408        LOGV("ES_rate_flag = %u", ES_rate_flag);
409
410        unsigned DSM_trick_mode_flag = br->getBits(1);
411        LOGV("DSM_trick_mode_flag = %u", DSM_trick_mode_flag);
412
413        unsigned additional_copy_info_flag = br->getBits(1);
414        LOGV("additional_copy_info_flag = %u", additional_copy_info_flag);
415
416        MY_LOGV("PES_CRC_flag = %u", br->getBits(1));
417        MY_LOGV("PES_extension_flag = %u", br->getBits(1));
418
419        unsigned PES_header_data_length = br->getBits(8);
420        LOGV("PES_header_data_length = %u", PES_header_data_length);
421
422        unsigned optional_bytes_remaining = PES_header_data_length;
423
424        uint64_t PTS = 0, DTS = 0;
425
426        if (PTS_DTS_flags == 2 || PTS_DTS_flags == 3) {
427            CHECK_GE(optional_bytes_remaining, 5u);
428
429            CHECK_EQ(br->getBits(4), PTS_DTS_flags);
430
431            PTS = ((uint64_t)br->getBits(3)) << 30;
432            CHECK_EQ(br->getBits(1), 1u);
433            PTS |= ((uint64_t)br->getBits(15)) << 15;
434            CHECK_EQ(br->getBits(1), 1u);
435            PTS |= br->getBits(15);
436            CHECK_EQ(br->getBits(1), 1u);
437
438            LOGV("PTS = %llu", PTS);
439            // LOGI("PTS = %.2f secs", PTS / 90000.0f);
440
441            optional_bytes_remaining -= 5;
442
443            if (PTS_DTS_flags == 3) {
444                CHECK_GE(optional_bytes_remaining, 5u);
445
446                CHECK_EQ(br->getBits(4), 1u);
447
448                DTS = ((uint64_t)br->getBits(3)) << 30;
449                CHECK_EQ(br->getBits(1), 1u);
450                DTS |= ((uint64_t)br->getBits(15)) << 15;
451                CHECK_EQ(br->getBits(1), 1u);
452                DTS |= br->getBits(15);
453                CHECK_EQ(br->getBits(1), 1u);
454
455                LOGV("DTS = %llu", DTS);
456
457                optional_bytes_remaining -= 5;
458            }
459        }
460
461        if (ESCR_flag) {
462            CHECK_GE(optional_bytes_remaining, 6u);
463
464            br->getBits(2);
465
466            uint64_t ESCR = ((uint64_t)br->getBits(3)) << 30;
467            CHECK_EQ(br->getBits(1), 1u);
468            ESCR |= ((uint64_t)br->getBits(15)) << 15;
469            CHECK_EQ(br->getBits(1), 1u);
470            ESCR |= br->getBits(15);
471            CHECK_EQ(br->getBits(1), 1u);
472
473            LOGV("ESCR = %llu", ESCR);
474            MY_LOGV("ESCR_extension = %u", br->getBits(9));
475
476            CHECK_EQ(br->getBits(1), 1u);
477
478            optional_bytes_remaining -= 6;
479        }
480
481        if (ES_rate_flag) {
482            CHECK_GE(optional_bytes_remaining, 3u);
483
484            CHECK_EQ(br->getBits(1), 1u);
485            MY_LOGV("ES_rate = %u", br->getBits(22));
486            CHECK_EQ(br->getBits(1), 1u);
487
488            optional_bytes_remaining -= 3;
489        }
490
491        br->skipBits(optional_bytes_remaining * 8);
492
493        // ES data follows.
494
495        if (PES_packet_length != 0) {
496            CHECK_GE(PES_packet_length, PES_header_data_length + 3);
497
498            unsigned dataLength =
499                PES_packet_length - 3 - PES_header_data_length;
500
501            CHECK_GE(br->numBitsLeft(), dataLength * 8);
502
503            onPayloadData(
504                    PTS_DTS_flags, PTS, DTS, br->data(), dataLength);
505
506            br->skipBits(dataLength * 8);
507        } else {
508            onPayloadData(
509                    PTS_DTS_flags, PTS, DTS,
510                    br->data(), br->numBitsLeft() / 8);
511
512            size_t payloadSizeBits = br->numBitsLeft();
513            CHECK_EQ(payloadSizeBits % 8, 0u);
514
515            LOGV("There's %d bytes of payload.", payloadSizeBits / 8);
516        }
517    } else if (stream_id == 0xbe) {  // padding_stream
518        CHECK_NE(PES_packet_length, 0u);
519        br->skipBits(PES_packet_length * 8);
520    } else {
521        CHECK_NE(PES_packet_length, 0u);
522        br->skipBits(PES_packet_length * 8);
523    }
524}
525
526void ATSParser::Stream::flush() {
527    if (mBuffer->size() == 0) {
528        return;
529    }
530
531    LOGV("flushing stream 0x%04x size = %d", mElementaryPID, mBuffer->size());
532
533    ABitReader br(mBuffer->data(), mBuffer->size());
534    parsePES(&br);
535
536    mBuffer->setRange(0, 0);
537}
538
539void ATSParser::Stream::onPayloadData(
540        unsigned PTS_DTS_flags, uint64_t PTS, uint64_t DTS,
541        const uint8_t *data, size_t size) {
542    LOGV("onPayloadData mStreamType=0x%02x", mStreamType);
543
544    CHECK(PTS_DTS_flags == 2 || PTS_DTS_flags == 3);
545    int64_t timeUs = mProgram->convertPTSToTimestamp(PTS);
546
547    status_t err = mQueue.appendData(data, size, timeUs);
548
549    if (err != OK) {
550        return;
551    }
552
553    sp<ABuffer> accessUnit;
554    while ((accessUnit = mQueue.dequeueAccessUnit()) != NULL) {
555        if (mSource == NULL) {
556            sp<MetaData> meta = mQueue.getFormat();
557
558            if (meta != NULL) {
559                LOGV("created source!");
560                mSource = new AnotherPacketSource(meta);
561
562                mSource->queueAccessUnit(accessUnit);
563            }
564        } else if (mQueue.getFormat() != NULL) {
565            // After a discontinuity we invalidate the queue's format
566            // and won't enqueue any access units to the source until
567            // the queue has reestablished the new format.
568
569            if (mSource->getFormat() == NULL) {
570                mSource->setFormat(mQueue.getFormat());
571            }
572            mSource->queueAccessUnit(accessUnit);
573        }
574    }
575}
576
577sp<MediaSource> ATSParser::Stream::getSource(SourceType type) {
578    if ((type == AVC_VIDEO && mStreamType == 0x1b)
579        || (type == MPEG2ADTS_AUDIO && mStreamType == 0x0f)) {
580        return mSource;
581    }
582
583    return NULL;
584}
585
586////////////////////////////////////////////////////////////////////////////////
587
588ATSParser::ATSParser() {
589}
590
591ATSParser::~ATSParser() {
592}
593
594void ATSParser::feedTSPacket(const void *data, size_t size) {
595    CHECK_EQ(size, kTSPacketSize);
596
597    ABitReader br((const uint8_t *)data, kTSPacketSize);
598    parseTS(&br);
599}
600
601void ATSParser::signalDiscontinuity(DiscontinuityType type) {
602    for (size_t i = 0; i < mPrograms.size(); ++i) {
603        mPrograms.editItemAt(i)->signalDiscontinuity(type);
604    }
605}
606
607void ATSParser::signalEOS(status_t finalResult) {
608    CHECK_NE(finalResult, (status_t)OK);
609
610    for (size_t i = 0; i < mPrograms.size(); ++i) {
611        mPrograms.editItemAt(i)->signalEOS(finalResult);
612    }
613}
614
615void ATSParser::parseProgramAssociationTable(ABitReader *br) {
616    unsigned table_id = br->getBits(8);
617    LOGV("  table_id = %u", table_id);
618    CHECK_EQ(table_id, 0x00u);
619
620    unsigned section_syntax_indictor = br->getBits(1);
621    LOGV("  section_syntax_indictor = %u", section_syntax_indictor);
622    CHECK_EQ(section_syntax_indictor, 1u);
623
624    CHECK_EQ(br->getBits(1), 0u);
625    MY_LOGV("  reserved = %u", br->getBits(2));
626
627    unsigned section_length = br->getBits(12);
628    LOGV("  section_length = %u", section_length);
629    CHECK_EQ(section_length & 0xc00, 0u);
630
631    MY_LOGV("  transport_stream_id = %u", br->getBits(16));
632    MY_LOGV("  reserved = %u", br->getBits(2));
633    MY_LOGV("  version_number = %u", br->getBits(5));
634    MY_LOGV("  current_next_indicator = %u", br->getBits(1));
635    MY_LOGV("  section_number = %u", br->getBits(8));
636    MY_LOGV("  last_section_number = %u", br->getBits(8));
637
638    size_t numProgramBytes = (section_length - 5 /* header */ - 4 /* crc */);
639    CHECK_EQ((numProgramBytes % 4), 0u);
640
641    for (size_t i = 0; i < numProgramBytes / 4; ++i) {
642        unsigned program_number = br->getBits(16);
643        LOGV("    program_number = %u", program_number);
644
645        MY_LOGV("    reserved = %u", br->getBits(3));
646
647        if (program_number == 0) {
648            MY_LOGV("    network_PID = 0x%04x", br->getBits(13));
649        } else {
650            unsigned programMapPID = br->getBits(13);
651
652            LOGV("    program_map_PID = 0x%04x", programMapPID);
653
654            mPrograms.push(new Program(this, programMapPID));
655        }
656    }
657
658    MY_LOGV("  CRC = 0x%08x", br->getBits(32));
659}
660
661void ATSParser::parsePID(
662        ABitReader *br, unsigned PID,
663        unsigned payload_unit_start_indicator) {
664    if (PID == 0) {
665        if (payload_unit_start_indicator) {
666            unsigned skip = br->getBits(8);
667            br->skipBits(skip * 8);
668        }
669        parseProgramAssociationTable(br);
670        return;
671    }
672
673    bool handled = false;
674    for (size_t i = 0; i < mPrograms.size(); ++i) {
675        if (mPrograms.editItemAt(i)->parsePID(
676                    PID, payload_unit_start_indicator, br)) {
677            handled = true;
678            break;
679        }
680    }
681
682    if (!handled) {
683        LOGV("PID 0x%04x not handled.", PID);
684    }
685}
686
687void ATSParser::parseAdaptationField(ABitReader *br) {
688    unsigned adaptation_field_length = br->getBits(8);
689    if (adaptation_field_length > 0) {
690        br->skipBits(adaptation_field_length * 8);  // XXX
691    }
692}
693
694void ATSParser::parseTS(ABitReader *br) {
695    LOGV("---");
696
697    unsigned sync_byte = br->getBits(8);
698    CHECK_EQ(sync_byte, 0x47u);
699
700    MY_LOGV("transport_error_indicator = %u", br->getBits(1));
701
702    unsigned payload_unit_start_indicator = br->getBits(1);
703    LOGV("payload_unit_start_indicator = %u", payload_unit_start_indicator);
704
705    MY_LOGV("transport_priority = %u", br->getBits(1));
706
707    unsigned PID = br->getBits(13);
708    LOGV("PID = 0x%04x", PID);
709
710    MY_LOGV("transport_scrambling_control = %u", br->getBits(2));
711
712    unsigned adaptation_field_control = br->getBits(2);
713    LOGV("adaptation_field_control = %u", adaptation_field_control);
714
715    unsigned continuity_counter = br->getBits(4);
716    LOGV("continuity_counter = %u", continuity_counter);
717
718    // LOGI("PID = 0x%04x, continuity_counter = %u", PID, continuity_counter);
719
720    if (adaptation_field_control == 2 || adaptation_field_control == 3) {
721        parseAdaptationField(br);
722    }
723
724    if (adaptation_field_control == 1 || adaptation_field_control == 3) {
725        parsePID(br, PID, payload_unit_start_indicator);
726    }
727}
728
729sp<MediaSource> ATSParser::getSource(SourceType type) {
730    for (size_t i = 0; i < mPrograms.size(); ++i) {
731        sp<MediaSource> source = mPrograms.editItemAt(i)->getSource(type);
732
733        if (source != NULL) {
734            return source;
735        }
736    }
737
738    return NULL;
739}
740
741bool ATSParser::PTSTimeDeltaEstablished() {
742    if (mPrograms.isEmpty()) {
743        return false;
744    }
745
746    return mPrograms.editItemAt(0)->PTSTimeDeltaEstablished();
747}
748
749}  // namespace android
750