diff --git a/webrtc/tools/BUILD.gn b/webrtc/tools/BUILD.gn index 5353ba8e8a..c8604f1067 100644 --- a/webrtc/tools/BUILD.gn +++ b/webrtc/tools/BUILD.gn @@ -87,6 +87,29 @@ rtc_executable("psnr_ssim_analyzer") { ] } +rtc_static_library("reference_less_video_analysis_lib") { + sources = [ + "frame_analyzer/reference_less_video_analysis_lib.cc", + "frame_analyzer/reference_less_video_analysis_lib.h", + ] + + deps = [ + ":video_quality_analysis", + ] +} + +rtc_executable("reference_less_video_analysis") { + sources = [ + "frame_analyzer/reference_less_video_analysis.cc", + ] + + deps = [ + ":command_line_parser", + ":reference_less_video_analysis_lib", + "//build/win:default_exe_manifest", + ] +} + rtc_executable("rgba_to_i420_converter") { sources = [ "converter/converter.cc", @@ -254,6 +277,7 @@ if (rtc_include_tests) { testonly = true sources = [ + "frame_analyzer/reference_less_video_analysis_unittest.cc", "frame_analyzer/video_quality_analysis_unittest.cc", "frame_editing/frame_editing_unittest.cc", "simple_command_line_parser_unittest.cc", @@ -270,6 +294,7 @@ if (rtc_include_tests) { deps = [ ":command_line_parser", ":frame_editing_lib", + ":reference_less_video_analysis_lib", ":video_quality_analysis", "../test:test_main", "//testing/gtest", diff --git a/webrtc/tools/frame_analyzer/reference_less_video_analysis.cc b/webrtc/tools/frame_analyzer/reference_less_video_analysis.cc new file mode 100644 index 0000000000..019564eaf4 --- /dev/null +++ b/webrtc/tools/frame_analyzer/reference_less_video_analysis.cc @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2016 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 +#include +#include + +#include "webrtc/tools/frame_analyzer/reference_less_video_analysis_lib.h" +#include "webrtc/tools/simple_command_line_parser.h" + +int main(int argc, char** argv) { + // This captures the freezing metrics for reference less video analysis. + std::string program_name = argv[0]; + std::string usage = "Outputs the freezing score by comparing current frame " + "with the previous frame.\nExample usage:\n" + program_name + + " --video_file=video_file.y4m\n" + "Command line flags:\n" + " - video_file(string): Path of the video " + "file to be analyzed. Only y4m file format is supported.\n"; + + webrtc::test::CommandLineParser parser; + + // Init the parser and set the usage message. + parser.Init(argc, argv); + parser.SetUsageMessage(usage); + + parser.SetFlag("video_file", ""); + parser.ProcessFlags(); + if (parser.GetFlag("video_file").empty()) { + parser.PrintUsageMessage(); + exit(EXIT_SUCCESS); + } + std::string video_file = parser.GetFlag("video_file"); + + return run_analysis(video_file); +} diff --git a/webrtc/tools/frame_analyzer/reference_less_video_analysis_lib.cc b/webrtc/tools/frame_analyzer/reference_less_video_analysis_lib.cc new file mode 100644 index 0000000000..ab484e9bb5 --- /dev/null +++ b/webrtc/tools/frame_analyzer/reference_less_video_analysis_lib.cc @@ -0,0 +1,202 @@ +/* + * Copyright (c) 2016 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 +#include +#include +#include +#include +#include + +#include "webrtc/tools/frame_analyzer/reference_less_video_analysis_lib.h" +#include "webrtc/tools/frame_analyzer/video_quality_analysis.h" + +#define STATS_LINE_LENGTH 28 +#define PSNR_FREEZE_THRESHOLD 47 +#define SSIM_FREEZE_THRESHOLD .999 + +#if defined(_WIN32) || defined(_WIN64) +#define strtok_r strtok_s +#endif + +void get_height_width_fps(int *height, int *width, int *fps, + const std::string& video_file) { + // File header looks like : + // YUV4MPEG2 W1280 H720 F25:1 Ip A0:0 C420mpeg2 XYSCSS=420MPEG2. + char frame_header[STATS_LINE_LENGTH]; + FILE* input_file = fopen(video_file.c_str(), "rb"); + + size_t bytes_read = fread(frame_header, 1, STATS_LINE_LENGTH - 1, input_file); + + frame_header[bytes_read] = '\0'; + std::string file_header_stats[5]; + int no_of_stats = 0; + char *save_ptr; + char *token = strtok_r(frame_header, " ", &save_ptr); + + while (token != NULL) { + file_header_stats[no_of_stats++] = token; + token = strtok_r(NULL, " ", &save_ptr); + } + + *width = std::stoi(file_header_stats[1].erase(0, 1)); + *height = std::stoi(file_header_stats[2].erase(0, 1)); + *fps = std::stoi(file_header_stats[3].erase(0, 1)); + + printf("Height: %d Width: %d fps:%d \n", *height, *width, *fps); + fclose(input_file); +} + +bool frozen_frame(std::vector psnr_per_frame, + std::vector ssim_per_frame, size_t frame) { + if (psnr_per_frame[frame] >= PSNR_FREEZE_THRESHOLD || + ssim_per_frame[frame] >= SSIM_FREEZE_THRESHOLD) + return true; + return false; +} + +std::vector find_frame_clusters(const std::vector& psnr_per_frame, + const std::vector& ssim_per_frame) { + std::vector identical_frame_clusters; + int num_frozen = 0; + size_t total_no_of_frames = psnr_per_frame.size(); + + for (size_t each_frame = 0; each_frame < total_no_of_frames; each_frame++) { + if (frozen_frame(psnr_per_frame, ssim_per_frame, each_frame)) { + num_frozen++; + } else if (num_frozen > 0) { + // Not frozen anymore. + identical_frame_clusters.push_back(num_frozen); + num_frozen = 0; + } + } + return identical_frame_clusters; +} + +void print_freezing_metrics(const std::vector& psnr_per_frame, + const std::vector& ssim_per_frame) { + /* + * Prints the different metrics mainly: + * 1) Identical frame number, PSNR and SSIM values. + * 2) Length of continuous frozen frames. + * 3) Max length of continuous freezed frames. + * 4) No of unique frames found. + * 5) Total different identical frames found. + * + * Sample output: + * Printing metrics for file: /src/webrtc/tools/test_3.y4m + ============================= + Total number of frames received: 74 + Total identical frames: 5 + Number of unique frames: 69 + Printing Identical Frames: + Frame Number: 29 PSNR: 48.000000 SSIM: 0.999618 + Frame Number: 30 PSNR: 48.000000 SSIM: 0.999898 + Frame Number: 60 PSNR: 48.000000 SSIM: 0.999564 + Frame Number: 64 PSNR: 48.000000 SSIM: 0.999651 + Frame Number: 69 PSNR: 48.000000 SSIM: 0.999684 + Print identical frame which appears in clusters : + 2 1 1 1 + * + */ + size_t total_no_of_frames = psnr_per_frame.size(); + std::vector identical_frame_clusters = find_frame_clusters( + psnr_per_frame, ssim_per_frame); + int total_identical_frames = std::accumulate( + identical_frame_clusters.begin(), identical_frame_clusters.end(), 0); + size_t unique_frames = total_no_of_frames - total_identical_frames; + + printf("Total number of frames received: %zu\n", total_no_of_frames); + printf("Total identical frames: %d\n", total_identical_frames); + printf("Number of unique frames: %zu\n", unique_frames); + + printf("Printing Identical Frames: \n"); + for (size_t frame = 0; frame < total_no_of_frames; frame++) { + if (frozen_frame(psnr_per_frame, ssim_per_frame, frame)) { + printf(" Frame Number: %zu PSNR: %f SSIM: %f \n", frame, + psnr_per_frame[frame], ssim_per_frame[frame]); + } + } + + printf("Print identical frame which appears in clusters : \n"); + for (int cluster = 0; + cluster < static_cast(identical_frame_clusters.size()); cluster++) + printf("%d ", identical_frame_clusters[cluster]); + printf("\n"); +} + +void compute_metrics(const std::string& video_file_name, + std::vector* psnr_per_frame, + std::vector* ssim_per_frame) { + int height = 0, width = 0, fps = 0; + get_height_width_fps(&height, &width, &fps, video_file_name); + + int no_of_frames = 0; + int size = webrtc::test::GetI420FrameSize(width, height); + + // Allocate buffers for test and reference frames. + uint8_t* current_frame = new uint8_t[size]; + uint8_t* next_frame = new uint8_t[size]; + + while (true) { + if (!(webrtc::test::ExtractFrameFromY4mFile (video_file_name.c_str(), + width, height, + no_of_frames, + current_frame))) { + break; + } + + if (!(webrtc::test::ExtractFrameFromY4mFile (video_file_name.c_str(), + width, height, + no_of_frames + 1, + next_frame))) { + break; + } + + double result_psnr = webrtc::test::CalculateMetrics(webrtc::test::kPSNR, + current_frame, + next_frame, + width, height); + double result_ssim = webrtc::test::CalculateMetrics(webrtc::test::kSSIM, + current_frame, + next_frame, + width, height); + + psnr_per_frame->push_back(result_psnr); + ssim_per_frame->push_back(result_ssim); + no_of_frames++; + } + // Cleanup. + delete[] current_frame; + delete[] next_frame; +} + +bool check_file_extension(const std::string& video_file_name) { + if (video_file_name.substr(video_file_name.length()-3, 3) != "y4m") { + printf("Only y4m video file format is supported. Given: %s\n", + video_file_name.c_str()); + return false; + } + return true; +} + +int run_analysis(const std::string& video_file) { + std::vector psnr_per_frame; + std::vector ssim_per_frame; + if (check_file_extension(video_file)) { + compute_metrics(video_file, &psnr_per_frame, &ssim_per_frame); + } else { + return -1; + } + printf("=============================\n"); + printf("Printing metrics for file: %s\n", video_file.c_str()); + printf("=============================\n"); + print_freezing_metrics(psnr_per_frame, ssim_per_frame); + return 0; +} diff --git a/webrtc/tools/frame_analyzer/reference_less_video_analysis_lib.h b/webrtc/tools/frame_analyzer/reference_less_video_analysis_lib.h new file mode 100644 index 0000000000..2fa0898c32 --- /dev/null +++ b/webrtc/tools/frame_analyzer/reference_less_video_analysis_lib.h @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2016 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. + */ + +#ifndef WEBRTC_TOOLS_FRAME_ANALYZER_REFERENCE_LESS_VIDEO_ANALYSIS_LIB_H_ +#define WEBRTC_TOOLS_FRAME_ANALYZER_REFERENCE_LESS_VIDEO_ANALYSIS_LIB_H_ + +#include +#include + +// Parse the file header to extract height, width and fps +// for a given video file. +void get_height_width_fps(int *height, int *width, int *fps, + const std::string& video_file); + +// Returns true if the frame is frozen based on psnr and ssim freezing +// threshold values. +bool frozen_frame(std::vector psnr_per_frame, + std::vector ssim_per_frame, size_t frame); + +// Returns the vector of identical cluster of frames that are frozen +// and appears continuously. +std::vector find_frame_clusters(const std::vector& psnr_per_frame, + const std::vector& ssim_per_frame); + +// Prints various freezing metrics like identical frames, +// total unique frames etc. +void print_freezing_metrics(const std::vector& psnr_per_frame, + const std::vector& ssim_per_frame); + +// Compute the metrics like freezing score based on PSNR and SSIM values for a +// given video file. +void compute_metrics(const std::string& video_file_name, + std::vector* psnr_per_frame, + std::vector* ssim_per_frame); + +// Checks the file extension and return true if it is y4m. +bool check_file_extension(const std::string& video_file_name); + +// Compute freezing score metrics and prints the metrics +// for a list of video files. +int run_analysis(const std::string& video_file); + +#endif // WEBRTC_TOOLS_FRAME_ANALYZER_REFERENCE_LESS_VIDEO_ANALYSIS_LIB_H_ diff --git a/webrtc/tools/frame_analyzer/reference_less_video_analysis_unittest.cc b/webrtc/tools/frame_analyzer/reference_less_video_analysis_unittest.cc new file mode 100644 index 0000000000..b8e1c551af --- /dev/null +++ b/webrtc/tools/frame_analyzer/reference_less_video_analysis_unittest.cc @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2016 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 +#include +#include +#include +#include + +#include "webrtc/test/gtest.h" +#include "webrtc/test/testsupport/fileutils.h" +#include "webrtc/tools/frame_analyzer/reference_less_video_analysis_lib.h" + +class ReferenceLessVideoAnalysisTest : public ::testing::Test { + public: + void SetUp() override { + video_file = + webrtc::test::ResourcePath("reference_less_video_test_file", "y4m"); + } + std::string video_file; + std::vector psnr_per_frame; + std::vector ssim_per_frame; +}; + +TEST_F(ReferenceLessVideoAnalysisTest, MatchComputedMetrics) { + compute_metrics(video_file, &psnr_per_frame, &ssim_per_frame); + EXPECT_EQ(74, (int)psnr_per_frame.size()); + + ASSERT_NEAR(27.2f, psnr_per_frame[1], 0.1f); + ASSERT_NEAR(24.9f, psnr_per_frame[5], 0.1f); + + ASSERT_NEAR(0.9f, ssim_per_frame[1], 0.1f); + ASSERT_NEAR(0.9f, ssim_per_frame[5], 0.1f); +} + +TEST_F(ReferenceLessVideoAnalysisTest, MatchHeightWidthFps) { + int height = 0, width = 0, fps = 0; + get_height_width_fps(&height, &width, &fps, video_file.c_str()); + EXPECT_EQ(height, 720); + EXPECT_EQ(width, 1280); + EXPECT_EQ(fps, 25); +} + +TEST_F(ReferenceLessVideoAnalysisTest, MatchIdenticalFrameClusters) { + compute_metrics(video_file, &psnr_per_frame, &ssim_per_frame); + std::vector identical_frame_clusters = + find_frame_clusters(psnr_per_frame, ssim_per_frame); + EXPECT_EQ(5, (int)identical_frame_clusters.size()); + EXPECT_EQ(1, identical_frame_clusters[0]); + EXPECT_EQ(1, identical_frame_clusters[4]); +} + +TEST_F(ReferenceLessVideoAnalysisTest, CheckFileExtension) { + EXPECT_TRUE(check_file_extension(video_file)); + std::string txt_file = + webrtc::test::ResourcePath("video_quality_analysis_frame", "txt"); + EXPECT_FALSE(check_file_extension(txt_file)); +} + + + +