Fix memory leaks in media_bench.

media/bench/bench.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.
 
 // Standalone benchmarking application based on FFmpeg.  This tool is used to
 // measure decoding performance between different FFmpeg compile and run-time
 // options.  We also use this tool to measure performance regressions when
 // testing newer builds of FFmpeg from trunk.
 
 #include "build/build_config.h"
@@ skipping 299 matching lines @@
 
   // Initialize our codec.
   if (avcodec_open(codec_context, codec) < 0) {
     std::cerr << "Error: Could not open codec "
               << codec_context->codec->name << " for "
               << in_path << std::endl;
     return 1;
   }
 
   // Buffer used for audio decoding.
-  int16* samples =
-      reinterpret_cast<int16*>(av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE));
+  scoped_ptr_malloc<int16, media::ScopedPtrAVFree> samples(
+      reinterpret_cast<int16*>(av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE)));
 
   // Buffer used for video decoding.
-  AVFrame* frame = avcodec_alloc_frame();
-  if (!frame) {
+  scoped_ptr_malloc<AVFrame, media::ScopedPtrAVFree> frame(
+      avcodec_alloc_frame());
+  if (!frame.get()) {
     std::cerr << "Error: avcodec_alloc_frame for "
               << in_path << std::endl;
     return 1;
   }
 
   // Stats collector.
   EnterTimingSection();
   std::vector<double> decode_times;
   decode_times.reserve(4096);
   // Parse through the entire stream until we hit EOF.
@@ skipping 20 matching lines @@
       }
     }
 
     // Only decode packets from our target stream.
     if (packet.stream_index == target_stream) {
       int result = -1;
       if (target_codec == CODEC_TYPE_AUDIO) {
         int size_out = AVCODEC_MAX_AUDIO_FRAME_SIZE;
 
         base::TimeTicks decode_start = base::TimeTicks::HighResNow();
-        result = avcodec_decode_audio3(codec_context, samples, &size_out,
+        result = avcodec_decode_audio3(codec_context, samples.get(), &size_out,
                                        &packet);
         base::TimeDelta delta = base::TimeTicks::HighResNow() - decode_start;
 
         if (size_out) {
           decode_times.push_back(delta.InMillisecondsF());
           ++frames;
           read_result = 0;  // Force continuation.
 
           if (output) {
-            if (fwrite(samples, 1, size_out, output) !=
+            if (fwrite(samples.get(), 1, size_out, output) !=
                 static_cast<size_t>(size_out)) {
               std::cerr << "Error: Could not write "
                         << size_out << " bytes for " << in_path << std::endl;
               return 1;
             }
           }
+
+          const uint8* u8_samples =
+              reinterpret_cast<const uint8*>(samples.get());
           if (hash_djb2) {
-            hash_value = DJB2Hash(reinterpret_cast<const uint8*>(samples),
-                                  size_out, hash_value);
+            hash_value = DJB2Hash(u8_samples, size_out, hash_value);
           }
           if (hash_md5) {
-            MD5Update(&ctx, reinterpret_cast<const uint8*>(samples),
-                      size_out);
+            MD5Update(&ctx, u8_samples, size_out);
           }
         }
       } else if (target_codec == CODEC_TYPE_VIDEO) {
         int got_picture = 0;
 
         base::TimeTicks decode_start = base::TimeTicks::HighResNow();
-        result = avcodec_decode_video2(codec_context, frame, &got_picture,
-                                       &packet);
+        result = avcodec_decode_video2(codec_context, frame.get(),
+                                       &got_picture, &packet);
         base::TimeDelta delta = base::TimeTicks::HighResNow() - decode_start;
 
         if (got_picture) {
           decode_times.push_back(delta.InMillisecondsF());
           ++frames;
           read_result = 0;  // Force continuation.
 
           for (int plane = 0; plane < 3; ++plane) {
             const uint8* source = frame->data[plane];
             const size_t source_stride = frame->linesize[plane];
@@ skipping 59 matching lines @@
     }
     // Free our packet.
     av_free_packet(&packet);
 
     if (max_frames && (frames >= max_frames))
       break;
   } while (read_result >= 0);
   base::TimeDelta total = base::TimeTicks::HighResNow() - start;
   LeaveTimingSection();
 
+  // Clean up.
   if (output)
     file_util::CloseFile(output);
+  if (codec_context)
+    avcodec_close(codec_context);
+  if (format_context)
+    av_close_input_file(format_context);
 
   // Calculate the sum of times.  Note that some of these may be zero.
   double sum = 0;
   for (size_t i = 0; i < decode_times.size(); ++i) {
     sum += decode_times[i];
   }
 
   // Print our results.
   log_out->setf(std::ios::fixed);
   log_out->precision(2);
@@ skipping 38 matching lines @@
   }
 #if defined(OS_WIN)
   } __except(EXCEPTION_EXECUTE_HANDLER) {
     *log_out << "  Exception:" << std::setw(11) << GetExceptionCode()
              << " " << in_path << std::endl;
     return 1;
   }
 #endif
   return 0;
 }