Roll src/third_party/ffmpeg/ 3c7a09882..cdf4accee (3188 commits).

media/filters/ffmpeg_aac_bitstream_converter.cc

 // Copyright 2014 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_aac_bitstream_converter.h"
 
 #include "base/logging.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 
 namespace media {
@@ skipping 140 matching lines @@
   hdr[6] |= (buffer_fullness & 0x3F) << 2;
 
   hdr[6] |= number_of_frames_minus_one & 0x3;
 
   return true;
 }
 
 }
 
 FFmpegAACBitstreamConverter::FFmpegAACBitstreamConverter(
-    AVCodecContext* stream_codec_context)
-    : stream_codec_context_(stream_codec_context),
+    AVCodecParameters* stream_codec_parameters)
+    : stream_codec_parameters_(stream_codec_parameters),
       header_generated_(false),
       codec_(),
       audio_profile_(),
       sample_rate_index_(),
       channel_configuration_(),
       frame_length_() {
-  CHECK(stream_codec_context_);
+  CHECK(stream_codec_parameters_);
 }
 
 FFmpegAACBitstreamConverter::~FFmpegAACBitstreamConverter() {
 }
 
 bool FFmpegAACBitstreamConverter::ConvertPacket(AVPacket* packet) {
   if (packet == NULL || !packet->data) {
     return false;
   }
 
   int header_plus_packet_size =
       packet->size + kAdtsHeaderSize;
-  if (!stream_codec_context_->extradata) {
+  if (!stream_codec_parameters_->extradata) {
     DLOG(ERROR) << "extradata is null";
     return false;
   }
-  if (stream_codec_context_->extradata_size < 2) {
+  if (stream_codec_parameters_->extradata_size < 2) {
     DLOG(ERROR) << "extradata too small to contain MP4A header";
     return false;
   }
   int sample_rate_index =
-      ((stream_codec_context_->extradata[0] & 0x07) << 1) |
-      ((stream_codec_context_->extradata[1] & 0x80) >> 7);
+      ((stream_codec_parameters_->extradata[0] & 0x07) << 1) |
+      ((stream_codec_parameters_->extradata[1] & 0x80) >> 7);
   if (sample_rate_index > 12) {
     sample_rate_index = 4;
   }
 
-  if (!header_generated_ ||
-      codec_ != stream_codec_context_->codec_id ||
-      audio_profile_ != stream_codec_context_->profile ||
+  if (!header_generated_ || codec_ != stream_codec_parameters_->codec_id ||
+      audio_profile_ != stream_codec_parameters_->profile ||
       sample_rate_index_ != sample_rate_index ||
-      channel_configuration_ != stream_codec_context_->channels ||
+      channel_configuration_ != stream_codec_parameters_->channels ||
       frame_length_ != header_plus_packet_size) {
-    header_generated_ = GenerateAdtsHeader(stream_codec_context_->codec_id,
-                                           0,  // layer
-                                           stream_codec_context_->profile,
-                                           sample_rate_index,
-                                           0,  // private stream
-                                           stream_codec_context_->channels,
-                                           0,  // originality
-                                           0,  // home
-                                           0,  // copyrighted_stream
-                                           0,  // copyright_ start
-                                           header_plus_packet_size,
-                                           0x7FF,  // buffer fullness
-                                           0,  // one frame per packet
-                                           hdr_);
-    codec_ = stream_codec_context_->codec_id;
-    audio_profile_ = stream_codec_context_->profile;
+    header_generated_ =
+        GenerateAdtsHeader(stream_codec_parameters_->codec_id,
+                           0,  // layer
+                           stream_codec_parameters_->profile, sample_rate_index,
+                           0,  // private stream
+                           stream_codec_parameters_->channels,
+                           0,  // originality
+                           0,  // home
+                           0,  // copyrighted_stream
+                           0,  // copyright_ start
+                           header_plus_packet_size,
+                           0x7FF,  // buffer fullness
+                           0,      // one frame per packet
+                           hdr_);
+    codec_ = stream_codec_parameters_->codec_id;
+    audio_profile_ = stream_codec_parameters_->profile;
     sample_rate_index_ = sample_rate_index;
-    channel_configuration_ = stream_codec_context_->channels;
+    channel_configuration_ = stream_codec_parameters_->channels;
     frame_length_ = header_plus_packet_size;
   }
 
   // Inform caller if the header generation failed.
   if (!header_generated_)
     return false;
 
   // Allocate new packet for the output.
   AVPacket dest_packet;
   if (av_new_packet(&dest_packet, header_plus_packet_size) != 0)
     return false;  // Memory allocation failure.
 
   memcpy(dest_packet.data, hdr_, kAdtsHeaderSize);
   memcpy(reinterpret_cast<void*>(dest_packet.data + kAdtsHeaderSize),
          reinterpret_cast<void*>(packet->data), packet->size);
 
   // This is a bit tricky: since the interface does not allow us to replace
   // the pointer of the old packet with a new one, we will initially copy the
   // metadata from old packet to new bigger packet.
   av_packet_copy_props(&dest_packet, packet);
 
   // Release the old packet.
   av_packet_unref(packet);
   *packet = dest_packet;  // Finally, replace the values in the input packet.
 
   return true;
 }
 
 }  // namespace media