1 /* 2 * Copyright (C) 2009 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 "Utils" 19 #include <utils/Log.h> 20 21 #include "include/ESDS.h" 22 23 #include <arpa/inet.h> 24 #include <cutils/properties.h> 25 #include <media/stagefright/foundation/ABuffer.h> 26 #include <media/stagefright/foundation/ADebug.h> 27 #include <media/stagefright/foundation/AMessage.h> 28 #include <media/stagefright/MetaData.h> 29 #include <media/stagefright/MediaDefs.h> 30 #include <media/AudioSystem.h> 31 #include <media/MediaPlayerInterface.h> 32 #include <hardware/audio.h> 33 #include <media/stagefright/Utils.h> 34 #include <media/AudioParameter.h> 35 36 namespace android { 37 38 uint16_t U16_AT(const uint8_t *ptr) { 39 return ptr[0] << 8 | ptr[1]; 40 } 41 42 uint32_t U32_AT(const uint8_t *ptr) { 43 return ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3]; 44 } 45 46 uint64_t U64_AT(const uint8_t *ptr) { 47 return ((uint64_t)U32_AT(ptr)) << 32 | U32_AT(ptr + 4); 48 } 49 50 uint16_t U16LE_AT(const uint8_t *ptr) { 51 return ptr[0] | (ptr[1] << 8); 52 } 53 54 uint32_t U32LE_AT(const uint8_t *ptr) { 55 return ptr[3] << 24 | ptr[2] << 16 | ptr[1] << 8 | ptr[0]; 56 } 57 58 uint64_t U64LE_AT(const uint8_t *ptr) { 59 return ((uint64_t)U32LE_AT(ptr + 4)) << 32 | U32LE_AT(ptr); 60 } 61 62 // XXX warning: these won't work on big-endian host. 63 uint64_t ntoh64(uint64_t x) { 64 return ((uint64_t)ntohl(x & 0xffffffff) << 32) | ntohl(x >> 32); 65 } 66 67 uint64_t hton64(uint64_t x) { 68 return ((uint64_t)htonl(x & 0xffffffff) << 32) | htonl(x >> 32); 69 } 70 71 status_t convertMetaDataToMessage( 72 const sp<MetaData> &meta, sp<AMessage> *format) { 73 format->clear(); 74 75 const char *mime; 76 CHECK(meta->findCString(kKeyMIMEType, &mime)); 77 78 sp<AMessage> msg = new AMessage; 79 msg->setString("mime", mime); 80 81 int64_t durationUs; 82 if (meta->findInt64(kKeyDuration, &durationUs)) { 83 msg->setInt64("durationUs", durationUs); 84 } 85 86 int32_t isSync; 87 if (meta->findInt32(kKeyIsSyncFrame, &isSync) && isSync != 0) { 88 msg->setInt32("is-sync-frame", 1); 89 } 90 91 if (!strncasecmp("video/", mime, 6)) { 92 int32_t width, height; 93 CHECK(meta->findInt32(kKeyWidth, &width)); 94 CHECK(meta->findInt32(kKeyHeight, &height)); 95 96 msg->setInt32("width", width); 97 msg->setInt32("height", height); 98 99 int32_t sarWidth, sarHeight; 100 if (meta->findInt32(kKeySARWidth, &sarWidth) 101 && meta->findInt32(kKeySARHeight, &sarHeight)) { 102 msg->setInt32("sar-width", sarWidth); 103 msg->setInt32("sar-height", sarHeight); 104 } 105 } else if (!strncasecmp("audio/", mime, 6)) { 106 int32_t numChannels, sampleRate; 107 CHECK(meta->findInt32(kKeyChannelCount, &numChannels)); 108 CHECK(meta->findInt32(kKeySampleRate, &sampleRate)); 109 110 msg->setInt32("channel-count", numChannels); 111 msg->setInt32("sample-rate", sampleRate); 112 113 int32_t channelMask; 114 if (meta->findInt32(kKeyChannelMask, &channelMask)) { 115 msg->setInt32("channel-mask", channelMask); 116 } 117 118 int32_t delay = 0; 119 if (meta->findInt32(kKeyEncoderDelay, &delay)) { 120 msg->setInt32("encoder-delay", delay); 121 } 122 int32_t padding = 0; 123 if (meta->findInt32(kKeyEncoderPadding, &padding)) { 124 msg->setInt32("encoder-padding", padding); 125 } 126 127 int32_t isADTS; 128 if (meta->findInt32(kKeyIsADTS, &isADTS)) { 129 msg->setInt32("is-adts", true); 130 } 131 } 132 133 int32_t maxInputSize; 134 if (meta->findInt32(kKeyMaxInputSize, &maxInputSize)) { 135 msg->setInt32("max-input-size", maxInputSize); 136 } 137 138 uint32_t type; 139 const void *data; 140 size_t size; 141 if (meta->findData(kKeyAVCC, &type, &data, &size)) { 142 // Parse the AVCDecoderConfigurationRecord 143 144 const uint8_t *ptr = (const uint8_t *)data; 145 146 CHECK(size >= 7); 147 CHECK_EQ((unsigned)ptr[0], 1u); // configurationVersion == 1 148 uint8_t profile = ptr[1]; 149 uint8_t level = ptr[3]; 150 151 // There is decodable content out there that fails the following 152 // assertion, let's be lenient for now... 153 // CHECK((ptr[4] >> 2) == 0x3f); // reserved 154 155 size_t lengthSize = 1 + (ptr[4] & 3); 156 157 // commented out check below as H264_QVGA_500_NO_AUDIO.3gp 158 // violates it... 159 // CHECK((ptr[5] >> 5) == 7); // reserved 160 161 size_t numSeqParameterSets = ptr[5] & 31; 162 163 ptr += 6; 164 size -= 6; 165 166 sp<ABuffer> buffer = new ABuffer(1024); 167 buffer->setRange(0, 0); 168 169 for (size_t i = 0; i < numSeqParameterSets; ++i) { 170 CHECK(size >= 2); 171 size_t length = U16_AT(ptr); 172 173 ptr += 2; 174 size -= 2; 175 176 CHECK(size >= length); 177 178 memcpy(buffer->data() + buffer->size(), "\x00\x00\x00\x01", 4); 179 memcpy(buffer->data() + buffer->size() + 4, ptr, length); 180 buffer->setRange(0, buffer->size() + 4 + length); 181 182 ptr += length; 183 size -= length; 184 } 185 186 buffer->meta()->setInt32("csd", true); 187 buffer->meta()->setInt64("timeUs", 0); 188 189 msg->setBuffer("csd-0", buffer); 190 191 buffer = new ABuffer(1024); 192 buffer->setRange(0, 0); 193 194 CHECK(size >= 1); 195 size_t numPictureParameterSets = *ptr; 196 ++ptr; 197 --size; 198 199 for (size_t i = 0; i < numPictureParameterSets; ++i) { 200 CHECK(size >= 2); 201 size_t length = U16_AT(ptr); 202 203 ptr += 2; 204 size -= 2; 205 206 CHECK(size >= length); 207 208 memcpy(buffer->data() + buffer->size(), "\x00\x00\x00\x01", 4); 209 memcpy(buffer->data() + buffer->size() + 4, ptr, length); 210 buffer->setRange(0, buffer->size() + 4 + length); 211 212 ptr += length; 213 size -= length; 214 } 215 216 buffer->meta()->setInt32("csd", true); 217 buffer->meta()->setInt64("timeUs", 0); 218 msg->setBuffer("csd-1", buffer); 219 } else if (meta->findData(kKeyESDS, &type, &data, &size)) { 220 ESDS esds((const char *)data, size); 221 CHECK_EQ(esds.InitCheck(), (status_t)OK); 222 223 const void *codec_specific_data; 224 size_t codec_specific_data_size; 225 esds.getCodecSpecificInfo( 226 &codec_specific_data, &codec_specific_data_size); 227 228 sp<ABuffer> buffer = new ABuffer(codec_specific_data_size); 229 230 memcpy(buffer->data(), codec_specific_data, 231 codec_specific_data_size); 232 233 buffer->meta()->setInt32("csd", true); 234 buffer->meta()->setInt64("timeUs", 0); 235 msg->setBuffer("csd-0", buffer); 236 } else if (meta->findData(kKeyVorbisInfo, &type, &data, &size)) { 237 sp<ABuffer> buffer = new ABuffer(size); 238 memcpy(buffer->data(), data, size); 239 240 buffer->meta()->setInt32("csd", true); 241 buffer->meta()->setInt64("timeUs", 0); 242 msg->setBuffer("csd-0", buffer); 243 244 if (!meta->findData(kKeyVorbisBooks, &type, &data, &size)) { 245 return -EINVAL; 246 } 247 248 buffer = new ABuffer(size); 249 memcpy(buffer->data(), data, size); 250 251 buffer->meta()->setInt32("csd", true); 252 buffer->meta()->setInt64("timeUs", 0); 253 msg->setBuffer("csd-1", buffer); 254 } 255 256 *format = msg; 257 258 return OK; 259 } 260 261 static size_t reassembleAVCC(const sp<ABuffer> &csd0, const sp<ABuffer> csd1, char *avcc) { 262 263 avcc[0] = 1; // version 264 avcc[1] = 0x64; // profile 265 avcc[2] = 0; // unused (?) 266 avcc[3] = 0xd; // level 267 avcc[4] = 0xff; // reserved+size 268 269 size_t i = 0; 270 int numparams = 0; 271 int lastparamoffset = 0; 272 int avccidx = 6; 273 do { 274 if (i >= csd0->size() - 4 || 275 memcmp(csd0->data() + i, "\x00\x00\x00\x01", 4) == 0) { 276 if (i >= csd0->size() - 4) { 277 // there can't be another param here, so use all the rest 278 i = csd0->size(); 279 } 280 ALOGV("block at %d, last was %d", i, lastparamoffset); 281 if (lastparamoffset > 0) { 282 int size = i - lastparamoffset; 283 avcc[avccidx++] = size >> 8; 284 avcc[avccidx++] = size & 0xff; 285 memcpy(avcc+avccidx, csd0->data() + lastparamoffset, size); 286 avccidx += size; 287 numparams++; 288 } 289 i += 4; 290 lastparamoffset = i; 291 } else { 292 i++; 293 } 294 } while(i < csd0->size()); 295 ALOGV("csd0 contains %d params", numparams); 296 297 avcc[5] = 0xe0 | numparams; 298 //and now csd-1 299 i = 0; 300 numparams = 0; 301 lastparamoffset = 0; 302 int numpicparamsoffset = avccidx; 303 avccidx++; 304 do { 305 if (i >= csd1->size() - 4 || 306 memcmp(csd1->data() + i, "\x00\x00\x00\x01", 4) == 0) { 307 if (i >= csd1->size() - 4) { 308 // there can't be another param here, so use all the rest 309 i = csd1->size(); 310 } 311 ALOGV("block at %d, last was %d", i, lastparamoffset); 312 if (lastparamoffset > 0) { 313 int size = i - lastparamoffset; 314 avcc[avccidx++] = size >> 8; 315 avcc[avccidx++] = size & 0xff; 316 memcpy(avcc+avccidx, csd1->data() + lastparamoffset, size); 317 avccidx += size; 318 numparams++; 319 } 320 i += 4; 321 lastparamoffset = i; 322 } else { 323 i++; 324 } 325 } while(i < csd1->size()); 326 avcc[numpicparamsoffset] = numparams; 327 return avccidx; 328 } 329 330 static void reassembleESDS(const sp<ABuffer> &csd0, char *esds) { 331 int csd0size = csd0->size(); 332 esds[0] = 3; // kTag_ESDescriptor; 333 int esdescriptorsize = 26 + csd0size; 334 CHECK(esdescriptorsize < 268435456); // 7 bits per byte, so max is 2^28-1 335 esds[1] = 0x80 | (esdescriptorsize >> 21); 336 esds[2] = 0x80 | ((esdescriptorsize >> 14) & 0x7f); 337 esds[3] = 0x80 | ((esdescriptorsize >> 7) & 0x7f); 338 esds[4] = (esdescriptorsize & 0x7f); 339 esds[5] = esds[6] = 0; // es id 340 esds[7] = 0; // flags 341 esds[8] = 4; // kTag_DecoderConfigDescriptor 342 int configdescriptorsize = 18 + csd0size; 343 esds[9] = 0x80 | (configdescriptorsize >> 21); 344 esds[10] = 0x80 | ((configdescriptorsize >> 14) & 0x7f); 345 esds[11] = 0x80 | ((configdescriptorsize >> 7) & 0x7f); 346 esds[12] = (configdescriptorsize & 0x7f); 347 esds[13] = 0x40; // objectTypeIndication 348 esds[14] = 0x15; // not sure what 14-25 mean, they are ignored by ESDS.cpp, 349 esds[15] = 0x00; // but the actual values here were taken from a real file. 350 esds[16] = 0x18; 351 esds[17] = 0x00; 352 esds[18] = 0x00; 353 esds[19] = 0x00; 354 esds[20] = 0xfa; 355 esds[21] = 0x00; 356 esds[22] = 0x00; 357 esds[23] = 0x00; 358 esds[24] = 0xfa; 359 esds[25] = 0x00; 360 esds[26] = 5; // kTag_DecoderSpecificInfo; 361 esds[27] = 0x80 | (csd0size >> 21); 362 esds[28] = 0x80 | ((csd0size >> 14) & 0x7f); 363 esds[29] = 0x80 | ((csd0size >> 7) & 0x7f); 364 esds[30] = (csd0size & 0x7f); 365 memcpy((void*)&esds[31], csd0->data(), csd0size); 366 // data following this is ignored, so don't bother appending it 367 368 } 369 370 void convertMessageToMetaData(const sp<AMessage> &msg, sp<MetaData> &meta) { 371 AString mime; 372 if (msg->findString("mime", &mime)) { 373 meta->setCString(kKeyMIMEType, mime.c_str()); 374 } else { 375 ALOGW("did not find mime type"); 376 } 377 378 int64_t durationUs; 379 if (msg->findInt64("durationUs", &durationUs)) { 380 meta->setInt64(kKeyDuration, durationUs); 381 } 382 383 int32_t isSync; 384 if (msg->findInt32("is-sync-frame", &isSync) && isSync != 0) { 385 meta->setInt32(kKeyIsSyncFrame, 1); 386 } 387 388 if (mime.startsWith("video/")) { 389 int32_t width; 390 int32_t height; 391 if (msg->findInt32("width", &width) && msg->findInt32("height", &height)) { 392 meta->setInt32(kKeyWidth, width); 393 meta->setInt32(kKeyHeight, height); 394 } else { 395 ALOGW("did not find width and/or height"); 396 } 397 398 int32_t sarWidth, sarHeight; 399 if (msg->findInt32("sar-width", &sarWidth) 400 && msg->findInt32("sar-height", &sarHeight)) { 401 meta->setInt32(kKeySARWidth, sarWidth); 402 meta->setInt32(kKeySARHeight, sarHeight); 403 } 404 } else if (mime.startsWith("audio/")) { 405 int32_t numChannels; 406 if (msg->findInt32("channel-count", &numChannels)) { 407 meta->setInt32(kKeyChannelCount, numChannels); 408 } 409 int32_t sampleRate; 410 if (msg->findInt32("sample-rate", &sampleRate)) { 411 meta->setInt32(kKeySampleRate, sampleRate); 412 } 413 int32_t channelMask; 414 if (msg->findInt32("channel-mask", &channelMask)) { 415 meta->setInt32(kKeyChannelMask, channelMask); 416 } 417 int32_t delay = 0; 418 if (msg->findInt32("encoder-delay", &delay)) { 419 meta->setInt32(kKeyEncoderDelay, delay); 420 } 421 int32_t padding = 0; 422 if (msg->findInt32("encoder-padding", &padding)) { 423 meta->setInt32(kKeyEncoderPadding, padding); 424 } 425 426 int32_t isADTS; 427 if (msg->findInt32("is-adts", &isADTS)) { 428 meta->setInt32(kKeyIsADTS, isADTS); 429 } 430 } 431 432 int32_t maxInputSize; 433 if (msg->findInt32("max-input-size", &maxInputSize)) { 434 meta->setInt32(kKeyMaxInputSize, maxInputSize); 435 } 436 437 // reassemble the csd data into its original form 438 sp<ABuffer> csd0; 439 if (msg->findBuffer("csd-0", &csd0)) { 440 if (mime.startsWith("video/")) { // do we need to be stricter than this? 441 sp<ABuffer> csd1; 442 if (msg->findBuffer("csd-1", &csd1)) { 443 char avcc[1024]; // that oughta be enough, right? 444 size_t outsize = reassembleAVCC(csd0, csd1, avcc); 445 meta->setData(kKeyAVCC, kKeyAVCC, avcc, outsize); 446 } 447 } else if (mime.startsWith("audio/")) { 448 int csd0size = csd0->size(); 449 char esds[csd0size + 31]; 450 reassembleESDS(csd0, esds); 451 meta->setData(kKeyESDS, kKeyESDS, esds, sizeof(esds)); 452 } 453 } 454 455 // XXX TODO add whatever other keys there are 456 457 #if 0 458 ALOGI("converted %s to:", msg->debugString(0).c_str()); 459 meta->dumpToLog(); 460 #endif 461 } 462 463 AString MakeUserAgent() { 464 AString ua; 465 ua.append("stagefright/1.2 (Linux;Android "); 466 467 #if (PROPERTY_VALUE_MAX < 8) 468 #error "PROPERTY_VALUE_MAX must be at least 8" 469 #endif 470 471 char value[PROPERTY_VALUE_MAX]; 472 property_get("ro.build.version.release", value, "Unknown"); 473 ua.append(value); 474 ua.append(")"); 475 476 return ua; 477 } 478 479 status_t sendMetaDataToHal(sp<MediaPlayerBase::AudioSink>& sink, 480 const sp<MetaData>& meta) 481 { 482 int32_t sampleRate = 0; 483 int32_t bitRate = 0; 484 int32_t channelMask = 0; 485 int32_t delaySamples = 0; 486 int32_t paddingSamples = 0; 487 488 AudioParameter param = AudioParameter(); 489 490 if (meta->findInt32(kKeySampleRate, &sampleRate)) { 491 param.addInt(String8(AUDIO_OFFLOAD_CODEC_SAMPLE_RATE), sampleRate); 492 } 493 if (meta->findInt32(kKeyChannelMask, &channelMask)) { 494 param.addInt(String8(AUDIO_OFFLOAD_CODEC_NUM_CHANNEL), channelMask); 495 } 496 if (meta->findInt32(kKeyBitRate, &bitRate)) { 497 param.addInt(String8(AUDIO_OFFLOAD_CODEC_AVG_BIT_RATE), bitRate); 498 } 499 if (meta->findInt32(kKeyEncoderDelay, &delaySamples)) { 500 param.addInt(String8(AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES), delaySamples); 501 } 502 if (meta->findInt32(kKeyEncoderPadding, &paddingSamples)) { 503 param.addInt(String8(AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES), paddingSamples); 504 } 505 506 ALOGV("sendMetaDataToHal: bitRate %d, sampleRate %d, chanMask %d," 507 "delaySample %d, paddingSample %d", bitRate, sampleRate, 508 channelMask, delaySamples, paddingSamples); 509 510 sink->setParameters(param.toString()); 511 return OK; 512 } 513 514 struct mime_conv_t { 515 const char* mime; 516 audio_format_t format; 517 }; 518 519 static const struct mime_conv_t mimeLookup[] = { 520 { MEDIA_MIMETYPE_AUDIO_MPEG, AUDIO_FORMAT_MP3 }, 521 { MEDIA_MIMETYPE_AUDIO_RAW, AUDIO_FORMAT_PCM_16_BIT }, 522 { MEDIA_MIMETYPE_AUDIO_AMR_NB, AUDIO_FORMAT_AMR_NB }, 523 { MEDIA_MIMETYPE_AUDIO_AMR_WB, AUDIO_FORMAT_AMR_WB }, 524 { MEDIA_MIMETYPE_AUDIO_AAC, AUDIO_FORMAT_AAC }, 525 { MEDIA_MIMETYPE_AUDIO_VORBIS, AUDIO_FORMAT_VORBIS }, 526 { 0, AUDIO_FORMAT_INVALID } 527 }; 528 529 status_t mapMimeToAudioFormat( audio_format_t& format, const char* mime ) 530 { 531 const struct mime_conv_t* p = &mimeLookup[0]; 532 while (p->mime != NULL) { 533 if (0 == strcasecmp(mime, p->mime)) { 534 format = p->format; 535 return OK; 536 } 537 ++p; 538 } 539 540 return BAD_VALUE; 541 } 542 543 bool canOffloadStream(const sp<MetaData>& meta, bool hasVideo, bool isStreaming) 544 { 545 const char *mime; 546 CHECK(meta->findCString(kKeyMIMEType, &mime)); 547 548 audio_offload_info_t info = AUDIO_INFO_INITIALIZER; 549 550 info.format = AUDIO_FORMAT_INVALID; 551 if (mapMimeToAudioFormat(info.format, mime) != OK) { 552 ALOGE(" Couldn't map mime type \"%s\" to a valid AudioSystem::audio_format !", mime); 553 return false; 554 } else { 555 ALOGV("Mime type \"%s\" mapped to audio_format %d", mime, info.format); 556 } 557 558 if (AUDIO_FORMAT_INVALID == info.format) { 559 // can't offload if we don't know what the source format is 560 ALOGE("mime type \"%s\" not a known audio format", mime); 561 return false; 562 } 563 564 int32_t srate = -1; 565 if (!meta->findInt32(kKeySampleRate, &srate)) { 566 ALOGV("track of type '%s' does not publish sample rate", mime); 567 } 568 info.sample_rate = srate; 569 570 int32_t cmask = 0; 571 if (!meta->findInt32(kKeyChannelMask, &cmask)) { 572 ALOGV("track of type '%s' does not publish channel mask", mime); 573 574 // Try a channel count instead 575 int32_t channelCount; 576 if (!meta->findInt32(kKeyChannelCount, &channelCount)) { 577 ALOGV("track of type '%s' does not publish channel count", mime); 578 } else { 579 cmask = audio_channel_out_mask_from_count(channelCount); 580 } 581 } 582 info.channel_mask = cmask; 583 584 int64_t duration = 0; 585 if (!meta->findInt64(kKeyDuration, &duration)) { 586 ALOGV("track of type '%s' does not publish duration", mime); 587 } 588 info.duration_us = duration; 589 590 int32_t brate = -1; 591 if (!meta->findInt32(kKeyBitRate, &brate)) { 592 ALOGV("track of type '%s' does not publish bitrate", mime); 593 } 594 info.bit_rate = brate; 595 596 597 info.stream_type = AUDIO_STREAM_MUSIC; 598 info.has_video = hasVideo; 599 info.is_streaming = isStreaming; 600 601 // Check if offload is possible for given format, stream type, sample rate, 602 // bit rate, duration, video and streaming 603 return AudioSystem::isOffloadSupported(info); 604 } 605 606 } // namespace android 607 608