| /* |
| * Copyright (c) 2013 The WebM project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include <queue> |
| #include <string> |
| |
| #include "test/codec_factory.h" |
| #include "test/decode_test_driver.h" |
| #include "test/ivf_video_source.h" |
| #include "test/md5_helper.h" |
| #include "test/util.h" |
| #include "test/webm_video_source.h" |
| |
| namespace { |
| |
| const int kVideoNameParam = 1; |
| |
| const char *kLRUTestVectors[] = { |
| "vp90-2-02-size-lf-1920x1080.webm", |
| "vp90-2-05-resize.ivf", |
| }; |
| |
| // Callback used by libvpx to request the application to allocate a frame |
| // buffer of at least |new_size| in bytes. |
| int realloc_vp9_frame_buffer(void *user_priv, size_t new_size, |
| vpx_codec_frame_buffer_t *fb) { |
| (void)user_priv; |
| if (fb == NULL) |
| return -1; |
| |
| delete [] fb->data; |
| fb->data = new uint8_t[new_size]; |
| fb->size = new_size; |
| |
| return 0; |
| } |
| |
| // Class for testing libvpx is using the least recently |
| // used frame buffer when a new buffer is requested. |
| class LRUFrameBufferTest |
| : public ::libvpx_test::DecoderTest, |
| public ::libvpx_test::CodecTestWithParam<const char*> { |
| protected: |
| struct FrameBufferMD5Sum { |
| int frame_buffer_index; |
| vpx_image_t img; |
| std::string md5; |
| }; |
| |
| LRUFrameBufferTest() |
| : DecoderTest(GET_PARAM(::libvpx_test::kCodecFactoryParam)), |
| num_buffers_(0), |
| num_jitter_buffers_(0), |
| frame_buffers_(NULL) {} |
| |
| virtual ~LRUFrameBufferTest() { |
| for (int i = 0; i < num_buffers_; ++i) { |
| delete [] frame_buffers_[i].data; |
| } |
| delete [] frame_buffers_; |
| } |
| |
| virtual void PreDecodeFrameHook( |
| const libvpx_test::CompressedVideoSource &video, |
| libvpx_test::Decoder *decoder) { |
| // Use external buffers for testing jitter buffers. |
| if (num_jitter_buffers_ > 0 && video.frame_number() == 0) { |
| const int max_reference_buffers = 8; |
| |
| // Add 1 for a work buffer. |
| num_buffers_ = max_reference_buffers + 1 + num_jitter_buffers_; |
| |
| // Have libvpx use frame buffers we create. |
| frame_buffers_ = new vpx_codec_frame_buffer_t[num_buffers_]; |
| memset(frame_buffers_, 0, sizeof(frame_buffers_[0]) * num_buffers_); |
| |
| decoder->SetExternalFrameBuffers(frame_buffers_, num_buffers_, |
| realloc_vp9_frame_buffer, NULL); |
| } |
| |
| // Turn on frame buffer LRU cache. |
| decoder->Control(VP9D_SET_FRAME_BUFFER_LRU_CACHE, 1); |
| } |
| |
| virtual void DecompressedFrameHook(const vpx_image_t &img, |
| const unsigned int frame_number) { |
| const uint32_t ximg_y_plane = 0; |
| const uint8_t *const y_buffer = img.planes[ximg_y_plane]; |
| |
| // Find which external buffer contains the y_buffer. |
| int i = 0; |
| for (i = 0; i < num_buffers_; ++i) { |
| if (y_buffer >= frame_buffers_[i].data && |
| y_buffer < (frame_buffers_[i].data + frame_buffers_[i].size)) { |
| break; |
| } |
| } |
| |
| FrameBufferMD5Sum fb_md5; |
| fb_md5.frame_buffer_index = i; |
| fb_md5.img = img; |
| |
| libvpx_test::MD5 md5; |
| md5.Add(&img); |
| fb_md5.md5 = md5.Get(); |
| jitter_buffer_md5_sums_.push(fb_md5); |
| |
| // Check to see if any of the reconstructed image changed. |
| if (jitter_buffer_md5_sums_.size() > |
| static_cast<size_t>(num_jitter_buffers_)) { |
| fb_md5 = jitter_buffer_md5_sums_.front(); |
| |
| libvpx_test::MD5 md5; |
| md5.Add(&fb_md5.img); |
| const std::string check_str = md5.Get(); |
| |
| ASSERT_EQ(fb_md5.md5, check_str); |
| jitter_buffer_md5_sums_.pop(); |
| } |
| } |
| |
| libvpx_test::CompressedVideoSource *OpenCompressedFile( |
| const std::string &filename) { |
| if (filename.substr(filename.length() - 3, 3) == "ivf") { |
| return new libvpx_test::IVFVideoSource(filename); |
| } else if (filename.substr(filename.length() - 4, 4) == "webm") { |
| return new libvpx_test::WebMVideoSource(filename); |
| } |
| return NULL; |
| } |
| |
| void set_num_jitter_buffers(int num_buffers) { |
| num_jitter_buffers_ = num_buffers; |
| } |
| |
| private: |
| // Total number of external frame buffers. |
| int num_buffers_; |
| int num_jitter_buffers_; |
| |
| // External frame buffers used by libvpx. |
| vpx_codec_frame_buffer_t *frame_buffers_; |
| |
| // Save the md5 checksums for later comparison. |
| std::queue<FrameBufferMD5Sum> jitter_buffer_md5_sums_; |
| }; |
| |
| // This test runs through a set of test vectors, and decodes them. |
| // Libvpx will call into the application to allocate a frame buffer when |
| // needed. The md5 checksums are computed for each frame after it is |
| // decoded and stored to be checked later. After a jitter frame buffer |
| // has expired, the md5 checksum is computed again for the expired jitter |
| // buffer frame and checked against the md5 checksum after the frame was |
| // decoded. If md5 checksums match, then the test is passed. Otherwise, |
| // the test failed. |
| TEST_P(LRUFrameBufferTest, CheckLRUOneJitterBuffer) { |
| const std::string filename = GET_PARAM(kVideoNameParam); |
| |
| set_num_jitter_buffers(1); |
| |
| libvpx_test::CompressedVideoSource *const video = |
| OpenCompressedFile(filename); |
| video->Init(); |
| |
| // Decode frame, and check the md5 matching. |
| ASSERT_NO_FATAL_FAILURE(RunLoop(video)); |
| delete video; |
| } |
| |
| TEST_P(LRUFrameBufferTest, CheckLRUFourJitterBuffers) { |
| const std::string filename = GET_PARAM(kVideoNameParam); |
| |
| set_num_jitter_buffers(4); |
| |
| libvpx_test::CompressedVideoSource *const video = |
| OpenCompressedFile(filename); |
| video->Init(); |
| |
| // Decode frame, and check the md5 matching. |
| ASSERT_NO_FATAL_FAILURE(RunLoop(video)); |
| delete video; |
| } |
| |
| TEST_P(LRUFrameBufferTest, CheckLRUEightJitterBuffers) { |
| const std::string filename = GET_PARAM(kVideoNameParam); |
| |
| set_num_jitter_buffers(8); |
| |
| libvpx_test::CompressedVideoSource *const video = |
| OpenCompressedFile(filename); |
| video->Init(); |
| |
| // Decode frame, and check the md5 matching. |
| ASSERT_NO_FATAL_FAILURE(RunLoop(video)); |
| delete video; |
| } |
| |
| VP9_INSTANTIATE_TEST_CASE(LRUFrameBufferTest, |
| ::testing::ValuesIn(kLRUTestVectors)); |
| } // namespace |