Enable pcm_s32le 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 "base/memory/scoped_ptr.h"
 #include "base/sha1.h"
@@ skipping 56 matching lines @@
   switch (codec_id) {
     case AV_CODEC_ID_AAC:
       return kCodecAAC;
     case AV_CODEC_ID_MP3:
       return kCodecMP3;
     case AV_CODEC_ID_VORBIS:
       return kCodecVorbis;
     case AV_CODEC_ID_PCM_U8:
     case AV_CODEC_ID_PCM_S16LE:
     case AV_CODEC_ID_PCM_S24LE:
+    case AV_CODEC_ID_PCM_S32LE:
     case AV_CODEC_ID_PCM_F32LE:
       return kCodecPCM;
     case AV_CODEC_ID_PCM_S16BE:
       return kCodecPCM_S16BE;
     case AV_CODEC_ID_PCM_S24BE:
       return kCodecPCM_S24BE;
     case AV_CODEC_ID_FLAC:
       return kCodecFLAC;
     case AV_CODEC_ID_AMR_NB:
       return kCodecAMR_NB;
@@ skipping 23 matching lines @@
     case kCodecALAC:
       return AV_CODEC_ID_ALAC;
     case kCodecMP3:
       return AV_CODEC_ID_MP3;
     case kCodecPCM:
       switch (sample_format) {
         case kSampleFormatU8:
           return AV_CODEC_ID_PCM_U8;
         case kSampleFormatS16:
           return AV_CODEC_ID_PCM_S16LE;
+        case kSampleFormatS24:
+          return AV_CODEC_ID_PCM_S24LE;
         case kSampleFormatS32:
-          return AV_CODEC_ID_PCM_S24LE;
+          return AV_CODEC_ID_PCM_S32LE;
         case kSampleFormatF32:
           return AV_CODEC_ID_PCM_F32LE;
         default:
           DVLOG(1) << "Unsupported sample format: " << sample_format;
       }
       break;
     case kCodecPCM_S16BE:
       return AV_CODEC_ID_PCM_S16BE;
     case kCodecPCM_S24BE:
       return AV_CODEC_ID_PCM_S24BE;
@@ skipping 105 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;
 }
 
-SampleFormat AVSampleFormatToSampleFormat(AVSampleFormat sample_format) {
+SampleFormat AVSampleFormatToSampleFormat(AVSampleFormat sample_format,
+                                          AVCodecID codec_id) {
   switch (sample_format) {
     case AV_SAMPLE_FMT_U8:
       return kSampleFormatU8;
     case AV_SAMPLE_FMT_S16:
       return kSampleFormatS16;
     case AV_SAMPLE_FMT_S32:
-      return kSampleFormatS32;
+      if (codec_id == AV_CODEC_ID_PCM_S24LE)
+        return kSampleFormatS24;
+      else
+        return kSampleFormatS32;
     case AV_SAMPLE_FMT_FLT:
       return kSampleFormatF32;
     case AV_SAMPLE_FMT_S16P:
       return kSampleFormatPlanarS16;
     case  AV_SAMPLE_FMT_S32P:
       return kSampleFormatPlanarS32;
     case AV_SAMPLE_FMT_FLTP:
       return kSampleFormatPlanarF32;
     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;
+    // pcm_s24le is treated as a codec with sample format s32 in ffmpeg
+    case kSampleFormatS24:
     case kSampleFormatS32:
       return AV_SAMPLE_FMT_S32;
     case kSampleFormatF32:
       return AV_SAMPLE_FMT_FLT;
     case kSampleFormatPlanarS16:
       return AV_SAMPLE_FMT_S16P;
     case kSampleFormatPlanarF32:
       return AV_SAMPLE_FMT_FLTP;
     default:
       DVLOG(1) << "Unknown SampleFormat: " << sample_format;
   }
   return AV_SAMPLE_FMT_NONE;
 }
 
 bool AVCodecContextToAudioDecoderConfig(const AVCodecContext* codec_context,
                                         bool is_encrypted,
                                         AudioDecoderConfig* config) {
   DCHECK_EQ(codec_context->codec_type, AVMEDIA_TYPE_AUDIO);
 
   AudioCodec codec = CodecIDToAudioCodec(codec_context->codec_id);
 
-  SampleFormat sample_format =
-      AVSampleFormatToSampleFormat(codec_context->sample_fmt);
+  SampleFormat sample_format = AVSampleFormatToSampleFormat(
+      codec_context->sample_fmt, codec_context->codec_id);
 
   ChannelLayout channel_layout = ChannelLayoutToChromeChannelLayout(
       codec_context->channel_layout, codec_context->channels);
 
   int sample_rate = codec_context->sample_rate;
   if (codec == kCodecOpus) {
     // |codec_context->sample_fmt| is not set by FFmpeg because Opus decoding is
     // not enabled in FFmpeg.  It doesn't matter what value is set here, so long
     // as it's valid, the true sample format is selected inside the decoder.
     sample_format = kSampleFormatF32;
@@ skipping 373 matching lines @@
 }
 
 int32_t HashCodecName(const char* codec_name) {
   // Use the first 32-bits from the SHA1 hash as the identifier.
   int32_t hash;
   memcpy(&hash, base::SHA1HashString(codec_name).substr(0, 4).c_str(), 4);
   return hash;
 }
 
 }  // namespace media