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