Cleanup resources allocated by FFmpeg to avoid memory and threads leaks...

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2009 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 "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "media/base/filter_host.h"
 #include "media/filters/ffmpeg_common.h"
@@ skipping 197 matching lines @@
 base::TimeDelta FFmpegDemuxerStream::ConvertTimestamp(int64 timestamp) {
   AVRational time_base = { 1, base::Time::kMicrosecondsPerSecond };
   int64 microseconds = av_rescale_q(timestamp, stream_->time_base, time_base);
   return base::TimeDelta::FromMicroseconds(microseconds);
 }
 
 //
 // FFmpegDemuxer
 //
 FFmpegDemuxer::FFmpegDemuxer()
-    : thread_id_(NULL) {
+    : format_context_(NULL),
+      thread_id_(NULL) {
 }
 
 FFmpegDemuxer::~FFmpegDemuxer() {
-  DCHECK(!format_context_.get());
-  // TODO(scherkus): I believe we need to use av_close_input_file() here
-  // instead of scoped_ptr_malloc calling av_free().
-  //
-  // Note that av_close_input_file() doesn't close the codecs so we need to
-  // figure out who's responsible for closing the them.
+  // In this destructor, we clean up resources held by FFmpeg. It is ugly to
+  // close the codec contexts here because the corresponding codecs are opened
+  // in the decoder filters. By reaching this point, all filters should have
+  // stopped, so this is the only safe place to do the global clean up.
+  // TODO(hclam): close the codecs in the corresponding decoders.
+  AutoLock auto_lock(FFmpegLock::get()->lock());
+  if (!format_context_)
+    return;
+
+  // Iterate each stream and destroy each one of them.
+  int streams = format_context_->nb_streams;
+  for (int i = 0; i < streams; ++i) {
+    AVStream* stream = format_context_->streams[i];
+
+    // The conditions for calling avcodec_close():
+    // 1. AVStream is alive.
+    // 2. AVCodecContext in AVStream is alive.
+    // 3. AVCodec in AVCodecContext is alive.
+    // Notice that closing a codec context without prior avcodec_open() will
+    // result in a crash in FFmpeg.
+    if (stream && stream->codec && stream->codec->codec) {
+      stream->discard = AVDISCARD_ALL;
+      avcodec_close(stream->codec);
+    }
+  }
+
+  // Then finally cleanup the format context.
+  av_close_input_file(format_context_);
+  format_context_ = NULL;
 }
 
 void FFmpegDemuxer::PostDemuxTask() {
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxer::DemuxTask));
 }
 
 void FFmpegDemuxer::Stop() {
   // Post a task to notify the streams to stop as well.
   message_loop_->PostTask(FROM_HERE,
@@ skipping 36 matching lines @@
   // Refer to media/filters/ffmpeg_glue.h for details.
 
   // Grab the thread id for debugging.
   DCHECK(!thread_id_);
   thread_id_ = PlatformThread::CurrentId();
 
   // Add our data source and get our unique key.
   std::string key = FFmpegGlue::get()->AddDataSource(data_source);
 
   // Open FFmpeg AVFormatContext.
-  DCHECK(!format_context_.get());
+  DCHECK(!format_context_);
   AVFormatContext* context = NULL;
   int result = av_open_input_file(&context, key.c_str(), NULL, 0, NULL);
 
   // Remove our data source.
   FFmpegGlue::get()->RemoveDataSource(data_source);
 
   if (result < 0) {
     host_->Error(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
-  // Assign to our scoped_ptr_malloc.
   DCHECK(context);
-  format_context_.reset(context);
+  format_context_ = context;
 
   // Serialize calls to av_find_stream_info().
   {
     AutoLock auto_lock(FFmpegLock::get()->lock());
 
     // Fully initialize AVFormatContext by parsing the stream a little.
-    result = av_find_stream_info(format_context_.get());
+    result = av_find_stream_info(format_context_);
     if (result < 0) {
       host_->Error(DEMUXER_ERROR_COULD_NOT_PARSE);
       return;
     }
   }
 
   // Create demuxer streams for all supported streams.
   base::TimeDelta max_duration;
   for (size_t i = 0; i < format_context_->nb_streams; ++i) {
     CodecType codec_type = format_context_->streams[i]->codec->codec_type;
@@ skipping 27 matching lines @@
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     (*iter)->FlushBuffers();
   }
 
   // Seek backwards if requested timestamp is behind FFmpeg's current time.
   int flags = 0;
   if (time <= current_timestamp_) {
     flags |= AVSEEK_FLAG_BACKWARD;
   }
 
-  if (av_seek_frame(format_context_.get(), -1, time.InMicroseconds(),
+  if (av_seek_frame(format_context_, -1, time.InMicroseconds(),
                     flags) < 0) {
     // TODO(scherkus): signal error.
     NOTIMPLEMENTED();
   }
 }
 
 void FFmpegDemuxer::DemuxTask() {
   DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
 
   // Make sure we have work to do before demuxing.
   if (!StreamsHavePendingReads()) {
     return;
   }
 
   // Allocate and read an AVPacket from the media.
   scoped_ptr<AVPacket> packet(new AVPacket());
-  int result = av_read_frame(format_context_.get(), packet.get());
+  int result = av_read_frame(format_context_, packet.get());
   if (result < 0) {
     // If we have reached the end of stream, tell the downstream filters about
     // the event.
     StreamHasEnded();
     return;
   }
 
   // Queue the packet with the appropriate stream.
   // TODO(scherkus): should we post this back to the pipeline thread?  I'm
   // worried about downstream filters (i.e., decoders) executing on this
@@ skipping 32 matching lines @@
     PostDemuxTask();
   }
 }
 
 void FFmpegDemuxer::StopTask() {
   DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     (*iter)->Stop();
   }
-
-  // Free our AVFormatContext.
-  format_context_.reset();
 }
 
 bool FFmpegDemuxer::StreamsHavePendingReads() {
   DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if ((*iter)->HasPendingReads()) {
       return true;
     }
   }
   return false;
 }
 
 void FFmpegDemuxer::StreamHasEnded() {
   DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     AVPacket* packet = new AVPacket();
     memset(packet, 0, sizeof(*packet));
     (*iter)->EnqueuePacket(packet);
   }
 }
 
 }  // namespace media