Remove DemuxerStream::GetAVStream() once and for all.

media/ffmpeg/ffmpeg_common.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/ffmpeg/ffmpeg_common.h"
 
 #include "base/logging.h"
 
 namespace media {
 
@@ skipping 49 matching lines @@
           NOTREACHED() << "Unsupported bits_per_channel: " << bits_per_channel;
       }
     case kCodecVorbis:
       return CODEC_ID_VORBIS;
     default:
       NOTREACHED();
   }
   return CODEC_ID_NONE;
 }
 
+static VideoCodec CodecIDToVideoCodec(CodecID codec_id) {
+  switch (codec_id) {
+    case CODEC_ID_VC1:
+      return kCodecVC1;
+    case CODEC_ID_H264:
+      return kCodecH264;
+    case CODEC_ID_THEORA:
+      return kCodecTheora;
+    case CODEC_ID_MPEG2VIDEO:
+      return kCodecMPEG2;
+    case CODEC_ID_MPEG4:
+      return kCodecMPEG4;
+    case CODEC_ID_VP8:
+      return kCodecVP8;
+    default:
+      NOTREACHED();
+  }
+  return kUnknownVideoCodec;
+}
+
+static CodecID VideoCodecToCodecID(VideoCodec video_codec) {
+  switch (video_codec) {
+    case kUnknownVideoCodec:
+      return CODEC_ID_NONE;
+    case kCodecVC1:
+      return CODEC_ID_VC1;
+    case kCodecH264:
+      return CODEC_ID_H264;
+    case kCodecTheora:
+      return CODEC_ID_THEORA;
+    case kCodecMPEG2:
+      return CODEC_ID_MPEG2VIDEO;
+    case kCodecMPEG4:
+      return CODEC_ID_MPEG4;
+    case kCodecVP8:
+      return CODEC_ID_VP8;
+    default:
+      NOTREACHED();
+  }
+  return CODEC_ID_NONE;
+}
+
 void AVCodecContextToAudioDecoderConfig(
     const AVCodecContext* codec_context,
     AudioDecoderConfig* config) {
   DCHECK_EQ(codec_context->codec_type, AVMEDIA_TYPE_AUDIO);
 
   AudioCodec codec = CodecIDToAudioCodec(codec_context->codec_id);
   int bits_per_channel = av_get_bits_per_sample_fmt(codec_context->sample_fmt);
   ChannelLayout channel_layout =
       ChannelLayoutToChromeChannelLayout(codec_context->channel_layout,
                                          codec_context->channels);
@@ skipping 41 matching lines @@
     memcpy(codec_context->extradata, config.extra_data(),
            config.extra_data_size());
     memset(codec_context->extradata + config.extra_data_size(), '\0',
            FF_INPUT_BUFFER_PADDING_SIZE);
   } else {
     codec_context->extradata = NULL;
     codec_context->extradata_size = 0;
   }
 }
 
-VideoCodec CodecIDToVideoCodec(CodecID codec_id) {
-  switch (codec_id) {
-    case CODEC_ID_VC1:
-      return kCodecVC1;
-    case CODEC_ID_H264:
-      return kCodecH264;
-    case CODEC_ID_THEORA:
-      return kCodecTheora;
-    case CODEC_ID_MPEG2VIDEO:
-      return kCodecMPEG2;
-    case CODEC_ID_MPEG4:
-      return kCodecMPEG4;
-    case CODEC_ID_VP8:
-      return kCodecVP8;
-    default:
-      NOTREACHED();
-  }
-  return kUnknownVideoCodec;
+void AVStreamToVideoDecoderConfig(
+    const AVStream* stream,
+    VideoDecoderConfig* config) {
+  gfx::Size coded_size(stream->codec->coded_width, stream->codec->coded_height);
+
+  // TODO(vrk): This assumes decoded frame data starts at (0, 0), which is true
+  // for now, but may not always be true forever. Fix this in the future.
+  gfx::Rect visible_rect(stream->codec->width, stream->codec->height);
+
+  AVRational aspect_ratio = { 1, 1 };
+  if (stream->sample_aspect_ratio.num)
+    aspect_ratio = stream->sample_aspect_ratio;
+  else if (stream->codec->sample_aspect_ratio.num)
+    aspect_ratio = stream->codec->sample_aspect_ratio;
+
+  config->Initialize(CodecIDToVideoCodec(stream->codec->codec_id),
+                     PixelFormatToVideoFormat(stream->codec->pix_fmt),
+                     coded_size, visible_rect,
+                     stream->r_frame_rate.num,
+                     stream->r_frame_rate.den,
+                     aspect_ratio.num,
+                     aspect_ratio.den,
+                     stream->codec->extradata,
+                     stream->codec->extradata_size);
 }
 
-CodecID VideoCodecToCodecID(VideoCodec video_codec) {
-  switch (video_codec) {
-    case kUnknownVideoCodec:
-      return CODEC_ID_NONE;
-    case kCodecVC1:
-      return CODEC_ID_VC1;
-    case kCodecH264:
-      return CODEC_ID_H264;
-    case kCodecTheora:
-      return CODEC_ID_THEORA;
-    case kCodecMPEG2:
-      return CODEC_ID_MPEG2VIDEO;
-    case kCodecMPEG4:
-      return CODEC_ID_MPEG4;
-    case kCodecVP8:
-      return CODEC_ID_VP8;
-    default:
-      NOTREACHED();
+void VideoDecoderConfigToAVCodecContext(
+    const VideoDecoderConfig& config,
+    AVCodecContext* codec_context) {
+  codec_context->codec_type = AVMEDIA_TYPE_VIDEO;
+  codec_context->codec_id = VideoCodecToCodecID(config.codec());
+  codec_context->coded_width = config.coded_size().width();
+  codec_context->coded_height = config.coded_size().height();
+  codec_context->pix_fmt = VideoFormatToPixelFormat(config.format());
+
+  if (config.extra_data()) {
+    codec_context->extradata_size = config.extra_data_size();
+    codec_context->extradata = reinterpret_cast<uint8_t*>(
+        av_malloc(config.extra_data_size() + FF_INPUT_BUFFER_PADDING_SIZE));
+    memcpy(codec_context->extradata, config.extra_data(),
+           config.extra_data_size());
+    memset(codec_context->extradata + config.extra_data_size(), '\0',
+           FF_INPUT_BUFFER_PADDING_SIZE);
+  } else {
+    codec_context->extradata = NULL;
+    codec_context->extradata_size = 0;
   }
-  return CODEC_ID_NONE;
 }
 
 ChannelLayout ChannelLayoutToChromeChannelLayout(int64_t layout,
                                                  int channels) {
   switch (layout) {
     case CH_LAYOUT_MONO:
       return CHANNEL_LAYOUT_MONO;
     case CH_LAYOUT_STEREO:
       return CHANNEL_LAYOUT_STEREO;
     case CH_LAYOUT_2_1:
@@ skipping 51 matching lines @@
     case VideoFrame::YV16:
       return PIX_FMT_YUV422P;
     case VideoFrame::YV12:
       return PIX_FMT_YUV420P;
     default:
       NOTREACHED() << "Unsupported VideoFrame Format: " << video_format;
   }
   return PIX_FMT_NONE;
 }
 
-base::TimeDelta GetFrameDuration(AVStream* stream) {
-  AVRational time_base = { stream->r_frame_rate.den, stream->r_frame_rate.num };
+base::TimeDelta GetFrameDuration(const VideoDecoderConfig& config) {
+  AVRational time_base = {
+    config.frame_rate_denominator(),
+    config.frame_rate_numerator()
+  };
   return ConvertFromTimeBase(time_base, 1);
 }
 
-gfx::Size GetNaturalSize(AVStream* stream) {
-  double aspect_ratio = 1.0;
-
-  if (stream->sample_aspect_ratio.num)
-    aspect_ratio = av_q2d(stream->sample_aspect_ratio);
-  else if (stream->codec->sample_aspect_ratio.num)
-    aspect_ratio = av_q2d(stream->codec->sample_aspect_ratio);
-
-  int height = stream->codec->height;
-  int width = floor(stream->codec->width * aspect_ratio + 0.5);
-
-  // An even width makes things easier for YV12 and appears to be the behavior
-  // expected by WebKit layout tests.
-  return gfx::Size(width & ~1, height);
-}
-
 void DestroyAVFormatContext(AVFormatContext* format_context) {
   DCHECK(format_context);
 
   // Iterate each stream and destroy each one of them.
   if (format_context->streams) {
     int streams = format_context->nb_streams;
     for (int i = 0; i < streams; ++i) {
       AVStream* stream = format_context->streams[i];
 
       // The conditions for calling avcodec_close():
       // 1. AVStream is alive.
       // 2. AVCodecContext in AVStream is alive.
       // 3. AVCodec in AVCodecContext is alive.
       // Notice that closing a codec context without prior avcodec_open() will
       // result in a crash in FFmpeg.
       if (stream && stream->codec && stream->codec->codec) {
         stream->discard = AVDISCARD_ALL;
         avcodec_close(stream->codec);
       }
     }
   }
 
   // Then finally cleanup the format context.
   av_close_input_file(format_context);
 }
 
 }  // namespace media