2021-08-28 12:36:42 +00:00
|
|
|
// Copyright (c) 2021 Michael Fabian Dirks <info@xaymar.com>
|
|
|
|
|
//
|
|
|
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
|
|
|
// in the Software without restriction, including without limitation the rights
|
|
|
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
|
|
|
// furnished to do so, subject to the following conditions:
|
|
|
|
|
//
|
|
|
|
|
// The above copyright notice and this permission notice shall be included in all
|
|
|
|
|
// copies or substantial portions of the Software.
|
|
|
|
|
//
|
|
|
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
|
// SOFTWARE.
|
|
|
|
|
|
2022-08-20 21:36:10 +00:00
|
|
|
//--------------------------------------------------------------------------------//
|
|
|
|
|
// THIS FEATURE IS DEPRECATED. SUBMITTED PATCHES WILL BE REJECTED.
|
|
|
|
|
//--------------------------------------------------------------------------------//
|
|
|
|
|
|
2021-08-28 12:36:42 +00:00
|
|
|
#include "encoder-aom-av1.hpp"
|
2022-08-29 10:29:44 +00:00
|
|
|
#include "util/util-logging.hpp"
|
|
|
|
|
|
|
|
|
|
#include "warning-disable.hpp"
|
2021-08-28 12:36:42 +00:00
|
|
|
#include <filesystem>
|
|
|
|
|
#include <thread>
|
2022-08-29 10:29:44 +00:00
|
|
|
#include "warning-enable.hpp"
|
2021-08-28 12:36:42 +00:00
|
|
|
|
|
|
|
|
#ifdef _DEBUG
|
|
|
|
|
#define ST_PREFIX "<%s> "
|
|
|
|
|
#define D_LOG_ERROR(x, ...) P_LOG_ERROR(ST_PREFIX##x, __FUNCTION_SIG__, __VA_ARGS__)
|
|
|
|
|
#define D_LOG_WARNING(x, ...) P_LOG_WARN(ST_PREFIX##x, __FUNCTION_SIG__, __VA_ARGS__)
|
|
|
|
|
#define D_LOG_INFO(x, ...) P_LOG_INFO(ST_PREFIX##x, __FUNCTION_SIG__, __VA_ARGS__)
|
|
|
|
|
#define D_LOG_DEBUG(x, ...) P_LOG_DEBUG(ST_PREFIX##x, __FUNCTION_SIG__, __VA_ARGS__)
|
|
|
|
|
#else
|
|
|
|
|
#define ST_PREFIX "<encoder::aom::av1> "
|
|
|
|
|
#define D_LOG_ERROR(...) P_LOG_ERROR(ST_PREFIX __VA_ARGS__)
|
|
|
|
|
#define D_LOG_WARNING(...) P_LOG_WARN(ST_PREFIX __VA_ARGS__)
|
|
|
|
|
#define D_LOG_INFO(...) P_LOG_INFO(ST_PREFIX __VA_ARGS__)
|
|
|
|
|
#define D_LOG_DEBUG(...) P_LOG_DEBUG(ST_PREFIX __VA_ARGS__)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define ST_I18N "Encoder.AOM.AV1"
|
|
|
|
|
|
|
|
|
|
// Preset
|
2022-08-20 21:36:10 +00:00
|
|
|
#define ST_I18N_DEPRECATED ST_I18N ".Deprecated"
|
2021-08-28 12:36:42 +00:00
|
|
|
#define ST_I18N_ENCODER ST_I18N ".Encoder"
|
|
|
|
|
#define ST_I18N_ENCODER_USAGE ST_I18N_ENCODER ".Usage"
|
|
|
|
|
#define ST_I18N_ENCODER_USAGE_GOODQUALITY ST_I18N_ENCODER_USAGE ".GoodQuality"
|
|
|
|
|
#define ST_I18N_ENCODER_USAGE_REALTIME ST_I18N_ENCODER_USAGE ".RealTime"
|
|
|
|
|
#define ST_I18N_ENCODER_USAGE_ALLINTRA ST_I18N_ENCODER_USAGE ".AllIntra"
|
|
|
|
|
#define ST_KEY_ENCODER_USAGE "Encoder.Usage"
|
|
|
|
|
#define ST_I18N_ENCODER_CPUUSAGE ST_I18N_ENCODER ".CPUUsage"
|
|
|
|
|
#define ST_I18N_ENCODER_CPUUSAGE_0 ST_I18N_ENCODER ".CPUUsage.0"
|
|
|
|
|
#define ST_I18N_ENCODER_CPUUSAGE_1 ST_I18N_ENCODER ".CPUUsage.1"
|
|
|
|
|
#define ST_I18N_ENCODER_CPUUSAGE_2 ST_I18N_ENCODER ".CPUUsage.2"
|
|
|
|
|
#define ST_I18N_ENCODER_CPUUSAGE_3 ST_I18N_ENCODER ".CPUUsage.3"
|
|
|
|
|
#define ST_I18N_ENCODER_CPUUSAGE_4 ST_I18N_ENCODER ".CPUUsage.4"
|
|
|
|
|
#define ST_I18N_ENCODER_CPUUSAGE_5 ST_I18N_ENCODER ".CPUUsage.5"
|
|
|
|
|
#define ST_I18N_ENCODER_CPUUSAGE_6 ST_I18N_ENCODER ".CPUUsage.6"
|
|
|
|
|
#define ST_I18N_ENCODER_CPUUSAGE_7 ST_I18N_ENCODER ".CPUUsage.7"
|
|
|
|
|
#define ST_I18N_ENCODER_CPUUSAGE_8 ST_I18N_ENCODER ".CPUUsage.8"
|
|
|
|
|
#define ST_I18N_ENCODER_CPUUSAGE_9 ST_I18N_ENCODER ".CPUUsage.9"
|
2021-10-17 07:52:40 +00:00
|
|
|
#define ST_I18N_ENCODER_CPUUSAGE_10 ST_I18N_ENCODER ".CPUUsage.10"
|
2021-08-28 12:36:42 +00:00
|
|
|
#define ST_KEY_ENCODER_CPUUSAGE "Encoder.CPUUsage"
|
|
|
|
|
#define ST_KEY_ENCODER_PROFILE "Encoder.Profile"
|
|
|
|
|
|
|
|
|
|
// Rate Control
|
|
|
|
|
#define ST_I18N_RATECONTROL ST_I18N ".RateControl"
|
|
|
|
|
#define ST_I18N_RATECONTROL_MODE ST_I18N_RATECONTROL ".Mode"
|
|
|
|
|
#define ST_I18N_RATECONTROL_MODE_CBR ST_I18N_RATECONTROL_MODE ".CBR"
|
|
|
|
|
#define ST_I18N_RATECONTROL_MODE_VBR ST_I18N_RATECONTROL_MODE ".VBR"
|
|
|
|
|
#define ST_I18N_RATECONTROL_MODE_CQ ST_I18N_RATECONTROL_MODE ".CQ"
|
|
|
|
|
#define ST_I18N_RATECONTROL_MODE_Q ST_I18N_RATECONTROL_MODE ".Q"
|
|
|
|
|
#define ST_KEY_RATECONTROL_MODE "RateControl.Mode"
|
|
|
|
|
#define ST_I18N_RATECONTROL_LOOKAHEAD ST_I18N_RATECONTROL ".LookAhead"
|
|
|
|
|
#define ST_KEY_RATECONTROL_LOOKAHEAD "RateControl.LookAhead"
|
|
|
|
|
#define ST_I18N_RATECONTROL_LIMITS ST_I18N_RATECONTROL ".Limits"
|
|
|
|
|
#define ST_I18N_RATECONTROL_LIMITS_BITRATE ST_I18N_RATECONTROL_LIMITS ".Bitrate"
|
|
|
|
|
#define ST_KEY_RATECONTROL_LIMITS_BITRATE "RateControl.Limits.Bitrate"
|
|
|
|
|
#define ST_I18N_RATECONTROL_LIMITS_BITRATE_UNDERSHOOT ST_I18N_RATECONTROL_LIMITS_BITRATE ".Undershoot"
|
|
|
|
|
#define ST_KEY_RATECONTROL_LIMITS_BITRATE_UNDERSHOOT "RateControl.Limits.Bitrate.Undershoot"
|
|
|
|
|
#define ST_I18N_RATECONTROL_LIMITS_BITRATE_OVERSHOOT ST_I18N_RATECONTROL_LIMITS_BITRATE ".Overshoot"
|
|
|
|
|
#define ST_KEY_RATECONTROL_LIMITS_BITRATE_OVERSHOOT "RateControl.Limits.Bitrate.Overshoot"
|
|
|
|
|
#define ST_I18N_RATECONTROL_LIMITS_QUALITY ST_I18N_RATECONTROL_LIMITS ".Quality"
|
|
|
|
|
#define ST_KEY_RATECONTROL_LIMITS_QUALITY "RateControl.Limits.Quality"
|
|
|
|
|
#define ST_I18N_RATECONTROL_LIMITS_QUANTIZER_MINIMUM ST_I18N_RATECONTROL_LIMITS ".Quantizer.Minimum"
|
|
|
|
|
#define ST_KEY_RATECONTROL_LIMITS_QUANTIZER_MINIMUM "RateControl.Limits.Quantizer.Minimum"
|
|
|
|
|
#define ST_I18N_RATECONTROL_LIMITS_QUANTIZER_MAXIMUM ST_I18N_RATECONTROL_LIMITS ".Quantizer.Maximum"
|
|
|
|
|
#define ST_KEY_RATECONTROL_LIMITS_QUANTIZER_MAXIMUM "RateControl.Limits.Quantizer.Maximum"
|
|
|
|
|
#define ST_I18N_RATECONTROL_BUFFER ST_I18N_RATECONTROL ".Buffer"
|
|
|
|
|
#define ST_I18N_RATECONTROL_BUFFER_SIZE ST_I18N_RATECONTROL_BUFFER ".Size"
|
|
|
|
|
#define ST_KEY_RATECONTROL_BUFFER_SIZE "RateControl.Buffer.Size"
|
|
|
|
|
#define ST_I18N_RATECONTROL_BUFFER_SIZE_INITIAL ST_I18N_RATECONTROL_BUFFER_SIZE ".Initial"
|
|
|
|
|
#define ST_KEY_RATECONTROL_BUFFER_SIZE_INITIAL "RateControl.Buffer.Size.Initial"
|
|
|
|
|
#define ST_I18N_RATECONTROL_BUFFER_SIZE_OPTIMAL ST_I18N_RATECONTROL_BUFFER_SIZE ".Optimal"
|
|
|
|
|
#define ST_KEY_RATECONTROL_BUFFER_SIZE_OPTIMAL "RateControl.Buffer.Size.Optimal"
|
|
|
|
|
|
|
|
|
|
// Key-Frames
|
|
|
|
|
#define ST_I18N_KEYFRAMES ST_I18N ".KeyFrames"
|
|
|
|
|
#define ST_I18N_KEYFRAMES_INTERVALTYPE ST_I18N_KEYFRAMES ".IntervalType"
|
|
|
|
|
#define ST_I18N_KEYFRAMES_INTERVALTYPE_SECONDS ST_I18N_KEYFRAMES_INTERVALTYPE ".Seconds"
|
|
|
|
|
#define ST_I18N_KEYFRAMES_INTERVALTYPE_FRAMES ST_I18N_KEYFRAMES_INTERVALTYPE ".Frames"
|
|
|
|
|
#define ST_KEY_KEYFRAMES_INTERVALTYPE "KeyFrames.IntervalType"
|
|
|
|
|
#define ST_I18N_KEYFRAMES_INTERVAL ST_I18N_KEYFRAMES ".Interval"
|
|
|
|
|
#define ST_KEY_KEYFRAMES_INTERVAL_SECONDS "KeyFrames.Interval.Seconds"
|
|
|
|
|
#define ST_KEY_KEYFRAMES_INTERVAL_FRAMES "KeyFrames.Interval.Frames"
|
|
|
|
|
|
|
|
|
|
// Advanced
|
|
|
|
|
#define ST_I18N_ADVANCED ST_I18N ".Advanced"
|
|
|
|
|
#define ST_I18N_ADVANCED_THREADS ST_I18N_ADVANCED ".Threads"
|
|
|
|
|
#define ST_KEY_ADVANCED_THREADS "Advanced.Threads"
|
|
|
|
|
#define ST_I18N_ADVANCED_ROWMULTITHREADING ST_I18N_ADVANCED ".RowMultiThreading"
|
|
|
|
|
#define ST_KEY_ADVANCED_ROWMULTITHREADING "Advanced.RowMultiThreading"
|
|
|
|
|
#define ST_I18N_ADVANCED_TILE_COLUMNS ST_I18N_ADVANCED ".Tile.Columns"
|
|
|
|
|
#define ST_KEY_ADVANCED_TILE_COLUMNS "Advanced.Tile.Columns"
|
|
|
|
|
#define ST_I18N_ADVANCED_TILE_ROWS ST_I18N_ADVANCED ".Tile.Rows"
|
|
|
|
|
#define ST_KEY_ADVANCED_TILE_ROWS "Advanced.Tile.Rows"
|
|
|
|
|
#define ST_I18N_ADVANCED_TUNE ST_I18N_ADVANCED ".Tune"
|
|
|
|
|
#define ST_I18N_ADVANCED_TUNE_METRIC ST_I18N_ADVANCED_TUNE ".Metric"
|
|
|
|
|
#define ST_I18N_ADVANCED_TUNE_METRIC_PSNR ST_I18N_ADVANCED_TUNE_METRIC ".PSNR"
|
|
|
|
|
#define ST_I18N_ADVANCED_TUNE_METRIC_SSIM ST_I18N_ADVANCED_TUNE_METRIC ".SSIM"
|
|
|
|
|
#define ST_I18N_ADVANCED_TUNE_METRIC_VMAFWITHPREPROCESSING ST_I18N_ADVANCED_TUNE_METRIC ".VMAF.WithPreprocessing"
|
|
|
|
|
#define ST_I18N_ADVANCED_TUNE_METRIC_VMAFWITHOUTPREPROCESSING ST_I18N_ADVANCED_TUNE_METRIC ".VMAF.WithoutPreProcessing"
|
|
|
|
|
#define ST_I18N_ADVANCED_TUNE_METRIC_VMAFMAXGAIN ST_I18N_ADVANCED_TUNE_METRIC ".VMAF.MaxGain"
|
|
|
|
|
#define ST_I18N_ADVANCED_TUNE_METRIC_VMAFNEGMAXGAIN ST_I18N_ADVANCED_TUNE_METRIC ".VMAF.NegMaxGain"
|
|
|
|
|
#define ST_I18N_ADVANCED_TUNE_METRIC_BUTTERAUGLI ST_I18N_ADVANCED_TUNE_METRIC ".Butteraugli"
|
|
|
|
|
#define ST_KEY_ADVANCED_TUNE_METRIC "Advanced.Tune.Metric"
|
|
|
|
|
#define ST_I18N_ADVANCED_TUNE_CONTENT ST_I18N_ADVANCED_TUNE ".Content"
|
|
|
|
|
#define ST_I18N_ADVANCED_TUNE_CONTENT_SCREEN ST_I18N_ADVANCED_TUNE_CONTENT ".Screen"
|
|
|
|
|
#define ST_I18N_ADVANCED_TUNE_CONTENT_FILM ST_I18N_ADVANCED_TUNE_CONTENT ".Film"
|
|
|
|
|
#define ST_KEY_ADVANCED_TUNE_CONTENT "Advanced.Tune.Content"
|
|
|
|
|
|
|
|
|
|
using namespace streamfx::encoder::aom::av1;
|
|
|
|
|
|
|
|
|
|
static constexpr std::string_view HELP_URL = "https://github.com/Xaymar/obs-StreamFX/wiki/Encoder-AOM-AV1";
|
|
|
|
|
|
|
|
|
|
const char* obs_video_format_to_string(video_format format)
|
|
|
|
|
{
|
|
|
|
|
switch (format) {
|
|
|
|
|
case VIDEO_FORMAT_I420:
|
|
|
|
|
return "I420";
|
|
|
|
|
case VIDEO_FORMAT_NV12:
|
|
|
|
|
return "NV12";
|
|
|
|
|
case VIDEO_FORMAT_YVYU:
|
|
|
|
|
return "YVYU";
|
|
|
|
|
case VIDEO_FORMAT_YUY2:
|
|
|
|
|
return "YUY";
|
|
|
|
|
case VIDEO_FORMAT_UYVY:
|
|
|
|
|
return "UYVY";
|
|
|
|
|
case VIDEO_FORMAT_RGBA:
|
|
|
|
|
return "RGBA";
|
|
|
|
|
case VIDEO_FORMAT_BGRA:
|
|
|
|
|
return "BGRA";
|
|
|
|
|
case VIDEO_FORMAT_BGRX:
|
|
|
|
|
return "BGRX";
|
|
|
|
|
case VIDEO_FORMAT_Y800:
|
|
|
|
|
return "Y800";
|
|
|
|
|
case VIDEO_FORMAT_I444:
|
|
|
|
|
return "I444";
|
|
|
|
|
case VIDEO_FORMAT_BGR3:
|
|
|
|
|
return "BGR3";
|
|
|
|
|
case VIDEO_FORMAT_I422:
|
|
|
|
|
return "I422";
|
|
|
|
|
case VIDEO_FORMAT_I40A:
|
|
|
|
|
return "I40A";
|
|
|
|
|
case VIDEO_FORMAT_I42A:
|
|
|
|
|
return "I42A";
|
|
|
|
|
case VIDEO_FORMAT_YUVA:
|
|
|
|
|
return "YUVA";
|
|
|
|
|
case VIDEO_FORMAT_AYUV:
|
|
|
|
|
return "AYUV";
|
|
|
|
|
default:
|
|
|
|
|
return "Unknown";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* aom_color_format_to_string(aom_img_fmt format)
|
|
|
|
|
{
|
|
|
|
|
switch (format) {
|
|
|
|
|
case AOM_IMG_FMT_AOMYV12:
|
|
|
|
|
return "AOM-YV12";
|
|
|
|
|
case AOM_IMG_FMT_AOMI420:
|
|
|
|
|
return "AOM-I420";
|
|
|
|
|
case AOM_IMG_FMT_YV12:
|
|
|
|
|
return "YV12";
|
|
|
|
|
case AOM_IMG_FMT_I420:
|
|
|
|
|
return "I420";
|
|
|
|
|
case AOM_IMG_FMT_I422:
|
|
|
|
|
return "I422";
|
|
|
|
|
case AOM_IMG_FMT_I444:
|
|
|
|
|
return "I444";
|
|
|
|
|
case AOM_IMG_FMT_YV1216:
|
|
|
|
|
return "YV12-16";
|
|
|
|
|
case AOM_IMG_FMT_I42016:
|
|
|
|
|
return "I420-16";
|
|
|
|
|
case AOM_IMG_FMT_I42216:
|
|
|
|
|
return "I422-16";
|
|
|
|
|
case AOM_IMG_FMT_I44416:
|
|
|
|
|
return "I444-16";
|
|
|
|
|
default:
|
|
|
|
|
return "Unknown";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* aom_color_trc_to_string(aom_transfer_characteristics_t trc)
|
|
|
|
|
{
|
|
|
|
|
switch (trc) {
|
|
|
|
|
case AOM_CICP_TC_BT_709:
|
|
|
|
|
return "Bt.709";
|
|
|
|
|
case AOM_CICP_TC_BT_470_M:
|
|
|
|
|
return "Bt.407 M";
|
|
|
|
|
case AOM_CICP_TC_BT_470_B_G:
|
|
|
|
|
return "Bt.407 B/G";
|
|
|
|
|
case AOM_CICP_TC_BT_601:
|
|
|
|
|
return "Bt.601";
|
|
|
|
|
case AOM_CICP_TC_SMPTE_240:
|
|
|
|
|
return "SMPTE 240 M";
|
|
|
|
|
case AOM_CICP_TC_LINEAR:
|
|
|
|
|
return "Linear";
|
|
|
|
|
case AOM_CICP_TC_LOG_100:
|
|
|
|
|
return "Logarithmic (100:1 range)";
|
|
|
|
|
case AOM_CICP_TC_LOG_100_SQRT10:
|
|
|
|
|
return "Logarithmic (100*sqrt(10):1 range)";
|
|
|
|
|
case AOM_CICP_TC_IEC_61966:
|
|
|
|
|
return "IEC 61966-2-4";
|
|
|
|
|
case AOM_CICP_TC_BT_1361:
|
|
|
|
|
return "Bt.1361";
|
|
|
|
|
case AOM_CICP_TC_SRGB:
|
|
|
|
|
return "sRGB";
|
|
|
|
|
case AOM_CICP_TC_BT_2020_10_BIT:
|
|
|
|
|
return "Bt.2020 10b";
|
|
|
|
|
case AOM_CICP_TC_BT_2020_12_BIT:
|
|
|
|
|
return "Bt.2020 12b";
|
|
|
|
|
case AOM_CICP_TC_SMPTE_2084:
|
|
|
|
|
return "Bt.2100 PQ";
|
|
|
|
|
case AOM_CICP_TC_SMPTE_428:
|
|
|
|
|
return "SMPTE ST 428";
|
|
|
|
|
case AOM_CICP_TC_HLG:
|
|
|
|
|
return "Bt.2100 HLG";
|
|
|
|
|
default:
|
|
|
|
|
return "Unknown";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* aom_rc_mode_to_string(aom_rc_mode mode)
|
|
|
|
|
{
|
|
|
|
|
switch (mode) {
|
|
|
|
|
case AOM_VBR:
|
|
|
|
|
return "Variable Bitrate (VBR)";
|
|
|
|
|
case AOM_CBR:
|
|
|
|
|
return "Constant Bitrate (CBR)";
|
|
|
|
|
case AOM_CQ:
|
|
|
|
|
return "Constrained Quality (CQ)";
|
|
|
|
|
case AOM_Q:
|
|
|
|
|
return "Constant Quality (Q)";
|
|
|
|
|
default:
|
|
|
|
|
return "Unknown";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* aom_kf_mode_to_string(aom_kf_mode mode)
|
|
|
|
|
{
|
|
|
|
|
switch (mode) {
|
|
|
|
|
case AOM_KF_AUTO:
|
|
|
|
|
return "Automatic";
|
|
|
|
|
case AOM_KF_DISABLED:
|
|
|
|
|
return "Disabled";
|
|
|
|
|
default:
|
|
|
|
|
return "Unknown";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* aom_tune_metric_to_string(aom_tune_metric tune)
|
|
|
|
|
{
|
|
|
|
|
switch (tune) {
|
|
|
|
|
case AOM_TUNE_PSNR:
|
|
|
|
|
return "PSNR";
|
|
|
|
|
case AOM_TUNE_SSIM:
|
|
|
|
|
return "SSIM";
|
|
|
|
|
case AOM_TUNE_VMAF_WITH_PREPROCESSING:
|
|
|
|
|
return "VMAF w/ pre-processing";
|
|
|
|
|
case AOM_TUNE_VMAF_WITHOUT_PREPROCESSING:
|
|
|
|
|
return "VMAF w/o pre-processing";
|
|
|
|
|
case AOM_TUNE_VMAF_MAX_GAIN:
|
|
|
|
|
return "VMAF max. gain";
|
|
|
|
|
case AOM_TUNE_VMAF_NEG_MAX_GAIN:
|
|
|
|
|
return "VMAF negative max. gain";
|
|
|
|
|
case AOM_TUNE_BUTTERAUGLI:
|
|
|
|
|
return "Butteraugli";
|
|
|
|
|
default:
|
|
|
|
|
return "Unknown";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* aom_tune_content_to_string(aom_tune_content tune)
|
|
|
|
|
{
|
|
|
|
|
switch (tune) {
|
|
|
|
|
case AOM_CONTENT_DEFAULT:
|
|
|
|
|
return "Default";
|
|
|
|
|
case AOM_CONTENT_FILM:
|
|
|
|
|
return "Film";
|
|
|
|
|
case AOM_CONTENT_SCREEN:
|
|
|
|
|
return "Screen";
|
|
|
|
|
default:
|
|
|
|
|
return "Unknown";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
aom_av1_instance::aom_av1_instance(obs_data_t* settings, obs_encoder_t* self, bool is_hw)
|
|
|
|
|
: obs::encoder_instance(settings, self, is_hw), _factory(aom_av1_factory::get()), _iface(nullptr), _ctx(), _cfg(),
|
|
|
|
|
_image_index(0), _images(), _global_headers(nullptr), _initialized(false), _settings()
|
|
|
|
|
{
|
|
|
|
|
if (is_hw) {
|
|
|
|
|
throw std::runtime_error("Hardware encoding isn't even registered, how did you get here?");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Retrieve encoder interface.
|
|
|
|
|
_iface = _factory->libaom_codec_av1_cx();
|
|
|
|
|
if (!_iface) {
|
|
|
|
|
throw std::runtime_error("AOM library does not provide AV1 encoder.");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef ENABLE_PROFILING
|
|
|
|
|
// Profilers
|
|
|
|
|
_profiler_copy = streamfx::util::profiler::create();
|
|
|
|
|
_profiler_encode = streamfx::util::profiler::create();
|
|
|
|
|
_profiler_packet = streamfx::util::profiler::create();
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
{ // Generate Static Configuration
|
|
|
|
|
{ // OBS Information
|
|
|
|
|
video_scale_info ovsi;
|
|
|
|
|
video_t* video = obs_encoder_video(_self);
|
|
|
|
|
const struct video_output_info* video_info = video_output_get_info(video);
|
|
|
|
|
|
|
|
|
|
ovsi.colorspace = video_info->colorspace;
|
|
|
|
|
ovsi.format = video_info->format;
|
|
|
|
|
ovsi.range = video_info->range;
|
|
|
|
|
get_video_info(&ovsi);
|
|
|
|
|
|
|
|
|
|
// Video
|
|
|
|
|
_settings.width = static_cast<uint16_t>(obs_encoder_get_width(_self));
|
|
|
|
|
_settings.height = static_cast<uint16_t>(obs_encoder_get_height(_self));
|
|
|
|
|
_settings.fps.num = static_cast<uint32_t>(video_info->fps_num);
|
|
|
|
|
_settings.fps.den = static_cast<uint32_t>(video_info->fps_den);
|
|
|
|
|
|
|
|
|
|
// Color Format
|
|
|
|
|
switch (ovsi.format) {
|
|
|
|
|
case VIDEO_FORMAT_I420:
|
|
|
|
|
_settings.color_format = AOM_IMG_FMT_I420;
|
|
|
|
|
break;
|
|
|
|
|
case VIDEO_FORMAT_I422:
|
|
|
|
|
_settings.color_format = AOM_IMG_FMT_I422;
|
|
|
|
|
break;
|
|
|
|
|
case VIDEO_FORMAT_I444:
|
|
|
|
|
_settings.color_format = AOM_IMG_FMT_I444;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2022-08-28 12:55:40 +00:00
|
|
|
throw std::runtime_error("Color Format is unknown.");
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Color Space
|
|
|
|
|
switch (ovsi.colorspace) {
|
|
|
|
|
case VIDEO_CS_601:
|
|
|
|
|
_settings.color_primaries = AOM_CICP_CP_BT_601;
|
|
|
|
|
_settings.color_trc = AOM_CICP_TC_BT_601;
|
|
|
|
|
_settings.color_matrix = AOM_CICP_MC_BT_601;
|
|
|
|
|
break;
|
|
|
|
|
case VIDEO_CS_709:
|
|
|
|
|
_settings.color_primaries = AOM_CICP_CP_BT_709;
|
|
|
|
|
_settings.color_trc = AOM_CICP_TC_BT_709;
|
|
|
|
|
_settings.color_matrix = AOM_CICP_MC_BT_709;
|
|
|
|
|
break;
|
|
|
|
|
case VIDEO_CS_SRGB:
|
|
|
|
|
_settings.color_primaries = AOM_CICP_CP_BT_709;
|
|
|
|
|
_settings.color_trc = AOM_CICP_TC_SRGB;
|
|
|
|
|
_settings.color_matrix = AOM_CICP_MC_BT_709;
|
|
|
|
|
break;
|
2022-08-28 12:55:40 +00:00
|
|
|
default:
|
|
|
|
|
throw std::runtime_error("Color Space is unknown.");
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Color Range
|
|
|
|
|
switch (ovsi.range) {
|
|
|
|
|
case VIDEO_RANGE_FULL:
|
|
|
|
|
_settings.color_range = AOM_CR_FULL_RANGE;
|
|
|
|
|
break;
|
|
|
|
|
case VIDEO_RANGE_PARTIAL:
|
|
|
|
|
_settings.color_range = AOM_CR_STUDIO_RANGE;
|
|
|
|
|
break;
|
2022-08-28 12:55:40 +00:00
|
|
|
default:
|
|
|
|
|
throw std::runtime_error("Color Range is unknown.");
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Monochrome
|
|
|
|
|
_settings.monochrome = (video_info->format == VIDEO_FORMAT_Y800);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Encoder
|
|
|
|
|
_settings.profile = static_cast<codec::av1::profile>(obs_data_get_int(settings, ST_KEY_ENCODER_PROFILE));
|
|
|
|
|
if (_settings.profile == codec::av1::profile::UNKNOWN) {
|
|
|
|
|
// Resolve the automatic profile to a proper value.
|
2021-10-06 21:20:57 +00:00
|
|
|
bool need_professional = (_settings.color_format == AOM_IMG_FMT_I422);
|
|
|
|
|
bool need_high = (_settings.color_format == AOM_IMG_FMT_I444) || _settings.monochrome;
|
2021-08-28 12:36:42 +00:00
|
|
|
|
|
|
|
|
if (need_professional) {
|
|
|
|
|
_settings.profile = codec::av1::profile::PROFESSIONAL;
|
|
|
|
|
} else if (need_high) {
|
|
|
|
|
_settings.profile = codec::av1::profile::HIGH;
|
|
|
|
|
} else {
|
|
|
|
|
_settings.profile = codec::av1::profile::MAIN;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Rate Control
|
|
|
|
|
_settings.rc_mode = static_cast<aom_rc_mode>(obs_data_get_int(settings, ST_KEY_RATECONTROL_MODE));
|
|
|
|
|
_settings.rc_lookahead = static_cast<int8_t>(obs_data_get_int(settings, ST_KEY_RATECONTROL_LOOKAHEAD));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Threading
|
|
|
|
|
if (auto threads = obs_data_get_int(settings, ST_KEY_ADVANCED_THREADS); threads > 0) {
|
|
|
|
|
_settings.threads = static_cast<int8_t>(threads);
|
|
|
|
|
} else {
|
2022-08-28 11:44:00 +00:00
|
|
|
_settings.threads = static_cast<int8_t>(std::thread::hardware_concurrency());
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
_settings.rowmultithreading =
|
|
|
|
|
static_cast<int8_t>(obs_data_get_int(settings, ST_KEY_ADVANCED_ROWMULTITHREADING));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Tiling
|
|
|
|
|
_settings.tile_columns = static_cast<int8_t>(obs_data_get_int(settings, ST_KEY_ADVANCED_TILE_COLUMNS));
|
|
|
|
|
_settings.tile_rows = static_cast<int8_t>(obs_data_get_int(settings, ST_KEY_ADVANCED_TILE_ROWS));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Tuning
|
2021-10-06 21:22:49 +00:00
|
|
|
if (auto v = obs_data_get_int(settings, ST_KEY_ADVANCED_TUNE_METRIC); v != -1) {
|
|
|
|
|
_settings.tune_metric = static_cast<aom_tune_metric>(v);
|
|
|
|
|
}
|
2021-08-28 12:36:42 +00:00
|
|
|
_settings.tune_content =
|
|
|
|
|
static_cast<aom_tune_content>(obs_data_get_int(settings, ST_KEY_ADVANCED_TUNE_CONTENT));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Apply Settings
|
|
|
|
|
update(settings);
|
|
|
|
|
|
|
|
|
|
// Initialize Encoder
|
|
|
|
|
if (auto error = _factory->libaom_codec_enc_init_ver(&_ctx, _iface, &_cfg, 0, AOM_ENCODER_ABI_VERSION);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
D_LOG_ERROR("Failed to initialize codec, unexpected error: %s (code %" PRIu32 ")", errstr, error);
|
|
|
|
|
throw std::runtime_error(errstr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Apply Static Control Settings
|
|
|
|
|
|
|
|
|
|
{ // Color Information
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_COLOR_PRIMARIES
|
|
|
|
|
if (auto error = _factory->libaom_codec_control(&_ctx, AV1E_SET_COLOR_PRIMARIES, _settings.color_primaries);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AV1E_SET_COLOR_PRIMARIES", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
D_LOG_ERROR("AOM library was built without AV1E_SET_COLOR_PRIMARIES, behavior is unknown.");
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_TRANSFER_CHARACTERISTICS
|
|
|
|
|
if (auto error =
|
|
|
|
|
_factory->libaom_codec_control(&_ctx, AV1E_SET_TRANSFER_CHARACTERISTICS, _settings.color_trc);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AV1E_SET_TRANSFER_CHARACTERISTICS", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
D_LOG_ERROR("AOM library was built without AV1E_SET_TRANSFER_CHARACTERISTICS, behavior is unknown.");
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_MATRIX_COEFFICIENTS
|
|
|
|
|
if (auto error =
|
|
|
|
|
_factory->libaom_codec_control(&_ctx, AV1E_SET_MATRIX_COEFFICIENTS, _settings.color_matrix);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AV1E_SET_MATRIX_COEFFICIENTS", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
D_LOG_ERROR("AOM library was built without AV1E_SET_MATRIX_COEFFICIENTS, behavior is unknown.");
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_COLOR_RANGE
|
|
|
|
|
if (auto error = _factory->libaom_codec_control(&_ctx, AV1E_SET_COLOR_RANGE, _settings.color_range);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AV1E_SET_COLOR_RANGE", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
D_LOG_ERROR("AOM library was built without AV1_SET_COLOR_RANGE, behavior is unknown.");
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_CHROMA_SAMPLE_POSITION
|
|
|
|
|
// !TODO: Consider making this user-controlled. At the moment, this follows the H.264 chroma standard.
|
|
|
|
|
if (auto error = _factory->libaom_codec_control(&_ctx, AV1E_SET_CHROMA_SAMPLE_POSITION, AOM_CSP_VERTICAL);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AV1E_SET_CHROMA_SAMPLE_POSITION", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_RENDER_SIZE
|
|
|
|
|
int32_t size[2] = {_settings.width, _settings.height};
|
|
|
|
|
if (auto error = _factory->libaom_codec_control(&_ctx, AV1E_SET_RENDER_SIZE, &size);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AV1E_SET_RENDER_SIZE", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Apply Dynamic Control Settings
|
|
|
|
|
if (!update(settings)) {
|
|
|
|
|
throw std::runtime_error("Unexpected error during configuration.");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Preallocate global headers.
|
|
|
|
|
_global_headers = _factory->libaom_codec_get_global_headers(&_ctx);
|
|
|
|
|
|
|
|
|
|
// Allocate frames.
|
|
|
|
|
_images.resize(_cfg.g_threads);
|
|
|
|
|
for (auto& image : _images) {
|
|
|
|
|
_factory->libaom_img_alloc(&image, _settings.color_format, _settings.width, _settings.height, 8);
|
|
|
|
|
|
|
|
|
|
// Color Information.
|
|
|
|
|
image.fmt = _settings.color_format;
|
|
|
|
|
image.cp = _settings.color_primaries;
|
|
|
|
|
image.tc = _settings.color_trc;
|
|
|
|
|
image.mc = _settings.color_matrix;
|
|
|
|
|
image.range = _settings.color_range;
|
|
|
|
|
image.monochrome = _settings.monochrome ? 1 : 0;
|
|
|
|
|
image.csp = AOM_CSP_VERTICAL; // !TODO: Consider making this user-controlled.
|
|
|
|
|
|
|
|
|
|
// Size
|
|
|
|
|
image.r_w = image.d_w;
|
|
|
|
|
image.r_h = image.d_h;
|
|
|
|
|
image.r_w = image.w;
|
|
|
|
|
image.r_h = image.h;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Log Settings
|
|
|
|
|
log();
|
|
|
|
|
|
|
|
|
|
// Signal to future update() calls that we are fully initialized.
|
|
|
|
|
_initialized = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
aom_av1_instance::~aom_av1_instance()
|
|
|
|
|
{
|
|
|
|
|
#ifdef ENABLE_PROFILING
|
|
|
|
|
// Profiling
|
|
|
|
|
D_LOG_INFO("Timings | Avg. µs | 99.9ile µs | 99.0ile µs | 95.0ile µs | Samples ", "");
|
|
|
|
|
D_LOG_INFO("--------+---------------+---------------+---------------+---------------+----------", "");
|
|
|
|
|
D_LOG_INFO("Copy | %13.1f | %13" PRId64 " | %13" PRId64 " | %13" PRId64 " | %9" PRIu64,
|
|
|
|
|
_profiler_copy->average_duration() / 1000.,
|
|
|
|
|
std::chrono::duration_cast<std::chrono::microseconds>(_profiler_copy->percentile(0.999)).count(),
|
|
|
|
|
std::chrono::duration_cast<std::chrono::microseconds>(_profiler_copy->percentile(0.990)).count(),
|
|
|
|
|
std::chrono::duration_cast<std::chrono::microseconds>(_profiler_copy->percentile(0.950)).count(),
|
|
|
|
|
_profiler_copy->count());
|
|
|
|
|
D_LOG_INFO("Encode | %13.1f | %13" PRId64 " | %13" PRId64 " | %13" PRId64 " | %9" PRIu64,
|
|
|
|
|
_profiler_encode->average_duration() / 1000.,
|
|
|
|
|
std::chrono::duration_cast<std::chrono::microseconds>(_profiler_encode->percentile(0.999)).count(),
|
|
|
|
|
std::chrono::duration_cast<std::chrono::microseconds>(_profiler_encode->percentile(0.990)).count(),
|
|
|
|
|
std::chrono::duration_cast<std::chrono::microseconds>(_profiler_encode->percentile(0.950)).count(),
|
|
|
|
|
_profiler_encode->count());
|
|
|
|
|
D_LOG_INFO("Packet | %13.1f | %13" PRId64 " | %13" PRId64 " | %13" PRId64 " | %9" PRIu64,
|
|
|
|
|
_profiler_packet->average_duration() / 1000.,
|
|
|
|
|
std::chrono::duration_cast<std::chrono::microseconds>(_profiler_packet->percentile(0.999)).count(),
|
|
|
|
|
std::chrono::duration_cast<std::chrono::microseconds>(_profiler_packet->percentile(0.990)).count(),
|
|
|
|
|
std::chrono::duration_cast<std::chrono::microseconds>(_profiler_packet->percentile(0.950)).count(),
|
|
|
|
|
_profiler_packet->count());
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
// Deallocate global buffer.
|
|
|
|
|
if (_global_headers) {
|
|
|
|
|
/* Breaks heap
|
|
|
|
|
if (_global_headers->buf) {
|
|
|
|
|
free(_global_headers->buf);
|
|
|
|
|
_global_headers->buf = nullptr;
|
|
|
|
|
}
|
|
|
|
|
free(_global_headers);
|
|
|
|
|
_global_headers = nullptr;
|
|
|
|
|
*/
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Deallocate frames.
|
|
|
|
|
for (auto& image : _images) {
|
|
|
|
|
_factory->libaom_img_free(&image);
|
|
|
|
|
}
|
|
|
|
|
_images.clear();
|
|
|
|
|
|
|
|
|
|
// Destroy encoder.
|
|
|
|
|
_factory->libaom_codec_destroy(&_ctx);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void aom_av1_instance::migrate(obs_data_t* settings, uint64_t version) {}
|
|
|
|
|
|
|
|
|
|
bool aom_av1_instance::update(obs_data_t* settings)
|
|
|
|
|
{
|
|
|
|
|
video_t* obsVideo = obs_encoder_video(_self);
|
|
|
|
|
const struct video_output_info* obsVideoInfo = video_output_get_info(obsVideo);
|
|
|
|
|
uint32_t obsFPSnum = obsVideoInfo->fps_num;
|
|
|
|
|
uint32_t obsFPSden = obsVideoInfo->fps_den;
|
|
|
|
|
bool obsMonochrome = (obsVideoInfo->format == VIDEO_FORMAT_Y800);
|
|
|
|
|
|
|
|
|
|
#define SET_IF_NOT_DEFAULT(X, Y) \
|
|
|
|
|
if (X != -1) { \
|
|
|
|
|
Y = static_cast<decltype(Y)>(X); \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Generate Dynamic Settings
|
|
|
|
|
|
|
|
|
|
{ // Encoder
|
|
|
|
|
_settings.preset = static_cast<int8_t>(obs_data_get_int(settings, ST_KEY_ENCODER_CPUUSAGE));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Rate Control
|
2022-08-28 11:44:00 +00:00
|
|
|
_settings.rc_bitrate = static_cast<int8_t>(obs_data_get_int(settings, ST_KEY_RATECONTROL_LIMITS_BITRATE));
|
2021-08-28 12:36:42 +00:00
|
|
|
_settings.rc_bitrate_overshoot =
|
|
|
|
|
static_cast<int32_t>(obs_data_get_int(settings, ST_KEY_RATECONTROL_LIMITS_BITRATE_UNDERSHOOT));
|
|
|
|
|
_settings.rc_bitrate_undershoot =
|
|
|
|
|
static_cast<int32_t>(obs_data_get_int(settings, ST_KEY_RATECONTROL_LIMITS_BITRATE_OVERSHOOT));
|
2022-08-28 11:44:00 +00:00
|
|
|
_settings.rc_quality = static_cast<int8_t>(obs_data_get_int(settings, ST_KEY_RATECONTROL_LIMITS_QUALITY));
|
2021-08-28 12:36:42 +00:00
|
|
|
_settings.rc_quantizer_min =
|
2022-08-28 11:44:00 +00:00
|
|
|
static_cast<int8_t>(obs_data_get_int(settings, ST_KEY_RATECONTROL_LIMITS_QUANTIZER_MINIMUM));
|
2021-08-28 12:36:42 +00:00
|
|
|
_settings.rc_quantizer_max =
|
2022-08-28 11:44:00 +00:00
|
|
|
static_cast<int8_t>(obs_data_get_int(settings, ST_KEY_RATECONTROL_LIMITS_QUANTIZER_MAXIMUM));
|
2021-08-28 12:36:42 +00:00
|
|
|
_settings.rc_buffer_ms = static_cast<int32_t>(obs_data_get_int(settings, ST_KEY_RATECONTROL_BUFFER_SIZE));
|
|
|
|
|
_settings.rc_buffer_initial_ms =
|
|
|
|
|
static_cast<int32_t>(obs_data_get_int(settings, ST_KEY_RATECONTROL_BUFFER_SIZE_INITIAL));
|
|
|
|
|
_settings.rc_buffer_optimal_ms =
|
|
|
|
|
static_cast<int32_t>(obs_data_get_int(settings, ST_KEY_RATECONTROL_BUFFER_SIZE_OPTIMAL));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Key-Frames
|
|
|
|
|
int64_t kf_type = obs_data_get_int(settings, ST_KEY_KEYFRAMES_INTERVALTYPE);
|
|
|
|
|
bool is_seconds = (kf_type == 0);
|
|
|
|
|
|
|
|
|
|
_settings.kf_mode = AOM_KF_AUTO;
|
|
|
|
|
if (is_seconds) {
|
2022-08-28 11:44:00 +00:00
|
|
|
_settings.kf_distance_max = static_cast<int32_t>(
|
2021-08-28 12:36:42 +00:00
|
|
|
std::lround(obs_data_get_double(settings, ST_KEY_KEYFRAMES_INTERVAL_SECONDS)
|
|
|
|
|
* static_cast<double>(obsFPSnum) / static_cast<double>(obsFPSden)));
|
|
|
|
|
} else {
|
|
|
|
|
_settings.kf_distance_max =
|
2022-08-28 11:44:00 +00:00
|
|
|
static_cast<int32_t>(obs_data_get_int(settings, ST_KEY_KEYFRAMES_INTERVAL_FRAMES));
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
_settings.kf_distance_min = _settings.kf_distance_max;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// All-Intra requires us to never set Key-Frames.
|
|
|
|
|
if (_cfg.g_usage == AOM_USAGE_ALL_INTRA) {
|
|
|
|
|
_settings.rc_lookahead = 0;
|
|
|
|
|
_settings.kf_mode = AOM_KF_DISABLED;
|
|
|
|
|
_settings.kf_distance_min = 0;
|
|
|
|
|
_settings.kf_distance_max = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Configuration.
|
|
|
|
|
|
|
|
|
|
{ // Usage and Defaults
|
|
|
|
|
_cfg.g_usage = static_cast<unsigned int>(obs_data_get_int(settings, ST_KEY_ENCODER_USAGE));
|
|
|
|
|
_factory->libaom_codec_enc_config_default(_iface, &_cfg, _cfg.g_usage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Frame Information
|
|
|
|
|
// Size
|
|
|
|
|
_cfg.g_w = _settings.width;
|
|
|
|
|
_cfg.g_h = _settings.height;
|
|
|
|
|
|
|
|
|
|
// Time Base (Rate is inverted Time Base)
|
2022-08-28 11:44:00 +00:00
|
|
|
_cfg.g_timebase.num = static_cast<int>(_settings.fps.den);
|
|
|
|
|
_cfg.g_timebase.den = static_cast<int>(_settings.fps.num);
|
2021-08-28 12:36:42 +00:00
|
|
|
|
|
|
|
|
// !INFO: Whenever OBS decides to support anything but 8-bits, let me know.
|
|
|
|
|
_cfg.g_bit_depth = AOM_BITS_8;
|
|
|
|
|
_cfg.g_input_bit_depth = AOM_BITS_8;
|
|
|
|
|
|
|
|
|
|
// Monochrome color
|
2022-08-28 11:44:00 +00:00
|
|
|
_cfg.monochrome = _settings.monochrome ? 1u : 0u;
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Encoder
|
|
|
|
|
|
|
|
|
|
// AV1 Profile
|
|
|
|
|
_cfg.g_profile = static_cast<unsigned int>(_settings.profile);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Rate Control
|
|
|
|
|
// Mode
|
|
|
|
|
_cfg.rc_end_usage = static_cast<aom_rc_mode>(obs_data_get_int(settings, ST_KEY_RATECONTROL_MODE));
|
|
|
|
|
|
|
|
|
|
// Look-Ahead
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.rc_lookahead, _cfg.g_lag_in_frames);
|
|
|
|
|
|
|
|
|
|
// Limits
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.rc_bitrate, _cfg.rc_target_bitrate);
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.rc_bitrate_overshoot, _cfg.rc_overshoot_pct);
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.rc_bitrate_undershoot, _cfg.rc_undershoot_pct);
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.rc_quantizer_min, _cfg.rc_min_quantizer);
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.rc_quantizer_max, _cfg.rc_max_quantizer);
|
|
|
|
|
|
|
|
|
|
// Buffer
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.rc_buffer_ms, _cfg.rc_buf_sz);
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.rc_buffer_initial_ms, _cfg.rc_buf_initial_sz);
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.rc_buffer_optimal_ms, _cfg.rc_buf_optimal_sz);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Key-Frames
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.kf_mode, _cfg.kf_mode);
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.kf_distance_min, _cfg.kf_min_dist);
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.kf_distance_max, _cfg.kf_max_dist);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Advanced
|
|
|
|
|
|
|
|
|
|
// Single-Pass
|
|
|
|
|
_cfg.g_pass = AOM_RC_ONE_PASS;
|
|
|
|
|
|
|
|
|
|
// Threading
|
|
|
|
|
SET_IF_NOT_DEFAULT(_settings.threads, _cfg.g_threads);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// TODO: Future
|
|
|
|
|
//_cfg.rc_resize_mode = 0; // "RESIZE_NONE
|
|
|
|
|
//_cfg.rc_resize_denominator = ?;
|
|
|
|
|
//_cfg.rc_resize_kf_denominator = ?;
|
|
|
|
|
//_cfg.rc_superres_mode = AOM_SUPERRES_NONE;
|
|
|
|
|
//_cfg.rc_superres_denominator = ?;
|
|
|
|
|
//_cfg.rc_superres_kf_denominator = ?;
|
|
|
|
|
//_cfg.rc_superres_qthresh = ?;
|
|
|
|
|
//_cfg.rc_superres_kf_qtresh = ?;
|
|
|
|
|
//_cfg.rc_dropframe_thresh = ?;
|
|
|
|
|
//_cfg.fwd_kf_enabled = ?;
|
|
|
|
|
//_cfg.g_forced_max_frame_width = ?;
|
|
|
|
|
//_cfg.g_forced_max_frame_height = ?;
|
|
|
|
|
//_cfg.g_error_resilient = ?;
|
|
|
|
|
//_cfg.g_lag_in_frames = ?;
|
|
|
|
|
//_cfg.sframe_dist = ?;
|
|
|
|
|
//_cfg.sframe_mode = 0;
|
|
|
|
|
//_cfg.large_scale_tile = 0;
|
|
|
|
|
//_cfg.full_still_picture_hdr = ?;
|
|
|
|
|
//_cfg.save_as_annexb = ?;
|
|
|
|
|
//_cfg.encoder_cfg = ?;
|
|
|
|
|
|
|
|
|
|
// Apply configuration
|
|
|
|
|
if (_initialized) {
|
|
|
|
|
if (auto error = _factory->libaom_codec_enc_config_set(&_ctx, &_cfg); error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing configuration: %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (_ctx.iface) { // Control
|
|
|
|
|
|
|
|
|
|
{ // Encoder
|
|
|
|
|
#ifdef AOM_CTRL_AOME_SET_CPUUSED
|
|
|
|
|
if (_settings.preset != -1) {
|
|
|
|
|
if (auto error = _factory->libaom_codec_control(&_ctx, AOME_SET_CPUUSED, _settings.preset);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AOME_SET_CPUUSED", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Rate Control
|
|
|
|
|
#ifdef AOM_CTRL_AOME_SET_CQ_LEVEL
|
|
|
|
|
if ((_settings.rc_quality != -1) && ((_settings.rc_mode == AOM_CQ) || (_settings.rc_mode == AOM_Q))) {
|
|
|
|
|
if (auto error = _factory->libaom_codec_control(&_ctx, AOME_SET_CQ_LEVEL, _settings.rc_quality);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AOME_SET_CQ_LEVEL", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Advanced
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_ROW_MT
|
|
|
|
|
if (_settings.rowmultithreading != -1) {
|
|
|
|
|
if (auto error = _factory->libaom_codec_control(&_ctx, AV1E_SET_ROW_MT, _settings.rowmultithreading);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AV1E_SET_ROW_MT", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_TILE_COLUMNS
|
|
|
|
|
if (_settings.tile_columns != -1) {
|
|
|
|
|
if (auto error = _factory->libaom_codec_control(&_ctx, AV1E_SET_TILE_COLUMNS, _settings.tile_columns);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AV1E_SET_TILE_COLUMNS", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_TILE_ROWS
|
|
|
|
|
if (_settings.tile_rows != -1) {
|
|
|
|
|
if (auto error = _factory->libaom_codec_control(&_ctx, AV1E_SET_TILE_ROWS, _settings.tile_rows);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AV1E_SET_TILE_ROWS", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef AOM_CTRL_AOME_SET_TUNING
|
|
|
|
|
if (_settings.tune_metric != -1) {
|
|
|
|
|
if (auto error = _factory->libaom_codec_control(&_ctx, AOME_SET_TUNING, _settings.tune_metric);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AOME_SET_TUNING", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_TUNE_CONTENT
|
|
|
|
|
if (_settings.tune_content != AOM_CONTENT_DEFAULT) {
|
|
|
|
|
if (auto error = _factory->libaom_codec_control(&_ctx, AV1E_SET_TUNE_CONTENT, _settings.tune_content);
|
|
|
|
|
error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
const char* err = _factory->libaom_codec_error(&_ctx);
|
|
|
|
|
const char* errdtl = _factory->libaom_codec_error_detail(&_ctx);
|
|
|
|
|
D_LOG_WARNING("Error changing '%s': %s (code %" PRIu32 ")%s%s%s%s", //
|
|
|
|
|
"AV1E_SET_TUNE_CONTENT", //
|
|
|
|
|
(errstr ? errstr : ""), error, //
|
|
|
|
|
(err ? "\n\tMessage: " : ""), (err ? err : ""), //
|
|
|
|
|
(errdtl ? "\n\tDetails: " : ""), (errdtl ? errdtl : "") //
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#undef SET_IF_NOT_DEFAULT
|
|
|
|
|
|
|
|
|
|
// Log the changed settings.
|
|
|
|
|
if (_initialized) {
|
|
|
|
|
log();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void aom_av1_instance::log()
|
|
|
|
|
{
|
|
|
|
|
D_LOG_INFO("AOM AV1:", "");
|
|
|
|
|
D_LOG_INFO(" Video: %" PRIu16 "x%" PRIu16 "@%1.2ffps (%" PRIu32 "/%" PRIu32 ")", _settings.width, _settings.height,
|
|
|
|
|
static_cast<double>(_settings.fps.num) / static_cast<float>(_settings.fps.den), _settings.fps.num,
|
|
|
|
|
_settings.fps.den);
|
|
|
|
|
D_LOG_INFO(" Color: %s/%s/%s%s", aom_color_format_to_string(_settings.color_format),
|
|
|
|
|
aom_color_trc_to_string(_settings.color_trc),
|
|
|
|
|
_settings.color_range == AOM_CR_FULL_RANGE ? "Full" : "Partial",
|
|
|
|
|
_settings.monochrome ? "/Monochrome" : "");
|
|
|
|
|
|
|
|
|
|
// Rate Control
|
|
|
|
|
D_LOG_INFO(" Rate Control: %s", aom_rc_mode_to_string(_settings.rc_mode));
|
|
|
|
|
D_LOG_INFO(" Look-Ahead: %" PRId8, _settings.rc_lookahead);
|
|
|
|
|
D_LOG_INFO(" Buffers: %" PRId32 " ms / %" PRId32 " ms / %" PRId32 " ms", _settings.rc_buffer_ms,
|
|
|
|
|
_settings.rc_buffer_initial_ms, _settings.rc_buffer_optimal_ms);
|
|
|
|
|
D_LOG_INFO(" Bitrate: %" PRId32 " kbit/s (-%" PRId32 "%% - +%" PRId32 "%%)", _settings.rc_bitrate,
|
|
|
|
|
_settings.rc_bitrate_undershoot, _settings.rc_bitrate_overshoot);
|
|
|
|
|
D_LOG_INFO(" Quality: %" PRId8, _settings.rc_quality);
|
|
|
|
|
D_LOG_INFO(" Quantizer: %" PRId8 " - %" PRId8, _settings.rc_quantizer_min, _settings.rc_quantizer_max);
|
|
|
|
|
|
|
|
|
|
// Key-Frames
|
|
|
|
|
D_LOG_INFO(" Key-Frames: %s", aom_kf_mode_to_string(_settings.kf_mode));
|
|
|
|
|
D_LOG_INFO(" Distance: %" PRId32 " - %" PRId32 " frames", _settings.kf_distance_min, _settings.kf_distance_max);
|
|
|
|
|
|
|
|
|
|
// Advanced
|
|
|
|
|
D_LOG_INFO(" Advanced: ", "");
|
|
|
|
|
D_LOG_INFO(" Threads: %" PRId8, _settings.threads);
|
|
|
|
|
D_LOG_INFO(" Row-Multi-Threading: %s", _settings.rowmultithreading == -1 ? "Default"
|
|
|
|
|
: _settings.rowmultithreading == 1 ? "Enabled"
|
|
|
|
|
: "Disabled");
|
|
|
|
|
D_LOG_INFO(" Tiling: %" PRId8 "x%" PRId8, _settings.tile_columns, _settings.tile_rows);
|
|
|
|
|
D_LOG_INFO(" Tune: %s (Metric), %s (Content)", aom_tune_metric_to_string(_settings.tune_metric),
|
|
|
|
|
aom_tune_content_to_string(_settings.tune_content));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool aom_av1_instance::get_extra_data(uint8_t** extra_data, size_t* size)
|
|
|
|
|
{
|
|
|
|
|
if (!_global_headers) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*extra_data = static_cast<uint8_t*>(_global_headers->buf);
|
|
|
|
|
*size = _global_headers->sz;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool aom_av1_instance::get_sei_data(uint8_t** sei_data, size_t* size)
|
|
|
|
|
{
|
|
|
|
|
return get_extra_data(sei_data, size);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void aom_av1_instance::get_video_info(struct video_scale_info* info)
|
|
|
|
|
{
|
|
|
|
|
// Fix up color format.
|
|
|
|
|
auto format = obs_encoder_get_preferred_video_format(_self);
|
|
|
|
|
if (format == VIDEO_FORMAT_NONE) {
|
|
|
|
|
format = info->format;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (format) {
|
|
|
|
|
// Perfect matches.
|
|
|
|
|
case VIDEO_FORMAT_I444: // AOM_IMG_I444.
|
|
|
|
|
case VIDEO_FORMAT_I422: // AOM_IMG_I422.
|
|
|
|
|
case VIDEO_FORMAT_I420: // AOM_IMG_I420.
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
// 4:2:0 formats
|
|
|
|
|
case VIDEO_FORMAT_NV12: // Y, UV Interleaved.
|
|
|
|
|
case VIDEO_FORMAT_I40A:
|
|
|
|
|
D_LOG_WARNING("Color-format '%s' is not supported, forcing 'I420'...", obs_video_format_to_string(format));
|
|
|
|
|
info->format = VIDEO_FORMAT_I420;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
// 4:2:2-like formats
|
|
|
|
|
case VIDEO_FORMAT_UYVY:
|
|
|
|
|
case VIDEO_FORMAT_YUY2:
|
|
|
|
|
case VIDEO_FORMAT_YVYU:
|
|
|
|
|
case VIDEO_FORMAT_I42A:
|
|
|
|
|
D_LOG_WARNING("Color-format '%s' is not supported, forcing 'I422'...", obs_video_format_to_string(format));
|
|
|
|
|
info->format = VIDEO_FORMAT_I422;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
// 4:4:4
|
|
|
|
|
case VIDEO_FORMAT_BGR3:
|
|
|
|
|
case VIDEO_FORMAT_BGRA:
|
|
|
|
|
case VIDEO_FORMAT_BGRX:
|
|
|
|
|
case VIDEO_FORMAT_RGBA:
|
|
|
|
|
case VIDEO_FORMAT_YUVA:
|
|
|
|
|
case VIDEO_FORMAT_AYUV:
|
|
|
|
|
case VIDEO_FORMAT_Y800: // Grayscale, no exact match.
|
|
|
|
|
D_LOG_WARNING("Color-format '%s' is not supported, forcing 'I444'...", obs_video_format_to_string(format));
|
|
|
|
|
info->format = VIDEO_FORMAT_I444;
|
|
|
|
|
break;
|
2022-08-28 12:55:40 +00:00
|
|
|
default:
|
|
|
|
|
throw std::runtime_error("Color Format is unknown.");
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Fix up color space.
|
|
|
|
|
if (info->colorspace == VIDEO_CS_DEFAULT) {
|
|
|
|
|
info->colorspace = VIDEO_CS_SRGB;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Fix up color range.
|
|
|
|
|
if (info->range == VIDEO_RANGE_DEFAULT) {
|
|
|
|
|
info->range = VIDEO_RANGE_PARTIAL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool streamfx::encoder::aom::av1::aom_av1_instance::encode_video(encoder_frame* frame, encoder_packet* packet,
|
|
|
|
|
bool* received_packet)
|
|
|
|
|
{
|
|
|
|
|
// Retrieve current indexed image.
|
|
|
|
|
auto& image = _images.at(_image_index);
|
|
|
|
|
|
|
|
|
|
{ // Copy Image data.
|
|
|
|
|
#ifdef ENABLE_PROFILING
|
|
|
|
|
auto profile = _profiler_copy->track();
|
|
|
|
|
#endif
|
|
|
|
|
std::memcpy(image.planes[AOM_PLANE_Y], frame->data[0], frame->linesize[0] * image.h);
|
|
|
|
|
if (image.fmt == AOM_IMG_FMT_I420) {
|
|
|
|
|
std::memcpy(image.planes[AOM_PLANE_U], frame->data[1], frame->linesize[1] * image.h / 2);
|
|
|
|
|
std::memcpy(image.planes[AOM_PLANE_V], frame->data[2], frame->linesize[2] * image.h / 2);
|
|
|
|
|
} else {
|
|
|
|
|
std::memcpy(image.planes[AOM_PLANE_U], frame->data[1], frame->linesize[1] * image.h);
|
|
|
|
|
std::memcpy(image.planes[AOM_PLANE_V], frame->data[2], frame->linesize[2] * image.h);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Try to encode the new image.
|
|
|
|
|
#ifdef ENABLE_PROFILING
|
|
|
|
|
auto profile = _profiler_encode->track();
|
|
|
|
|
#endif
|
|
|
|
|
aom_enc_frame_flags_t flags = 0;
|
|
|
|
|
if (_cfg.g_usage == AOM_USAGE_ALL_INTRA) {
|
|
|
|
|
flags = AOM_EFLAG_FORCE_KF;
|
|
|
|
|
}
|
|
|
|
|
if (auto error = _factory->libaom_codec_encode(&_ctx, &image, frame->pts, 1, flags); error != AOM_CODEC_OK) {
|
|
|
|
|
const char* errstr = _factory->libaom_codec_err_to_string(error);
|
|
|
|
|
D_LOG_ERROR("Encoding frame failed with error: %s (code %" PRIu32 ")\n%s\n%s", errstr, error,
|
|
|
|
|
_factory->libaom_codec_error(&_ctx), _factory->libaom_codec_error_detail(&_ctx));
|
|
|
|
|
return false;
|
|
|
|
|
} else {
|
|
|
|
|
// Increment the image index.
|
|
|
|
|
_image_index = (_image_index++) % _images.size();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Get Packet
|
|
|
|
|
#ifdef ENABLE_PROFILING
|
|
|
|
|
auto profile = _profiler_packet->track();
|
|
|
|
|
#endif
|
|
|
|
|
aom_codec_iter_t iter = NULL;
|
|
|
|
|
for (auto* pkt = _factory->libaom_codec_get_cx_data(&_ctx, &iter); pkt != nullptr;
|
|
|
|
|
pkt = _factory->libaom_codec_get_cx_data(&_ctx, &iter)) {
|
|
|
|
|
#ifdef _DEBUG
|
|
|
|
|
{
|
|
|
|
|
const char* kind = "";
|
|
|
|
|
switch (pkt->kind) {
|
|
|
|
|
case AOM_CODEC_CX_FRAME_PKT:
|
|
|
|
|
kind = "Frame";
|
|
|
|
|
break;
|
|
|
|
|
case AOM_CODEC_STATS_PKT:
|
|
|
|
|
kind = "Stats";
|
|
|
|
|
break;
|
|
|
|
|
case AOM_CODEC_FPMB_STATS_PKT:
|
|
|
|
|
kind = "FPMB Stats";
|
|
|
|
|
break;
|
|
|
|
|
case AOM_CODEC_PSNR_PKT:
|
|
|
|
|
kind = "PSNR";
|
|
|
|
|
break;
|
|
|
|
|
case AOM_CODEC_CUSTOM_PKT:
|
|
|
|
|
kind = "Custom";
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
D_LOG_DEBUG("\tPacket: Kind=%s", kind)
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) {
|
|
|
|
|
// Status
|
|
|
|
|
packet->type = OBS_ENCODER_VIDEO;
|
|
|
|
|
packet->keyframe = ((pkt->data.frame.flags & AOM_FRAME_IS_KEY) == AOM_FRAME_IS_KEY)
|
|
|
|
|
|| (_cfg.g_usage == AOM_USAGE_ALL_INTRA);
|
|
|
|
|
if (packet->keyframe) {
|
|
|
|
|
//
|
2021-12-02 16:49:51 +00:00
|
|
|
packet->priority = 3; // OBS_NAL_PRIORITY_HIGHEST
|
|
|
|
|
packet->drop_priority = 3; // OBS_NAL_PRIORITY_HIGHEST
|
2021-08-28 12:36:42 +00:00
|
|
|
} else if ((pkt->data.frame.flags & AOM_FRAME_IS_DROPPABLE) != AOM_FRAME_IS_DROPPABLE) {
|
|
|
|
|
// Dropping this frame breaks the bitstream.
|
2021-12-02 16:49:51 +00:00
|
|
|
packet->priority = 2; // OBS_NAL_PRIORITY_HIGH
|
|
|
|
|
packet->drop_priority = 3; // OBS_NAL_PRIORITY_HIGHEST
|
2021-08-28 12:36:42 +00:00
|
|
|
} else {
|
|
|
|
|
// This frame can be dropped at will.
|
2021-12-02 16:49:51 +00:00
|
|
|
packet->priority = 0; // OBS_NAL_PRIORITY_DISPOSABLE
|
|
|
|
|
packet->drop_priority = 0; // OBS_NAL_PRIORITY_DISPOSABLE
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Data
|
|
|
|
|
packet->data = static_cast<uint8_t*>(pkt->data.frame.buf);
|
|
|
|
|
packet->size = pkt->data.frame.sz;
|
|
|
|
|
|
|
|
|
|
// Timestamps
|
|
|
|
|
//TODO: Temporarily set both to the same until there is a way to figure out actual order.
|
|
|
|
|
packet->pts = pkt->data.frame.pts;
|
|
|
|
|
packet->dts = pkt->data.frame.pts;
|
|
|
|
|
|
|
|
|
|
*received_packet = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (*received_packet == true)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!*received_packet) {
|
|
|
|
|
packet->type = OBS_ENCODER_VIDEO;
|
|
|
|
|
packet->data = nullptr;
|
|
|
|
|
packet->size = 0;
|
|
|
|
|
packet->pts = -1;
|
|
|
|
|
packet->dts = -1;
|
|
|
|
|
#ifdef _DEBUG
|
|
|
|
|
D_LOG_DEBUG("No Packet", "");
|
|
|
|
|
#endif
|
|
|
|
|
// Not necessarily an error.
|
|
|
|
|
//return false;
|
|
|
|
|
} else {
|
|
|
|
|
#ifdef _DEBUG
|
|
|
|
|
D_LOG_DEBUG("Packet: Type=%s PTS=%06" PRId64 " DTS=%06" PRId64 " Size=%016" PRIuPTR "",
|
|
|
|
|
packet->keyframe ? "I" : "P", packet->pts, packet->dts, packet->size);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
aom_av1_factory::aom_av1_factory()
|
|
|
|
|
{
|
|
|
|
|
// Try and load the AOM library.
|
|
|
|
|
std::vector<std::filesystem::path> libs;
|
|
|
|
|
|
|
|
|
|
#ifdef D_PLATFORM_WINDOWS
|
|
|
|
|
// Try loading from the data directory first.
|
|
|
|
|
libs.push_back(streamfx::data_file_path("aom.dll")); // MSVC (preferred)
|
|
|
|
|
libs.push_back(streamfx::data_file_path("libaom.dll")); // Cross-Compile
|
|
|
|
|
// In any other case, load the system-wide binary.
|
|
|
|
|
libs.push_back("aom.dll");
|
|
|
|
|
libs.push_back("libaom.dll");
|
|
|
|
|
#else
|
|
|
|
|
// Try loading from the data directory first.
|
|
|
|
|
libs.push_back(streamfx::data_file_path("libaom.so"));
|
|
|
|
|
// In any other case, load the system-wide binary.
|
|
|
|
|
libs.push_back("libaom");
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
for (auto lib : libs) {
|
|
|
|
|
try {
|
|
|
|
|
_library = streamfx::util::library::load(lib);
|
|
|
|
|
if (_library)
|
|
|
|
|
break;
|
|
|
|
|
} catch (...) {
|
|
|
|
|
D_LOG_WARNING("Loading of '%s' failed.", lib.generic_string().c_str());
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (!_library) {
|
|
|
|
|
throw std::runtime_error("Unable to load AOM library.");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Load all necessary functions.
|
|
|
|
|
#define _LOAD_SYMBOL(X) \
|
|
|
|
|
{ \
|
|
|
|
|
lib##X = reinterpret_cast<decltype(lib##X)>(_library->load_symbol(std::string(#X))); \
|
|
|
|
|
}
|
|
|
|
|
#define _LOAD_SYMBOL_(X, Y) \
|
|
|
|
|
{ \
|
|
|
|
|
lib##X = reinterpret_cast<decltype(lib##X)>(_library->load_symbol(std::string(Y))); \
|
|
|
|
|
}
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_version);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_version_str);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_version_extra_str);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_build_config);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_iface_name);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_err_to_string);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_error);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_error_detail);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_destroy);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_get_caps);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_control);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_set_option);
|
|
|
|
|
_LOAD_SYMBOL(aom_obu_type_to_string);
|
|
|
|
|
_LOAD_SYMBOL(aom_uleb_size_in_bytes);
|
|
|
|
|
_LOAD_SYMBOL(aom_uleb_decode);
|
|
|
|
|
_LOAD_SYMBOL(aom_uleb_encode);
|
|
|
|
|
_LOAD_SYMBOL(aom_uleb_encode_fixed_size);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_alloc);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_wrap);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_alloc_with_border);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_set_rect);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_flip);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_free);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_plane_width);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_plane_height);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_add_metadata);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_get_metadata);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_num_metadata);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_remove_metadata);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_metadata_alloc);
|
|
|
|
|
_LOAD_SYMBOL(aom_img_metadata_free);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_enc_init_ver);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_enc_config_default);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_enc_config_set);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_get_global_headers);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_encode);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_set_cx_data_buf);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_get_cx_data);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_get_preview_frame);
|
|
|
|
|
_LOAD_SYMBOL(aom_codec_av1_cx);
|
|
|
|
|
#undef _LOAD_SYMBOL
|
|
|
|
|
|
|
|
|
|
// Register encoder.
|
|
|
|
|
_info.id = S_PREFIX "aom-av1";
|
|
|
|
|
_info.type = obs_encoder_type::OBS_ENCODER_VIDEO;
|
|
|
|
|
_info.codec = "av1";
|
|
|
|
|
_info.caps = OBS_ENCODER_CAP_DYN_BITRATE;
|
2022-08-20 21:36:10 +00:00
|
|
|
_info.caps |= OBS_ENCODER_CAP_DEPRECATED;
|
2021-08-28 12:36:42 +00:00
|
|
|
|
|
|
|
|
finish_setup();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
aom_av1_factory::~aom_av1_factory() {}
|
|
|
|
|
|
|
|
|
|
std::shared_ptr<aom_av1_factory> _aom_av1_factory_instance = nullptr;
|
|
|
|
|
|
|
|
|
|
void aom_av1_factory::initialize()
|
2022-08-27 11:17:47 +00:00
|
|
|
{
|
|
|
|
|
try {
|
|
|
|
|
if (!_aom_av1_factory_instance) {
|
|
|
|
|
_aom_av1_factory_instance = std::make_shared<aom_av1_factory>();
|
|
|
|
|
}
|
|
|
|
|
} catch (std::exception const& ex) {
|
|
|
|
|
D_LOG_ERROR("Failed to initialize AOM AV1 encoder: %s", ex.what());
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void aom_av1_factory::finalize()
|
|
|
|
|
{
|
|
|
|
|
_aom_av1_factory_instance.reset();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::shared_ptr<aom_av1_factory> aom_av1_factory::get()
|
|
|
|
|
{
|
|
|
|
|
return _aom_av1_factory_instance;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* aom_av1_factory::get_name()
|
|
|
|
|
{
|
|
|
|
|
return "AV1 (via AOM)";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void* aom_av1_factory::create(obs_data_t* settings, obs_encoder_t* encoder, bool is_hw)
|
|
|
|
|
{
|
|
|
|
|
return new aom_av1_instance(settings, encoder, is_hw);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void aom_av1_factory::get_defaults2(obs_data_t* settings)
|
|
|
|
|
{
|
|
|
|
|
{ // Presets
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_ENCODER_USAGE, static_cast<long long>(AOM_USAGE_REALTIME));
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_ENCODER_CPUUSAGE, -1);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_ENCODER_PROFILE,
|
|
|
|
|
static_cast<long long>(codec::av1::profile::UNKNOWN));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Rate-Control
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_RATECONTROL_MODE, static_cast<long long>(AOM_CBR));
|
|
|
|
|
|
|
|
|
|
// Limits
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_RATECONTROL_LIMITS_BITRATE, 6000);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_RATECONTROL_LIMITS_BITRATE_UNDERSHOOT, -1);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_RATECONTROL_LIMITS_BITRATE_OVERSHOOT, -1);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_RATECONTROL_LIMITS_QUALITY, -1);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_RATECONTROL_LIMITS_QUANTIZER_MINIMUM, -1);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_RATECONTROL_LIMITS_QUANTIZER_MAXIMUM, -1);
|
|
|
|
|
|
|
|
|
|
// Buffer
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_RATECONTROL_BUFFER_SIZE, -1);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_RATECONTROL_BUFFER_SIZE_INITIAL, -1);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_RATECONTROL_BUFFER_SIZE_OPTIMAL, -1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Key-Frame Options
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_KEYFRAMES_INTERVALTYPE, 0);
|
|
|
|
|
obs_data_set_default_double(settings, ST_KEY_KEYFRAMES_INTERVAL_SECONDS, 2.0);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_KEYFRAMES_INTERVAL_FRAMES, 300);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Advanced Options
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_ADVANCED_THREADS, 0);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_ADVANCED_ROWMULTITHREADING, -1);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_ADVANCED_TILE_COLUMNS, -1);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_ADVANCED_TILE_ROWS, -1);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_ADVANCED_TUNE_METRIC, -1);
|
|
|
|
|
obs_data_set_default_int(settings, ST_KEY_ADVANCED_TUNE_CONTENT, static_cast<long long>(AOM_CONTENT_DEFAULT));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool modified_usage(obs_properties_t* props, obs_property_t*, obs_data_t* settings) noexcept
|
2022-08-27 11:17:47 +00:00
|
|
|
{
|
|
|
|
|
try {
|
|
|
|
|
bool is_all_intra = false;
|
|
|
|
|
if (obs_data_get_int(settings, ST_KEY_ENCODER_USAGE) == AOM_USAGE_ALL_INTRA) {
|
|
|
|
|
is_all_intra = true;
|
|
|
|
|
}
|
2021-08-28 12:36:42 +00:00
|
|
|
|
2022-08-27 11:17:47 +00:00
|
|
|
// All-Intra does not support these.
|
|
|
|
|
obs_property_set_visible(obs_properties_get(props, ST_KEY_RATECONTROL_LOOKAHEAD), !is_all_intra);
|
|
|
|
|
obs_property_set_visible(obs_properties_get(props, ST_I18N_KEYFRAMES), !is_all_intra);
|
2021-08-28 12:36:42 +00:00
|
|
|
|
2022-08-27 11:17:47 +00:00
|
|
|
return true;
|
|
|
|
|
} catch (const std::exception& ex) {
|
|
|
|
|
DLOG_ERROR("Unexpected exception in function '%s': %s.", __FUNCTION_NAME__, ex.what());
|
|
|
|
|
return false;
|
|
|
|
|
} catch (...) {
|
|
|
|
|
DLOG_ERROR("Unexpected exception in function '%s'.", __FUNCTION_NAME__);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool modified_ratecontrol_mode(obs_properties_t* props, obs_property_t*, obs_data_t* settings) noexcept
|
2022-08-27 11:17:47 +00:00
|
|
|
{
|
|
|
|
|
try {
|
|
|
|
|
bool is_bitrate_visible = false;
|
|
|
|
|
bool is_overundershoot_visible = false;
|
|
|
|
|
bool is_quality_visible = false;
|
|
|
|
|
|
|
|
|
|
// Fix rate control mode selection if ALL_INTRA is selected.
|
|
|
|
|
if (obs_data_get_int(settings, ST_KEY_ENCODER_USAGE) == AOM_USAGE_ALL_INTRA) {
|
|
|
|
|
obs_data_set_int(settings, ST_KEY_RATECONTROL_MODE, static_cast<long long>(aom_rc_mode::AOM_Q));
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
|
2022-08-27 11:17:47 +00:00
|
|
|
{ // Based on the Rate Control Mode, show and hide options.
|
|
|
|
|
auto mode = static_cast<aom_rc_mode>(obs_data_get_int(settings, ST_KEY_RATECONTROL_MODE));
|
|
|
|
|
if (mode == AOM_CBR) {
|
|
|
|
|
is_bitrate_visible = true;
|
|
|
|
|
is_overundershoot_visible = true;
|
|
|
|
|
} else if (mode == AOM_VBR) {
|
|
|
|
|
is_bitrate_visible = true;
|
|
|
|
|
is_overundershoot_visible = true;
|
|
|
|
|
} else if (mode == AOM_CQ) {
|
|
|
|
|
is_bitrate_visible = true;
|
|
|
|
|
is_overundershoot_visible = true;
|
|
|
|
|
is_quality_visible = true;
|
|
|
|
|
} else if (mode == AOM_Q) {
|
|
|
|
|
is_quality_visible = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
obs_property_set_visible(obs_properties_get(props, ST_KEY_RATECONTROL_LIMITS_BITRATE), is_bitrate_visible);
|
|
|
|
|
obs_property_set_visible(obs_properties_get(props, ST_KEY_RATECONTROL_LIMITS_BITRATE_UNDERSHOOT),
|
|
|
|
|
is_overundershoot_visible);
|
|
|
|
|
obs_property_set_visible(obs_properties_get(props, ST_KEY_RATECONTROL_LIMITS_BITRATE_OVERSHOOT),
|
|
|
|
|
is_overundershoot_visible);
|
2021-08-28 12:36:42 +00:00
|
|
|
#ifdef AOM_CTRL_AOME_SET_CQ_LEVEL
|
2022-08-27 11:17:47 +00:00
|
|
|
obs_property_set_visible(obs_properties_get(props, ST_KEY_RATECONTROL_LIMITS_QUALITY), is_quality_visible);
|
2021-08-28 12:36:42 +00:00
|
|
|
#endif
|
2022-08-27 11:17:47 +00:00
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
} catch (const std::exception& ex) {
|
|
|
|
|
DLOG_ERROR("Unexpected exception in function '%s': %s.", __FUNCTION_NAME__, ex.what());
|
|
|
|
|
return false;
|
|
|
|
|
} catch (...) {
|
|
|
|
|
DLOG_ERROR("Unexpected exception in function '%s'.", __FUNCTION_NAME__);
|
|
|
|
|
return false;
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool modified_keyframes(obs_properties_t* props, obs_property_t*, obs_data_t* settings) noexcept
|
2022-08-27 11:17:47 +00:00
|
|
|
{
|
|
|
|
|
try {
|
|
|
|
|
bool is_seconds = obs_data_get_int(settings, ST_KEY_KEYFRAMES_INTERVALTYPE) == 0;
|
|
|
|
|
obs_property_set_visible(obs_properties_get(props, ST_KEY_KEYFRAMES_INTERVAL_FRAMES), !is_seconds);
|
|
|
|
|
obs_property_set_visible(obs_properties_get(props, ST_KEY_KEYFRAMES_INTERVAL_SECONDS), is_seconds);
|
|
|
|
|
return true;
|
|
|
|
|
} catch (const std::exception& ex) {
|
|
|
|
|
DLOG_ERROR("Unexpected exception in function '%s': %s.", __FUNCTION_NAME__, ex.what());
|
|
|
|
|
return false;
|
|
|
|
|
} catch (...) {
|
|
|
|
|
DLOG_ERROR("Unexpected exception in function '%s'.", __FUNCTION_NAME__);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2021-08-28 12:36:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
obs_properties_t* aom_av1_factory::get_properties2(instance_t* data)
|
|
|
|
|
{
|
|
|
|
|
obs_properties_t* props = obs_properties_create();
|
|
|
|
|
|
2022-08-20 21:36:10 +00:00
|
|
|
{
|
|
|
|
|
auto p = obs_properties_add_text(props, "[[deprecated]]", D_TRANSLATE(ST_I18N_DEPRECATED), OBS_TEXT_INFO);
|
|
|
|
|
obs_property_text_set_info_type(p, OBS_TEXT_INFO_WARNING);
|
|
|
|
|
obs_property_text_set_info_word_wrap(p, true);
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-28 12:36:42 +00:00
|
|
|
#ifdef ENABLE_FRONTEND
|
|
|
|
|
{
|
|
|
|
|
obs_properties_add_button2(props, S_MANUAL_OPEN, D_TRANSLATE(S_MANUAL_OPEN), aom_av1_factory::on_manual_open,
|
|
|
|
|
this);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
{ // Presets
|
|
|
|
|
obs_properties_t* grp = obs_properties_create();
|
|
|
|
|
obs_properties_add_group(props, ST_I18N_ENCODER, D_TRANSLATE(ST_I18N_ENCODER), OBS_GROUP_NORMAL, grp);
|
|
|
|
|
//obs_properties_add_group(props, S_CODEC_AV1, D_TRANSLATE(S_CODEC_AV1), OBS_GROUP_NORMAL, grp);
|
|
|
|
|
|
|
|
|
|
{ // Usage
|
|
|
|
|
auto p = obs_properties_add_list(grp, ST_KEY_ENCODER_USAGE, D_TRANSLATE(ST_I18N_ENCODER_USAGE),
|
|
|
|
|
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
|
|
|
|
|
obs_property_set_modified_callback(p, modified_usage);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_USAGE_GOODQUALITY),
|
|
|
|
|
static_cast<long long>(AOM_USAGE_GOOD_QUALITY));
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_USAGE_REALTIME),
|
|
|
|
|
static_cast<long long>(AOM_USAGE_REALTIME));
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_USAGE_ALLINTRA),
|
|
|
|
|
static_cast<long long>(AOM_USAGE_ALL_INTRA));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AOME_SET_CPUUSED
|
|
|
|
|
{ // CPU Usage
|
|
|
|
|
auto p = obs_properties_add_list(grp, ST_KEY_ENCODER_CPUUSAGE, D_TRANSLATE(ST_I18N_ENCODER_CPUUSAGE),
|
|
|
|
|
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(S_STATE_DEFAULT), -1);
|
2021-10-17 07:52:40 +00:00
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_CPUUSAGE_10), 10);
|
2021-08-28 12:36:42 +00:00
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_CPUUSAGE_9), 9);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_CPUUSAGE_8), 8);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_CPUUSAGE_7), 7);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_CPUUSAGE_6), 6);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_CPUUSAGE_5), 5);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_CPUUSAGE_4), 4);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_CPUUSAGE_3), 3);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_CPUUSAGE_2), 2);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_CPUUSAGE_1), 1);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ENCODER_CPUUSAGE_0), 0);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
{ // Profile
|
|
|
|
|
auto p = obs_properties_add_list(grp, ST_KEY_ENCODER_PROFILE, D_TRANSLATE(S_CODEC_AV1_PROFILE),
|
|
|
|
|
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(S_STATE_AUTOMATIC),
|
|
|
|
|
static_cast<long long>(codec::av1::profile::UNKNOWN));
|
|
|
|
|
obs_property_list_add_int(p, codec::av1::profile_to_string(codec::av1::profile::MAIN),
|
|
|
|
|
static_cast<long long>(codec::av1::profile::MAIN));
|
|
|
|
|
obs_property_list_add_int(p, codec::av1::profile_to_string(codec::av1::profile::HIGH),
|
|
|
|
|
static_cast<long long>(codec::av1::profile::HIGH));
|
|
|
|
|
obs_property_list_add_int(p, codec::av1::profile_to_string(codec::av1::profile::PROFESSIONAL),
|
|
|
|
|
static_cast<long long>(codec::av1::profile::PROFESSIONAL));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Rate Control Options
|
|
|
|
|
obs_properties_t* grp = obs_properties_create();
|
|
|
|
|
obs_properties_add_group(props, ST_I18N_RATECONTROL, D_TRANSLATE(ST_I18N_RATECONTROL), OBS_GROUP_NORMAL, grp);
|
|
|
|
|
|
|
|
|
|
{ // Mode
|
|
|
|
|
auto p = obs_properties_add_list(grp, ST_KEY_RATECONTROL_MODE, D_TRANSLATE(ST_I18N_RATECONTROL_MODE),
|
|
|
|
|
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
|
|
|
|
|
obs_property_set_modified_callback(p, modified_ratecontrol_mode);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_RATECONTROL_MODE_VBR), static_cast<long long>(AOM_VBR));
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_RATECONTROL_MODE_CBR), static_cast<long long>(AOM_CBR));
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_RATECONTROL_MODE_CQ), static_cast<long long>(AOM_CQ));
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_RATECONTROL_MODE_Q), static_cast<long long>(AOM_Q));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Look-Ahead
|
|
|
|
|
auto p =
|
|
|
|
|
obs_properties_add_int(grp, ST_KEY_RATECONTROL_LOOKAHEAD, D_TRANSLATE(ST_I18N_RATECONTROL_LOOKAHEAD),
|
|
|
|
|
-1, std::numeric_limits<int32_t>::max(), 1);
|
|
|
|
|
obs_property_int_set_suffix(p, " frames");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Limits
|
|
|
|
|
obs_properties_t* grp2 = obs_properties_create();
|
|
|
|
|
obs_properties_add_group(grp, ST_I18N_RATECONTROL_LIMITS, D_TRANSLATE(ST_I18N_RATECONTROL_LIMITS),
|
|
|
|
|
OBS_GROUP_NORMAL, grp2);
|
|
|
|
|
|
|
|
|
|
{ // Bitrate
|
|
|
|
|
auto p = obs_properties_add_int(grp2, ST_KEY_RATECONTROL_LIMITS_BITRATE,
|
|
|
|
|
D_TRANSLATE(ST_I18N_RATECONTROL_LIMITS_BITRATE), 0,
|
|
|
|
|
std::numeric_limits<int32_t>::max(), 1);
|
|
|
|
|
obs_property_int_set_suffix(p, " kbit/s");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Bitrate Under/Overshoot
|
|
|
|
|
auto p1 = obs_properties_add_int_slider(grp2, ST_KEY_RATECONTROL_LIMITS_BITRATE_UNDERSHOOT,
|
|
|
|
|
D_TRANSLATE(ST_I18N_RATECONTROL_LIMITS_BITRATE_UNDERSHOOT), -1,
|
|
|
|
|
100, 1);
|
|
|
|
|
auto p2 = obs_properties_add_int_slider(grp2, ST_KEY_RATECONTROL_LIMITS_BITRATE_OVERSHOOT,
|
|
|
|
|
D_TRANSLATE(ST_I18N_RATECONTROL_LIMITS_BITRATE_OVERSHOOT), -1,
|
2021-10-06 14:42:47 +00:00
|
|
|
100, 1);
|
2021-08-28 12:36:42 +00:00
|
|
|
obs_property_float_set_suffix(p1, " %");
|
|
|
|
|
obs_property_float_set_suffix(p2, " %");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AOME_SET_CQ_LEVEL
|
|
|
|
|
{ // Quality
|
|
|
|
|
auto p = obs_properties_add_int_slider(grp2, ST_KEY_RATECONTROL_LIMITS_QUALITY,
|
|
|
|
|
D_TRANSLATE(ST_I18N_RATECONTROL_LIMITS_QUALITY), -1, 63, 1);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
{ // Quantizer
|
|
|
|
|
auto p1 =
|
|
|
|
|
obs_properties_add_int_slider(grp2, ST_KEY_RATECONTROL_LIMITS_QUANTIZER_MINIMUM,
|
|
|
|
|
D_TRANSLATE(ST_I18N_RATECONTROL_LIMITS_QUANTIZER_MINIMUM), -1, 63, 1);
|
|
|
|
|
auto p2 =
|
|
|
|
|
obs_properties_add_int_slider(grp2, ST_KEY_RATECONTROL_LIMITS_QUANTIZER_MAXIMUM,
|
|
|
|
|
D_TRANSLATE(ST_I18N_RATECONTROL_LIMITS_QUANTIZER_MAXIMUM), -1, 63, 1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Buffer
|
|
|
|
|
obs_properties_t* grp2 = obs_properties_create();
|
|
|
|
|
obs_properties_add_group(grp, ST_I18N_RATECONTROL_BUFFER, D_TRANSLATE(ST_I18N_RATECONTROL_BUFFER),
|
|
|
|
|
OBS_GROUP_NORMAL, grp2);
|
|
|
|
|
|
|
|
|
|
{ // Buffer Size
|
|
|
|
|
auto p = obs_properties_add_int(grp2, ST_KEY_RATECONTROL_BUFFER_SIZE,
|
|
|
|
|
D_TRANSLATE(ST_I18N_RATECONTROL_BUFFER_SIZE), -1,
|
|
|
|
|
std::numeric_limits<int32_t>::max(), 1);
|
|
|
|
|
obs_property_int_set_suffix(p, " ms");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Initial Buffer Size
|
|
|
|
|
auto p = obs_properties_add_int(grp2, ST_KEY_RATECONTROL_BUFFER_SIZE_INITIAL,
|
|
|
|
|
D_TRANSLATE(ST_I18N_RATECONTROL_BUFFER_SIZE_INITIAL), -1,
|
|
|
|
|
std::numeric_limits<int32_t>::max(), 1);
|
|
|
|
|
obs_property_int_set_suffix(p, " ms");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Optimal Buffer Size
|
|
|
|
|
auto p = obs_properties_add_int(grp2, ST_KEY_RATECONTROL_BUFFER_SIZE_OPTIMAL,
|
|
|
|
|
D_TRANSLATE(ST_I18N_RATECONTROL_BUFFER_SIZE_OPTIMAL), -1,
|
|
|
|
|
std::numeric_limits<int32_t>::max(), 1);
|
|
|
|
|
obs_property_int_set_suffix(p, " ms");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Key-Frame Options
|
|
|
|
|
obs_properties_t* grp = obs_properties_create();
|
|
|
|
|
obs_properties_add_group(props, ST_I18N_KEYFRAMES, D_TRANSLATE(ST_I18N_KEYFRAMES), OBS_GROUP_NORMAL, grp);
|
|
|
|
|
|
|
|
|
|
{ // Key-Frame Interval Type
|
|
|
|
|
auto p =
|
|
|
|
|
obs_properties_add_list(grp, ST_KEY_KEYFRAMES_INTERVALTYPE, D_TRANSLATE(ST_I18N_KEYFRAMES_INTERVALTYPE),
|
|
|
|
|
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
|
|
|
|
|
obs_property_set_modified_callback(p, modified_keyframes);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_KEYFRAMES_INTERVALTYPE_SECONDS), 0);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_KEYFRAMES_INTERVALTYPE_FRAMES), 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Key-Frame Interval Seconds
|
|
|
|
|
auto p = obs_properties_add_float(grp, ST_KEY_KEYFRAMES_INTERVAL_SECONDS,
|
|
|
|
|
D_TRANSLATE(ST_I18N_KEYFRAMES_INTERVAL), 0.00,
|
|
|
|
|
std::numeric_limits<uint16_t>::max(), 0.01);
|
|
|
|
|
obs_property_float_set_suffix(p, " seconds");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Key-Frame Interval Frames
|
|
|
|
|
auto p =
|
|
|
|
|
obs_properties_add_int(grp, ST_KEY_KEYFRAMES_INTERVAL_FRAMES, D_TRANSLATE(ST_I18N_KEYFRAMES_INTERVAL),
|
|
|
|
|
0, std::numeric_limits<int32_t>::max(), 1);
|
|
|
|
|
obs_property_int_set_suffix(p, " frames");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
{ // Advanced Options
|
|
|
|
|
obs_properties_t* grp = obs_properties_create();
|
|
|
|
|
obs_properties_add_group(props, ST_I18N_ADVANCED, D_TRANSLATE(ST_I18N_ADVANCED), OBS_GROUP_NORMAL, grp);
|
|
|
|
|
|
|
|
|
|
{ // Threads
|
|
|
|
|
auto p = obs_properties_add_int(grp, ST_KEY_ADVANCED_THREADS, D_TRANSLATE(ST_I18N_ADVANCED_THREADS), 0,
|
|
|
|
|
std::numeric_limits<int32_t>::max(), 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_ROW_MT
|
|
|
|
|
{ // Row-MT
|
|
|
|
|
auto p = streamfx::util::obs_properties_add_tristate(grp, ST_KEY_ADVANCED_ROWMULTITHREADING,
|
|
|
|
|
D_TRANSLATE(ST_I18N_ADVANCED_ROWMULTITHREADING));
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_TILE_COLUMNS
|
|
|
|
|
{ // Tile Columns
|
|
|
|
|
auto p = obs_properties_add_int_slider(grp, ST_KEY_ADVANCED_TILE_COLUMNS,
|
|
|
|
|
D_TRANSLATE(ST_I18N_ADVANCED_TILE_COLUMNS), -1, 6, 1);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_TILE_ROWS
|
|
|
|
|
{ // Tile Rows
|
|
|
|
|
auto p = obs_properties_add_int_slider(grp, ST_KEY_ADVANCED_TILE_ROWS,
|
|
|
|
|
D_TRANSLATE(ST_I18N_ADVANCED_TILE_ROWS), -1, 6, 1);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
{
|
|
|
|
|
obs_properties_t* grp2 = obs_properties_create();
|
|
|
|
|
obs_properties_add_group(grp, ST_I18N_ADVANCED_TUNE, D_TRANSLATE(ST_I18N_ADVANCED_TUNE), OBS_GROUP_NORMAL,
|
|
|
|
|
grp2);
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AOME_SET_TUNING
|
|
|
|
|
{ // Tuning
|
|
|
|
|
auto p = obs_properties_add_list(grp2, ST_KEY_ADVANCED_TUNE_METRIC,
|
|
|
|
|
D_TRANSLATE(ST_I18N_ADVANCED_TUNE_METRIC), OBS_COMBO_TYPE_LIST,
|
|
|
|
|
OBS_COMBO_FORMAT_INT);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(S_STATE_DEFAULT), -1);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ADVANCED_TUNE_METRIC_PSNR),
|
|
|
|
|
static_cast<long long>(AOM_TUNE_PSNR));
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ADVANCED_TUNE_METRIC_SSIM),
|
|
|
|
|
static_cast<long long>(AOM_TUNE_SSIM));
|
|
|
|
|
#ifdef _DEBUG
|
|
|
|
|
// These have no actual use outside of debug builds, way too slow!
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ADVANCED_TUNE_METRIC_VMAFWITHPREPROCESSING),
|
|
|
|
|
static_cast<long long>(AOM_TUNE_VMAF_WITH_PREPROCESSING));
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ADVANCED_TUNE_METRIC_VMAFWITHOUTPREPROCESSING),
|
|
|
|
|
static_cast<long long>(AOM_TUNE_VMAF_WITHOUT_PREPROCESSING));
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ADVANCED_TUNE_METRIC_VMAFMAXGAIN),
|
|
|
|
|
static_cast<long long>(AOM_TUNE_VMAF_MAX_GAIN));
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ADVANCED_TUNE_METRIC_VMAFNEGMAXGAIN),
|
|
|
|
|
static_cast<long long>(AOM_TUNE_VMAF_NEG_MAX_GAIN));
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ADVANCED_TUNE_METRIC_BUTTERAUGLI),
|
|
|
|
|
static_cast<long long>(AOM_TUNE_BUTTERAUGLI));
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef AOM_CTRL_AV1E_SET_TUNE_CONTENT
|
|
|
|
|
{ // Content Tuning
|
|
|
|
|
auto p = obs_properties_add_list(grp2, ST_KEY_ADVANCED_TUNE_CONTENT,
|
|
|
|
|
D_TRANSLATE(ST_I18N_ADVANCED_TUNE_CONTENT), OBS_COMBO_TYPE_LIST,
|
|
|
|
|
OBS_COMBO_FORMAT_INT);
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(S_STATE_DEFAULT), static_cast<long long>(AOM_CONTENT_DEFAULT));
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ADVANCED_TUNE_CONTENT_SCREEN),
|
|
|
|
|
static_cast<long long>(AOM_CONTENT_SCREEN));
|
|
|
|
|
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_ADVANCED_TUNE_CONTENT_FILM),
|
|
|
|
|
static_cast<long long>(AOM_CONTENT_FILM));
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return props;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef ENABLE_FRONTEND
|
|
|
|
|
bool aom_av1_factory::on_manual_open(obs_properties_t* props, obs_property_t* property, void* data)
|
|
|
|
|
{
|
|
|
|
|
streamfx::open_url(HELP_URL);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
