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