media/ffmpeg/ffmpeg_common.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/ffmpeg/ffmpeg_common.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/logging.h"
   9 #include "base/metrics/histogram.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/strings/string_util.h"
  12 #include "media/base/decoder_buffer.h"
  13 #include "media/base/video_frame.h"
  14 #include "media/base/video_util.h"
  15
  16 namespace media {
  17
  18 // Why FF_INPUT_BUFFER_PADDING_SIZE? FFmpeg assumes all input buffers are
  19 // padded. Check here to ensure FFmpeg only receives data padded to its
  20 // specifications.
  21 COMPILE_ASSERT(DecoderBuffer::kPaddingSize >= FF_INPUT_BUFFER_PADDING_SIZE,
  22                decoder_buffer_padding_size_does_not_fit_ffmpeg_requirement);
  23
  24 // Alignment requirement by FFmpeg for input and output buffers. This need to
  25 // be updated to match FFmpeg when it changes.
  26 #if defined(ARCH_CPU_ARM_FAMILY)
  27 static const int kFFmpegBufferAddressAlignment = 16;
  28 #else
  29 static const int kFFmpegBufferAddressAlignment = 32;
  30 #endif
  31
  32 // Check here to ensure FFmpeg only receives data aligned to its specifications.
  33 COMPILE_ASSERT(
  34     DecoderBuffer::kAlignmentSize >= kFFmpegBufferAddressAlignment &&
  35     DecoderBuffer::kAlignmentSize % kFFmpegBufferAddressAlignment == 0,
  36     decoder_buffer_alignment_size_does_not_fit_ffmpeg_requirement);
  37
  38 // Allows faster SIMD YUV convert. Also, FFmpeg overreads/-writes occasionally.
  39 // See video_get_buffer() in libavcodec/utils.c.
  40 static const int kFFmpegOutputBufferPaddingSize = 16;
  41
  42 COMPILE_ASSERT(VideoFrame::kFrameSizePadding >= kFFmpegOutputBufferPaddingSize,
  43                video_frame_padding_size_does_not_fit_ffmpeg_requirement);
  44
  45 COMPILE_ASSERT(
  46     VideoFrame::kFrameAddressAlignment >= kFFmpegBufferAddressAlignment &&
  47     VideoFrame::kFrameAddressAlignment % kFFmpegBufferAddressAlignment == 0,
  48     video_frame_address_alignment_does_not_fit_ffmpeg_requirement);
  49
  50 static const AVRational kMicrosBase = { 1, base::Time::kMicrosecondsPerSecond };
  51
  52 base::TimeDelta ConvertFromTimeBase(const AVRational& time_base,
  53                                     int64 timestamp) {
  54   int64 microseconds = av_rescale_q(timestamp, time_base, kMicrosBase);
  55   return base::TimeDelta::FromMicroseconds(microseconds);
  56 }
  57
  58 int64 ConvertToTimeBase(const AVRational& time_base,
  59                         const base::TimeDelta& timestamp) {
  60   return av_rescale_q(timestamp.InMicroseconds(), kMicrosBase, time_base);
  61 }
  62
  63 // Converts an FFmpeg audio codec ID into its corresponding supported codec id.
  64 static AudioCodec CodecIDToAudioCodec(AVCodecID codec_id) {
  65   switch (codec_id) {
  66     case AV_CODEC_ID_AAC:
  67       return kCodecAAC;
  68     case AV_CODEC_ID_MP3:
  69       return kCodecMP3;
  70     case AV_CODEC_ID_VORBIS:
  71       return kCodecVorbis;
  72     case AV_CODEC_ID_PCM_U8:
  73     case AV_CODEC_ID_PCM_S16LE:
  74     case AV_CODEC_ID_PCM_S24LE:
  75     case AV_CODEC_ID_PCM_F32LE:
  76       return kCodecPCM;
  77     case AV_CODEC_ID_PCM_S16BE:
  78       return kCodecPCM_S16BE;
  79     case AV_CODEC_ID_PCM_S24BE:
  80       return kCodecPCM_S24BE;
  81     case AV_CODEC_ID_FLAC:
  82       return kCodecFLAC;
  83     case AV_CODEC_ID_AMR_NB:
  84       return kCodecAMR_NB;
  85     case AV_CODEC_ID_AMR_WB:
  86       return kCodecAMR_WB;
  87     case AV_CODEC_ID_GSM_MS:
  88       return kCodecGSM_MS;
  89     case AV_CODEC_ID_PCM_ALAW:
  90       return kCodecPCM_ALAW;
  91     case AV_CODEC_ID_PCM_MULAW:
  92       return kCodecPCM_MULAW;
  93     case AV_CODEC_ID_OPUS:
  94       return kCodecOpus;
  95     default:
  96       DVLOG(1) << "Unknown audio CodecID: " << codec_id;
  97   }
  98   return kUnknownAudioCodec;
  99 }
 100
 101 static AVCodecID AudioCodecToCodecID(AudioCodec audio_codec,
 102                                      SampleFormat sample_format) {
 103   switch (audio_codec) {
 104     case kCodecAAC:
 105       return AV_CODEC_ID_AAC;
 106     case kCodecMP3:
 107       return AV_CODEC_ID_MP3;
 108     case kCodecPCM:
 109       switch (sample_format) {
 110         case kSampleFormatU8:
 111           return AV_CODEC_ID_PCM_U8;
 112         case kSampleFormatS16:
 113           return AV_CODEC_ID_PCM_S16LE;
 114         case kSampleFormatS32:
 115           return AV_CODEC_ID_PCM_S24LE;
 116         case kSampleFormatF32:
 117           return AV_CODEC_ID_PCM_F32LE;
 118         default:
 119           DVLOG(1) << "Unsupported sample format: " << sample_format;
 120       }
 121       break;
 122     case kCodecPCM_S16BE:
 123       return AV_CODEC_ID_PCM_S16BE;
 124     case kCodecPCM_S24BE:
 125       return AV_CODEC_ID_PCM_S24BE;
 126     case kCodecVorbis:
 127       return AV_CODEC_ID_VORBIS;
 128     case kCodecFLAC:
 129       return AV_CODEC_ID_FLAC;
 130     case kCodecAMR_NB:
 131       return AV_CODEC_ID_AMR_NB;
 132     case kCodecAMR_WB:
 133       return AV_CODEC_ID_AMR_WB;
 134     case kCodecGSM_MS:
 135       return AV_CODEC_ID_GSM_MS;
 136     case kCodecPCM_ALAW:
 137       return AV_CODEC_ID_PCM_ALAW;
 138     case kCodecPCM_MULAW:
 139       return AV_CODEC_ID_PCM_MULAW;
 140     case kCodecOpus:
 141       return AV_CODEC_ID_OPUS;
 142     default:
 143       DVLOG(1) << "Unknown AudioCodec: " << audio_codec;
 144   }
 145   return AV_CODEC_ID_NONE;
 146 }
 147
 148 // Converts an FFmpeg video codec ID into its corresponding supported codec id.
 149 static VideoCodec CodecIDToVideoCodec(AVCodecID codec_id) {
 150   switch (codec_id) {
 151     case AV_CODEC_ID_H264:
 152       return kCodecH264;
 153     case AV_CODEC_ID_THEORA:
 154       return kCodecTheora;
 155     case AV_CODEC_ID_MPEG4:
 156       return kCodecMPEG4;
 157     case AV_CODEC_ID_VP8:
 158       return kCodecVP8;
 159     case AV_CODEC_ID_VP9:
 160       return kCodecVP9;
 161     default:
 162       DVLOG(1) << "Unknown video CodecID: " << codec_id;
 163   }
 164   return kUnknownVideoCodec;
 165 }
 166
 167 static AVCodecID VideoCodecToCodecID(VideoCodec video_codec) {
 168   switch (video_codec) {
 169     case kCodecH264:
 170       return AV_CODEC_ID_H264;
 171     case kCodecTheora:
 172       return AV_CODEC_ID_THEORA;
 173     case kCodecMPEG4:
 174       return AV_CODEC_ID_MPEG4;
 175     case kCodecVP8:
 176       return AV_CODEC_ID_VP8;
 177     case kCodecVP9:
 178       return AV_CODEC_ID_VP9;
 179     default:
 180       DVLOG(1) << "Unknown VideoCodec: " << video_codec;
 181   }
 182   return AV_CODEC_ID_NONE;
 183 }
 184
 185 static VideoCodecProfile ProfileIDToVideoCodecProfile(int profile) {
 186   // Clear out the CONSTRAINED & INTRA flags which are strict subsets of the
 187   // corresponding profiles with which they're used.
 188   profile &= ~FF_PROFILE_H264_CONSTRAINED;
 189   profile &= ~FF_PROFILE_H264_INTRA;
 190   switch (profile) {
 191     case FF_PROFILE_H264_BASELINE:
 192       return H264PROFILE_BASELINE;
 193     case FF_PROFILE_H264_MAIN:
 194       return H264PROFILE_MAIN;
 195     case FF_PROFILE_H264_EXTENDED:
 196       return H264PROFILE_EXTENDED;
 197     case FF_PROFILE_H264_HIGH:
 198       return H264PROFILE_HIGH;
 199     case FF_PROFILE_H264_HIGH_10:
 200       return H264PROFILE_HIGH10PROFILE;
 201     case FF_PROFILE_H264_HIGH_422:
 202       return H264PROFILE_HIGH422PROFILE;
 203     case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
 204       return H264PROFILE_HIGH444PREDICTIVEPROFILE;
 205     default:
 206       DVLOG(1) << "Unknown profile id: " << profile;
 207   }
 208   return VIDEO_CODEC_PROFILE_UNKNOWN;
 209 }
 210
 211 static int VideoCodecProfileToProfileID(VideoCodecProfile profile) {
 212   switch (profile) {
 213     case H264PROFILE_BASELINE:
 214       return FF_PROFILE_H264_BASELINE;
 215     case H264PROFILE_MAIN:
 216       return FF_PROFILE_H264_MAIN;
 217     case H264PROFILE_EXTENDED:
 218       return FF_PROFILE_H264_EXTENDED;
 219     case H264PROFILE_HIGH:
 220       return FF_PROFILE_H264_HIGH;
 221     case H264PROFILE_HIGH10PROFILE:
 222       return FF_PROFILE_H264_HIGH_10;
 223     case H264PROFILE_HIGH422PROFILE:
 224       return FF_PROFILE_H264_HIGH_422;
 225     case H264PROFILE_HIGH444PREDICTIVEPROFILE:
 226       return FF_PROFILE_H264_HIGH_444_PREDICTIVE;
 227     default:
 228       DVLOG(1) << "Unknown VideoCodecProfile: " << profile;
 229   }
 230   return FF_PROFILE_UNKNOWN;
 231 }
 232
 233 SampleFormat AVSampleFormatToSampleFormat(AVSampleFormat sample_format) {
 234   switch (sample_format) {
 235     case AV_SAMPLE_FMT_U8:
 236       return kSampleFormatU8;
 237     case AV_SAMPLE_FMT_S16:
 238       return kSampleFormatS16;
 239     case AV_SAMPLE_FMT_S32:
 240       return kSampleFormatS32;
 241     case AV_SAMPLE_FMT_FLT:
 242       return kSampleFormatF32;
 243     case AV_SAMPLE_FMT_S16P:
 244       return kSampleFormatPlanarS16;
 245     case AV_SAMPLE_FMT_FLTP:
 246       return kSampleFormatPlanarF32;
 247     default:
 248       DVLOG(1) << "Unknown AVSampleFormat: " << sample_format;
 249   }
 250   return kUnknownSampleFormat;
 251 }
 252
 253 static AVSampleFormat SampleFormatToAVSampleFormat(SampleFormat sample_format) {
 254   switch (sample_format) {
 255     case kSampleFormatU8:
 256       return AV_SAMPLE_FMT_U8;
 257     case kSampleFormatS16:
 258       return AV_SAMPLE_FMT_S16;
 259     case kSampleFormatS32:
 260       return AV_SAMPLE_FMT_S32;
 261     case kSampleFormatF32:
 262       return AV_SAMPLE_FMT_FLT;
 263     case kSampleFormatPlanarS16:
 264       return AV_SAMPLE_FMT_S16P;
 265     case kSampleFormatPlanarF32:
 266       return AV_SAMPLE_FMT_FLTP;
 267     default:
 268       DVLOG(1) << "Unknown SampleFormat: " << sample_format;
 269   }
 270   return AV_SAMPLE_FMT_NONE;
 271 }
 272
 273 void AVCodecContextToAudioDecoderConfig(
 274     const AVCodecContext* codec_context,
 275     bool is_encrypted,
 276     AudioDecoderConfig* config,
 277     bool record_stats) {
 278   DCHECK_EQ(codec_context->codec_type, AVMEDIA_TYPE_AUDIO);
 279
 280   AudioCodec codec = CodecIDToAudioCodec(codec_context->codec_id);
 281
 282   SampleFormat sample_format =
 283       AVSampleFormatToSampleFormat(codec_context->sample_fmt);
 284
 285   ChannelLayout channel_layout = ChannelLayoutToChromeChannelLayout(
 286       codec_context->channel_layout, codec_context->channels);
 287
 288   int sample_rate = codec_context->sample_rate;
 289   if (codec == kCodecOpus) {
 290     // |codec_context->sample_fmt| is not set by FFmpeg because Opus decoding is
 291     // not enabled in FFmpeg.  It doesn't matter what value is set here, so long
 292     // as it's valid, the true sample format is selected inside the decoder.
 293     sample_format = kSampleFormatF32;
 294
 295     // Always use 48kHz for OPUS.  Technically we should match to the highest
 296     // supported hardware sample rate among [8, 12, 16, 24, 48] kHz, but we
 297     // don't know the hardware sample rate at this point and those rates are
 298     // rarely used for output.  See the "Input Sample Rate" section of the spec:
 299     // http://tools.ietf.org/html/draft-terriberry-oggopus-01#page-11
 300     sample_rate = 48000;
 301   }
 302
 303   base::TimeDelta seek_preroll;
 304   if (codec_context->seek_preroll > 0) {
 305     seek_preroll = base::TimeDelta::FromMicroseconds(
 306         codec_context->seek_preroll * 1000000.0 / codec_context->sample_rate);
 307   }
 308
 309   config->Initialize(codec,
 310                      sample_format,
 311                      channel_layout,
 312                      sample_rate,
 313                      codec_context->extradata,
 314                      codec_context->extradata_size,
 315                      is_encrypted,
 316                      record_stats,
 317                      seek_preroll,
 318                      codec_context->delay);
 319   if (codec != kCodecOpus) {
 320     DCHECK_EQ(av_get_bytes_per_sample(codec_context->sample_fmt) * 8,
 321               config->bits_per_channel());
 322   }
 323 }
 324
 325 void AVStreamToAudioDecoderConfig(
 326     const AVStream* stream,
 327     AudioDecoderConfig* config,
 328     bool record_stats) {
 329   bool is_encrypted = false;
 330   AVDictionaryEntry* key = av_dict_get(stream->metadata, "enc_key_id", NULL, 0);
 331   if (key)
 332     is_encrypted = true;
 333   return AVCodecContextToAudioDecoderConfig(
 334       stream->codec, is_encrypted, config, record_stats);
 335 }
 336
 337 void AudioDecoderConfigToAVCodecContext(const AudioDecoderConfig& config,
 338                                         AVCodecContext* codec_context) {
 339   codec_context->codec_type = AVMEDIA_TYPE_AUDIO;
 340   codec_context->codec_id = AudioCodecToCodecID(config.codec(),
 341                                                 config.sample_format());
 342   codec_context->sample_fmt = SampleFormatToAVSampleFormat(
 343       config.sample_format());
 344
 345   // TODO(scherkus): should we set |channel_layout|? I'm not sure if FFmpeg uses
 346   // said information to decode.
 347   codec_context->channels =
 348       ChannelLayoutToChannelCount(config.channel_layout());
 349   codec_context->sample_rate = config.samples_per_second();
 350
 351   if (config.extra_data()) {
 352     codec_context->extradata_size = config.extra_data_size();
 353     codec_context->extradata = reinterpret_cast<uint8_t*>(
 354         av_malloc(config.extra_data_size() + FF_INPUT_BUFFER_PADDING_SIZE));
 355     memcpy(codec_context->extradata, config.extra_data(),
 356            config.extra_data_size());
 357     memset(codec_context->extradata + config.extra_data_size(), '\0',
 358            FF_INPUT_BUFFER_PADDING_SIZE);
 359   } else {
 360     codec_context->extradata = NULL;
 361     codec_context->extradata_size = 0;
 362   }
 363 }
 364
 365 void AVStreamToVideoDecoderConfig(
 366     const AVStream* stream,
 367     VideoDecoderConfig* config,
 368     bool record_stats) {
 369   gfx::Size coded_size(stream->codec->coded_width, stream->codec->coded_height);
 370
 371   // TODO(vrk): This assumes decoded frame data starts at (0, 0), which is true
 372   // for now, but may not always be true forever. Fix this in the future.
 373   gfx::Rect visible_rect(stream->codec->width, stream->codec->height);
 374
 375   AVRational aspect_ratio = { 1, 1 };
 376   if (stream->sample_aspect_ratio.num)
 377     aspect_ratio = stream->sample_aspect_ratio;
 378   else if (stream->codec->sample_aspect_ratio.num)
 379     aspect_ratio = stream->codec->sample_aspect_ratio;
 380
 381   VideoCodec codec = CodecIDToVideoCodec(stream->codec->codec_id);
 382
 383   VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
 384   if (codec == kCodecVP8)
 385     profile = VP8PROFILE_ANY;
 386   else if (codec == kCodecVP9)
 387     profile = VP9PROFILE_ANY;
 388   else
 389     profile = ProfileIDToVideoCodecProfile(stream->codec->profile);
 390
 391   gfx::Size natural_size = GetNaturalSize(
 392       visible_rect.size(), aspect_ratio.num, aspect_ratio.den);
 393
 394   if (record_stats) {
 395     // Note the PRESUBMIT_IGNORE_UMA_MAX below, this silences the PRESUBMIT.py
 396     // check for uma enum max usage, since we're abusing
 397     // UMA_HISTOGRAM_ENUMERATION to report a discrete value.
 398     UMA_HISTOGRAM_ENUMERATION("Media.VideoColorRange",
 399                               stream->codec->color_range,
 400                               AVCOL_RANGE_NB);  // PRESUBMIT_IGNORE_UMA_MAX
 401   }
 402
 403   VideoFrame::Format format = PixelFormatToVideoFormat(stream->codec->pix_fmt);
 404   if (codec == kCodecVP9) {
 405     // TODO(tomfinegan): libavcodec doesn't know about VP9.
 406     format = VideoFrame::YV12;
 407     coded_size = visible_rect.size();
 408   }
 409
 410   // Pad out |coded_size| for subsampled YUV formats.
 411   if (format != VideoFrame::YV24) {
 412     coded_size.set_width((coded_size.width() + 1) / 2 * 2);
 413     if (format != VideoFrame::YV16)
 414       coded_size.set_height((coded_size.height() + 1) / 2 * 2);
 415   }
 416
 417   bool is_encrypted = false;
 418   AVDictionaryEntry* key = av_dict_get(stream->metadata, "enc_key_id", NULL, 0);
 419   if (key)
 420     is_encrypted = true;
 421
 422   AVDictionaryEntry* webm_alpha =
 423       av_dict_get(stream->metadata, "alpha_mode", NULL, 0);
 424   if (webm_alpha && !strcmp(webm_alpha->value, "1")) {
 425     format = VideoFrame::YV12A;
 426   }
 427
 428   config->Initialize(codec,
 429                      profile,
 430                      format,
 431                      coded_size, visible_rect, natural_size,
 432                      stream->codec->extradata, stream->codec->extradata_size,
 433                      is_encrypted,
 434                      record_stats);
 435 }
 436
 437 void VideoDecoderConfigToAVCodecContext(
 438     const VideoDecoderConfig& config,
 439     AVCodecContext* codec_context) {
 440   codec_context->codec_type = AVMEDIA_TYPE_VIDEO;
 441   codec_context->codec_id = VideoCodecToCodecID(config.codec());
 442   codec_context->profile = VideoCodecProfileToProfileID(config.profile());
 443   codec_context->coded_width = config.coded_size().width();
 444   codec_context->coded_height = config.coded_size().height();
 445   codec_context->pix_fmt = VideoFormatToPixelFormat(config.format());
 446
 447   if (config.extra_data()) {
 448     codec_context->extradata_size = config.extra_data_size();
 449     codec_context->extradata = reinterpret_cast<uint8_t*>(
 450         av_malloc(config.extra_data_size() + FF_INPUT_BUFFER_PADDING_SIZE));
 451     memcpy(codec_context->extradata, config.extra_data(),
 452            config.extra_data_size());
 453     memset(codec_context->extradata + config.extra_data_size(), '\0',
 454            FF_INPUT_BUFFER_PADDING_SIZE);
 455   } else {
 456     codec_context->extradata = NULL;
 457     codec_context->extradata_size = 0;
 458   }
 459 }
 460
 461 ChannelLayout ChannelLayoutToChromeChannelLayout(int64_t layout, int channels) {
 462   switch (layout) {
 463     case AV_CH_LAYOUT_MONO:
 464       return CHANNEL_LAYOUT_MONO;
 465     case AV_CH_LAYOUT_STEREO:
 466       return CHANNEL_LAYOUT_STEREO;
 467     case AV_CH_LAYOUT_2_1:
 468       return CHANNEL_LAYOUT_2_1;
 469     case AV_CH_LAYOUT_SURROUND:
 470       return CHANNEL_LAYOUT_SURROUND;
 471     case AV_CH_LAYOUT_4POINT0:
 472       return CHANNEL_LAYOUT_4_0;
 473     case AV_CH_LAYOUT_2_2:
 474       return CHANNEL_LAYOUT_2_2;
 475     case AV_CH_LAYOUT_QUAD:
 476       return CHANNEL_LAYOUT_QUAD;
 477     case AV_CH_LAYOUT_5POINT0:
 478       return CHANNEL_LAYOUT_5_0;
 479     case AV_CH_LAYOUT_5POINT1:
 480       return CHANNEL_LAYOUT_5_1;
 481     case AV_CH_LAYOUT_5POINT0_BACK:
 482       return CHANNEL_LAYOUT_5_0_BACK;
 483     case AV_CH_LAYOUT_5POINT1_BACK:
 484       return CHANNEL_LAYOUT_5_1_BACK;
 485     case AV_CH_LAYOUT_7POINT0:
 486       return CHANNEL_LAYOUT_7_0;
 487     case AV_CH_LAYOUT_7POINT1:
 488       return CHANNEL_LAYOUT_7_1;
 489     case AV_CH_LAYOUT_7POINT1_WIDE:
 490       return CHANNEL_LAYOUT_7_1_WIDE;
 491     case AV_CH_LAYOUT_STEREO_DOWNMIX:
 492       return CHANNEL_LAYOUT_STEREO_DOWNMIX;
 493     case AV_CH_LAYOUT_2POINT1:
 494       return CHANNEL_LAYOUT_2POINT1;
 495     case AV_CH_LAYOUT_3POINT1:
 496       return CHANNEL_LAYOUT_3_1;
 497     case AV_CH_LAYOUT_4POINT1:
 498       return CHANNEL_LAYOUT_4_1;
 499     case AV_CH_LAYOUT_6POINT0:
 500       return CHANNEL_LAYOUT_6_0;
 501     case AV_CH_LAYOUT_6POINT0_FRONT:
 502       return CHANNEL_LAYOUT_6_0_FRONT;
 503     case AV_CH_LAYOUT_HEXAGONAL:
 504       return CHANNEL_LAYOUT_HEXAGONAL;
 505     case AV_CH_LAYOUT_6POINT1:
 506       return CHANNEL_LAYOUT_6_1;
 507     case AV_CH_LAYOUT_6POINT1_BACK:
 508       return CHANNEL_LAYOUT_6_1_BACK;
 509     case AV_CH_LAYOUT_6POINT1_FRONT:
 510       return CHANNEL_LAYOUT_6_1_FRONT;
 511     case AV_CH_LAYOUT_7POINT0_FRONT:
 512       return CHANNEL_LAYOUT_7_0_FRONT;
 513 #ifdef AV_CH_LAYOUT_7POINT1_WIDE_BACK
 514     case AV_CH_LAYOUT_7POINT1_WIDE_BACK:
 515       return CHANNEL_LAYOUT_7_1_WIDE_BACK;
 516 #endif
 517     case AV_CH_LAYOUT_OCTAGONAL:
 518       return CHANNEL_LAYOUT_OCTAGONAL;
 519     default:
 520       // FFmpeg channel_layout is 0 for .wav and .mp3.  Attempt to guess layout
 521       // based on the channel count.
 522       return GuessChannelLayout(channels);
 523   }
 524 }
 525
 526 VideoFrame::Format PixelFormatToVideoFormat(PixelFormat pixel_format) {
 527   switch (pixel_format) {
 528     case PIX_FMT_YUV422P:
 529       return VideoFrame::YV16;
 530     case PIX_FMT_YUV444P:
 531       return VideoFrame::YV24;
 532     case PIX_FMT_YUV420P:
 533       return VideoFrame::YV12;
 534     case PIX_FMT_YUVJ420P:
 535       return VideoFrame::YV12J;
 536     case PIX_FMT_YUVA420P:
 537       return VideoFrame::YV12A;
 538     default:
 539       DVLOG(1) << "Unsupported PixelFormat: " << pixel_format;
 540   }
 541   return VideoFrame::UNKNOWN;
 542 }
 543
 544 PixelFormat VideoFormatToPixelFormat(VideoFrame::Format video_format) {
 545   switch (video_format) {
 546     case VideoFrame::YV16:
 547       return PIX_FMT_YUV422P;
 548     case VideoFrame::YV12:
 549       return PIX_FMT_YUV420P;
 550     case VideoFrame::YV12J:
 551       return PIX_FMT_YUVJ420P;
 552     case VideoFrame::YV12A:
 553       return PIX_FMT_YUVA420P;
 554     case VideoFrame::YV24:
 555       return PIX_FMT_YUV444P;
 556     default:
 557       DVLOG(1) << "Unsupported VideoFrame::Format: " << video_format;
 558   }
 559   return PIX_FMT_NONE;
 560 }
 561
 562 bool FFmpegUTCDateToTime(const char* date_utc,
 563                          base::Time* out) {
 564   DCHECK(date_utc);
 565   DCHECK(out);
 566
 567   std::vector<std::string> fields;
 568   std::vector<std::string> date_fields;
 569   std::vector<std::string> time_fields;
 570   base::Time::Exploded exploded;
 571   exploded.millisecond = 0;
 572
 573   // TODO(acolwell): Update this parsing code when FFmpeg returns sub-second
 574   // information.
 575   if ((Tokenize(date_utc, " ", &fields) == 2) &&
 576       (Tokenize(fields[0], "-", &date_fields) == 3) &&
 577       (Tokenize(fields[1], ":", &time_fields) == 3) &&
 578       base::StringToInt(date_fields[0], &exploded.year) &&
 579       base::StringToInt(date_fields[1], &exploded.month) &&
 580       base::StringToInt(date_fields[2], &exploded.day_of_month) &&
 581       base::StringToInt(time_fields[0], &exploded.hour) &&
 582       base::StringToInt(time_fields[1], &exploded.minute) &&
 583       base::StringToInt(time_fields[2], &exploded.second)) {
 584     base::Time parsed_time = base::Time::FromUTCExploded(exploded);
 585     if (parsed_time.is_null())
 586       return false;
 587
 588     *out = parsed_time;
 589     return true;
 590   }
 591
 592   return false;
 593 }
 594
 595 }  // namespace media