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 13 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/filters/ivf_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"
 // Status has been defined as int in Xlib.h.
 #undef Status
@@ skipping 557 matching lines @@
   void AddDecodeBuffer(const scoped_refptr<media::DecoderBuffer>& buffer);
   // Flush the decoder.
   void Flush();
 
  private:
   void InitializeCB(bool success);
   void DecodeDone(media::VideoDecoder::Status status);
   void FlushDone(media::VideoDecoder::Status status);
   void VerifyOutputFrame(const scoped_refptr<media::VideoFrame>& output_frame);
   void Decode();
+  void SaveFrameToFile(const scoped_refptr<media::VideoFrame>& frame,
+                       const base::FilePath& filename);
 
   enum State { UNINITIALIZED, INITIALIZED, DECODING, ERROR };
 
   const media::VideoCodecProfile profile_;
   scoped_ptr<media::FFmpegVideoDecoder> decoder_;
   media::VideoDecoder::DecodeCB decode_cb_;
   // Decode callback of an EOS buffer.
   media::VideoDecoder::DecodeCB eos_decode_cb_;
   // Callback of Flush(). Called after all frames are decoded.
   const base::Closure flush_complete_cb_;
   const base::Closure decode_error_cb_;
   State decoder_state_;
   std::queue<scoped_refptr<media::VideoFrame>> original_frames_;
   std::queue<scoped_refptr<media::DecoderBuffer>> decode_buffers_;
+
+  int frame_id_;
 };
 
 VideoFrameQualityValidator::VideoFrameQualityValidator(
     const media::VideoCodecProfile profile,
     const base::Closure& flush_complete_cb,
     const base::Closure& decode_error_cb)
     : profile_(profile),
       decoder_(new media::FFmpegVideoDecoder(base::MessageLoop::current()
                                                  ->task_runner())),
       decode_cb_(base::Bind(&VideoFrameQualityValidator::DecodeDone,
                             base::Unretained(this))),
       eos_decode_cb_(base::Bind(&VideoFrameQualityValidator::FlushDone,
                                 base::Unretained(this))),
       flush_complete_cb_(flush_complete_cb),
       decode_error_cb_(decode_error_cb),
-      decoder_state_(UNINITIALIZED) {
+      decoder_state_(UNINITIALIZED),
+      frame_id_(0) {
   // Allow decoding of individual NALU. Entire frames are required by default.
   decoder_->set_decode_nalus(true);
 }
 
 void VideoFrameQualityValidator::Initialize(const gfx::Size& coded_size,
                                             const gfx::Rect& visible_size) {
   media::FFmpegGlue::InitializeFFmpeg();
+  media::InitializeCPUSpecificYUVConversions();
 
   gfx::Size natural_size(visible_size.size());
   // The default output format of ffmpeg video decoder is YV12.
   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);
   else if (IsH264(profile_))
     config.Initialize(media::kCodecH264, media::H264PROFILE_MAIN, kInputFormat,
@@ skipping 68 matching lines @@
     else
       decoder_->Decode(next_buffer, decode_cb_);
   }
 }
 
 void VideoFrameQualityValidator::VerifyOutputFrame(
     const scoped_refptr<media::VideoFrame>& output_frame) {
   scoped_refptr<media::VideoFrame> original_frame = original_frames_.front();
   original_frames_.pop();
   gfx::Size visible_size = original_frame->visible_rect().size();
+  frame_id_++;
 
   int planes[] = {media::VideoFrame::kYPlane, media::VideoFrame::kUPlane,
                   media::VideoFrame::kVPlane};
   double difference = 0;
   for (int plane : planes) {
     uint8_t* original_plane = original_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 = original_frame->stride(plane);
 
     for (size_t i = 0; i < rows; i++)
       for (size_t j = 0; j < columns; j++)
         difference += std::abs(original_plane[stride * i + j] -
                                output_plane[stride * i + j]);
   }
   // Divide the difference by the size of frame.
   difference /= media::VideoFrame::AllocationSize(kInputFormat, visible_size);
   EXPECT_TRUE(difference <= kDecodeSimilarityThreshold)
       << "differrence = " << difference << "  > decode similarity threshold";
+
+  // Save both origin and output frames to files if its difference is larger
+  // than kDecodeSimilarityThreshold
+  if (difference >= kDecodeSimilarityThreshold) {
+    std::string filename =
+        base::StringPrintf("%.4d_origin_frame.png", frame_id_);
+    SaveFrameToFile(original_frame, base::FilePath::FromUTF8Unsafe(filename));
+    filename = base::StringPrintf("%.4d_output_frame.png", frame_id_);
+    SaveFrameToFile(output_frame, base::FilePath::FromUTF8Unsafe(filename));

[Owen Lin, 2015/09/04 03:34:47]

Remove EXPECT_TRUE at l.773
Add the following line here. 
ADD_FAILURE() << "difference = " ......

+  }
+}
+
+void VideoFrameQualityValidator::SaveFrameToFile(
+    const scoped_refptr<media::VideoFrame>& frame,
+    const base::FilePath& filename) {
+  size_t row_bytes = frame->visible_rect().width() * 4u;

[Owen Lin, 2015/09/04 03:34:47]

const int RGB32_BYTES_PER_PIXEL = 4;

+  uint8* rgb_pixels = reinterpret_cast<uint8*>(
+      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;
+  CHECK(gfx::PNGCodec::Encode(

[Owen Lin, 2015/09/04 03:34:47]

LOG_ASSERT

+      rgb_pixels, gfx::PNGCodec::FORMAT_RGBA, frame->coded_size(),
+      base::checked_cast<int>(row_bytes), true,
+      std::vector<gfx::PNGCodec::Comment>(), &png_output));
+  base::WriteFile(filename, reinterpret_cast<char*>(&*png_output.begin()),

[Owen Lin, 2015/09/04 03:34:47]

&png_output[0]

+                  base::checked_cast<int>(png_output.size()));
+  base::AlignedFree(rgb_pixels);
 }
 
 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 989 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_all_output)));
 
   return RUN_ALL_TESTS();
 }