utils/codec_utils.cpp

   1 /*
   2  * Copyright 2012 Michael Chen <omxcodec@gmail.com>
   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 "codec_utils"
  19 #include <utils/Log.h>
  20
  21 #ifdef __cplusplus
  22 extern "C" {
  23 #endif
  24
  25 #include "config.h"
  26 #include "libavcodec/xiph.h"
  27 #include "libavutil/intreadwrite.h"
  28
  29 #ifdef __cplusplus
  30 }
  31 #endif
  32
  33 #include <utils/Errors.h>
  34 #include <media/stagefright/foundation/ADebug.h>
  35 #include <media/stagefright/MediaDefs.h>
  36 #include <media/stagefright/MediaErrors.h>
  37 #include <media/stagefright/MetaData.h>
  38 #include "include/avc_utils.h"
  39
  40 #include "codec_utils.h"
  41
  42 namespace android {
  43
  44 static void EncodeSize14(uint8_t **_ptr, size_t size) {
  45     CHECK_LE(size, 0x3fff);
  46
  47     uint8_t *ptr = *_ptr;
  48
  49     *ptr++ = 0x80 | (size >> 7);
  50     *ptr++ = size & 0x7f;
  51
  52     *_ptr = ptr;
  53 }
  54
  55 static sp<ABuffer> MakeMPEGVideoESDS(const sp<ABuffer> &csd) {
  56     sp<ABuffer> esds = new ABuffer(csd->size() + 25);
  57
  58     uint8_t *ptr = esds->data();
  59     *ptr++ = 0x03;
  60     EncodeSize14(&ptr, 22 + csd->size());
  61
  62     *ptr++ = 0x00;  // ES_ID
  63     *ptr++ = 0x00;
  64
  65     *ptr++ = 0x00;  // streamDependenceFlag, URL_Flag, OCRstreamFlag
  66
  67     *ptr++ = 0x04;
  68     EncodeSize14(&ptr, 16 + csd->size());
  69
  70     *ptr++ = 0x40;  // Audio ISO/IEC 14496-3
  71
  72     for (size_t i = 0; i < 12; ++i) {
  73         *ptr++ = 0x00;
  74     }
  75
  76     *ptr++ = 0x05;
  77     EncodeSize14(&ptr, csd->size());
  78
  79     memcpy(ptr, csd->data(), csd->size());
  80
  81     return esds;
  82 }
  83
  84 //Returns the sample rate based on the sampling frequency index
  85 static uint32_t getAACSampleRate(const uint8_t sf_index)
  86 {
  87     static const uint32_t sample_rates[] =
  88     {
  89         96000, 88200, 64000, 48000, 44100, 32000,
  90         24000, 22050, 16000, 12000, 11025, 8000
  91     };
  92
  93     if (sf_index < sizeof(sample_rates) / sizeof(sample_rates[0])) {
  94         return sample_rates[sf_index];
  95     }
  96
  97     return 0;
  98 }
  99
 100 //video
 101
 102 //H.264 Video Types
 103 //http://msdn.microsoft.com/en-us/library/dd757808(v=vs.85).aspx
 104
 105 // H.264 bitstream without start codes.
 106 sp<MetaData> setAVCFormat(AVCodecContext *avctx)
 107 {
 108     ALOGV("AVC");
 109
 110     CHECK_EQ(avctx->codec_id, AV_CODEC_ID_H264);
 111     CHECK_GT(avctx->extradata_size, 0);
 112     CHECK_EQ(avctx->extradata[0], 1); //configurationVersion
 113
 114     if (avctx->width == 0 || avctx->height == 0) {
 115          int32_t width, height;
 116          sp<ABuffer> seqParamSet = new ABuffer(avctx->extradata_size - 8);
 117          memcpy(seqParamSet->data(), avctx->extradata + 8, avctx->extradata_size - 8);
 118          FindAVCDimensions(seqParamSet, &width, &height);
 119          avctx->width  = width;
 120          avctx->height = height;
 121      }
 122
 123     sp<MetaData> meta = new MetaData;
 124     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
 125     meta->setData(kKeyAVCC, kTypeAVCC, avctx->extradata, avctx->extradata_size);
 126
 127     return meta;
 128 }
 129
 130 // H.264 bitstream with start codes.
 131 sp<MetaData> setH264Format(AVCodecContext *avctx)
 132 {
 133     ALOGV("H264");
 134
 135     CHECK_EQ(avctx->codec_id, AV_CODEC_ID_H264);
 136     CHECK_NE(avctx->extradata[0], 1); //configurationVersion
 137
 138     sp<ABuffer> buffer = new ABuffer(avctx->extradata_size);
 139     memcpy(buffer->data(), avctx->extradata, avctx->extradata_size);
 140     return MakeAVCCodecSpecificData(buffer);
 141 }
 142
 143 sp<MetaData> setMPEG4Format(AVCodecContext *avctx)
 144 {
 145     ALOGV("MPEG4");
 146
 147     sp<ABuffer> csd = new ABuffer(avctx->extradata_size);
 148     memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
 149     sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
 150
 151     sp<MetaData> meta = new MetaData;
 152     meta->setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
 153
 154     int divxVersion = getDivXVersion(avctx);
 155     if (divxVersion >= 0) {
 156         meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_DIVX);
 157         meta->setInt32(kKeyDivXVersion, divxVersion);
 158     } else {
 159         meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
 160     }
 161     return meta;
 162 }
 163
 164 sp<MetaData> setH263Format(AVCodecContext *avctx __unused)
 165 {
 166     ALOGV("H263");
 167
 168     sp<MetaData> meta = new MetaData;
 169     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
 170
 171     return meta;
 172 }
 173
 174 sp<MetaData> setMPEG2VIDEOFormat(AVCodecContext *avctx)
 175 {
 176     ALOGV("MPEG%uVIDEO", avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 2 : 1);
 177
 178     sp<ABuffer> csd = new ABuffer(avctx->extradata_size);
 179     memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
 180     sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
 181
 182     sp<MetaData> meta = new MetaData;
 183     meta->setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
 184     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
 185
 186     return meta;
 187 }
 188
 189 sp<MetaData> setVC1Format(AVCodecContext *avctx)
 190 {
 191     ALOGV("VC1");
 192
 193     sp<MetaData> meta = new MetaData;
 194     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VC1);
 195     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 196
 197     return meta;
 198 }
 199
 200 sp<MetaData> setWMV1Format(AVCodecContext *avctx __unused)
 201 {
 202     ALOGV("WMV1");
 203
 204     sp<MetaData> meta = new MetaData;
 205     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
 206     meta->setInt32(kKeyWMVVersion, kTypeWMVVer_7);
 207
 208     return meta;
 209 }
 210
 211 sp<MetaData> setWMV2Format(AVCodecContext *avctx)
 212 {
 213     ALOGV("WMV2");
 214
 215     sp<MetaData> meta = new MetaData;
 216     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
 217     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 218     meta->setInt32(kKeyWMVVersion, kTypeWMVVer_8);
 219
 220     return meta;
 221 }
 222
 223 sp<MetaData> setWMV3Format(AVCodecContext *avctx)
 224 {
 225     ALOGV("WMV3");
 226
 227     sp<MetaData> meta = new MetaData;
 228     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
 229     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 230     meta->setInt32(kKeyWMVVersion, kTypeWMVVer_9);
 231
 232     return meta;
 233 }
 234
 235 sp<MetaData> setRV20Format(AVCodecContext *avctx)
 236 {
 237     ALOGV("RV20");
 238
 239     sp<MetaData> meta = new MetaData;
 240     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
 241     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 242     meta->setInt32(kKeyRVVersion, kTypeRVVer_G2); //http://en.wikipedia.org/wiki/RealVide
 243
 244     return meta;
 245 }
 246
 247 sp<MetaData> setRV30Format(AVCodecContext *avctx)
 248 {
 249     ALOGV("RV30");
 250
 251     sp<MetaData> meta = new MetaData;
 252     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
 253     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 254     meta->setInt32(kKeyRVVersion, kTypeRVVer_8); //http://en.wikipedia.org/wiki/RealVide
 255
 256     return meta;
 257 }
 258
 259 sp<MetaData> setRV40Format(AVCodecContext *avctx)
 260 {
 261     ALOGV("RV40");
 262
 263     sp<MetaData> meta = new MetaData;
 264     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
 265     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 266     meta->setInt32(kKeyRVVersion, kTypeRVVer_9); //http://en.wikipedia.org/wiki/RealVide
 267
 268     return meta;
 269 }
 270
 271 sp<MetaData> setFLV1Format(AVCodecContext *avctx)
 272 {
 273     ALOGV("FLV1(Sorenson H263)");
 274
 275     sp<MetaData> meta = new MetaData;
 276     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FLV1);
 277     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 278
 279     return meta;
 280 }
 281
 282 sp<MetaData> setHEVCFormat(AVCodecContext *avctx)
 283 {
 284     ALOGV("HEVC");
 285
 286     sp<MetaData> meta = new MetaData;
 287     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_HEVC);
 288     meta->setData(kKeyHVCC, 0, avctx->extradata, avctx->extradata_size);
 289
 290     return meta;
 291 }
 292
 293 sp<MetaData> setVP8Format(AVCodecContext *avctx __unused)
 294 {
 295     ALOGV("VP8");
 296
 297     sp<MetaData> meta = new MetaData;
 298     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP8);
 299
 300     return meta;
 301 }
 302
 303 sp<MetaData> setVP9Format(AVCodecContext *avctx __unused)
 304 {
 305     ALOGV("VP9");
 306
 307     sp<MetaData> meta = new MetaData;
 308     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP9);
 309
 310     return meta;
 311 }
 312
 313 //audio
 314
 315 sp<MetaData> setMP2Format(AVCodecContext *avctx __unused)
 316 {
 317     ALOGV("MP2");
 318
 319     sp<MetaData> meta = new MetaData;
 320     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
 321
 322     return meta;
 323 }
 324
 325 sp<MetaData> setMP3Format(AVCodecContext *avctx __unused)
 326 {
 327     ALOGV("MP3");
 328
 329     sp<MetaData> meta = new MetaData;
 330     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
 331
 332     return meta;
 333 }
 334
 335 sp<MetaData> setVORBISFormat(AVCodecContext *avctx)
 336 {
 337     ALOGV("VORBIS");
 338
 339     const uint8_t *header_start[3];
 340     int header_len[3];
 341     if (avpriv_split_xiph_headers(avctx->extradata,
 342                 avctx->extradata_size, 30,
 343                 header_start, header_len) < 0) {
 344         ALOGE("vorbis extradata corrupt.");
 345         return NULL;
 346     }
 347
 348     sp<MetaData> meta = new MetaData;
 349     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS);
 350     //identification header
 351     meta->setData(kKeyVorbisInfo,  0, header_start[0], header_len[0]);
 352     //setup header
 353     meta->setData(kKeyVorbisBooks, 0, header_start[2], header_len[2]);
 354
 355     return meta;
 356 }
 357
 358 sp<MetaData> setAC3Format(AVCodecContext *avctx __unused)
 359 {
 360     ALOGV("AC3");
 361
 362     sp<MetaData> meta = new MetaData;
 363     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
 364
 365     return meta;
 366 }
 367
 368 sp<MetaData> setAACFormat(AVCodecContext *avctx)
 369 {
 370     ALOGV("AAC");
 371
 372     uint32_t sr;
 373     const uint8_t *header;
 374     uint8_t profile, sf_index, channel;
 375
 376     header = avctx->extradata;
 377     CHECK(header != NULL);
 378
 379     // AudioSpecificInfo follows
 380     // oooo offf fccc c000
 381     // o - audioObjectType
 382     // f - samplingFreqIndex
 383     // c - channelConfig
 384     profile = ((header[0] & 0xf8) >> 3) - 1;
 385     sf_index = (header[0] & 0x07) << 1 | (header[1] & 0x80) >> 7;
 386     sr = getAACSampleRate(sf_index);
 387     if (sr == 0) {
 388         ALOGE("unsupport the aac sample rate");
 389         return NULL;
 390     }
 391     channel = (header[1] >> 3) & 0xf;
 392     ALOGV("aac profile: %d, sf_index: %d, channel: %d", profile, sf_index, channel);
 393
 394     sp<MetaData> meta = MakeAACCodecSpecificData(profile, sf_index, channel);
 395     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
 396     meta->setInt32(kKeyAACAOT, profile);
 397     return meta;
 398 }
 399
 400 sp<MetaData> setWMAV1Format(AVCodecContext *avctx)
 401 {
 402     ALOGV("WMAV1");
 403
 404     sp<MetaData> meta = new MetaData;
 405     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 406     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 407     meta->setInt32(kKeyWMAVersion, kTypeWMA); //FIXME version?
 408
 409     return meta;
 410 }
 411
 412 sp<MetaData> setWMAV2Format(AVCodecContext *avctx)
 413 {
 414     ALOGV("WMAV2");
 415
 416     sp<MetaData> meta = new MetaData;
 417     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 418     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 419     meta->setInt32(kKeyWMAVersion, kTypeWMA);
 420
 421     return meta;
 422 }
 423
 424 sp<MetaData> setWMAProFormat(AVCodecContext *avctx)
 425 {
 426     ALOGV("WMAPro");
 427
 428     sp<MetaData> meta = new MetaData;
 429     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 430     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 431     meta->setInt32(kKeyWMAVersion, kTypeWMAPro);
 432
 433     return meta;
 434 }
 435
 436 sp<MetaData> setWMALossLessFormat(AVCodecContext *avctx)
 437 {
 438     ALOGV("WMALOSSLESS");
 439
 440     sp<MetaData> meta = new MetaData;
 441     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 442     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 443     meta->setInt32(kKeyWMAVersion, kTypeWMALossLess);
 444
 445     return meta;
 446 }
 447
 448 sp<MetaData> setRAFormat(AVCodecContext *avctx)
 449 {
 450     ALOGV("COOK");
 451
 452     sp<MetaData> meta = new MetaData;
 453     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RA);
 454     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 455
 456     return meta;
 457 }
 458
 459 sp<MetaData> setAPEFormat(AVCodecContext *avctx)
 460 {
 461     ALOGV("APE");
 462
 463     sp<MetaData> meta = new MetaData;
 464     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_APE);
 465     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 466
 467     return meta;
 468 }
 469
 470 sp<MetaData> setDTSFormat(AVCodecContext *avctx)
 471 {
 472     ALOGV("DTS");
 473
 474     sp<MetaData> meta = new MetaData;
 475     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_DTS);
 476     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 477
 478     return meta;
 479 }
 480
 481 sp<MetaData> setFLACFormat(AVCodecContext *avctx)
 482 {
 483     ALOGV("FLAC");
 484
 485     sp<MetaData> meta = new MetaData;
 486     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC);
 487     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 488
 489     return meta;
 490 }
 491
 492 //Convert H.264 NAL format to annex b
 493 status_t convertNal2AnnexB(uint8_t *dst, size_t dst_size,
 494         uint8_t *src, size_t src_size, size_t nal_len_size)
 495 {
 496     size_t i = 0;
 497     size_t nal_len = 0;
 498     status_t status = OK;
 499
 500     CHECK_EQ(dst_size, src_size);
 501     CHECK(nal_len_size == 3 || nal_len_size == 4);
 502
 503     while (src_size >= nal_len_size) {
 504         nal_len = 0;
 505         for( i = 0; i < nal_len_size; i++ ) {
 506             nal_len = (nal_len << 8) | src[i];
 507             dst[i] = 0;
 508         }
 509         dst[nal_len_size - 1] = 1;
 510         if (nal_len > INT_MAX || nal_len > src_size) {
 511             status = ERROR_MALFORMED;
 512             break;
 513         }
 514         dst += nal_len_size;
 515         src += nal_len_size;
 516         src_size -= nal_len_size;
 517
 518         memcpy(dst, src, nal_len);
 519
 520         dst += nal_len;
 521         src += nal_len;
 522         src_size -= nal_len;
 523     }
 524
 525     return status;
 526 }
 527
 528 int getDivXVersion(AVCodecContext *avctx)
 529 {
 530     if (avctx->codec_tag == AV_RL32("DIV3")
 531             || avctx->codec_tag == AV_RL32("div3")
 532             || avctx->codec_tag == AV_RL32("DIV4")
 533             || avctx->codec_tag == AV_RL32("div4")) {
 534         return kTypeDivXVer_3_11;
 535     }
 536     if (avctx->codec_tag == AV_RL32("DIVX")
 537             || avctx->codec_tag == AV_RL32("divx")) {
 538         return kTypeDivXVer_4;
 539     }
 540     if (avctx->codec_tag == AV_RL32("DX50")
 541            || avctx->codec_tag == AV_RL32("dx50")) {
 542         return kTypeDivXVer_5;
 543     }
 544     return -1;
 545 }
 546
 547 }  // namespace android
 548