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