media_bench optionally dump raw output to a file....

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.
 //
 // This tool requires FFMPeg DLL's built with --enable-protocol=file.
 
 #include <iomanip>
 #include <iostream>
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "media/base/media.h"
 #include "media/filters/ffmpeg_common.h"
+#include "media/filters/ffmpeg_video_decoder.h"

[scherkus (not reviewing), 2009/09/03 22:03:36]

hmm.. don't think you need to include this

 
 namespace switches {
 const wchar_t kStream[]                 = L"stream";
 const wchar_t kVideoThreads[]           = L"video-threads";
 const wchar_t kFast2[]                  = L"fast2";
 const wchar_t kSkip[]                   = L"skip";
 const wchar_t kFlush[]                  = L"flush";
 }  // namespace switches
 
 int main(int argc, const char** argv) {
   base::AtExitManager exit_manager;
 
   CommandLine::Init(argc, argv);
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 
   std::vector<std::wstring> filenames(cmd_line->GetLooseValues());
   if (filenames.empty()) {
-    std::cerr << "Usage: media_bench [OPTIONS] FILE\n"
+    std::cerr << "Usage: media_bench [OPTIONS] FILE [DUMPFILE]\n"
               << "  --stream=[audio|video]          "
               << "Benchmark either the audio or video stream\n"
               << "  --video-threads=N               "
               << "Decode video using N threads\n"
               << "  --fast2                         "
               << "Enable fast2 flag\n"
               << "  --flush                         "
               << "Flush last frame\n"
               << "  --skip=[1|2|3]                  "
               << "1=loop nonref, 2=loop, 3= frame nonref\n" << std::endl;
     return 1;
   }
 
   // Initialize our media library (try loading DLLs, etc.) before continuing.
   // We use an empty file path as the parameter to force searching of the
   // default locations for necessary DLLs and DSOs.
   if (media::InitializeMediaLibrary(FilePath()) == false) {
     std::cerr << "Unable to initialize the media library.";
     return 1;
   }
 
   // Retrieve command line options.
-  std::string path(WideToUTF8(filenames[0]));
+  std::string in_path(WideToUTF8(filenames[0]));
+  std::string out_path;
+  if (filenames.size() > 1) {
+    out_path = WideToUTF8(filenames[1]);
+  }
   CodecType target_codec = CODEC_TYPE_UNKNOWN;
   int video_threads = 0;
 
   // Determine whether to benchmark audio or video decoding.
   std::wstring stream(cmd_line->GetSwitchValue(switches::kStream));
   if (!stream.empty()) {
     if (stream.compare(L"audio") == 0) {
       target_codec = CODEC_TYPE_AUDIO;
     } else if (stream.compare(L"video") == 0) {
       target_codec = CODEC_TYPE_VIDEO;
@@ skipping 25 matching lines @@
     std::wstring skip_opt(cmd_line->GetSwitchValue(switches::kSkip));
     if (!StringToInt(WideToUTF16Hack(skip_opt), &skip)) {
       skip = 0;
     }
   }
 
   // Register FFmpeg and attempt to open file.
   avcodec_init();
   av_register_all();
   AVFormatContext* format_context = NULL;
-  if (av_open_input_file(&format_context, path.c_str(), NULL, 0, NULL) < 0) {
-    std::cerr << "Could not open " << path << std::endl;
+  if (av_open_input_file(&format_context, in_path.c_str(), NULL, 0, NULL) < 0) {
+    std::cerr << "Could not open " << in_path << std::endl;
     return 1;
   }
 
+  // Open output file.
+  FILE *output = NULL;

[scherkus (not reviewing), 2009/09/03 22:03:36]

pointer goes with typename

+  if (!out_path.empty()) {
+    output = file_util::OpenFile(out_path.c_str(), "wb");
+    if (!output) {
+      LOG(ERROR) << "could not open output";
+      return 1;
+    }
+  }
+
   // Parse a little bit of the stream to fill out the format context.
   if (av_find_stream_info(format_context) < 0) {
-    std::cerr << "Could not find stream info for " << path << std::endl;
+    std::cerr << "Could not find stream info for " << in_path << std::endl;
     return 1;
   }
 
   // Find our target stream.
   int target_stream = -1;
   for (size_t i = 0; i < format_context->nb_streams; ++i) {
     AVCodecContext* codec_context = format_context->streams[i]->codec;
     AVCodec* codec = avcodec_find_decoder(codec_context->codec_id);
 
     // See if we found our target codec.
@@ skipping 84 matching lines @@
     if (packet.stream_index == target_stream) {
       int result = -1;
       base::TimeTicks decode_start = base::TimeTicks::HighResNow();
       if (target_codec == CODEC_TYPE_AUDIO) {
         int size_out = AVCODEC_MAX_AUDIO_FRAME_SIZE;
         result = avcodec_decode_audio3(codec_context, samples, &size_out,
                                        &packet);
         if (size_out) {
           ++frames;
           read_result = 0;  // Force continuation.
+
+          if (output) {
+            if (fwrite(samples, 1, size_out, output) !=
+                static_cast<size_t>(size_out)) {
+              std::cerr << "could not write data after " << size_out;
+              return 1;
+            }
+          }
         }
       } else if (target_codec == CODEC_TYPE_VIDEO) {
         int got_picture = 0;
         result = avcodec_decode_video2(codec_context, frame, &got_picture,
                                        &packet);
         if (got_picture) {
           ++frames;
           read_result = 0;  // Force continuation.
+
+          // TODO(fbarchard): support formats other than YV12.

[scherkus (not reviewing), 2009/09/03 22:03:36]

this comment is out of date

+          if (output) {
+            for (int plane = 0; plane < 3; ++plane) {
+              const uint8* source = frame->data[plane];
+              const size_t source_stride = frame->linesize[plane];
+              size_t bytes_per_line = codec_context->width;
+              size_t copy_lines = codec_context->height;
+              if (plane != 0) {
+                switch (codec_context->pix_fmt) {
+                  case PIX_FMT_YUV420P:
+                  case PIX_FMT_YUVJ420P:
+                    bytes_per_line /= 2;
+                    copy_lines = (copy_lines + 1) / 2;
+                    break;
+                  case PIX_FMT_YUV422P:
+                  case PIX_FMT_YUVJ422P:
+                    bytes_per_line /= 2;
+                    copy_lines = copy_lines;

[scherkus (not reviewing), 2009/09/03 22:03:36]

redundant?

+                    break;
+                  case PIX_FMT_YUV444P:
+                  case PIX_FMT_YUVJ444P:
+                    copy_lines = copy_lines;

[scherkus (not reviewing), 2009/09/03 22:03:36]

redundant?

+                    break;
+                  default:
+                    std::cerr << "unknown video format: "
+                              << codec_context->pix_fmt;
+                    return 1;
+                }
+              }
+              for (size_t i = 0; i < copy_lines; ++i) {
+                if (fwrite(source, 1, bytes_per_line, output) !=
+                           bytes_per_line) {
+                  std::cerr << "could not write data after "
+                            << bytes_per_line;
+                  return 1;
+                }
+                source += source_stride;
+              }
+            }
+          }
         }
       } else {
         NOTREACHED();
       }
       base::TimeDelta delta = base::TimeTicks::HighResNow() - decode_start;
 
       decode_times.push_back(delta.InMillisecondsF());
 
       // Make sure our decoding went OK.
       if (result < 0) {
         std::cerr << "Error while decoding" << std::endl;
         return 1;
       }
     }
     // Free our packet.
     av_free_packet(&packet);
   } while (read_result >= 0);
   base::TimeDelta total = base::TimeTicks::HighResNow() - start;
 
+  if (output)
+    file_util::CloseFile(output);
+
   // 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.
   std::cout.setf(std::ios::fixed);
   std::cout.precision(2);
   std::cout << std::endl;
@@ skipping 20 matching lines @@
     // Calculate the standard deviation (jitter).
     double stddev = sqrt(squared_sum / frames);
 
     std::cout << "    Average:" << std::setw(10) << average
               << " ms" << std::endl;
     std::cout << "     StdDev:" << std::setw(10) << stddev
               << " ms" << std::endl;
   }
   return 0;
 }