FFmpeg roll for M31.

media/filters/ffmpeg_audio_decoder.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/filters/ffmpeg_audio_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 339 matching lines @@
 
   // Release existing decoder resources if necessary.
   ReleaseFFmpegResources();
 
   // Initialize AVCodecContext structure.
   codec_context_ = avcodec_alloc_context3(NULL);
   AudioDecoderConfigToAVCodecContext(config, codec_context_);
 
   codec_context_->opaque = this;
   codec_context_->get_buffer2 = GetAudioBufferImpl;
+  codec_context_->refcounted_frames = 1;
 
   AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
   if (!codec || avcodec_open2(codec_context_, codec, NULL) < 0) {
     DLOG(ERROR) << "Could not initialize audio decoder: "
                 << codec_context_->codec_id;
     return false;
   }
 
   // Success!
   av_frame_ = avcodec_alloc_frame();
@@ skipping 19 matching lines @@
   return true;
 }
 
 void FFmpegAudioDecoder::ReleaseFFmpegResources() {
   if (codec_context_) {
     av_free(codec_context_->extradata);
     avcodec_close(codec_context_);
     av_free(codec_context_);
   }
 
-  if (av_frame_) {
-    av_free(av_frame_);
-    av_frame_ = NULL;
-  }
+  if (av_frame_)
+    av_frame_free(&av_frame_);
 }
 
 void FFmpegAudioDecoder::ResetTimestampState() {
   output_timestamp_helper_->SetBaseTimestamp(kNoTimestamp());
   last_input_timestamp_ = kNoTimestamp();
   output_frames_to_drop_ = 0;
 }
 
 void FFmpegAudioDecoder::RunDecodeLoop(
     const scoped_refptr<DecoderBuffer>& input,
     bool skip_eos_append) {
   AVPacket packet;
   av_init_packet(&packet);
   if (input->end_of_stream()) {
     packet.data = NULL;
     packet.size = 0;
   } else {
     packet.data = const_cast<uint8*>(input->data());
     packet.size = input->data_size();
   }
 
   // Each audio packet may contain several frames, so we must call the decoder
   // until we've exhausted the packet.  Regardless of the packet size we always
   // want to hand it to the decoder at least once, otherwise we would end up
   // skipping end of stream packets since they have a size of zero.
   do {
-    // Reset frame to default values.
-    avcodec_get_frame_defaults(av_frame_);
-
     int frame_decoded = 0;
     int result = avcodec_decode_audio4(
         codec_context_, av_frame_, &frame_decoded, &packet);
 
     if (result < 0) {
       DCHECK(!input->end_of_stream())
           << "End of stream buffer produced an error! "
           << "This is quite possibly a bug in the audio decoder not handling "
           << "end of stream AVPackets correctly.";
 
@@ skipping 38 matching lines @@
                     << " Sample Rate: " << av_frame_->sample_rate << " vs "
                     << samples_per_second_
                     << ", Channels: " << channels << " vs "
                     << channels_
                     << ", Sample Format: " << av_frame_->format << " vs "
                     << av_sample_format_;
 
         // This is an unrecoverable error, so bail out.
         QueuedAudioBuffer queue_entry = { kDecodeError, NULL };
         queued_audio_.push_back(queue_entry);
+        av_frame_unref(av_frame_);
         break;
       }
 
       // Get the AudioBuffer that the data was decoded into. Adjust the number
       // of frames, in case fewer than requested were actually decoded.
       output = reinterpret_cast<AudioBuffer*>(
           av_buffer_get_opaque(av_frame_->buf[0]));
       DCHECK_EQ(channels_, output->channel_count());
       original_frames = av_frame_->nb_samples;
       int unread_frames = output->frame_count() - original_frames;
       DCHECK_GE(unread_frames, 0);
       if (unread_frames > 0)
         output->TrimEnd(unread_frames);
 
       // If there are frames to drop, get rid of as many as we can.
       if (output_frames_to_drop_ > 0) {
         int drop = std::min(output->frame_count(), output_frames_to_drop_);
         output->TrimStart(drop);
         output_frames_to_drop_ -= drop;
       }
 
       decoded_frames = output->frame_count();
+      av_frame_unref(av_frame_);
     }
 
+    // WARNING: |av_frame_| no longer has valid data at this point.
+
     if (decoded_frames > 0) {
       // Set the timestamp/duration once all the extra frames have been
       // discarded.
       output->set_timestamp(output_timestamp_helper_->GetTimestamp());
       output->set_duration(
           output_timestamp_helper_->GetFrameDuration(decoded_frames));
       output_timestamp_helper_->AddFrames(decoded_frames);
     } else if (IsEndOfStream(result, original_frames, input) &&
                !skip_eos_append) {
       DCHECK_EQ(packet.size, 0);
@@ skipping 11 matching lines @@
     // Decoding finished successfully, update statistics.
     if (result > 0) {
       PipelineStatistics statistics;
       statistics.audio_bytes_decoded = result;
       statistics_cb_.Run(statistics);
     }
   } while (packet.size > 0);
 }
 
 }  // namespace media