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 //video
  86
  87 //H.264 Video Types
  88 //http://msdn.microsoft.com/en-us/library/dd757808(v=vs.85).aspx
  89
  90 // H.264 bitstream without start codes.
  91 sp<MetaData> setAVCFormat(AVCodecContext *avctx)
  92 {
  93     ALOGV("AVC");
  94
  95     CHECK_EQ(avctx->codec_id, AV_CODEC_ID_H264);
  96     CHECK_GT(avctx->extradata_size, 0);
  97     CHECK_EQ(avctx->extradata[0], 1); //configurationVersion
  98
  99     if (avctx->width == 0 || avctx->height == 0) {
 100          int32_t width, height;
 101          sp<ABuffer> seqParamSet = new ABuffer(avctx->extradata_size - 8);
 102          memcpy(seqParamSet->data(), avctx->extradata + 8, avctx->extradata_size - 8);
 103          FindAVCDimensions(seqParamSet, &width, &height);
 104          avctx->width  = width;
 105          avctx->height = height;
 106      }
 107
 108     sp<MetaData> meta = new MetaData;
 109     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
 110     meta->setData(kKeyAVCC, kTypeAVCC, avctx->extradata, avctx->extradata_size);
 111
 112     return meta;
 113 }
 114
 115 // H.264 bitstream with start codes.
 116 sp<MetaData> setH264Format(AVCodecContext *avctx)
 117 {
 118     ALOGV("H264");
 119
 120     CHECK_EQ(avctx->codec_id, AV_CODEC_ID_H264);
 121     CHECK_NE(avctx->extradata[0], 1); //configurationVersion
 122
 123     sp<ABuffer> buffer = new ABuffer(avctx->extradata_size);
 124     memcpy(buffer->data(), avctx->extradata, avctx->extradata_size);
 125     return MakeAVCCodecSpecificData(buffer);
 126 }
 127
 128 sp<MetaData> setMPEG4Format(AVCodecContext *avctx)
 129 {
 130     ALOGV("MPEG4");
 131
 132     sp<ABuffer> csd = new ABuffer(avctx->extradata_size);
 133     memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
 134     sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
 135
 136     sp<MetaData> meta = new MetaData;
 137     meta->setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
 138
 139     int divxVersion = getDivXVersion(avctx);
 140     if (divxVersion >= 0) {
 141         meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_DIVX);
 142         meta->setInt32(kKeyDivXVersion, divxVersion);
 143     } else {
 144         meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
 145     }
 146     return meta;
 147 }
 148
 149 sp<MetaData> setH263Format(AVCodecContext *avctx __unused)
 150 {
 151     ALOGV("H263");
 152
 153     sp<MetaData> meta = new MetaData;
 154     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
 155
 156     return meta;
 157 }
 158
 159 sp<MetaData> setMPEG2VIDEOFormat(AVCodecContext *avctx)
 160 {
 161     ALOGV("MPEG%uVIDEO", avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 2 : 1);
 162
 163     sp<ABuffer> csd = new ABuffer(avctx->extradata_size);
 164     memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
 165     sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
 166
 167     sp<MetaData> meta = new MetaData;
 168     meta->setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
 169     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
 170
 171     return meta;
 172 }
 173
 174 sp<MetaData> setVC1Format(AVCodecContext *avctx)
 175 {
 176     ALOGV("VC1");
 177
 178     sp<MetaData> meta = new MetaData;
 179     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VC1);
 180     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 181
 182     return meta;
 183 }
 184
 185 sp<MetaData> setWMV1Format(AVCodecContext *avctx __unused)
 186 {
 187     ALOGV("WMV1");
 188
 189     sp<MetaData> meta = new MetaData;
 190     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
 191     meta->setInt32(kKeyWMVVersion, kTypeWMVVer_7);
 192
 193     return meta;
 194 }
 195
 196 sp<MetaData> setWMV2Format(AVCodecContext *avctx)
 197 {
 198     ALOGV("WMV2");
 199
 200     sp<MetaData> meta = new MetaData;
 201     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
 202     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 203     meta->setInt32(kKeyWMVVersion, kTypeWMVVer_8);
 204
 205     return meta;
 206 }
 207
 208 sp<MetaData> setWMV3Format(AVCodecContext *avctx)
 209 {
 210     ALOGV("WMV3");
 211
 212     sp<MetaData> meta = new MetaData;
 213     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
 214     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 215     meta->setInt32(kKeyWMVVersion, kTypeWMVVer_9);
 216
 217     return meta;
 218 }
 219
 220 sp<MetaData> setRV20Format(AVCodecContext *avctx)
 221 {
 222     ALOGV("RV20");
 223
 224     sp<MetaData> meta = new MetaData;
 225     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
 226     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 227     meta->setInt32(kKeyRVVersion, kTypeRVVer_G2); //http://en.wikipedia.org/wiki/RealVide
 228
 229     return meta;
 230 }
 231
 232 sp<MetaData> setRV30Format(AVCodecContext *avctx)
 233 {
 234     ALOGV("RV30");
 235
 236     sp<MetaData> meta = new MetaData;
 237     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
 238     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 239     meta->setInt32(kKeyRVVersion, kTypeRVVer_8); //http://en.wikipedia.org/wiki/RealVide
 240
 241     return meta;
 242 }
 243
 244 sp<MetaData> setRV40Format(AVCodecContext *avctx)
 245 {
 246     ALOGV("RV40");
 247
 248     sp<MetaData> meta = new MetaData;
 249     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
 250     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 251     meta->setInt32(kKeyRVVersion, kTypeRVVer_9); //http://en.wikipedia.org/wiki/RealVide
 252
 253     return meta;
 254 }
 255
 256 sp<MetaData> setFLV1Format(AVCodecContext *avctx)
 257 {
 258     ALOGV("FLV1(Sorenson H263)");
 259
 260     sp<MetaData> meta = new MetaData;
 261     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FLV1);
 262     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 263
 264     return meta;
 265 }
 266
 267 sp<MetaData> setHEVCFormat(AVCodecContext *avctx)
 268 {
 269     ALOGV("HEVC");
 270
 271     sp<MetaData> meta = new MetaData;
 272     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_HEVC);
 273     meta->setData(kKeyHVCC, kTypeHVCC, avctx->extradata, avctx->extradata_size);
 274
 275     return meta;
 276 }
 277
 278 sp<MetaData> setVP8Format(AVCodecContext *avctx __unused)
 279 {
 280     ALOGV("VP8");
 281
 282     sp<MetaData> meta = new MetaData;
 283     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP8);
 284
 285     return meta;
 286 }
 287
 288 sp<MetaData> setVP9Format(AVCodecContext *avctx __unused)
 289 {
 290     ALOGV("VP9");
 291
 292     sp<MetaData> meta = new MetaData;
 293     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP9);
 294
 295     return meta;
 296 }
 297
 298 //audio
 299
 300 sp<MetaData> setMP2Format(AVCodecContext *avctx __unused)
 301 {
 302     ALOGV("MP2");
 303
 304     sp<MetaData> meta = new MetaData;
 305     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
 306
 307     return meta;
 308 }
 309
 310 sp<MetaData> setMP3Format(AVCodecContext *avctx __unused)
 311 {
 312     ALOGV("MP3");
 313
 314     sp<MetaData> meta = new MetaData;
 315     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
 316
 317     return meta;
 318 }
 319
 320 sp<MetaData> setVORBISFormat(AVCodecContext *avctx)
 321 {
 322     ALOGV("VORBIS");
 323
 324     const uint8_t *header_start[3];
 325     int header_len[3];
 326     if (avpriv_split_xiph_headers(avctx->extradata,
 327                 avctx->extradata_size, 30,
 328                 header_start, header_len) < 0) {
 329         ALOGE("vorbis extradata corrupt.");
 330         return NULL;
 331     }
 332
 333     sp<MetaData> meta = new MetaData;
 334     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS);
 335     //identification header
 336     meta->setData(kKeyVorbisInfo,  0, header_start[0], header_len[0]);
 337     //setup header
 338     meta->setData(kKeyVorbisBooks, 0, header_start[2], header_len[2]);
 339
 340     return meta;
 341 }
 342
 343 sp<MetaData> setAC3Format(AVCodecContext *avctx __unused)
 344 {
 345     ALOGV("AC3");
 346
 347     sp<MetaData> meta = new MetaData;
 348     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
 349
 350     return meta;
 351 }
 352
 353 sp<MetaData> setAACFormat(AVCodecContext *avctx)
 354 {
 355     ALOGV("AAC");
 356
 357     sp<MetaData> meta = new MetaData;
 358     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
 359     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 360     meta->setInt32(kKeyAACAOT, avctx->profile + 1);
 361     return meta;
 362 }
 363
 364 sp<MetaData> setWMAV1Format(AVCodecContext *avctx)
 365 {
 366     ALOGV("WMAV1");
 367
 368     sp<MetaData> meta = new MetaData;
 369     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 370     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 371     meta->setInt32(kKeyWMAVersion, kTypeWMA); //FIXME version?
 372
 373     return meta;
 374 }
 375
 376 sp<MetaData> setWMAV2Format(AVCodecContext *avctx)
 377 {
 378     ALOGV("WMAV2");
 379
 380     sp<MetaData> meta = new MetaData;
 381     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 382     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 383     meta->setInt32(kKeyWMAVersion, kTypeWMA);
 384
 385     return meta;
 386 }
 387
 388 sp<MetaData> setWMAProFormat(AVCodecContext *avctx)
 389 {
 390     ALOGV("WMAPro");
 391
 392     sp<MetaData> meta = new MetaData;
 393     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 394     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 395     meta->setInt32(kKeyWMAVersion, kTypeWMAPro);
 396
 397     return meta;
 398 }
 399
 400 sp<MetaData> setWMALossLessFormat(AVCodecContext *avctx)
 401 {
 402     ALOGV("WMALOSSLESS");
 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, kTypeWMALossLess);
 408
 409     return meta;
 410 }
 411
 412 sp<MetaData> setRAFormat(AVCodecContext *avctx)
 413 {
 414     ALOGV("COOK");
 415
 416     sp<MetaData> meta = new MetaData;
 417     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RA);
 418     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 419
 420     return meta;
 421 }
 422
 423 sp<MetaData> setALACFormat(AVCodecContext *avctx)
 424 {
 425     ALOGV("ALAC");
 426
 427     sp<MetaData> meta = new MetaData;
 428     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_ALAC);
 429     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 430
 431     return meta;
 432 }
 433
 434 sp<MetaData> setAPEFormat(AVCodecContext *avctx)
 435 {
 436     ALOGV("APE");
 437
 438     sp<MetaData> meta = new MetaData;
 439     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_APE);
 440     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 441
 442     return meta;
 443 }
 444
 445 sp<MetaData> setDTSFormat(AVCodecContext *avctx)
 446 {
 447     ALOGV("DTS");
 448
 449     sp<MetaData> meta = new MetaData;
 450     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_DTS);
 451     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 452
 453     return meta;
 454 }
 455
 456 sp<MetaData> setFLACFormat(AVCodecContext *avctx)
 457 {
 458     ALOGV("FLAC");
 459
 460     sp<MetaData> meta = new MetaData;
 461     meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC);
 462     meta->setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 463
 464     if (avctx->extradata_size < 10) {
 465         ALOGE("Invalid extradata in FLAC file! (size=%d)", avctx->extradata_size);
 466         return meta;
 467     }
 468
 469     ABitReader br(avctx->extradata, avctx->extradata_size);
 470     int32_t minBlockSize = br.getBits(16);
 471     int32_t maxBlockSize = br.getBits(16);
 472     int32_t minFrameSize = br.getBits(24);
 473     int32_t maxFrameSize = br.getBits(24);
 474
 475     meta->setInt32('mibs', minBlockSize);
 476     meta->setInt32('mabs', maxBlockSize);
 477     meta->setInt32('mifs', minFrameSize);
 478     meta->setInt32('mafs', maxFrameSize);
 479
 480     return meta;
 481 }
 482
 483 //Convert H.264 NAL format to annex b
 484 status_t convertNal2AnnexB(uint8_t *dst, size_t dst_size,
 485         uint8_t *src, size_t src_size, size_t nal_len_size)
 486 {
 487     size_t i = 0;
 488     size_t nal_len = 0;
 489     status_t status = OK;
 490
 491     CHECK_EQ(dst_size, src_size);
 492     CHECK(nal_len_size == 3 || nal_len_size == 4);
 493
 494     while (src_size >= nal_len_size) {
 495         nal_len = 0;
 496         for( i = 0; i < nal_len_size; i++ ) {
 497             nal_len = (nal_len << 8) | src[i];
 498             dst[i] = 0;
 499         }
 500         dst[nal_len_size - 1] = 1;
 501         if (nal_len > INT_MAX || nal_len > src_size) {
 502             status = ERROR_MALFORMED;
 503             break;
 504         }
 505         dst += nal_len_size;
 506         src += nal_len_size;
 507         src_size -= nal_len_size;
 508
 509         memcpy(dst, src, nal_len);
 510
 511         dst += nal_len;
 512         src += nal_len;
 513         src_size -= nal_len;
 514     }
 515
 516     return status;
 517 }
 518
 519 int getDivXVersion(AVCodecContext *avctx)
 520 {
 521     if (avctx->codec_tag == AV_RL32("DIV3")
 522             || avctx->codec_tag == AV_RL32("div3")
 523             || avctx->codec_tag == AV_RL32("DIV4")
 524             || avctx->codec_tag == AV_RL32("div4")) {
 525         return kTypeDivXVer_3_11;
 526     }
 527     if (avctx->codec_tag == AV_RL32("DIVX")
 528             || avctx->codec_tag == AV_RL32("divx")) {
 529         return kTypeDivXVer_4;
 530     }
 531     if (avctx->codec_tag == AV_RL32("DX50")
 532            || avctx->codec_tag == AV_RL32("dx50")) {
 533         return kTypeDivXVer_5;
 534     }
 535     return -1;
 536 }
 537
 538 status_t parseMetadataTags(AVFormatContext *ctx, const sp<MetaData> &meta) {
 539     if (meta == NULL || ctx == NULL) {
 540         return NO_INIT;
 541     }
 542
 543     AVDictionary *dict = ctx->metadata;
 544     if (dict == NULL) {
 545         return NO_INIT;
 546     }
 547
 548     struct MetadataMapping {
 549         const char *from;
 550         int to;
 551     };
 552
 553     // avformat -> android mapping
 554     static const MetadataMapping kMap[] = {
 555         { "track", kKeyCDTrackNumber },
 556         { "disc", kKeyDiscNumber },
 557         { "album", kKeyAlbum },
 558         { "artist", kKeyArtist },
 559         { "album_artist", kKeyAlbumArtist },
 560         { "composer", kKeyComposer },
 561         { "date", kKeyDate },
 562         { "genre", kKeyGenre },
 563         { "title", kKeyTitle },
 564         { "year", kKeyYear },
 565         { "compilation", kKeyCompilation },
 566         { "location", kKeyLocation },
 567     };
 568
 569     static const size_t kNumEntries = sizeof(kMap) / sizeof(kMap[0]);
 570
 571     for (size_t i = 0; i < kNumEntries; ++i) {
 572         AVDictionaryEntry *entry = av_dict_get(dict, kMap[i].from, NULL, 0);
 573         if (entry != NULL) {
 574             ALOGV("found key %s with value %s", entry->key, entry->value);
 575             meta->setCString(kMap[i].to, entry->value);
 576         }
 577     }
 578
 579     // now look for album art- this will be in a separate stream
 580     for (size_t i = 0; i < ctx->nb_streams; i++) {
 581         if (ctx->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC) {
 582             AVPacket pkt = ctx->streams[i]->attached_pic;
 583             if (pkt.size > 0) {
 584                 if (ctx->streams[i]->codec != NULL) {
 585                     const char *mime;
 586                     if (ctx->streams[i]->codec->codec_id == AV_CODEC_ID_MJPEG) {
 587                         mime = MEDIA_MIMETYPE_IMAGE_JPEG;
 588                     } else if (ctx->streams[i]->codec->codec_id == AV_CODEC_ID_PNG) {
 589                         mime = "image/png";
 590                     } else {
 591                         mime = NULL;
 592                     }
 593                     if (mime != NULL) {
 594                         ALOGV("found albumart in stream %zu with type %s len %d", i, mime, pkt.size);
 595                         meta->setData(kKeyAlbumArt, MetaData::TYPE_NONE, pkt.data, pkt.size);
 596                         meta->setCString(kKeyAlbumArtMIME, mime);
 597                     }
 598                 }
 599             }
 600         }
 601     }
 602     return OK;
 603 }
 604
 605 AudioEncoding sampleFormatToEncoding(AVSampleFormat fmt) {
 606
 607     // we resample planar formats to interleaved
 608     switch (fmt) {
 609         case AV_SAMPLE_FMT_U8:
 610         case AV_SAMPLE_FMT_U8P:
 611             return kAudioEncodingPcm8bit;
 612         case AV_SAMPLE_FMT_S16:
 613         case AV_SAMPLE_FMT_S16P:
 614             return kAudioEncodingPcm16bit;
 615         case AV_SAMPLE_FMT_S32:
 616         case AV_SAMPLE_FMT_S32P:
 617             return kAudioEncodingPcm32bit;
 618         case AV_SAMPLE_FMT_FLT:
 619         case AV_SAMPLE_FMT_FLTP:
 620             return kAudioEncodingPcmFloat;
 621         case AV_SAMPLE_FMT_DBL:
 622         case AV_SAMPLE_FMT_DBLP:
 623             return kAudioEncodingPcmFloat;
 624         default:
 625             return kAudioEncodingInvalid;
 626     }
 627
 628 }
 629
 630 AVSampleFormat encodingToSampleFormat(AudioEncoding encoding) {
 631     switch (encoding) {
 632         case kAudioEncodingPcm8bit:
 633             return AV_SAMPLE_FMT_U8;
 634         case kAudioEncodingPcm16bit:
 635             return AV_SAMPLE_FMT_S16;
 636         case kAudioEncodingPcm24bitPacked:
 637         case kAudioEncodingPcm32bit:
 638             return AV_SAMPLE_FMT_S32;
 639         case kAudioEncodingPcmFloat:
 640             return AV_SAMPLE_FMT_FLT;
 641         default:
 642             return AV_SAMPLE_FMT_NONE;
 643     }
 644 }
 645
 646 }  // namespace android
 647