roll ffmpeg to nov 4 to fix clang issue

media/filters/ffmpeg_audio_decoder.cc

 // Copyright (c) 2010 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/filters/ffmpeg_audio_decoder.h"
 
 #include "media/base/callback.h"
 #include "media/base/data_buffer.h"
 #include "media/base/limits.h"
 #include "media/ffmpeg/ffmpeg_common.h"
@@ skipping 32 matching lines @@
 
   // Get the AVStream by querying for the provider interface.
   AVStreamProvider* av_stream_provider;
   if (!demuxer_stream->QueryInterface(&av_stream_provider)) {
     return;
   }
   AVStream* av_stream = av_stream_provider->GetAVStream();
 
   // Grab the AVStream's codec context and make sure we have sensible values.
   codec_context_ = av_stream->codec;
-  int bps = av_get_bits_per_sample_format(codec_context_->sample_fmt);
+  int bps = av_get_bits_per_sample_fmt(codec_context_->sample_fmt);
   if (codec_context_->channels <= 0 ||
       codec_context_->channels > Limits::kMaxChannels ||
       bps <= 0 || bps > Limits::kMaxBitsPerSample ||
       codec_context_->sample_rate <= 0 ||
       codec_context_->sample_rate > Limits::kMaxSampleRate) {
     DLOG(WARNING) << "Invalid audio stream -"
         << " channels: " << codec_context_->channels
         << " bps: " << bps
         << " sample rate: " << codec_context_->sample_rate;
     return;
   }
 
   // Serialize calls to avcodec_open().
   AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
   if (!codec || avcodec_open(codec_context_, codec) < 0) {
     return;
   }
 
   // When calling avcodec_find_decoder(), |codec_context_| might be altered by
   // the decoder to give more accurate values of the output format of the
   // decoder. So set the media format after a decoder is allocated.
   // TODO(hclam): Reuse the information provided by the demuxer for now, we may
   // need to wait until the first buffer is decoded to know the correct
   // information.
   media_format_.SetAsInteger(MediaFormat::kChannels, codec_context_->channels);
   media_format_.SetAsInteger(MediaFormat::kSampleBits,
-      av_get_bits_per_sample_format(codec_context_->sample_fmt));
+      av_get_bits_per_sample_fmt(codec_context_->sample_fmt));
   media_format_.SetAsInteger(MediaFormat::kSampleRate,
       codec_context_->sample_rate);
   media_format_.SetAsString(MediaFormat::kMimeType,
       mime_type::kUncompressedAudio);
 
   // Prepare the output buffer.
   output_buffer_.reset(static_cast<uint8*>(av_malloc(kOutputBufferSize)));
   if (!output_buffer_.get()) {
     host()->SetError(PIPELINE_ERROR_OUT_OF_MEMORY);
     return;
@@ skipping 147 matching lines @@
     DataBuffer* result_buffer = new DataBuffer(0);
     result_buffer->SetTimestamp(input->GetTimestamp());
     result_buffer->SetDuration(input->GetDuration());
     EnqueueResult(result_buffer);
   }
   DecoderBase<AudioDecoder, Buffer>::OnDecodeComplete();
 }
 
 base::TimeDelta FFmpegAudioDecoder::CalculateDuration(size_t size) {
   int64 denominator = codec_context_->channels *
-      av_get_bits_per_sample_format(codec_context_->sample_fmt) / 8 *
+      av_get_bits_per_sample_fmt(codec_context_->sample_fmt) / 8 *
       codec_context_->sample_rate;
   double microseconds = size /
       (denominator / static_cast<double>(base::Time::kMicrosecondsPerSecond));
   return base::TimeDelta::FromMicroseconds(static_cast<int64>(microseconds));
 }
 
 }  // namespace