// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <iostream>
#include <sstream>
#include <string>
#include "base/command_line.h"
#include "base/files/file.h"
#include "base/files/file_util.h"
#include "base/files/memory_mapped_file.h"
#include "base/hash/md5.h"
#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "media/gpu/v4l2/test/video_decoder.h"
#include "media/gpu/v4l2/test/vp8_decoder.h"
#include "media/gpu/v4l2/test/vp9_decoder.h"
#include "media/media_buildflags.h"
// AV1 stateless decoding not supported upstream yet
#if BUILDFLAG(IS_CHROMEOS)
#include "media/gpu/v4l2/test/av1_decoder.h"
#endif
#include "media/gpu/v4l2/test/h264_decoder.h"
#if BUILDFLAG(ENABLE_HEVC_PARSER_AND_HW_DECODER)
#include "media/gpu/v4l2/test/h265_decoder.h"
#endif
// AV1 stateless decoding not supported upstream yet
#if BUILDFLAG(IS_CHROMEOS)
using media::v4l2_test::Av1Decoder;
#endif
using media::v4l2_test::H264Decoder;
#if BUILDFLAG(ENABLE_HEVC_PARSER_AND_HW_DECODER)
using media::v4l2_test::H265Decoder;
#endif
using media::v4l2_test::VideoDecoder;
using media::v4l2_test::Vp8Decoder;
using media::v4l2_test::Vp9Decoder;
namespace {
constexpr char kUsageMsg[] =
"usage: v4l2_stateless_decoder\n"
" --video=<video path>\n"
" [--frames=<number of frames to decode>]\n"
" [--v=<log verbosity>]\n"
" [--output_format]=<output type of yuv or png>]\n"
" [--output_path_prefix=<output files path prefix>]\n"
" [--md5=<md_log_path>]\n"
" [--visible]\n"
" [--help]\n";
constexpr char kHelpMsg[] =
"This binary decodes the IVF video in <video> path with specified \n"
"video <profile> via thinly wrapped v4l2 calls.\n"
"Supported codecs: VP9 (profile 0), AV1 (profile 0), and H.265\n"
"\nThe following arguments are supported:\n"
" --video=<path>\n"
" Required. Path to IVF-formatted video to decode.\n"
" --frames=<int>\n"
" Optional. Number of frames to decode, defaults to all.\n"
" Override with a positive integer to decode at most that many.\n"
" --output_format=<str>\n"
" Optional. Output type for decoded frames, defaults to YUV.\n"
" YUV and PNG are supported.\n"
" --output_path_prefix=<path>\n"
" Optional. Prefix to the filepaths where raw YUV or PNG files\n"
" will be written. For example, setting <path> to \"test/test_\"\n"
" would result in output files of the form\n"
" \"test/test_000000.yuv\" \"test/test_000001.yuv\", etc.\n"
" --md5=<path>\n"
" Optional. If specified, computes md5 checksum. If specified\n"
" with argument, prints the md5 checksum of each decoded (and\n"
" visible, if --visible is specified) frame in I420 format\n"
" to specified file. Verbose level 2 will display md5 checksums.\n"
" --visible\n"
" Optional. If specified, computes md5 hash values only for\n"
" visible frames.\n"
" --help\n"
" Display this help message and exit.\n";
} // namespace
// Computes the md5 of given I420 data |yuv_plane| and prints the md5 to stdout.
// This functionality is needed for tast tests.
void ComputeAndPrintMD5hash(const std::vector<uint8_t>& yuv_plane,
const base::FilePath md5_log_location) {
base::MD5Digest md5_digest;
base::MD5Sum(yuv_plane, &md5_digest);
std::string md5_digest_b16 = MD5DigestToBase16(md5_digest);
if (!md5_log_location.empty()) {
if (!PathExists(md5_log_location))
WriteFile(md5_log_location, md5_digest_b16 + "\n");
else
AppendToFile(md5_log_location, md5_digest_b16 + "\n");
}
VLOG(2) << md5_digest_b16;
}
// Creates the appropriate decoder for |stream|, which points to IVF data.
// Returns nullptr on failure.
std::unique_ptr<VideoDecoder> CreateVideoDecoder(
const base::MemoryMappedFile& stream) {
CHECK(stream.IsValid());
std::unique_ptr<VideoDecoder> decoder;
// AV1 stateless decoding not supported upstream yet
#if BUILDFLAG(IS_CHROMEOS)
decoder = Av1Decoder::Create(stream);
#endif
if (!decoder)
decoder = Vp9Decoder::Create(stream);
if (!decoder)
decoder = H264Decoder::Create(stream);
if (!decoder)
decoder = Vp8Decoder::Create(stream);
#if BUILDFLAG(ENABLE_HEVC_PARSER_AND_HW_DECODER)
if (!decoder) {
decoder = H265Decoder::Create(stream);
}
#endif
return decoder;
}
int main(int argc, char** argv) {
base::CommandLine::Init(argc, argv);
logging::LoggingSettings settings;
settings.logging_dest =
logging::LOG_TO_SYSTEM_DEBUG_LOG | logging::LOG_TO_STDERR;
logging::InitLogging(settings);
const base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
if (cmd->HasSwitch("help")) {
std::cout << kUsageMsg << "\n" << kHelpMsg;
return EXIT_SUCCESS;
}
const bool has_output_file = cmd->HasSwitch("output_path_prefix");
const std::string output_file_prefix =
cmd->GetSwitchValueASCII("output_path_prefix");
std::string output_format = "yuv";
if (has_output_file && cmd->HasSwitch("output_format")) {
output_format =
base::ToLowerASCII(cmd->GetSwitchValueASCII("output_format"));
if (output_format != "yuv" && output_format != "png") {
LOG(ERROR) << "Unsupported output format: " << output_format;
return EXIT_FAILURE;
}
}
const base::FilePath video_path = cmd->GetSwitchValuePath("video");
if (video_path.empty()) {
LOG(ERROR) << "No input video path provided to decode.\n" << kUsageMsg;
return EXIT_FAILURE;
}
const std::string frames = cmd->GetSwitchValueASCII("frames");
int n_frames;
if (frames.empty()) {
n_frames = 0;
} else if (!base::StringToInt(frames, &n_frames) || n_frames <= 0) {
LOG(ERROR) << "Number of frames to decode must be positive integer, got "
<< frames;
return EXIT_FAILURE;
}
const base::FilePath md5_log_location = cmd->GetSwitchValuePath("md5");
// Deletes md5 log file if it already exists.
if (PathExists(md5_log_location)) {
DeleteFile(md5_log_location);
}
// Set up video stream.
base::MemoryMappedFile stream;
if (!stream.Initialize(video_path)) {
LOG(ERROR) << "Couldn't open file: " << video_path;
return EXIT_FAILURE;
}
const std::unique_ptr<VideoDecoder> dec = CreateVideoDecoder(stream);
if (!dec) {
LOG(ERROR) << "Failed to create decoder for file: " << video_path;
return EXIT_FAILURE;
}
for (int i = 0; i < n_frames || n_frames == 0; i++) {
VLOG(1) << "Frame " << i << "...";
std::vector<uint8_t> y_plane;
std::vector<uint8_t> u_plane;
std::vector<uint8_t> v_plane;
gfx::Size size;
VideoDecoder::BitDepth bit_depth;
const VideoDecoder::Result res =
dec->DecodeNextFrame(i, y_plane, u_plane, v_plane, size, bit_depth);
if (res == VideoDecoder::kEOStream) {
VLOG(1) << "End of stream.";
break;
} else if (res == VideoDecoder::kError) {
LOG(ERROR) << "Unable to decode next frame.";
return EXIT_FAILURE;
}
if (cmd->HasSwitch("visible") && !dec->LastDecodedFrameVisible())
continue;
std::vector<uint8_t> yuv_plane(y_plane);
yuv_plane.insert(yuv_plane.end(), u_plane.begin(), u_plane.end());
yuv_plane.insert(yuv_plane.end(), v_plane.begin(), v_plane.end());
if (cmd->HasSwitch("md5"))
ComputeAndPrintMD5hash(yuv_plane, md5_log_location);
if (!has_output_file)
continue;
base::FilePath filename(base::StringPrintf(
"%s%.6d.%s", output_file_prefix.c_str(), i, output_format.c_str()));
base::File output_file(
filename, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
if (output_format == "yuv") {
output_file.Write(0, reinterpret_cast<const char*>(yuv_plane.data()),
yuv_plane.size());
} else {
std::vector<uint8_t> image_buffer = dec->ConvertYUVToPNG(
y_plane.data(), u_plane.data(), v_plane.data(), size, bit_depth);
output_file.Write(0, reinterpret_cast<char*>(image_buffer.data()),
image_buffer.size());
}
}
return EXIT_SUCCESS;
}
Codebase Browser
chromium