| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 // Joint encoder and decoder testing. | |
| 6 // These tests operate directly on the VP8 encoder and decoder, not the | |
| 7 // transport layer, and are targeted at validating the bit stream. | |
| 8 | |
| 9 #include <gtest/gtest.h> | |
| 10 #include <stdint.h> | |
| 11 | |
| 12 #include "base/bind.h" | |
| 13 #include "base/memory/scoped_ptr.h" | |
| 14 #include "media/base/video_frame.h" | |
| 15 #include "media/cast/cast_environment.h" | |
| 16 #include "media/cast/test/fake_single_thread_task_runner.h" | |
| 17 #include "media/cast/test/utility/video_utility.h" | |
| 18 #include "media/cast/video_receiver/codecs/vp8/vp8_decoder.h" | |
| 19 #include "media/cast/video_sender/codecs/vp8/vp8_encoder.h" | |
| 20 | |
| 21 namespace media { | |
| 22 namespace cast { | |
| 23 | |
| 24 static const int64 kStartMillisecond = INT64_C(1245); | |
| 25 static const int kWidth = 1280; | |
| 26 static const int kHeight = 720; | |
| 27 static const int kStartbitrate = 4000000; | |
| 28 static const int kMaxQp = 54; | |
| 29 static const int kMinQp = 4; | |
| 30 static const int kMaxFrameRate = 30; | |
| 31 | |
| 32 namespace { | |
| 33 class EncodeDecodeTestFrameCallback | |
| 34 : public base::RefCountedThreadSafe<EncodeDecodeTestFrameCallback> { | |
| 35 public: | |
| 36 EncodeDecodeTestFrameCallback() : num_called_(0) { | |
| 37 gfx::Size size(kWidth, kHeight); | |
| 38 original_frame_ = media::VideoFrame::CreateFrame( | |
| 39 VideoFrame::I420, size, gfx::Rect(size), size, base::TimeDelta()); | |
| 40 } | |
| 41 | |
| 42 void SetFrameStartValue(int start_value) { | |
| 43 PopulateVideoFrame(original_frame_.get(), start_value); | |
| 44 } | |
| 45 | |
| 46 void DecodeComplete(const scoped_refptr<media::VideoFrame>& decoded_frame, | |
| 47 const base::TimeTicks& render_time) { | |
| 48 ++num_called_; | |
| 49 // Compare resolution. | |
| 50 EXPECT_EQ(original_frame_->coded_size().width(), | |
| 51 decoded_frame->coded_size().width()); | |
| 52 EXPECT_EQ(original_frame_->coded_size().height(), | |
| 53 decoded_frame->coded_size().height()); | |
| 54 // Compare data. | |
| 55 EXPECT_GT(I420PSNR(original_frame_, decoded_frame), 40.0); | |
| 56 } | |
| 57 | |
| 58 int num_called() const { return num_called_; } | |
| 59 | |
| 60 protected: | |
| 61 virtual ~EncodeDecodeTestFrameCallback() {} | |
| 62 | |
| 63 private: | |
| 64 friend class base::RefCountedThreadSafe<EncodeDecodeTestFrameCallback>; | |
| 65 | |
| 66 int num_called_; | |
| 67 scoped_refptr<media::VideoFrame> original_frame_; | |
| 68 }; | |
| 69 } // namespace | |
| 70 | |
| 71 class EncodeDecodeTest : public ::testing::Test { | |
| 72 protected: | |
| 73 EncodeDecodeTest() | |
| 74 : testing_clock_(new base::SimpleTestTickClock()), | |
| 75 task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)), | |
| 76 // CastEnvironment will only be used by the vp8 decoder; Enable only the | |
| 77 // video and main threads. | |
| 78 cast_environment_(new CastEnvironment( | |
| 79 scoped_ptr<base::TickClock>(testing_clock_).Pass(), | |
| 80 task_runner_, | |
| 81 NULL, | |
| 82 task_runner_)), | |
| 83 test_callback_(new EncodeDecodeTestFrameCallback()) { | |
| 84 testing_clock_->Advance( | |
| 85 base::TimeDelta::FromMilliseconds(kStartMillisecond)); | |
| 86 encoder_config_.max_number_of_video_buffers_used = 1; | |
| 87 encoder_config_.number_of_cores = 1; | |
| 88 encoder_config_.width = kWidth; | |
| 89 encoder_config_.height = kHeight; | |
| 90 encoder_config_.start_bitrate = kStartbitrate; | |
| 91 encoder_config_.min_qp = kMaxQp; | |
| 92 encoder_config_.min_qp = kMinQp; | |
| 93 encoder_config_.max_frame_rate = kMaxFrameRate; | |
| 94 int max_unacked_frames = 1; | |
| 95 encoder_.reset(new Vp8Encoder(encoder_config_, max_unacked_frames)); | |
| 96 // Initialize to use one core. | |
| 97 decoder_.reset(new Vp8Decoder(cast_environment_)); | |
| 98 } | |
| 99 | |
| 100 virtual ~EncodeDecodeTest() {} | |
| 101 | |
| 102 virtual void SetUp() OVERRIDE { | |
| 103 // Create test frame. | |
| 104 int start_value = 10; // Random value to start from. | |
| 105 gfx::Size size(encoder_config_.width, encoder_config_.height); | |
| 106 video_frame_ = media::VideoFrame::CreateFrame( | |
| 107 VideoFrame::I420, size, gfx::Rect(size), size, base::TimeDelta()); | |
| 108 PopulateVideoFrame(video_frame_, start_value); | |
| 109 test_callback_->SetFrameStartValue(start_value); | |
| 110 } | |
| 111 | |
| 112 VideoSenderConfig encoder_config_; | |
| 113 scoped_ptr<Vp8Encoder> encoder_; | |
| 114 scoped_ptr<Vp8Decoder> decoder_; | |
| 115 scoped_refptr<media::VideoFrame> video_frame_; | |
| 116 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. | |
| 117 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; | |
| 118 scoped_refptr<CastEnvironment> cast_environment_; | |
| 119 scoped_refptr<EncodeDecodeTestFrameCallback> test_callback_; | |
| 120 }; | |
| 121 | |
| 122 TEST_F(EncodeDecodeTest, BasicEncodeDecode) { | |
| 123 transport::EncodedVideoFrame encoded_frame; | |
| 124 encoder_->Initialize(); | |
| 125 // Encode frame. | |
| 126 encoder_->Encode(video_frame_, &encoded_frame); | |
| 127 EXPECT_GT(encoded_frame.data.size(), UINT64_C(0)); | |
| 128 // Decode frame. | |
| 129 decoder_->Decode(&encoded_frame, | |
| 130 base::TimeTicks(), | |
| 131 base::Bind(&EncodeDecodeTestFrameCallback::DecodeComplete, | |
| 132 test_callback_)); | |
| 133 task_runner_->RunTasks(); | |
| 134 } | |
| 135 | |
| 136 } // namespace cast | |
| 137 } // namespace media | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 225023010:
[Cast] Refactor/clean-up VideoReceiver to match AudioReceiver as closely as possible. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src