blob: cf615c5d95e1f5da6d28f95e190860ce4d4c53a5 [file] [log] [blame] [edit]
/*
* Copyright (c) 2019 The WebRTC 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 "modules/video_coding/utility/ivf_file_reader.h"
#include <memory>
#include <string>
#include "modules/video_coding/utility/ivf_file_writer.h"
#include "test/gtest.h"
#include "test/testsupport/file_utils.h"
namespace webrtc {
namespace {
constexpr int kWidth = 320;
constexpr int kHeight = 240;
constexpr int kNumFrames = 3;
constexpr uint8_t kDummyPayload[4] = {'0', '1', '2', '3'};
} // namespace
class IvfFileReaderTest : public ::testing::Test {
protected:
void SetUp() override {
file_name_ =
webrtc::test::TempFilename(webrtc::test::OutputPath(), "test_file.ivf");
}
void TearDown() override { webrtc::test::RemoveFile(file_name_); }
bool WriteDummyTestFrames(IvfFileWriter* file_writer,
VideoCodecType codec_type,
int width,
int height,
int num_frames,
bool use_capture_tims_ms,
int spatial_layers_count) {
EncodedImage frame;
frame.SetSpatialIndex(spatial_layers_count);
rtc::scoped_refptr<EncodedImageBuffer> payload = EncodedImageBuffer::Create(
sizeof(kDummyPayload) * spatial_layers_count);
for (int i = 0; i < spatial_layers_count; ++i) {
memcpy(&payload->data()[i * sizeof(kDummyPayload)], kDummyPayload,
sizeof(kDummyPayload));
frame.SetSpatialLayerFrameSize(i, sizeof(kDummyPayload));
}
frame.SetEncodedData(payload);
frame._encodedWidth = width;
frame._encodedHeight = height;
for (int i = 1; i <= num_frames; ++i) {
if (use_capture_tims_ms) {
frame.capture_time_ms_ = i;
} else {
frame.SetRtpTimestamp(i);
}
if (!file_writer->WriteFrame(frame, codec_type))
return false;
}
return true;
}
void CreateTestFile(VideoCodecType codec_type,
bool use_capture_tims_ms,
int spatial_layers_count) {
std::unique_ptr<IvfFileWriter> file_writer =
IvfFileWriter::Wrap(FileWrapper::OpenWriteOnly(file_name_), 0);
ASSERT_TRUE(file_writer.get());
ASSERT_TRUE(WriteDummyTestFrames(file_writer.get(), codec_type, kWidth,
kHeight, kNumFrames, use_capture_tims_ms,
spatial_layers_count));
ASSERT_TRUE(file_writer->Close());
}
void ValidateFrame(std::optional<EncodedImage> frame,
int frame_index,
bool use_capture_tims_ms,
int spatial_layers_count) {
ASSERT_TRUE(frame);
EXPECT_EQ(frame->SpatialIndex(), spatial_layers_count - 1);
if (use_capture_tims_ms) {
EXPECT_EQ(frame->capture_time_ms_, static_cast<int64_t>(frame_index));
EXPECT_EQ(frame->RtpTimestamp(), static_cast<int64_t>(90 * frame_index));
} else {
EXPECT_EQ(frame->RtpTimestamp(), static_cast<int64_t>(frame_index));
}
ASSERT_EQ(frame->size(), sizeof(kDummyPayload) * spatial_layers_count);
for (int i = 0; i < spatial_layers_count; ++i) {
EXPECT_EQ(memcmp(&frame->data()[i * sizeof(kDummyPayload)], kDummyPayload,
sizeof(kDummyPayload)),
0)
<< std::string(reinterpret_cast<char const*>(
&frame->data()[i * sizeof(kDummyPayload)]),
sizeof(kDummyPayload));
}
}
void ValidateContent(VideoCodecType codec_type,
bool use_capture_tims_ms,
int spatial_layers_count) {
std::unique_ptr<IvfFileReader> reader =
IvfFileReader::Create(FileWrapper::OpenReadOnly(file_name_));
ASSERT_TRUE(reader.get());
EXPECT_EQ(reader->GetVideoCodecType(), codec_type);
EXPECT_EQ(reader->GetFramesCount(),
spatial_layers_count * static_cast<size_t>(kNumFrames));
for (int i = 1; i <= kNumFrames; ++i) {
ASSERT_TRUE(reader->HasMoreFrames());
ValidateFrame(reader->NextFrame(), i, use_capture_tims_ms,
spatial_layers_count);
EXPECT_FALSE(reader->HasError());
}
EXPECT_FALSE(reader->HasMoreFrames());
EXPECT_FALSE(reader->NextFrame());
EXPECT_FALSE(reader->HasError());
ASSERT_TRUE(reader->Close());
}
std::string file_name_;
};
TEST_F(IvfFileReaderTest, BasicVp8FileNtpTimestamp) {
CreateTestFile(kVideoCodecVP8, false, 1);
ValidateContent(kVideoCodecVP8, false, 1);
}
TEST_F(IvfFileReaderTest, BasicVP8FileMsTimestamp) {
CreateTestFile(kVideoCodecVP8, true, 1);
ValidateContent(kVideoCodecVP8, true, 1);
}
TEST_F(IvfFileReaderTest, BasicVP9FileNtpTimestamp) {
CreateTestFile(kVideoCodecVP9, false, 1);
ValidateContent(kVideoCodecVP9, false, 1);
}
TEST_F(IvfFileReaderTest, BasicVP9FileMsTimestamp) {
CreateTestFile(kVideoCodecVP9, true, 1);
ValidateContent(kVideoCodecVP9, true, 1);
}
TEST_F(IvfFileReaderTest, BasicAv1FileNtpTimestamp) {
CreateTestFile(kVideoCodecAV1, false, 1);
ValidateContent(kVideoCodecAV1, false, 1);
}
TEST_F(IvfFileReaderTest, BasicAv1FileMsTimestamp) {
CreateTestFile(kVideoCodecAV1, true, 1);
ValidateContent(kVideoCodecAV1, true, 1);
}
TEST_F(IvfFileReaderTest, BasicH264FileNtpTimestamp) {
CreateTestFile(kVideoCodecH264, false, 1);
ValidateContent(kVideoCodecH264, false, 1);
}
TEST_F(IvfFileReaderTest, BasicH264FileMsTimestamp) {
CreateTestFile(kVideoCodecH264, true, 1);
ValidateContent(kVideoCodecH264, true, 1);
}
TEST_F(IvfFileReaderTest, MultilayerVp8FileNtpTimestamp) {
CreateTestFile(kVideoCodecVP8, false, 3);
ValidateContent(kVideoCodecVP8, false, 3);
}
TEST_F(IvfFileReaderTest, MultilayerVP9FileNtpTimestamp) {
CreateTestFile(kVideoCodecVP9, false, 3);
ValidateContent(kVideoCodecVP9, false, 3);
}
TEST_F(IvfFileReaderTest, MultilayerAv1FileNtpTimestamp) {
CreateTestFile(kVideoCodecAV1, false, 3);
ValidateContent(kVideoCodecAV1, false, 3);
}
TEST_F(IvfFileReaderTest, MultilayerH264FileNtpTimestamp) {
CreateTestFile(kVideoCodecH264, false, 3);
ValidateContent(kVideoCodecH264, false, 3);
}
} // namespace webrtc