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