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