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