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 "ESQueue"
19 #include <media/stagefright/foundation/ADebug.h>
20
21 #include "ESQueue.h"
22
23 #include <media/stagefright/foundation/hexdump.h>
24 #include <media/stagefright/foundation/ABitReader.h>
25 #include <media/stagefright/foundation/ABuffer.h>
26 #include <media/stagefright/foundation/AMessage.h>
27 #include <media/stagefright/MediaErrors.h>
28 #include <media/stagefright/MediaDefs.h>
29 #include <media/stagefright/MetaData.h>
30 #include <media/stagefright/Utils.h>
31 #include <media/cas/DescramblerAPI.h>
32 #include <media/hardware/CryptoAPI.h>
33
34 #include "include/avc_utils.h"
35
36 #include <inttypes.h>
37 #include <netinet/in.h>
38
39 namespace android {
40
ElementaryStreamQueue(Mode mode,uint32_t flags)41 ElementaryStreamQueue::ElementaryStreamQueue(Mode mode, uint32_t flags)
42 : mMode(mode),
43 mFlags(flags),
44 mEOSReached(false),
45 mCASystemId(0),
46 mAUIndex(0) {
47
48 ALOGV("ElementaryStreamQueue(%p) mode %x flags %x isScrambled %d isSampleEncrypted %d",
49 this, mode, flags, isScrambled(), isSampleEncrypted());
50
51 // Create the decryptor anyway since we don't know the use-case unless key is provided
52 // Won't decrypt if key info not available (e.g., scanner/extractor just parsing ts files)
53 mSampleDecryptor = isSampleEncrypted() ? new HlsSampleDecryptor : NULL;
54 }
55
getFormat()56 sp<MetaData> ElementaryStreamQueue::getFormat() {
57 return mFormat;
58 }
59
clear(bool clearFormat)60 void ElementaryStreamQueue::clear(bool clearFormat) {
61 if (mBuffer != NULL) {
62 mBuffer->setRange(0, 0);
63 }
64
65 mRangeInfos.clear();
66
67 if (mScrambledBuffer != NULL) {
68 mScrambledBuffer->setRange(0, 0);
69 }
70 mScrambledRangeInfos.clear();
71
72 if (clearFormat) {
73 mFormat.clear();
74 }
75
76 mEOSReached = false;
77 }
78
isScrambled() const79 bool ElementaryStreamQueue::isScrambled() const {
80 return (mFlags & kFlag_ScrambledData) != 0;
81 }
82
setCasInfo(int32_t systemId,const std::vector<uint8_t> & sessionId)83 void ElementaryStreamQueue::setCasInfo(
84 int32_t systemId, const std::vector<uint8_t> &sessionId) {
85 mCASystemId = systemId;
86 mCasSessionId = sessionId;
87 }
88
89 // Parse AC3 header assuming the current ptr is start position of syncframe,
90 // update metadata only applicable, and return the payload size
parseAC3SyncFrame(const uint8_t * ptr,size_t size,sp<MetaData> * metaData)91 static unsigned parseAC3SyncFrame(
92 const uint8_t *ptr, size_t size, sp<MetaData> *metaData) {
93 static const unsigned channelCountTable[] = {2, 1, 2, 3, 3, 4, 4, 5};
94 static const unsigned samplingRateTable[] = {48000, 44100, 32000};
95
96 static const unsigned frameSizeTable[19][3] = {
97 { 64, 69, 96 },
98 { 80, 87, 120 },
99 { 96, 104, 144 },
100 { 112, 121, 168 },
101 { 128, 139, 192 },
102 { 160, 174, 240 },
103 { 192, 208, 288 },
104 { 224, 243, 336 },
105 { 256, 278, 384 },
106 { 320, 348, 480 },
107 { 384, 417, 576 },
108 { 448, 487, 672 },
109 { 512, 557, 768 },
110 { 640, 696, 960 },
111 { 768, 835, 1152 },
112 { 896, 975, 1344 },
113 { 1024, 1114, 1536 },
114 { 1152, 1253, 1728 },
115 { 1280, 1393, 1920 },
116 };
117
118 ABitReader bits(ptr, size);
119 if (bits.numBitsLeft() < 16) {
120 return 0;
121 }
122 if (bits.getBits(16) != 0x0B77) {
123 return 0;
124 }
125
126 if (bits.numBitsLeft() < 16 + 2 + 6 + 5 + 3 + 3) {
127 ALOGV("Not enough bits left for further parsing");
128 return 0;
129 }
130 bits.skipBits(16); // crc1
131
132 unsigned fscod = bits.getBits(2);
133 if (fscod == 3) {
134 ALOGW("Incorrect fscod in AC3 header");
135 return 0;
136 }
137
138 unsigned frmsizecod = bits.getBits(6);
139 if (frmsizecod > 37) {
140 ALOGW("Incorrect frmsizecod in AC3 header");
141 return 0;
142 }
143
144 unsigned bsid = bits.getBits(5);
145 if (bsid > 8) {
146 ALOGW("Incorrect bsid in AC3 header. Possibly E-AC-3?");
147 return 0;
148 }
149
150 unsigned bsmod __unused = bits.getBits(3);
151 unsigned acmod = bits.getBits(3);
152 unsigned cmixlev __unused = 0;
153 unsigned surmixlev __unused = 0;
154 unsigned dsurmod __unused = 0;
155
156 if ((acmod & 1) > 0 && acmod != 1) {
157 if (bits.numBitsLeft() < 2) {
158 return 0;
159 }
160 cmixlev = bits.getBits(2);
161 }
162 if ((acmod & 4) > 0) {
163 if (bits.numBitsLeft() < 2) {
164 return 0;
165 }
166 surmixlev = bits.getBits(2);
167 }
168 if (acmod == 2) {
169 if (bits.numBitsLeft() < 2) {
170 return 0;
171 }
172 dsurmod = bits.getBits(2);
173 }
174
175 if (bits.numBitsLeft() < 1) {
176 return 0;
177 }
178 unsigned lfeon = bits.getBits(1);
179
180 unsigned samplingRate = samplingRateTable[fscod];
181 unsigned payloadSize = frameSizeTable[frmsizecod >> 1][fscod];
182 if (fscod == 1) {
183 payloadSize += frmsizecod & 1;
184 }
185 payloadSize <<= 1; // convert from 16-bit words to bytes
186
187 unsigned channelCount = channelCountTable[acmod] + lfeon;
188
189 if (metaData != NULL) {
190 (*metaData)->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
191 (*metaData)->setInt32(kKeyChannelCount, channelCount);
192 (*metaData)->setInt32(kKeySampleRate, samplingRate);
193 }
194
195 return payloadSize;
196 }
197
IsSeeminglyValidAC3Header(const uint8_t * ptr,size_t size)198 static bool IsSeeminglyValidAC3Header(const uint8_t *ptr, size_t size) {
199 return parseAC3SyncFrame(ptr, size, NULL) > 0;
200 }
201
IsSeeminglyValidADTSHeader(const uint8_t * ptr,size_t size,size_t * frameLength)202 static bool IsSeeminglyValidADTSHeader(
203 const uint8_t *ptr, size_t size, size_t *frameLength) {
204 if (size < 7) {
205 // Not enough data to verify header.
206 return false;
207 }
208
209 if (ptr[0] != 0xff || (ptr[1] >> 4) != 0x0f) {
210 return false;
211 }
212
213 unsigned layer = (ptr[1] >> 1) & 3;
214
215 if (layer != 0) {
216 return false;
217 }
218
219 unsigned ID = (ptr[1] >> 3) & 1;
220 unsigned profile_ObjectType = ptr[2] >> 6;
221
222 if (ID == 1 && profile_ObjectType == 3) {
223 // MPEG-2 profile 3 is reserved.
224 return false;
225 }
226
227 size_t frameLengthInHeader =
228 ((ptr[3] & 3) << 11) + (ptr[4] << 3) + ((ptr[5] >> 5) & 7);
229 if (frameLengthInHeader > size) {
230 return false;
231 }
232
233 *frameLength = frameLengthInHeader;
234 return true;
235 }
236
IsSeeminglyValidMPEGAudioHeader(const uint8_t * ptr,size_t size)237 static bool IsSeeminglyValidMPEGAudioHeader(const uint8_t *ptr, size_t size) {
238 if (size < 3) {
239 // Not enough data to verify header.
240 return false;
241 }
242
243 if (ptr[0] != 0xff || (ptr[1] >> 5) != 0x07) {
244 return false;
245 }
246
247 unsigned ID = (ptr[1] >> 3) & 3;
248
249 if (ID == 1) {
250 return false; // reserved
251 }
252
253 unsigned layer = (ptr[1] >> 1) & 3;
254
255 if (layer == 0) {
256 return false; // reserved
257 }
258
259 unsigned bitrateIndex = (ptr[2] >> 4);
260
261 if (bitrateIndex == 0x0f) {
262 return false; // reserved
263 }
264
265 unsigned samplingRateIndex = (ptr[2] >> 2) & 3;
266
267 if (samplingRateIndex == 3) {
268 return false; // reserved
269 }
270
271 return true;
272 }
273
appendData(const void * data,size_t size,int64_t timeUs,int32_t payloadOffset,uint32_t pesScramblingControl)274 status_t ElementaryStreamQueue::appendData(
275 const void *data, size_t size, int64_t timeUs,
276 int32_t payloadOffset, uint32_t pesScramblingControl) {
277
278 if (mEOSReached) {
279 ALOGE("appending data after EOS");
280 return ERROR_MALFORMED;
281 }
282 if (mBuffer == NULL || mBuffer->size() == 0) {
283 switch (mMode) {
284 case H264:
285 case MPEG_VIDEO:
286 {
287 #if 0
288 if (size < 4 || memcmp("\x00\x00\x00\x01", data, 4)) {
289 return ERROR_MALFORMED;
290 }
291 #else
292 uint8_t *ptr = (uint8_t *)data;
293
294 ssize_t startOffset = -1;
295 for (size_t i = 0; i + 2 < size; ++i) {
296 if (!memcmp("\x00\x00\x01", &ptr[i], 3)) {
297 startOffset = i;
298 break;
299 }
300 }
301
302 if (startOffset < 0) {
303 return ERROR_MALFORMED;
304 }
305
306 if (mFormat == NULL && startOffset > 0) {
307 ALOGI("found something resembling an H.264/MPEG syncword "
308 "at offset %zd",
309 startOffset);
310 }
311
312 data = &ptr[startOffset];
313 size -= startOffset;
314 #endif
315 break;
316 }
317
318 case MPEG4_VIDEO:
319 {
320 #if 0
321 if (size < 3 || memcmp("\x00\x00\x01", data, 3)) {
322 return ERROR_MALFORMED;
323 }
324 #else
325 uint8_t *ptr = (uint8_t *)data;
326
327 ssize_t startOffset = -1;
328 for (size_t i = 0; i + 2 < size; ++i) {
329 if (!memcmp("\x00\x00\x01", &ptr[i], 3)) {
330 startOffset = i;
331 break;
332 }
333 }
334
335 if (startOffset < 0) {
336 return ERROR_MALFORMED;
337 }
338
339 if (startOffset > 0) {
340 ALOGI("found something resembling an H.264/MPEG syncword "
341 "at offset %zd",
342 startOffset);
343 }
344
345 data = &ptr[startOffset];
346 size -= startOffset;
347 #endif
348 break;
349 }
350
351 case AAC:
352 {
353 uint8_t *ptr = (uint8_t *)data;
354
355 #if 0
356 if (size < 2 || ptr[0] != 0xff || (ptr[1] >> 4) != 0x0f) {
357 return ERROR_MALFORMED;
358 }
359 #else
360 ssize_t startOffset = -1;
361 size_t frameLength;
362 for (size_t i = 0; i < size; ++i) {
363 if (IsSeeminglyValidADTSHeader(
364 &ptr[i], size - i, &frameLength)) {
365 startOffset = i;
366 break;
367 }
368 }
369
370 if (startOffset < 0) {
371 return ERROR_MALFORMED;
372 }
373
374 if (startOffset > 0) {
375 ALOGI("found something resembling an AAC syncword at "
376 "offset %zd",
377 startOffset);
378 }
379
380 if (frameLength != size - startOffset) {
381 ALOGV("First ADTS AAC frame length is %zd bytes, "
382 "while the buffer size is %zd bytes.",
383 frameLength, size - startOffset);
384 }
385
386 data = &ptr[startOffset];
387 size -= startOffset;
388 #endif
389 break;
390 }
391
392 case AC3:
393 {
394 uint8_t *ptr = (uint8_t *)data;
395
396 ssize_t startOffset = -1;
397 for (size_t i = 0; i < size; ++i) {
398 if (IsSeeminglyValidAC3Header(&ptr[i], size - i)) {
399 startOffset = i;
400 break;
401 }
402 }
403
404 if (startOffset < 0) {
405 return ERROR_MALFORMED;
406 }
407
408 if (startOffset > 0) {
409 ALOGI("found something resembling an AC3 syncword at "
410 "offset %zd",
411 startOffset);
412 }
413
414 data = &ptr[startOffset];
415 size -= startOffset;
416 break;
417 }
418
419 case MPEG_AUDIO:
420 {
421 uint8_t *ptr = (uint8_t *)data;
422
423 ssize_t startOffset = -1;
424 for (size_t i = 0; i < size; ++i) {
425 if (IsSeeminglyValidMPEGAudioHeader(&ptr[i], size - i)) {
426 startOffset = i;
427 break;
428 }
429 }
430
431 if (startOffset < 0) {
432 return ERROR_MALFORMED;
433 }
434
435 if (startOffset > 0) {
436 ALOGI("found something resembling an MPEG audio "
437 "syncword at offset %zd",
438 startOffset);
439 }
440
441 data = &ptr[startOffset];
442 size -= startOffset;
443 break;
444 }
445
446 case PCM_AUDIO:
447 case METADATA:
448 {
449 break;
450 }
451
452 default:
453 ALOGE("Unknown mode: %d", mMode);
454 return ERROR_MALFORMED;
455 }
456 }
457
458 size_t neededSize = (mBuffer == NULL ? 0 : mBuffer->size()) + size;
459 if (mBuffer == NULL || neededSize > mBuffer->capacity()) {
460 neededSize = (neededSize + 65535) & ~65535;
461
462 ALOGV("resizing buffer to size %zu", neededSize);
463
464 sp<ABuffer> buffer = new ABuffer(neededSize);
465 if (mBuffer != NULL) {
466 memcpy(buffer->data(), mBuffer->data(), mBuffer->size());
467 buffer->setRange(0, mBuffer->size());
468 } else {
469 buffer->setRange(0, 0);
470 }
471
472 mBuffer = buffer;
473 }
474
475 memcpy(mBuffer->data() + mBuffer->size(), data, size);
476 mBuffer->setRange(0, mBuffer->size() + size);
477
478 RangeInfo info;
479 info.mLength = size;
480 info.mTimestampUs = timeUs;
481 info.mPesOffset = payloadOffset;
482 info.mPesScramblingControl = pesScramblingControl;
483 mRangeInfos.push_back(info);
484
485 #if 0
486 if (mMode == AAC) {
487 ALOGI("size = %zu, timeUs = %.2f secs", size, timeUs / 1E6);
488 hexdump(data, size);
489 }
490 #endif
491
492 return OK;
493 }
494
appendScrambledData(const void * data,size_t size,int32_t keyId,bool isSync,sp<ABuffer> clearSizes,sp<ABuffer> encSizes)495 void ElementaryStreamQueue::appendScrambledData(
496 const void *data, size_t size,
497 int32_t keyId, bool isSync,
498 sp<ABuffer> clearSizes, sp<ABuffer> encSizes) {
499 if (!isScrambled()) {
500 return;
501 }
502
503 size_t neededSize = (mScrambledBuffer == NULL ? 0 : mScrambledBuffer->size()) + size;
504 if (mScrambledBuffer == NULL || neededSize > mScrambledBuffer->capacity()) {
505 neededSize = (neededSize + 65535) & ~65535;
506
507 ALOGI("resizing scrambled buffer to size %zu", neededSize);
508
509 sp<ABuffer> buffer = new ABuffer(neededSize);
510 if (mScrambledBuffer != NULL) {
511 memcpy(buffer->data(), mScrambledBuffer->data(), mScrambledBuffer->size());
512 buffer->setRange(0, mScrambledBuffer->size());
513 } else {
514 buffer->setRange(0, 0);
515 }
516
517 mScrambledBuffer = buffer;
518 }
519 memcpy(mScrambledBuffer->data() + mScrambledBuffer->size(), data, size);
520 mScrambledBuffer->setRange(0, mScrambledBuffer->size() + size);
521
522 ScrambledRangeInfo scrambledInfo;
523 scrambledInfo.mLength = size;
524 scrambledInfo.mKeyId = keyId;
525 scrambledInfo.mIsSync = isSync;
526 scrambledInfo.mClearSizes = clearSizes;
527 scrambledInfo.mEncSizes = encSizes;
528
529 ALOGV("[stream %d] appending scrambled range: size=%zu", mMode, size);
530
531 mScrambledRangeInfos.push_back(scrambledInfo);
532 }
533
dequeueScrambledAccessUnit()534 sp<ABuffer> ElementaryStreamQueue::dequeueScrambledAccessUnit() {
535 size_t nextScan = mBuffer->size();
536 mBuffer->setRange(0, 0);
537 int32_t pesOffset = 0, pesScramblingControl = 0;
538 int64_t timeUs = fetchTimestamp(nextScan, &pesOffset, &pesScramblingControl);
539 if (timeUs < 0ll) {
540 ALOGE("Negative timeUs");
541 return NULL;
542 }
543
544 // return scrambled unit
545 int32_t keyId = pesScramblingControl, isSync = 0, scrambledLength = 0;
546 sp<ABuffer> clearSizes, encSizes;
547 while (mScrambledRangeInfos.size() > mRangeInfos.size()) {
548 auto it = mScrambledRangeInfos.begin();
549 ALOGV("[stream %d] fetching scrambled range: size=%zu", mMode, it->mLength);
550
551 if (scrambledLength > 0) {
552 // This shouldn't happen since we always dequeue the entire PES.
553 ALOGW("Discarding srambled length %d", scrambledLength);
554 }
555 scrambledLength = it->mLength;
556
557 // TODO: handle key id change, use first non-zero keyId for now
558 if (keyId == 0) {
559 keyId = it->mKeyId;
560 }
561 clearSizes = it->mClearSizes;
562 encSizes = it->mEncSizes;
563 isSync = it->mIsSync;
564 mScrambledRangeInfos.erase(it);
565 }
566 if (scrambledLength == 0) {
567 ALOGE("[stream %d] empty scrambled unit!", mMode);
568 return NULL;
569 }
570
571 // skip the PES header, and copy the rest into scrambled access unit
572 sp<ABuffer> scrambledAccessUnit = ABuffer::CreateAsCopy(
573 mScrambledBuffer->data() + pesOffset,
574 scrambledLength - pesOffset);
575
576 // fix up first sample size after skipping the PES header
577 if (pesOffset > 0) {
578 int32_t &firstClearSize = *(int32_t*)clearSizes->data();
579 int32_t &firstEncSize = *(int32_t*)encSizes->data();
580 // Cut away the PES header
581 if (firstClearSize >= pesOffset) {
582 // This is for TS-level scrambling, we descrambled the first
583 // (or it was clear to begin with)
584 firstClearSize -= pesOffset;
585 } else if (firstEncSize >= pesOffset) {
586 // This can only be PES-level scrambling
587 firstEncSize -= pesOffset;
588 }
589 }
590
591 scrambledAccessUnit->meta()->setInt64("timeUs", timeUs);
592 if (isSync) {
593 scrambledAccessUnit->meta()->setInt32("isSync", 1);
594 }
595
596 // fill in CryptoInfo fields for AnotherPacketSource::read()
597 // MediaCas doesn't use cryptoMode, but set to non-zero value here.
598 scrambledAccessUnit->meta()->setInt32(
599 "cryptoMode", CryptoPlugin::kMode_AES_CTR);
600 scrambledAccessUnit->meta()->setInt32("cryptoKey", keyId);
601 scrambledAccessUnit->meta()->setBuffer("clearBytes", clearSizes);
602 scrambledAccessUnit->meta()->setBuffer("encBytes", encSizes);
603
604 memmove(mScrambledBuffer->data(),
605 mScrambledBuffer->data() + scrambledLength,
606 mScrambledBuffer->size() - scrambledLength);
607
608 mScrambledBuffer->setRange(0, mScrambledBuffer->size() - scrambledLength);
609
610 ALOGV("[stream %d] dequeued scrambled AU: timeUs=%lld, size=%zu",
611 mMode, (long long)timeUs, scrambledAccessUnit->size());
612
613 return scrambledAccessUnit;
614 }
615
dequeueAccessUnit()616 sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnit() {
617 if ((mFlags & kFlag_AlignedData) && mMode == H264 && !isScrambled()) {
618 if (mRangeInfos.empty()) {
619 return NULL;
620 }
621
622 RangeInfo info = *mRangeInfos.begin();
623 mRangeInfos.erase(mRangeInfos.begin());
624
625 sp<ABuffer> accessUnit = new ABuffer(info.mLength);
626 memcpy(accessUnit->data(), mBuffer->data(), info.mLength);
627 accessUnit->meta()->setInt64("timeUs", info.mTimestampUs);
628
629 memmove(mBuffer->data(),
630 mBuffer->data() + info.mLength,
631 mBuffer->size() - info.mLength);
632
633 mBuffer->setRange(0, mBuffer->size() - info.mLength);
634
635 if (mFormat == NULL) {
636 mFormat = MakeAVCCodecSpecificData(accessUnit);
637 }
638
639 return accessUnit;
640 }
641
642 switch (mMode) {
643 case H264:
644 return dequeueAccessUnitH264();
645 case AAC:
646 return dequeueAccessUnitAAC();
647 case AC3:
648 return dequeueAccessUnitAC3();
649 case MPEG_VIDEO:
650 return dequeueAccessUnitMPEGVideo();
651 case MPEG4_VIDEO:
652 return dequeueAccessUnitMPEG4Video();
653 case PCM_AUDIO:
654 return dequeueAccessUnitPCMAudio();
655 case METADATA:
656 return dequeueAccessUnitMetadata();
657 default:
658 if (mMode != MPEG_AUDIO) {
659 ALOGE("Unknown mode");
660 return NULL;
661 }
662 return dequeueAccessUnitMPEGAudio();
663 }
664 }
665
dequeueAccessUnitAC3()666 sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitAC3() {
667 unsigned syncStartPos = 0; // in bytes
668 unsigned payloadSize = 0;
669 sp<MetaData> format = new MetaData;
670
671 ALOGV("dequeueAccessUnit_AC3[%d]: mBuffer %p(%zu)", mAUIndex, mBuffer->data(), mBuffer->size());
672
673 while (true) {
674 if (syncStartPos + 2 >= mBuffer->size()) {
675 return NULL;
676 }
677
678 payloadSize = parseAC3SyncFrame(
679 mBuffer->data() + syncStartPos,
680 mBuffer->size() - syncStartPos,
681 &format);
682 if (payloadSize > 0) {
683 break;
684 }
685
686 ALOGV("dequeueAccessUnit_AC3[%d]: syncStartPos %u payloadSize %u",
687 mAUIndex, syncStartPos, payloadSize);
688
689 ++syncStartPos;
690 }
691
692 if (mBuffer->size() < syncStartPos + payloadSize) {
693 ALOGV("Not enough buffer size for AC3");
694 return NULL;
695 }
696
697 if (mFormat == NULL) {
698 mFormat = format;
699 }
700
701
702 int64_t timeUs = fetchTimestamp(syncStartPos + payloadSize);
703 if (timeUs < 0ll) {
704 ALOGE("negative timeUs");
705 return NULL;
706 }
707
708 // Not decrypting if key info not available (e.g., scanner/extractor parsing ts files)
709 if (mSampleDecryptor != NULL) {
710 mSampleDecryptor->processAC3(mBuffer->data() + syncStartPos, payloadSize);
711 }
712 mAUIndex++;
713
714 sp<ABuffer> accessUnit = new ABuffer(syncStartPos + payloadSize);
715 memcpy(accessUnit->data(), mBuffer->data(), syncStartPos + payloadSize);
716
717 accessUnit->meta()->setInt64("timeUs", timeUs);
718 accessUnit->meta()->setInt32("isSync", 1);
719
720 memmove(
721 mBuffer->data(),
722 mBuffer->data() + syncStartPos + payloadSize,
723 mBuffer->size() - syncStartPos - payloadSize);
724
725 mBuffer->setRange(0, mBuffer->size() - syncStartPos - payloadSize);
726
727 return accessUnit;
728 }
729
dequeueAccessUnitPCMAudio()730 sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitPCMAudio() {
731 if (mBuffer->size() < 4) {
732 return NULL;
733 }
734
735 ABitReader bits(mBuffer->data(), 4);
736 if (bits.getBits(8) != 0xa0) {
737 ALOGE("Unexpected bit values");
738 return NULL;
739 }
740 unsigned numAUs = bits.getBits(8);
741 bits.skipBits(8);
742 unsigned quantization_word_length __unused = bits.getBits(2);
743 unsigned audio_sampling_frequency = bits.getBits(3);
744 unsigned num_channels = bits.getBits(3);
745
746 if (audio_sampling_frequency != 2) {
747 ALOGE("Wrong sampling freq");
748 return NULL;
749 }
750 if (num_channels != 1u) {
751 ALOGE("Wrong channel #");
752 return NULL;
753 }
754
755 if (mFormat == NULL) {
756 mFormat = new MetaData;
757 mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RAW);
758 mFormat->setInt32(kKeyChannelCount, 2);
759 mFormat->setInt32(kKeySampleRate, 48000);
760 mFormat->setInt32(kKeyPcmEncoding, kAudioEncodingPcm16bit);
761 }
762
763 static const size_t kFramesPerAU = 80;
764 size_t frameSize = 2 /* numChannels */ * sizeof(int16_t);
765
766 size_t payloadSize = numAUs * frameSize * kFramesPerAU;
767
768 if (mBuffer->size() < 4 + payloadSize) {
769 return NULL;
770 }
771
772 sp<ABuffer> accessUnit = new ABuffer(payloadSize);
773 memcpy(accessUnit->data(), mBuffer->data() + 4, payloadSize);
774
775 int64_t timeUs = fetchTimestamp(payloadSize + 4);
776 if (timeUs < 0ll) {
777 ALOGE("Negative timeUs");
778 return NULL;
779 }
780 accessUnit->meta()->setInt64("timeUs", timeUs);
781 accessUnit->meta()->setInt32("isSync", 1);
782
783 int16_t *ptr = (int16_t *)accessUnit->data();
784 for (size_t i = 0; i < payloadSize / sizeof(int16_t); ++i) {
785 ptr[i] = ntohs(ptr[i]);
786 }
787
788 memmove(
789 mBuffer->data(),
790 mBuffer->data() + 4 + payloadSize,
791 mBuffer->size() - 4 - payloadSize);
792
793 mBuffer->setRange(0, mBuffer->size() - 4 - payloadSize);
794
795 return accessUnit;
796 }
797
dequeueAccessUnitAAC()798 sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitAAC() {
799 if (mBuffer->size() == 0) {
800 return NULL;
801 }
802
803 if (mRangeInfos.empty()) {
804 return NULL;
805 }
806
807 const RangeInfo &info = *mRangeInfos.begin();
808 if (mBuffer->size() < info.mLength) {
809 return NULL;
810 }
811
812 if (info.mTimestampUs < 0ll) {
813 ALOGE("Negative info.mTimestampUs");
814 return NULL;
815 }
816
817 ALOGV("dequeueAccessUnit_AAC[%d]: mBuffer %zu info.mLength %zu",
818 mAUIndex, mBuffer->size(), info.mLength);
819
820 struct ADTSPosition {
821 size_t offset;
822 size_t headerSize;
823 size_t length;
824 };
825
826 Vector<ADTSPosition> frames;
827
828 // The idea here is consume all AAC frames starting at offsets before
829 // info.mLength so we can assign a meaningful timestamp without
830 // having to interpolate.
831 // The final AAC frame may well extend into the next RangeInfo but
832 // that's ok.
833 size_t offset = 0;
834 while (offset < info.mLength) {
835 if (offset + 7 > mBuffer->size()) {
836 return NULL;
837 }
838
839 ABitReader bits(mBuffer->data() + offset, mBuffer->size() - offset);
840
841 // adts_fixed_header
842
843 if (bits.getBits(12) != 0xfffu) {
844 ALOGE("Wrong atds_fixed_header");
845 return NULL;
846 }
847 bits.skipBits(3); // ID, layer
848 bool protection_absent = bits.getBits(1) != 0;
849
850 if (mFormat == NULL) {
851 unsigned profile = bits.getBits(2);
852 if (profile == 3u) {
853 ALOGE("profile should not be 3");
854 return NULL;
855 }
856 unsigned sampling_freq_index = bits.getBits(4);
857 bits.getBits(1); // private_bit
858 unsigned channel_configuration = bits.getBits(3);
859 if (channel_configuration == 0u) {
860 ALOGE("channel_config should not be 0");
861 return NULL;
862 }
863 bits.skipBits(2); // original_copy, home
864
865 mFormat = MakeAACCodecSpecificData(
866 profile, sampling_freq_index, channel_configuration);
867
868 mFormat->setInt32(kKeyIsADTS, true);
869
870 int32_t sampleRate;
871 int32_t numChannels;
872 if (!mFormat->findInt32(kKeySampleRate, &sampleRate)) {
873 ALOGE("SampleRate not found");
874 return NULL;
875 }
876 if (!mFormat->findInt32(kKeyChannelCount, &numChannels)) {
877 ALOGE("ChannelCount not found");
878 return NULL;
879 }
880
881 ALOGI("found AAC codec config (%d Hz, %d channels)",
882 sampleRate, numChannels);
883 } else {
884 // profile_ObjectType, sampling_frequency_index, private_bits,
885 // channel_configuration, original_copy, home
886 bits.skipBits(12);
887 }
888
889 // adts_variable_header
890
891 // copyright_identification_bit, copyright_identification_start
892 bits.skipBits(2);
893
894 unsigned aac_frame_length = bits.getBits(13);
895 if (aac_frame_length == 0){
896 ALOGE("b/62673179, Invalid AAC frame length!");
897 android_errorWriteLog(0x534e4554, "62673179");
898 return NULL;
899 }
900
901 bits.skipBits(11); // adts_buffer_fullness
902
903 unsigned number_of_raw_data_blocks_in_frame = bits.getBits(2);
904
905 if (number_of_raw_data_blocks_in_frame != 0) {
906 // To be implemented.
907 ALOGE("Should not reach here.");
908 return NULL;
909 }
910
911 if (offset + aac_frame_length > mBuffer->size()) {
912 return NULL;
913 }
914
915 size_t headerSize = protection_absent ? 7 : 9;
916
917 // tracking the frame positions first then decrypt only if an accessUnit to be generated
918 if (mSampleDecryptor != NULL) {
919 ADTSPosition frame = {
920 .offset = offset,
921 .headerSize = headerSize,
922 .length = aac_frame_length
923 };
924
925 frames.push(frame);
926 }
927
928 offset += aac_frame_length;
929 }
930
931 // Decrypting only if the loop didn't exit early and an accessUnit is about to be generated
932 // Not decrypting if key info not available (e.g., scanner/extractor parsing ts files)
933 if (mSampleDecryptor != NULL) {
934 for (size_t frameId = 0; frameId < frames.size(); frameId++) {
935 const ADTSPosition &frame = frames.itemAt(frameId);
936
937 mSampleDecryptor->processAAC(frame.headerSize,
938 mBuffer->data() + frame.offset, frame.length);
939 // ALOGV("dequeueAccessUnitAAC[%zu]: while offset %zu headerSize %zu frame_len %zu",
940 // frameId, frame.offset, frame.headerSize, frame.length);
941 }
942 }
943 mAUIndex++;
944
945 int64_t timeUs = fetchTimestamp(offset);
946
947 sp<ABuffer> accessUnit = new ABuffer(offset);
948 memcpy(accessUnit->data(), mBuffer->data(), offset);
949
950 memmove(mBuffer->data(), mBuffer->data() + offset,
951 mBuffer->size() - offset);
952 mBuffer->setRange(0, mBuffer->size() - offset);
953
954 accessUnit->meta()->setInt64("timeUs", timeUs);
955 accessUnit->meta()->setInt32("isSync", 1);
956
957 return accessUnit;
958 }
959
fetchTimestamp(size_t size,int32_t * pesOffset,int32_t * pesScramblingControl)960 int64_t ElementaryStreamQueue::fetchTimestamp(
961 size_t size, int32_t *pesOffset, int32_t *pesScramblingControl) {
962 int64_t timeUs = -1;
963 bool first = true;
964
965 while (size > 0) {
966 if (mRangeInfos.empty()) {
967 return timeUs;
968 }
969
970 RangeInfo *info = &*mRangeInfos.begin();
971
972 if (first) {
973 timeUs = info->mTimestampUs;
974 if (pesOffset != NULL) {
975 *pesOffset = info->mPesOffset;
976 }
977 if (pesScramblingControl != NULL) {
978 *pesScramblingControl = info->mPesScramblingControl;
979 }
980 first = false;
981 }
982
983 if (info->mLength > size) {
984 info->mLength -= size;
985 size = 0;
986 } else {
987 size -= info->mLength;
988
989 mRangeInfos.erase(mRangeInfos.begin());
990 info = NULL;
991 }
992
993 }
994
995 if (timeUs == 0ll) {
996 ALOGV("Returning 0 timestamp");
997 }
998
999 return timeUs;
1000 }
1001
dequeueAccessUnitH264()1002 sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitH264() {
1003 if (isScrambled()) {
1004 if (mBuffer == NULL || mBuffer->size() == 0) {
1005 return NULL;
1006 }
1007 if (mFormat == NULL) {
1008 mFormat = MakeAVCCodecSpecificData(mBuffer);
1009 if (mFormat == NULL) {
1010 ALOGI("Creating dummy AVC format for scrambled content");
1011 mFormat = new MetaData;
1012 mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
1013 mFormat->setInt32(kKeyWidth, 1280);
1014 mFormat->setInt32(kKeyHeight, 720);
1015 }
1016 // for MediaExtractor.CasInfo
1017 mFormat->setInt32(kKeyCASystemID, mCASystemId);
1018 mFormat->setData(kKeyCASessionID, 0,
1019 mCasSessionId.data(), mCasSessionId.size());
1020 }
1021 return dequeueScrambledAccessUnit();
1022 }
1023
1024 const uint8_t *data = mBuffer->data();
1025
1026 size_t size = mBuffer->size();
1027 Vector<NALPosition> nals;
1028
1029 size_t totalSize = 0;
1030 size_t seiCount = 0;
1031
1032 status_t err;
1033 const uint8_t *nalStart;
1034 size_t nalSize;
1035 bool foundSlice = false;
1036 bool foundIDR = false;
1037
1038 ALOGV("dequeueAccessUnit_H264[%d] %p/%zu", mAUIndex, data, size);
1039
1040 while ((err = getNextNALUnit(&data, &size, &nalStart, &nalSize)) == OK) {
1041 if (nalSize == 0) continue;
1042
1043 unsigned nalType = nalStart[0] & 0x1f;
1044 bool flush = false;
1045
1046 if (nalType == 1 || nalType == 5) {
1047 if (nalType == 5) {
1048 foundIDR = true;
1049 }
1050 if (foundSlice) {
1051 //TODO: Shouldn't this have been called with nalSize-1?
1052 ABitReader br(nalStart + 1, nalSize);
1053 unsigned first_mb_in_slice = parseUE(&br);
1054
1055 if (first_mb_in_slice == 0) {
1056 // This slice starts a new frame.
1057
1058 flush = true;
1059 }
1060 }
1061
1062 foundSlice = true;
1063 } else if ((nalType == 9 || nalType == 7) && foundSlice) {
1064 // Access unit delimiter and SPS will be associated with the
1065 // next frame.
1066
1067 flush = true;
1068 } else if (nalType == 6 && nalSize > 0) {
1069 // found non-zero sized SEI
1070 ++seiCount;
1071 }
1072
1073 if (flush) {
1074 // The access unit will contain all nal units up to, but excluding
1075 // the current one, separated by 0x00 0x00 0x00 0x01 startcodes.
1076
1077 size_t auSize = 4 * nals.size() + totalSize;
1078 sp<ABuffer> accessUnit = new ABuffer(auSize);
1079 sp<ABuffer> sei;
1080
1081 if (seiCount > 0) {
1082 sei = new ABuffer(seiCount * sizeof(NALPosition));
1083 accessUnit->meta()->setBuffer("sei", sei);
1084 }
1085
1086 #if !LOG_NDEBUG
1087 AString out;
1088 #endif
1089
1090 size_t dstOffset = 0;
1091 size_t seiIndex = 0;
1092 size_t shrunkBytes = 0;
1093 for (size_t i = 0; i < nals.size(); ++i) {
1094 const NALPosition &pos = nals.itemAt(i);
1095
1096 unsigned nalType = mBuffer->data()[pos.nalOffset] & 0x1f;
1097
1098 if (nalType == 6 && pos.nalSize > 0) {
1099 if (seiIndex >= sei->size() / sizeof(NALPosition)) {
1100 ALOGE("Wrong seiIndex");
1101 return NULL;
1102 }
1103 NALPosition &seiPos = ((NALPosition *)sei->data())[seiIndex++];
1104 seiPos.nalOffset = dstOffset + 4;
1105 seiPos.nalSize = pos.nalSize;
1106 }
1107
1108 #if !LOG_NDEBUG
1109 char tmp[128];
1110 sprintf(tmp, "0x%02x", nalType);
1111 if (i > 0) {
1112 out.append(", ");
1113 }
1114 out.append(tmp);
1115 #endif
1116
1117 memcpy(accessUnit->data() + dstOffset, "\x00\x00\x00\x01", 4);
1118
1119 if (mSampleDecryptor != NULL && (nalType == 1 || nalType == 5)) {
1120 uint8_t *nalData = mBuffer->data() + pos.nalOffset;
1121 size_t newSize = mSampleDecryptor->processNal(nalData, pos.nalSize);
1122 // Note: the data can shrink due to unescaping
1123 memcpy(accessUnit->data() + dstOffset + 4,
1124 nalData,
1125 newSize);
1126 dstOffset += newSize + 4;
1127
1128 size_t thisShrunkBytes = pos.nalSize - newSize;
1129 //ALOGV("dequeueAccessUnitH264[%d]: nalType: %d -> %zu (%zu)",
1130 // nalType, (int)pos.nalSize, newSize, thisShrunkBytes);
1131
1132 shrunkBytes += thisShrunkBytes;
1133 }
1134 else {
1135 memcpy(accessUnit->data() + dstOffset + 4,
1136 mBuffer->data() + pos.nalOffset,
1137 pos.nalSize);
1138
1139 dstOffset += pos.nalSize + 4;
1140 //ALOGV("dequeueAccessUnitH264 [%d] %d @%d",
1141 // nalType, (int)pos.nalSize, (int)pos.nalOffset);
1142 }
1143 }
1144
1145 #if !LOG_NDEBUG
1146 ALOGV("accessUnit contains nal types %s", out.c_str());
1147 #endif
1148
1149 const NALPosition &pos = nals.itemAt(nals.size() - 1);
1150 size_t nextScan = pos.nalOffset + pos.nalSize;
1151
1152 memmove(mBuffer->data(),
1153 mBuffer->data() + nextScan,
1154 mBuffer->size() - nextScan);
1155
1156 mBuffer->setRange(0, mBuffer->size() - nextScan);
1157
1158 int64_t timeUs = fetchTimestamp(nextScan);
1159 if (timeUs < 0ll) {
1160 ALOGE("Negative timeUs");
1161 return NULL;
1162 }
1163
1164 accessUnit->meta()->setInt64("timeUs", timeUs);
1165 if (foundIDR) {
1166 accessUnit->meta()->setInt32("isSync", 1);
1167 }
1168
1169 if (mFormat == NULL) {
1170 mFormat = MakeAVCCodecSpecificData(accessUnit);
1171 }
1172
1173 if (mSampleDecryptor != NULL && shrunkBytes > 0) {
1174 size_t adjustedSize = accessUnit->size() - shrunkBytes;
1175 ALOGV("dequeueAccessUnitH264[%d]: AU size adjusted %zu -> %zu",
1176 mAUIndex, accessUnit->size(), adjustedSize);
1177 accessUnit->setRange(0, adjustedSize);
1178 }
1179
1180 ALOGV("dequeueAccessUnitH264[%d]: AU %p(%zu) dstOffset:%zu, nals:%zu, totalSize:%zu ",
1181 mAUIndex, accessUnit->data(), accessUnit->size(),
1182 dstOffset, nals.size(), totalSize);
1183 mAUIndex++;
1184
1185 return accessUnit;
1186 }
1187
1188 NALPosition pos;
1189 pos.nalOffset = nalStart - mBuffer->data();
1190 pos.nalSize = nalSize;
1191
1192 nals.push(pos);
1193
1194 totalSize += nalSize;
1195 }
1196 if (err != (status_t)-EAGAIN) {
1197 ALOGE("Unexpeted err");
1198 return NULL;
1199 }
1200
1201 return NULL;
1202 }
1203
dequeueAccessUnitMPEGAudio()1204 sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitMPEGAudio() {
1205 const uint8_t *data = mBuffer->data();
1206 size_t size = mBuffer->size();
1207
1208 if (size < 4) {
1209 return NULL;
1210 }
1211
1212 uint32_t header = U32_AT(data);
1213
1214 size_t frameSize;
1215 int samplingRate, numChannels, bitrate, numSamples;
1216 if (!GetMPEGAudioFrameSize(
1217 header, &frameSize, &samplingRate, &numChannels,
1218 &bitrate, &numSamples)) {
1219 ALOGE("Failed to get audio frame size");
1220 return NULL;
1221 }
1222
1223 if (size < frameSize) {
1224 return NULL;
1225 }
1226
1227 unsigned layer = 4 - ((header >> 17) & 3);
1228
1229 sp<ABuffer> accessUnit = new ABuffer(frameSize);
1230 memcpy(accessUnit->data(), data, frameSize);
1231
1232 memmove(mBuffer->data(),
1233 mBuffer->data() + frameSize,
1234 mBuffer->size() - frameSize);
1235
1236 mBuffer->setRange(0, mBuffer->size() - frameSize);
1237
1238 int64_t timeUs = fetchTimestamp(frameSize);
1239 if (timeUs < 0ll) {
1240 ALOGE("Negative timeUs");
1241 return NULL;
1242 }
1243
1244 accessUnit->meta()->setInt64("timeUs", timeUs);
1245 accessUnit->meta()->setInt32("isSync", 1);
1246
1247 if (mFormat == NULL) {
1248 mFormat = new MetaData;
1249
1250 switch (layer) {
1251 case 1:
1252 mFormat->setCString(
1253 kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I);
1254 break;
1255 case 2:
1256 mFormat->setCString(
1257 kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
1258 break;
1259 case 3:
1260 mFormat->setCString(
1261 kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
1262 break;
1263 default:
1264 return NULL;
1265 }
1266
1267 mFormat->setInt32(kKeySampleRate, samplingRate);
1268 mFormat->setInt32(kKeyChannelCount, numChannels);
1269 }
1270
1271 return accessUnit;
1272 }
1273
EncodeSize14(uint8_t ** _ptr,size_t size)1274 static void EncodeSize14(uint8_t **_ptr, size_t size) {
1275 if (size > 0x3fff) {
1276 ALOGE("Wrong size");
1277 return;
1278 }
1279
1280 uint8_t *ptr = *_ptr;
1281
1282 *ptr++ = 0x80 | (size >> 7);
1283 *ptr++ = size & 0x7f;
1284
1285 *_ptr = ptr;
1286 }
1287
MakeMPEGVideoESDS(const sp<ABuffer> & csd)1288 static sp<ABuffer> MakeMPEGVideoESDS(const sp<ABuffer> &csd) {
1289 sp<ABuffer> esds = new ABuffer(csd->size() + 25);
1290
1291 uint8_t *ptr = esds->data();
1292 *ptr++ = 0x03;
1293 EncodeSize14(&ptr, 22 + csd->size());
1294
1295 *ptr++ = 0x00; // ES_ID
1296 *ptr++ = 0x00;
1297
1298 *ptr++ = 0x00; // streamDependenceFlag, URL_Flag, OCRstreamFlag
1299
1300 *ptr++ = 0x04;
1301 EncodeSize14(&ptr, 16 + csd->size());
1302
1303 *ptr++ = 0x40; // Audio ISO/IEC 14496-3
1304
1305 for (size_t i = 0; i < 12; ++i) {
1306 *ptr++ = 0x00;
1307 }
1308
1309 *ptr++ = 0x05;
1310 EncodeSize14(&ptr, csd->size());
1311
1312 memcpy(ptr, csd->data(), csd->size());
1313
1314 return esds;
1315 }
1316
dequeueAccessUnitMPEGVideo()1317 sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitMPEGVideo() {
1318 if (isScrambled()) {
1319 if (mBuffer == NULL || mBuffer->size() == 0) {
1320 return NULL;
1321 }
1322 if (mFormat == NULL) {
1323 ALOGI("Creating dummy MPEG format for scrambled content");
1324 mFormat = new MetaData;
1325 mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
1326 mFormat->setInt32(kKeyWidth, 1280);
1327 mFormat->setInt32(kKeyHeight, 720);
1328
1329 // for MediaExtractor.CasInfo
1330 mFormat->setInt32(kKeyCASystemID, mCASystemId);
1331 mFormat->setData(kKeyCASessionID, 0,
1332 mCasSessionId.data(), mCasSessionId.size());
1333 }
1334 return dequeueScrambledAccessUnit();
1335 }
1336
1337 const uint8_t *data = mBuffer->data();
1338 size_t size = mBuffer->size();
1339
1340 Vector<size_t> userDataPositions;
1341
1342 bool sawPictureStart = false;
1343 int pprevStartCode = -1;
1344 int prevStartCode = -1;
1345 int currentStartCode = -1;
1346 bool gopFound = false;
1347 bool isClosedGop = false;
1348 bool brokenLink = false;
1349
1350 size_t offset = 0;
1351 while (offset + 3 < size) {
1352 if (memcmp(&data[offset], "\x00\x00\x01", 3)) {
1353 ++offset;
1354 continue;
1355 }
1356
1357 pprevStartCode = prevStartCode;
1358 prevStartCode = currentStartCode;
1359 currentStartCode = data[offset + 3];
1360
1361 if (currentStartCode == 0xb3 && mFormat == NULL) {
1362 memmove(mBuffer->data(), mBuffer->data() + offset, size - offset);
1363 size -= offset;
1364 (void)fetchTimestamp(offset);
1365 offset = 0;
1366 mBuffer->setRange(0, size);
1367 }
1368
1369 if ((prevStartCode == 0xb3 && currentStartCode != 0xb5)
1370 || (pprevStartCode == 0xb3 && prevStartCode == 0xb5)) {
1371 // seqHeader without/with extension
1372
1373 if (mFormat == NULL) {
1374 if (size < 7u) {
1375 ALOGE("Size too small");
1376 return NULL;
1377 }
1378
1379 unsigned width =
1380 (data[4] << 4) | data[5] >> 4;
1381
1382 unsigned height =
1383 ((data[5] & 0x0f) << 8) | data[6];
1384
1385 mFormat = new MetaData;
1386 mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
1387 mFormat->setInt32(kKeyWidth, width);
1388 mFormat->setInt32(kKeyHeight, height);
1389
1390 ALOGI("found MPEG2 video codec config (%d x %d)", width, height);
1391
1392 sp<ABuffer> csd = new ABuffer(offset);
1393 memcpy(csd->data(), data, offset);
1394
1395 memmove(mBuffer->data(),
1396 mBuffer->data() + offset,
1397 mBuffer->size() - offset);
1398
1399 mBuffer->setRange(0, mBuffer->size() - offset);
1400 size -= offset;
1401 (void)fetchTimestamp(offset);
1402 offset = 0;
1403
1404 // hexdump(csd->data(), csd->size());
1405
1406 sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
1407 mFormat->setData(
1408 kKeyESDS, kTypeESDS, esds->data(), esds->size());
1409
1410 return NULL;
1411 }
1412 }
1413
1414 if (mFormat != NULL && currentStartCode == 0xb8) {
1415 // GOP layer
1416 if (offset + 7 >= size) {
1417 ALOGE("Size too small");
1418 return NULL;
1419 }
1420 gopFound = true;
1421 isClosedGop = (data[offset + 7] & 0x40) != 0;
1422 brokenLink = (data[offset + 7] & 0x20) != 0;
1423 }
1424
1425 if (mFormat != NULL && currentStartCode == 0xb2) {
1426 userDataPositions.add(offset);
1427 }
1428
1429 if (mFormat != NULL && currentStartCode == 0x00) {
1430 // Picture start
1431
1432 if (!sawPictureStart) {
1433 sawPictureStart = true;
1434 } else {
1435 sp<ABuffer> accessUnit = new ABuffer(offset);
1436 memcpy(accessUnit->data(), data, offset);
1437
1438 memmove(mBuffer->data(),
1439 mBuffer->data() + offset,
1440 mBuffer->size() - offset);
1441
1442 mBuffer->setRange(0, mBuffer->size() - offset);
1443
1444 int64_t timeUs = fetchTimestamp(offset);
1445 if (timeUs < 0ll) {
1446 ALOGE("Negative timeUs");
1447 return NULL;
1448 }
1449
1450 offset = 0;
1451
1452 accessUnit->meta()->setInt64("timeUs", timeUs);
1453 if (gopFound && (!brokenLink || isClosedGop)) {
1454 accessUnit->meta()->setInt32("isSync", 1);
1455 }
1456
1457 ALOGV("returning MPEG video access unit at time %" PRId64 " us",
1458 timeUs);
1459
1460 // hexdump(accessUnit->data(), accessUnit->size());
1461
1462 if (userDataPositions.size() > 0) {
1463 sp<ABuffer> mpegUserData =
1464 new ABuffer(userDataPositions.size() * sizeof(size_t));
1465 if (mpegUserData != NULL && mpegUserData->data() != NULL) {
1466 for (size_t i = 0; i < userDataPositions.size(); ++i) {
1467 memcpy(
1468 mpegUserData->data() + i * sizeof(size_t),
1469 &userDataPositions[i], sizeof(size_t));
1470 }
1471 accessUnit->meta()->setBuffer("mpegUserData", mpegUserData);
1472 }
1473 }
1474
1475 return accessUnit;
1476 }
1477 }
1478
1479 ++offset;
1480 }
1481
1482 return NULL;
1483 }
1484
getNextChunkSize(const uint8_t * data,size_t size)1485 static ssize_t getNextChunkSize(
1486 const uint8_t *data, size_t size) {
1487 static const char kStartCode[] = "\x00\x00\x01";
1488
1489 if (size < 3) {
1490 return -EAGAIN;
1491 }
1492
1493 if (memcmp(kStartCode, data, 3)) {
1494 return -EAGAIN;
1495 }
1496
1497 size_t offset = 3;
1498 while (offset + 2 < size) {
1499 if (!memcmp(&data[offset], kStartCode, 3)) {
1500 return offset;
1501 }
1502
1503 ++offset;
1504 }
1505
1506 return -EAGAIN;
1507 }
1508
dequeueAccessUnitMPEG4Video()1509 sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitMPEG4Video() {
1510 uint8_t *data = mBuffer->data();
1511 size_t size = mBuffer->size();
1512
1513 enum {
1514 SKIP_TO_VISUAL_OBJECT_SEQ_START,
1515 EXPECT_VISUAL_OBJECT_START,
1516 EXPECT_VO_START,
1517 EXPECT_VOL_START,
1518 WAIT_FOR_VOP_START,
1519 SKIP_TO_VOP_START,
1520
1521 } state;
1522
1523 if (mFormat == NULL) {
1524 state = SKIP_TO_VISUAL_OBJECT_SEQ_START;
1525 } else {
1526 state = SKIP_TO_VOP_START;
1527 }
1528
1529 int32_t width = -1, height = -1;
1530
1531 size_t offset = 0;
1532 ssize_t chunkSize;
1533 while ((chunkSize = getNextChunkSize(
1534 &data[offset], size - offset)) > 0) {
1535 bool discard = false;
1536
1537 unsigned chunkType = data[offset + 3];
1538
1539 switch (state) {
1540 case SKIP_TO_VISUAL_OBJECT_SEQ_START:
1541 {
1542 if (chunkType == 0xb0) {
1543 // Discard anything before this marker.
1544
1545 state = EXPECT_VISUAL_OBJECT_START;
1546 } else {
1547 discard = true;
1548 }
1549 break;
1550 }
1551
1552 case EXPECT_VISUAL_OBJECT_START:
1553 {
1554 if (chunkType != 0xb5) {
1555 ALOGE("Unexpected chunkType");
1556 return NULL;
1557 }
1558 state = EXPECT_VO_START;
1559 break;
1560 }
1561
1562 case EXPECT_VO_START:
1563 {
1564 if (chunkType > 0x1f) {
1565 ALOGE("Unexpected chunkType");
1566 return NULL;
1567 }
1568 state = EXPECT_VOL_START;
1569 break;
1570 }
1571
1572 case EXPECT_VOL_START:
1573 {
1574 if ((chunkType & 0xf0) != 0x20) {
1575 ALOGE("Wrong chunkType");
1576 return NULL;
1577 }
1578
1579 if (!ExtractDimensionsFromVOLHeader(
1580 &data[offset], chunkSize,
1581 &width, &height)) {
1582 ALOGE("Failed to get dimension");
1583 return NULL;
1584 }
1585
1586 state = WAIT_FOR_VOP_START;
1587 break;
1588 }
1589
1590 case WAIT_FOR_VOP_START:
1591 {
1592 if (chunkType == 0xb3 || chunkType == 0xb6) {
1593 // group of VOP or VOP start.
1594
1595 mFormat = new MetaData;
1596 mFormat->setCString(
1597 kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
1598
1599 mFormat->setInt32(kKeyWidth, width);
1600 mFormat->setInt32(kKeyHeight, height);
1601
1602 ALOGI("found MPEG4 video codec config (%d x %d)",
1603 width, height);
1604
1605 sp<ABuffer> csd = new ABuffer(offset);
1606 memcpy(csd->data(), data, offset);
1607
1608 // hexdump(csd->data(), csd->size());
1609
1610 sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
1611 mFormat->setData(
1612 kKeyESDS, kTypeESDS,
1613 esds->data(), esds->size());
1614
1615 discard = true;
1616 state = SKIP_TO_VOP_START;
1617 }
1618
1619 break;
1620 }
1621
1622 case SKIP_TO_VOP_START:
1623 {
1624 if (chunkType == 0xb6) {
1625 int vopCodingType = (data[offset + 4] & 0xc0) >> 6;
1626
1627 offset += chunkSize;
1628
1629 sp<ABuffer> accessUnit = new ABuffer(offset);
1630 memcpy(accessUnit->data(), data, offset);
1631
1632 memmove(data, &data[offset], size - offset);
1633 size -= offset;
1634 mBuffer->setRange(0, size);
1635
1636 int64_t timeUs = fetchTimestamp(offset);
1637 if (timeUs < 0ll) {
1638 ALOGE("Negative timeus");
1639 return NULL;
1640 }
1641
1642 offset = 0;
1643
1644 accessUnit->meta()->setInt64("timeUs", timeUs);
1645 if (vopCodingType == 0) { // intra-coded VOP
1646 accessUnit->meta()->setInt32("isSync", 1);
1647 }
1648
1649 ALOGV("returning MPEG4 video access unit at time %" PRId64 " us",
1650 timeUs);
1651
1652 // hexdump(accessUnit->data(), accessUnit->size());
1653
1654 return accessUnit;
1655 } else if (chunkType != 0xb3) {
1656 offset += chunkSize;
1657 discard = true;
1658 }
1659
1660 break;
1661 }
1662
1663 default:
1664 ALOGE("Unknown state: %d", state);
1665 return NULL;
1666 }
1667
1668 if (discard) {
1669 (void)fetchTimestamp(offset);
1670 memmove(data, &data[offset], size - offset);
1671 size -= offset;
1672 offset = 0;
1673 mBuffer->setRange(0, size);
1674 } else {
1675 offset += chunkSize;
1676 }
1677 }
1678
1679 return NULL;
1680 }
1681
signalEOS()1682 void ElementaryStreamQueue::signalEOS() {
1683 if (!mEOSReached) {
1684 if (mMode == MPEG_VIDEO) {
1685 const char *theEnd = "\x00\x00\x01\x00";
1686 appendData(theEnd, 4, 0);
1687 }
1688 mEOSReached = true;
1689 } else {
1690 ALOGW("EOS already signaled");
1691 }
1692 }
1693
dequeueAccessUnitMetadata()1694 sp<ABuffer> ElementaryStreamQueue::dequeueAccessUnitMetadata() {
1695 size_t size = mBuffer->size();
1696 if (!size) {
1697 return NULL;
1698 }
1699
1700 sp<ABuffer> accessUnit = new ABuffer(size);
1701 int64_t timeUs = fetchTimestamp(size);
1702 accessUnit->meta()->setInt64("timeUs", timeUs);
1703
1704 memcpy(accessUnit->data(), mBuffer->data(), size);
1705 mBuffer->setRange(0, 0);
1706
1707 if (mFormat == NULL) {
1708 mFormat = new MetaData;
1709 mFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_DATA_TIMED_ID3);
1710 }
1711
1712 return accessUnit;
1713 }
1714
signalNewSampleAesKey(const sp<AMessage> & keyItem)1715 void ElementaryStreamQueue::signalNewSampleAesKey(const sp<AMessage> &keyItem) {
1716 if (mSampleDecryptor == NULL) {
1717 ALOGE("signalNewSampleAesKey: Stream %x is not encrypted; keyItem: %p",
1718 mMode, keyItem.get());
1719 return;
1720 }
1721
1722 mSampleDecryptor->signalNewSampleAesKey(keyItem);
1723 }
1724
1725
1726 } // namespace android
1727