Save both original frame and output frame into files if the absolute differences is larger than the…

content/common/gpu/media/video_encode_accelerator_unittest.cc

 // Copyright 2013 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 <inttypes.h>
 
 #include <algorithm>
 #include <queue>
 #include <string>
 
@@ skipping 14 matching lines @@
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "content/common/gpu/media/video_accelerator_unittest_helpers.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/test_data_util.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_frame.h"
+#include "media/base/yuv_convert.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "media/filters/h264_parser.h"
 #include "media/video/fake_video_encode_accelerator.h"
 #include "media/video/video_encode_accelerator.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/codec/png_codec.h"
 
 #if defined(OS_CHROMEOS)
 #if defined(ARCH_CPU_ARMEL) || (defined(USE_OZONE) && defined(USE_V4L2_CODEC))
 #include "content/common/gpu/media/v4l2_video_encode_accelerator.h"
 #endif
 #if defined(ARCH_CPU_X86_FAMILY)
 #include "content/common/gpu/media/vaapi_video_encode_accelerator.h"
 #include "content/common/gpu/media/vaapi_wrapper.h"
 #endif  // defined(ARCH_CPU_X86_FAMILY)
 #else
@@ skipping 557 matching lines @@
                   const gfx::Rect& visible_size,
                   const media::VideoCodecProfile profile);
   // Push original frame to origin_frames_ queue
   void AddOriginFrame(scoped_refptr<media::VideoFrame> frame);
   void Decode(const scoped_refptr<media::DecoderBuffer>& buffer);
 
  private:
   void InitializeCB(bool success);
   void DecodeDone(media::VideoDecoder::Status status);
   void CheckOutputFrame(const scoped_refptr<media::VideoFrame>& output_frame);
-
+  void SaveFrameToFile(const scoped_refptr<media::VideoFrame>& frame,
+                       base::FilePath filename);
   scoped_ptr<media::FFmpegVideoDecoder> decoder_;
   media::VideoDecoder::DecodeCB decode_cb_;
 
   std::queue<scoped_refptr<media::VideoFrame>> origin_frames_;
+
+  int frame_id_;
 };
 
 VideoFrameQualityValidator::VideoFrameQualityValidator()
     : decoder_(new media::FFmpegVideoDecoder(
           base::MessageLoop::current()->task_runner())),
       decode_cb_(base::Bind(&VideoFrameQualityValidator::DecodeDone,
-                            base::Unretained(this))) {
+                            base::Unretained(this))),
+      frame_id_(0) {
   decoder_->set_decode_nalus(true);
 }
 
 void VideoFrameQualityValidator::Initialize(
     const gfx::Size& coded_size,
     const gfx::Rect& visible_size,
     const media::VideoCodecProfile profile) {
   media::FFmpegGlue::InitializeFFmpeg();
+  media::InitializeCPUSpecificYUVConversions();
 
   gfx::Size natural_size(visible_size.size());
   media::VideoDecoderConfig config;
   if (IsVP8(profile))
     config.Initialize(media::kCodecVP8, media::VP8PROFILE_ANY, kInputFormat,
                       media::COLOR_SPACE_UNSPECIFIED, coded_size, visible_size,
                       natural_size, NULL, 0, false, true);
   else if (IsH264(profile))
     config.Initialize(media::kCodecH264, media::H264PROFILE_MAIN, kInputFormat,
                       media::COLOR_SPACE_UNSPECIFIED, coded_size, visible_size,
@@ skipping 22 matching lines @@
 
 void VideoFrameQualityValidator::Decode(
     const scoped_refptr<media::DecoderBuffer>& buffer) {
   decoder_->Decode(buffer, decode_cb_);
 }
 
 void VideoFrameQualityValidator::CheckOutputFrame(
     const scoped_refptr<media::VideoFrame>& output_frame) {
   scoped_refptr<media::VideoFrame> origin_frame = origin_frames_.front();
   origin_frames_.pop();
+  frame_id_++;
 
   gfx::Size visible_size = origin_frame->visible_rect().size();
   int planes[] = {media::VideoFrame::kYPlane,
                   media::VideoFrame::kUPlane,
                   media::VideoFrame::kVPlane};
   double difference = 0;
   for (int plane : planes) {
     uint8_t* origin_plane = origin_frame->data(plane);
     uint8_t* output_plane = output_frame->data(plane);
 
     size_t rows =
         media::VideoFrame::Rows(plane, kInputFormat, visible_size.height());
     size_t columns =
         media::VideoFrame::Columns(plane, kInputFormat, visible_size.width());
     size_t stride = origin_frame->stride(plane);
 
     for (size_t i = 0; i < rows; i++)
       for (size_t j = 0; j < columns; j++)
         difference += std::abs(origin_plane[stride * i + j] -
                                output_plane[stride * i + j]);
   }
   // Divide the difference by the size of frame
   difference /= media::VideoFrame::AllocationSize(kInputFormat, visible_size);
+
+  // Save both origin and output frames to files if its difference is larger
+  // than kDecodeSimilarityThreshold
   CHECK(difference < kDecodeSimilarityThreshold)

[Owen Lin, 2015/08/12 08:07:48]

I thought we will crash at CHECK and then no output will be generated.

       << "differrence = " << difference << " > kDecodeSimilarityThreshold";
+  if (difference >= kDecodeSimilarityThreshold) {
+    std::string filename =
+        base::StringPrintf("%.4d_origin_frame.png", frame_id_);
+    SaveFrameToFile(origin_frame, base::FilePath::FromUTF8Unsafe(filename));
+    filename = base::StringPrintf("%.4d_output_frame.png", frame_id_);
+    SaveFrameToFile(output_frame, base::FilePath::FromUTF8Unsafe(filename));
+  }
+}
+
+void VideoFrameQualityValidator::SaveFrameToFile(
+    const scoped_refptr<media::VideoFrame>& frame,
+    base::FilePath filename) {

[Owen Lin, 2015/08/12 08:07:48]

const base::FilePath &

+  size_t row_bytes = frame->coded_size().width() * 4u;

[Owen Lin, 2015/08/12 08:07:48]

use visible size for rgb_bytes.

+  uint8* rgb_pixels = reinterpret_cast<uint8*>(

[Owen Lin, 2015/08/12 08:07:48]

How do you free the rgb_pixels

+      base::AlignedAlloc(row_bytes * frame->coded_size().height() +
+                             media::VideoFrame::kFrameSizePadding,
+                         media::VideoFrame::kFrameAddressAlignment));
+  media::ConvertYUVToRGB32(
+      frame->data(media::VideoFrame::kYPlane),
+      frame->data(media::VideoFrame::kUPlane),
+      frame->data(media::VideoFrame::kVPlane), rgb_pixels,
+      frame->visible_rect().width(), frame->visible_rect().height(),
+      frame->stride(media::VideoFrame::kYPlane),
+      frame->stride(media::VideoFrame::kUPlane), row_bytes, media::YV12);
+
+  std::vector<unsigned char> png_output;
+  bool success = gfx::PNGCodec::Encode(
+      rgb_pixels, gfx::PNGCodec::FORMAT_RGBA, frame->coded_size(),
+      base::checked_cast<int>(row_bytes), true,
+      std::vector<gfx::PNGCodec::Comment>(), &png_output);
+  if (success) {

[Owen Lin, 2015/08/12 08:07:48]

CHECK(gfx::PNGCodec::...);

+    base::WriteFile(filename, reinterpret_cast<char*>(&*png_output.begin()),
+                    base::checked_cast<int>(png_output.size()));
+  }
 }
 
 class VEAClient : public VideoEncodeAccelerator::Client {
  public:
   VEAClient(TestStream* test_stream,
             ClientStateNotification<ClientState>* note,
             bool save_to_file,
             unsigned int keyframe_period,
             bool force_bitrate,
             bool test_perf,
@@ skipping 947 matching lines @@
 
   content::g_env =
       reinterpret_cast<content::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoEncodeAcceleratorTestEnvironment(
                   test_stream_data.Pass(), log_path, run_at_fps,
                   needs_encode_latency, verify_output)));
 
   return RUN_ALL_TESTS();
 }