Roll FFMpeg for M26. Fix ffmpeg float audio decoding.

media/ffmpeg/ffmpeg_common.cc

 // Copyright (c) 2012 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/basictypes.h"
 #include "base/logging.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/video_util.h"
@@ skipping 36 matching lines @@
   switch (codec_id) {
     case CODEC_ID_AAC:
       return kCodecAAC;
     case CODEC_ID_MP3:
       return kCodecMP3;
     case CODEC_ID_VORBIS:
       return kCodecVorbis;
     case CODEC_ID_PCM_U8:
     case CODEC_ID_PCM_S16LE:
     case CODEC_ID_PCM_S24LE:
+    case CODEC_ID_PCM_F32LE:
       return kCodecPCM;
     case CODEC_ID_PCM_S16BE:
       return kCodecPCM_S16BE;
     case CODEC_ID_PCM_S24BE:
       return kCodecPCM_S24BE;
     case CODEC_ID_FLAC:
       return kCodecFLAC;
     case CODEC_ID_AMR_NB:
       return kCodecAMR_NB;
     case CODEC_ID_AMR_WB:
       return kCodecAMR_WB;
     case CODEC_ID_GSM_MS:
       return kCodecGSM_MS;
     case CODEC_ID_PCM_MULAW:
       return kCodecPCM_MULAW;
     default:
       DVLOG(1) << "Unknown audio CodecID: " << codec_id;
   }
   return kUnknownAudioCodec;
 }
 
 static CodecID AudioCodecToCodecID(AudioCodec audio_codec,
-                                   int bits_per_channel) {
+                                   SampleFormat sample_format) {
   switch (audio_codec) {
     case kCodecAAC:
       return CODEC_ID_AAC;
     case kCodecMP3:
       return CODEC_ID_MP3;
     case kCodecPCM:
-      switch (bits_per_channel) {
-        case 8:
+      switch (sample_format) {
+        case kSampleFormatU8:
           return CODEC_ID_PCM_U8;
-        case 16:
+        case kSampleFormatS16:
           return CODEC_ID_PCM_S16LE;
-        case 32:
+        case kSampleFormatS32:
           return CODEC_ID_PCM_S24LE;
+        case kSampleFormatFLT:
+          return CODEC_ID_PCM_F32LE;
         default:
-          DVLOG(1) << "Unsupported bits per channel: " << bits_per_channel;
+          DVLOG(1) << "Unsupported sample format: " << sample_format;
       }
       break;
     case kCodecPCM_S16BE:
       return CODEC_ID_PCM_S16BE;
     case kCodecPCM_S24BE:
       return CODEC_ID_PCM_S24BE;
     case kCodecVorbis:
       return CODEC_ID_VORBIS;
     case kCodecFLAC:
       return CODEC_ID_FLAC;
     case kCodecAMR_NB:
       return CODEC_ID_AMR_NB;
     case kCodecAMR_WB:
       return CODEC_ID_AMR_WB;
     case kCodecGSM_MS:
       return CODEC_ID_GSM_MS;
     case kCodecPCM_MULAW:
       return CODEC_ID_PCM_MULAW;
     default:
       DVLOG(1) << "Unknown AudioCodec: " << audio_codec;
   }
   return CODEC_ID_NONE;
 }
 
 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:
       DVLOG(1) << "Unknown video CodecID: " << codec_id;
   }
   return kUnknownVideoCodec;
 }
 
 static CodecID VideoCodecToCodecID(VideoCodec video_codec) {
   switch (video_codec) {
-    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:
       DVLOG(1) << "Unknown VideoCodec: " << video_codec;
   }
   return CODEC_ID_NONE;
 }
 
@@ skipping 38 matching lines @@
     case H264PROFILE_HIGH422PROFILE:
       return FF_PROFILE_H264_HIGH_422;
     case H264PROFILE_HIGH444PREDICTIVEPROFILE:
       return FF_PROFILE_H264_HIGH_444_PREDICTIVE;
     default:
       DVLOG(1) << "Unknown VideoCodecProfile: " << profile;
   }
   return FF_PROFILE_UNKNOWN;
 }
 
+static SampleFormat AVSampleFormatToSampleFormat(AVSampleFormat sample_format) {
+  switch (sample_format) {
+    case AV_SAMPLE_FMT_U8:
+      return kSampleFormatU8;
+    case AV_SAMPLE_FMT_S16:
+      return kSampleFormatS16;
+    case AV_SAMPLE_FMT_S32:
+      return kSampleFormatS32;
+    case AV_SAMPLE_FMT_FLT:
+      return kSampleFormatFLT;
+    case AV_SAMPLE_FMT_FLTP:
+      return kSampleFormatFLTP;
+    default:
+      DVLOG(1) << "Unknown AVSampleFormat: " << sample_format;
+  }
+  return kUnknownSampleFormat;
+}
+
+static AVSampleFormat SampleFormatToAVSampleFormat(SampleFormat sample_format) {
+  switch (sample_format) {
+    case kSampleFormatU8:
+      return AV_SAMPLE_FMT_U8;
+    case kSampleFormatS16:
+      return AV_SAMPLE_FMT_S16;
+    case kSampleFormatS32:
+      return AV_SAMPLE_FMT_S32;
+    case kSampleFormatFLT:
+      return AV_SAMPLE_FMT_FLT;
+    case kSampleFormatFLTP:
+      return AV_SAMPLE_FMT_FLTP;
+    default:
+      DVLOG(1) << "Unknown SampleFormat: " << sample_format;
+  }
+  return AV_SAMPLE_FMT_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 bytes_per_channel = av_get_bytes_per_sample(codec_context->sample_fmt);
-  ChannelLayout channel_layout =
-      ChannelLayoutToChromeChannelLayout(codec_context->channel_layout,
-                                         codec_context->channels);
-  int samples_per_second = codec_context->sample_rate;
-
-  config->Initialize(codec,
-                     bytes_per_channel << 3,
+  ChannelLayout channel_layout = ChannelLayoutToChromeChannelLayout(
+      codec_context->channel_layout, codec_context->channels);
+  config->Initialize(CodecIDToAudioCodec(codec_context->codec_id),
+                     av_get_bytes_per_sample(codec_context->sample_fmt) * 8,
                      channel_layout,
-                     samples_per_second,
+                     codec_context->sample_rate,
                      codec_context->extradata,
                      codec_context->extradata_size,
+                     AVSampleFormatToSampleFormat(codec_context->sample_fmt),
                      false,  // Not encrypted.
                      true);
 }
 
 void AudioDecoderConfigToAVCodecContext(const AudioDecoderConfig& config,
                                         AVCodecContext* codec_context) {
   codec_context->codec_type = AVMEDIA_TYPE_AUDIO;
   codec_context->codec_id = AudioCodecToCodecID(config.codec(),
-                                                config.bits_per_channel());
-
-  switch (config.bits_per_channel()) {
-    case 8:
-      codec_context->sample_fmt = AV_SAMPLE_FMT_U8;
-      break;
-    case 16:
-      codec_context->sample_fmt = AV_SAMPLE_FMT_S16;
-      break;
-    case 32:
-      codec_context->sample_fmt = AV_SAMPLE_FMT_S32;
-      break;
-    default:
-      DVLOG(1) << "Unsupported bits per channel: " << config.bits_per_channel();
-      codec_context->sample_fmt = AV_SAMPLE_FMT_NONE;
-  }
+                                                config.sample_format());
+  codec_context->sample_fmt = SampleFormatToAVSampleFormat(
+      config.sample_format());
 
   // TODO(scherkus): should we set |channel_layout|? I'm not sure if FFmpeg uses
   // said information to decode.
   codec_context->channels =
       ChannelLayoutToChannelCount(config.channel_layout());
   codec_context->sample_rate = config.samples_per_second();
 
   if (config.extra_data()) {
     codec_context->extradata_size = config.extra_data_size();
     codec_context->extradata = reinterpret_cast<uint8_t*>(
@@ skipping 148 matching lines @@
       return PIX_FMT_YUV422P;
     case VideoFrame::YV12:
       return PIX_FMT_YUV420P;
     default:
       DVLOG(1) << "Unsupported VideoFrame::Format: " << video_format;
   }
   return PIX_FMT_NONE;
 }
 
 }  // namespace media