admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add YUV to IVF video converter util

Browse Source 
Bug: webrtc:10138
Change-Id: I79ca08c45a664c66b15a1ed0c1322719c9f5574d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161449
Reviewed-by: Patrik Höglund <phoglund@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30559}
This commit is contained in:
Artem Titov 2020-02-19 15:03:45 +01:00 committed by Commit Bot
parent 4a14f4997c
commit 8041b651a3
4 changed files with 340 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
rtc_tools/BUILD.gn
View File

@ -30,7 +30,10 @@ group("rtc_tools") {
}
if (rtc_include_tests) {
deps += [ ":tools_unittests" ]
deps += [
":tools_unittests",
":yuv_to_ivf_converter",
]
if (rtc_enable_protobuf) {
if (!build_with_chromium) {
deps += [ ":event_log_visualizer" ]
@ -363,6 +366,42 @@ if (!build_with_chromium) {
}
if (rtc_include_tests) {
rtc_executable("yuv_to_ivf_converter") {
visibility = [ "*" ]
testonly = true
sources = [
"converter/yuv_to_ivf_converter.cc",
]
deps = [
"../api:create_frame_generator",
"../api:frame_generator_api",
"../api/task_queue:default_task_queue_factory",
"../api/video:encoded_image",
"../api/video:video_frame",
"../api/video_codecs:video_codecs_api",
"../media:rtc_media_base",
"../modules/rtp_rtcp:rtp_rtcp_format",
"../modules/video_coding:video_codec_interface",
"../modules/video_coding:video_coding_utility",
"../modules/video_coding:webrtc_h264",
"../modules/video_coding:webrtc_vp8",
"../modules/video_coding:webrtc_vp9",
"../rtc_base:checks",
"../rtc_base:criticalsection",
"../rtc_base:logging",
"../rtc_base:rtc_event",
"../rtc_base:rtc_task_queue",
"../rtc_base/system:file_wrapper",
"../test:video_test_common",
"../test:video_test_support",
"//third_party/abseil-cpp/absl/debugging:failure_signal_handler",
"//third_party/abseil-cpp/absl/debugging:symbolize",
"//third_party/abseil-cpp/absl/flags:flag",
"//third_party/abseil-cpp/absl/flags:parse",
"//third_party/abseil-cpp/absl/strings",
]
}
if (rtc_enable_protobuf && !build_with_chromium) {
rtc_executable("event_log_visualizer") {
testonly = true

11
rtc_tools/DEPS
View File

@ -19,3 +19,14 @@ include_rules = [
"+third_party/libyuv",
]
specific_include_rules = {
".*ivf_converter\.cc": [
"+absl/debugging/failure_signal_handler.h",
"+absl/debugging/symbolize.h",
"+modules/video_coding/codecs/vp8/include/vp8.h",
"+modules/video_coding/codecs/vp9/include/vp9.h",
"+modules/video_coding/include/video_error_codes.h",
"+modules/video_coding/utility/ivf_file_writer.h",
"+modules/video_coding/codecs/h264/include/h264.h",
],
}

288
rtc_tools/converter/yuv_to_ivf_converter.cc Normal file
View File

@ -0,0 +1,288 @@
/*
* Copyright 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 <memory>
#include <string>
#include "absl/debugging/failure_signal_handler.h"
#include "absl/debugging/symbolize.h"
#include "absl/flags/flag.h"
#include "absl/flags/parse.h"
#include "absl/strings/match.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/test/create_frame_generator.h"
#include "api/test/frame_generator_interface.h"
#include "api/video/encoded_image.h"
#include "api/video/video_codec_type.h"
#include "api/video_codecs/video_codec.h"
#include "api/video_codecs/video_encoder.h"
#include "media/base/media_constants.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/video_coding/codecs/vp8/include/vp8.h"
#include "modules/video_coding/codecs/vp9/include/vp9.h"
#include "modules/video_coding/include/video_error_codes.h"
#include "modules/video_coding/utility/ivf_file_writer.h"
#include "rtc_base/checks.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/event.h"
#include "rtc_base/logging.h"
#include "rtc_base/system/file_wrapper.h"
#include "rtc_base/task_queue.h"
#include "test/testsupport/frame_reader.h"
#include "test/video_codec_settings.h"
#if defined(WEBRTC_USE_H264)
#include "modules/video_coding/codecs/h264/include/h264.h"
#endif
ABSL_FLAG(std::string, input, "", "Input YUV file to convert to IVF");
ABSL_FLAG(int, width, 0, "Input frame width");
ABSL_FLAG(int, height, 0, "Input frame height");
ABSL_FLAG(std::string, codec, cricket::kVp8CodecName, "Codec to use");
ABSL_FLAG(std::string, output, "", "Output IVF file");
namespace webrtc {
namespace test {
namespace {
constexpr int kMaxFramerate = 30;
// We use very big value here to ensure that codec won't hit any limits.
constexpr uint32_t kBitrateBps = 100000000;
constexpr int kKeyFrameIntervalMs = 30000;
constexpr int kMaxFrameEncodeWaitTimeoutMs = 2000;
constexpr int kFrameLogInterval = 100;
static const VideoEncoder::Capabilities kCapabilities(false);
class IvfFileWriterEncodedCallback : public EncodedImageCallback {
public:
IvfFileWriterEncodedCallback(const std::string& file_name,
VideoCodecType video_codec_type,
int expected_frames_count)
: file_writer_(
IvfFileWriter::Wrap(FileWrapper::OpenWriteOnly(file_name), 0)),
video_codec_type_(video_codec_type),
expected_frames_count_(expected_frames_count) {
RTC_CHECK(file_writer_.get());
}
~IvfFileWriterEncodedCallback() { RTC_CHECK(file_writer_->Close()); }
Result OnEncodedImage(const EncodedImage& encoded_image,
const CodecSpecificInfo* codec_specific_info,
const RTPFragmentationHeader* fragmentation) override {
RTC_CHECK(file_writer_->WriteFrame(encoded_image, video_codec_type_));
rtc::CritScope crit(&lock_);
received_frames_count_++;
RTC_CHECK_LE(received_frames_count_, expected_frames_count_);
if (received_frames_count_ % kFrameLogInterval == 0) {
RTC_LOG(INFO) << received_frames_count_ << " out of "
<< expected_frames_count_ << " frames written";
}
next_frame_written_.Set();
return Result(Result::Error::OK);
}
void WaitNextFrameWritten(int timeout_ms) {
RTC_CHECK(next_frame_written_.Wait(timeout_ms));
next_frame_written_.Reset();
}
private:
std::unique_ptr<IvfFileWriter> file_writer_;
const VideoCodecType video_codec_type_;
const int expected_frames_count_;
rtc::CriticalSection lock_;
int received_frames_count_ RTC_GUARDED_BY(lock_) = 0;
rtc::Event next_frame_written_;
};
class Encoder {
public:
Encoder(int width,
int height,
int frames_count,
const std::string& output_file_name,
VideoCodecType video_codec_type,
std::unique_ptr<VideoEncoder> video_encoder)
: video_encoder_(std::move(video_encoder)),
task_queue_(CreateDefaultTaskQueueFactory()->CreateTaskQueue(
"Encoder",
TaskQueueFactory::Priority::HIGH)) {
ivf_writer_callback_ = std::make_unique<IvfFileWriterEncodedCallback>(
output_file_name, video_codec_type, frames_count);
task_queue_.PostTask([width, height, video_codec_type, this]() {
VideoCodec codec_settings;
CodecSettings(video_codec_type, &codec_settings);
codec_settings.width = width;
codec_settings.height = height;
codec_settings.maxFramerate = kMaxFramerate;
codec_settings.startBitrate = kBitrateBps;
codec_settings.minBitrate = kBitrateBps;
codec_settings.maxBitrate = kBitrateBps;
switch (video_codec_type) {
case VideoCodecType::kVideoCodecVP8: {
VideoCodecVP8* vp8_settings = codec_settings.VP8();
vp8_settings->frameDroppingOn = false;
vp8_settings->keyFrameInterval = kKeyFrameIntervalMs;
vp8_settings->denoisingOn = false;
} break;
case VideoCodecType::kVideoCodecVP9: {
VideoCodecVP9* vp9_settings = codec_settings.VP9();
vp9_settings->denoisingOn = false;
vp9_settings->frameDroppingOn = false;
vp9_settings->keyFrameInterval = kKeyFrameIntervalMs;
vp9_settings->automaticResizeOn = false;
} break;
case VideoCodecType::kVideoCodecH264: {
VideoCodecH264* h264_settings = codec_settings.H264();
h264_settings->frameDroppingOn = false;
h264_settings->keyFrameInterval = kKeyFrameIntervalMs;
} break;
default:
RTC_CHECK(false) << "Unsupported codec type";
}
VideoBitrateAllocation bitrate_allocation;
bitrate_allocation.SetBitrate(0, 0, kBitrateBps);
video_encoder_->RegisterEncodeCompleteCallback(
ivf_writer_callback_.get());
RTC_CHECK_EQ(
WEBRTC_VIDEO_CODEC_OK,
video_encoder_->InitEncode(
&codec_settings,
VideoEncoder::Settings(kCapabilities, /*number_of_cores=*/4,
/*max_payload_size=*/0)));
video_encoder_->SetRates(VideoEncoder::RateControlParameters(
bitrate_allocation,
static_cast<double>(codec_settings.maxFramerate)));
});
}
void Encode(const VideoFrame& frame) {
task_queue_.PostTask([frame, this]() {
RTC_CHECK_EQ(WEBRTC_VIDEO_CODEC_OK,
video_encoder_->Encode(frame, nullptr));
});
}
void WaitNextFrameWritten(int timeout_ms) {
ivf_writer_callback_->WaitNextFrameWritten(timeout_ms);
}
private:
std::unique_ptr<VideoEncoder> video_encoder_;
std::unique_ptr<IvfFileWriterEncodedCallback> ivf_writer_callback_;
rtc::TaskQueue task_queue_;
};
int GetFrameCount(std::string yuv_file_name, int width, int height) {
std::unique_ptr<FrameReader> yuv_reader =
std::make_unique<YuvFrameReaderImpl>(std::move(yuv_file_name), width,
height);
RTC_CHECK(yuv_reader->Init());
int frames_count = yuv_reader->NumberOfFrames();
yuv_reader->Close();
return frames_count;
}
VideoFrame BuildFrame(FrameGeneratorInterface::VideoFrameData frame_data,
uint32_t rtp_timestamp) {
return VideoFrame::Builder()
.set_video_frame_buffer(frame_data.buffer)
.set_update_rect(frame_data.update_rect)
.set_timestamp_rtp(rtp_timestamp)
.build();
}
void WriteVideoFile(std::string input_file_name,
int width,
int height,
std::string output_file_name,
VideoCodecType video_codec_type,
std::unique_ptr<VideoEncoder> video_encoder) {
int frames_count = GetFrameCount(input_file_name, width, height);
std::unique_ptr<FrameGeneratorInterface> frame_generator =
CreateFromYuvFileFrameGenerator({input_file_name}, width, height,
/*frame_repeat_count=*/1);
Encoder encoder(width, height, frames_count, output_file_name,
video_codec_type, std::move(video_encoder));
uint32_t last_frame_timestamp = 0;
for (int i = 0; i < frames_count; ++i) {
const uint32_t timestamp =
last_frame_timestamp + kVideoPayloadTypeFrequency / kMaxFramerate;
VideoFrame frame = BuildFrame(frame_generator->NextFrame(), timestamp);
last_frame_timestamp = timestamp;
encoder.Encode(frame);
encoder.WaitNextFrameWritten(kMaxFrameEncodeWaitTimeoutMs);
if ((i + 1) % kFrameLogInterval == 0) {
RTC_LOG(INFO) << i + 1 << " out of " << frames_count
<< " frames are sent for encoding";
}
}
RTC_LOG(INFO) << "All " << frames_count << " frame are sent for encoding";
}
} // namespace
} // namespace test
} // namespace webrtc
int main(int argc, char* argv[]) {
// Initialize the symbolizer to get a human-readable stack trace.
absl::InitializeSymbolizer(argv[0]);
absl::FailureSignalHandlerOptions options;
absl::InstallFailureSignalHandler(options);
absl::ParseCommandLine(argc, argv);
std::string codec_name = absl::GetFlag(FLAGS_codec);
std::string input_file_name = absl::GetFlag(FLAGS_input);
std::string output_file_name = absl::GetFlag(FLAGS_output);
int width = absl::GetFlag(FLAGS_width);
int height = absl::GetFlag(FLAGS_height);
RTC_CHECK_NE(input_file_name, "") << "--input is required";
RTC_CHECK_NE(output_file_name, "") << "--output is required";
RTC_CHECK_GT(width, 0) << "width must be greater then 0";
RTC_CHECK_GT(height, 0) << "height must be greater then 0";
if (absl::EqualsIgnoreCase(codec_name, cricket::kVp8CodecName)) {
webrtc::test::WriteVideoFile(
input_file_name, width, height, output_file_name,
webrtc::VideoCodecType::kVideoCodecVP8, webrtc::VP8Encoder::Create());
return 0;
}
if (absl::EqualsIgnoreCase(codec_name, cricket::kVp9CodecName)) {
webrtc::test::WriteVideoFile(
input_file_name, width, height, output_file_name,
webrtc::VideoCodecType::kVideoCodecVP9, webrtc::VP9Encoder::Create());
return 0;
}
#if defined(WEBRTC_USE_H264)
if (absl::EqualsIgnoreCase(codec_name, cricket::kH264CodecName)) {
webrtc::test::WriteVideoFile(
input_file_name, width, height, output_file_name,
webrtc::VideoCodecType::kVideoCodecH264,
webrtc::H264Encoder::Create(
cricket::VideoCodec(cricket::kH264CodecName)));
return 0;
}
#endif
RTC_CHECK(false) << "Unsupported codec: " << codec_name;
return 1;
}

2
test/DEPS
View File

@ -65,5 +65,5 @@ specific_include_rules = {
".*sdp_changer\.(h|cc)": [
"+pc",
"+p2p",
]
],
}