Extract IVF parser from VP8 parser unittest

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 "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/memory/scoped_vector.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
-#include "base/sys_byteorder.h"
 #include "base/threading/thread.h"
 #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/test_data_util.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"
 
 #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"
@@ skipping 67 matching lines @@
 const char* g_default_in_parameters = ":320:192:1:out.h264:200000";
 
 // Enabled by including a --fake_encoder flag to the command line invoking the
 // test.
 bool g_fake_encoder = false;
 
 // Environment to store test stream data for all test cases.
 class VideoEncodeAcceleratorTestEnvironment;
 VideoEncodeAcceleratorTestEnvironment* g_env;
 
-struct IvfFileHeader {
-  char signature[4];     // signature: 'DKIF'
-  uint16_t version;      // version (should be 0)
-  uint16_t header_size;  // size of header in bytes
-  uint32_t fourcc;       // codec FourCC (e.g., 'VP80')
-  uint16_t width;        // width in pixels
-  uint16_t height;       // height in pixels
-  uint32_t framerate;    // frame rate per seconds
-  uint32_t timescale;    // time scale. For example, if framerate is 30 and
-                         // timescale is 2, the unit of IvfFrameHeader.timestamp
-                         // is 2/30 seconds.
-  uint32_t num_frames;   // number of frames in file
-  uint32_t unused;       // unused
-} __attribute__((packed));
-
-struct IvfFrameHeader {
-  uint32_t frame_size;  // Size of frame in bytes (not including the header)
-  uint64_t timestamp;   // 64-bit presentation timestamp
-} __attribute__((packed));
-
 // The number of frames to be encoded. This variable is set by the switch
 // "--num_frames_to_encode". Ignored if 0.
 int g_num_frames_to_encode = 0;
 
 struct TestStream {
   TestStream()
       : num_frames(0),
         aligned_buffer_size(0),
         requested_bitrate(0),
         requested_framerate(0),
@@ skipping 1131 matching lines @@
   // All requested keyframes should've been provided. Allow the last requested
   // frame to remain undelivered if we haven't reached the maximum frame number
   // by which it should have arrived.
   if (num_encoded_frames_ < next_keyframe_at_  + kMaxKeyframeDelay)
     EXPECT_LE(num_keyframes_requested_, 1UL);
   else
     EXPECT_EQ(num_keyframes_requested_, 0UL);
 }
 
 void VEAClient::WriteIvfFileHeader() {
-  IvfFileHeader header;
+  media::IvfFileHeader header = {};
 
-  memset(&header, 0, sizeof(header));
-  header.signature[0] = 'D';
-  header.signature[1] = 'K';
-  header.signature[2] = 'I';
-  header.signature[3] = 'F';
+  memcpy(header.signature, media::kIvfHeaderSignature,
+         sizeof(header.signature));
   header.version = 0;
-  header.header_size = base::ByteSwapToLE16(sizeof(header));
-  header.fourcc = base::ByteSwapToLE32(0x30385056);  // VP80
-  header.width = base::ByteSwapToLE16(
-      base::checked_cast<uint16_t>(test_stream_->visible_size.width()));
-  header.height = base::ByteSwapToLE16(
-      base::checked_cast<uint16_t>(test_stream_->visible_size.height()));
-  header.framerate = base::ByteSwapToLE32(requested_framerate_);
-  header.timescale = base::ByteSwapToLE32(1);
-  header.num_frames = base::ByteSwapToLE32(num_frames_to_encode_);
+  header.header_size = sizeof(header);
+  header.fourcc = 0x30385056;  // VP80
+  header.width =
+      base::checked_cast<uint16_t>(test_stream_->visible_size.width());
+  header.height =
+      base::checked_cast<uint16_t>(test_stream_->visible_size.height());
+  header.timebase_denum = requested_framerate_;
+  header.timebase_num = 1;
+  header.num_frames = num_frames_to_encode_;
+  header.ByteSwap();
 
   EXPECT_TRUE(base::AppendToFile(
       base::FilePath::FromUTF8Unsafe(test_stream_->out_filename),
       reinterpret_cast<char*>(&header), sizeof(header)));
 }
 
 void VEAClient::WriteIvfFrameHeader(int frame_index, size_t frame_size) {
-  IvfFrameHeader header;
+  media::IvfFrameHeader header = {};
 
-  memset(&header, 0, sizeof(header));
-  header.frame_size = base::ByteSwapToLE32(frame_size);
-  header.timestamp = base::ByteSwapToLE64(frame_index);
+  header.frame_size = frame_size;
+  header.timestamp = frame_index;
+  header.ByteSwap();
   EXPECT_TRUE(base::AppendToFile(
       base::FilePath::FromUTF8Unsafe(test_stream_->out_filename),
       reinterpret_cast<char*>(&header), sizeof(header)));
 }
 
 // Test parameters:
 // - Number of concurrent encoders. The value takes effect when there is only
 //   one input stream; otherwise, one encoder per input stream will be
 //   instantiated.
 // - If true, save output to file (provided an output filename was supplied).
@@ skipping 191 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)));
 
   return RUN_ALL_TESTS();
 }