Media bench add -hash, 64 bit IO, and some cleanup of dump

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.
@@ skipping 14 matching lines @@
 #include "media/bench/file_protocol.h"
 #include "media/filters/ffmpeg_common.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 
 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";
+const wchar_t kHash[]                   = L"hash";
 }  // namespace switches
 
+namespace {
+// DJB2 hash
+unsigned int hash_djb2(const uint8* s,
+                       size_t len, unsigned int hash) {
+  while (len--)
+    hash = hash * 33 + *s++;
+  return hash;
+}
+}
+
 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 [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"
+              << "  --hash                          "
+              << "Hash decoded buffers\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.";
@@ skipping 32 matching lines @@
   bool fast2 = false;
   if (cmd_line->HasSwitch(switches::kFast2)) {
     fast2 = true;
   }
 
   bool flush = false;
   if (cmd_line->HasSwitch(switches::kFlush)) {
     flush = true;
   }
 
+  unsigned int hash_value = 5381u;  // Seed for DJB2.
+  bool hash = false;
+  if (cmd_line->HasSwitch(switches::kHash)) {
+    hash = true;
+  }
+
   int skip = 0;
   if (cmd_line->HasSwitch(switches::kSkip)) {
     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();
@@ skipping 123 matching lines @@
           ++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;
             }
           }
+          if (hash) {
+            hash_value = hash_djb2(reinterpret_cast<const uint8*>(samples),
+                                   size_out, hash_value);
+          }
         }
       } 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.
-          if (output) {
+          if (output || hash) {
             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;
                     break;
                   case PIX_FMT_YUV444P:
                   case PIX_FMT_YUVJ444P:
-                    copy_lines = copy_lines;
                     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;
+              if (output) {
+                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;
                 }
-                source += source_stride;
+              }
+              if (hash) {
+                for (size_t i = 0; i < copy_lines; ++i) {
+                  hash_value = hash_djb2(source, bytes_per_line, hash_value);
+                  source += source_stride;
+                }
               }
             }
           }
         }
       } else {
         NOTREACHED();
       }
       base::TimeDelta delta = base::TimeTicks::HighResNow() - decode_start;
 
       decode_times.push_back(delta.InMillisecondsF());
@@ skipping 21 matching lines @@
   // Print our results.
   std::cout.setf(std::ios::fixed);
   std::cout.precision(2);
   std::cout << std::endl;
   std::cout << "     Frames:" << std::setw(10) << frames
             << std::endl;
   std::cout << "      Total:" << std::setw(10) << total.InMillisecondsF()
             << " ms" << std::endl;
   std::cout << "  Summation:" << std::setw(10) << sum
             << " ms" << std::endl;
+  if (hash) {
+    std::cout << "       Hash:" << std::setw(10) << hash_value
+              << std::endl;
+  }
 
   if (frames > 0u) {
     // Calculate the average time per frame.
     double average = sum / frames;
 
     // Calculate the sum of the squared differences.
     // Standard deviation will only be accurate if no threads are used.
     // TODO(fbarchard): Rethink standard deviation calculation.
     double squared_sum = 0;
     for (size_t i = 0; i < frames; ++i) {
       double difference = decode_times[i] - average;
       squared_sum += difference * difference;
     }
 
     // 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;
 }