From a3da829216e009fb001f8527e4258cc310fed663 Mon Sep 17 00:00:00 2001 From: Schrijvers Luc Date: Thu, 2 Nov 2023 08:59:12 +0000 Subject: [PATCH] rav1e, new recipe (#6978) --- .../rav1e/patches/rav1e-0.6.6.patchset | 976 ++++++++++++++++++ media-video/rav1e/rav1e-0.6.6.recipe | 92 ++ 2 files changed, 1068 insertions(+) create mode 100644 media-video/rav1e/patches/rav1e-0.6.6.patchset create mode 100644 media-video/rav1e/rav1e-0.6.6.recipe diff --git a/media-video/rav1e/patches/rav1e-0.6.6.patchset b/media-video/rav1e/patches/rav1e-0.6.6.patchset new file mode 100644 index 000000000..9e77499f3 --- /dev/null +++ b/media-video/rav1e/patches/rav1e-0.6.6.patchset @@ -0,0 +1,976 @@ +From b345b76505e1a4370ff97f69fde2f3ccd3369218 Mon Sep 17 00:00:00 2001 +From: Fabio Valentini +Date: Tue, 27 Jun 2023 20:30:34 +0200 +Subject: [PATCH] remove references to removed built and rust_hawktracer crates + +The "built" crate embeds information about the state of the git +repository into the binary, but this is useless when using tarballs. + +The macros from the "rust_hawktracer" crate are compiled down to +no-ops since the required features are disabled in release builds. +--- + build.rs | 2 -- + src/activity.rs | 3 --- + src/api/internal.rs | 11 -------- + src/api/lookahead.rs | 5 ---- + src/bin/common.rs | 9 +------ + src/bin/muxer/ivf.rs | 2 -- + src/bin/muxer/y4m.rs | 2 -- + src/bin/rav1e-ch.rs | 10 ------- + src/bin/rav1e.rs | 56 --------------------------------------- + src/bin/stats.rs | 2 -- + src/cdef.rs | 5 ---- + src/context/block_unit.rs | 2 -- + src/deblock.rs | 4 --- + src/encoder.rs | 14 ---------- + src/lib.rs | 5 ---- + src/lrf.rs | 6 ----- + src/me.rs | 9 ------- + src/rate.rs | 3 --- + src/rdo.rs | 9 ------- + src/scenechange/fast.rs | 3 --- + src/scenechange/mod.rs | 2 -- + src/segmentation.rs | 3 --- + 22 files changed, 1 insertion(+), 166 deletions(-) + +diff --git a/build.rs b/build.rs +index 52e544e..64aad99 100644 +--- a/build.rs ++++ b/build.rs +@@ -251,8 +251,6 @@ fn rustc_version_check() { + fn main() { + rustc_version_check(); + +- built::write_built_file().expect("Failed to acquire build-time information"); +- + let arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap(); + let os = env::var("CARGO_CFG_TARGET_OS").unwrap(); + // let env = env::var("CARGO_CFG_TARGET_ENV").unwrap(); +diff --git a/src/activity.rs b/src/activity.rs +index ae29826..df9ac8d 100644 +--- a/src/activity.rs ++++ b/src/activity.rs +@@ -12,7 +12,6 @@ use crate::rdo::DistortionScale; + use crate::tiling::*; + use crate::util::*; + use itertools::izip; +-use rust_hawktracer::*; + + #[derive(Debug, Default, Clone)] + pub struct ActivityMask { +@@ -20,7 +19,6 @@ pub struct ActivityMask { + } + + impl ActivityMask { +- #[hawktracer(ActivityMask_from_plane)] + pub fn from_plane(luma_plane: &Plane) -> ActivityMask { + let PlaneConfig { width, height, .. } = luma_plane.cfg; + +@@ -55,7 +53,6 @@ impl ActivityMask { + ActivityMask { variances: variances.into_boxed_slice() } + } + +- #[hawktracer(ActivityMask_fill_scales)] + pub fn fill_scales( + &self, bit_depth: usize, activity_scales: &mut Box<[DistortionScale]>, + ) { +diff --git a/src/api/internal.rs b/src/api/internal.rs +index b6cfaba..f1c9dbf 100644 +--- a/src/api/internal.rs ++++ b/src/api/internal.rs +@@ -28,7 +28,6 @@ use crate::stats::EncoderStats; + use crate::tiling::Area; + use crate::util::Pixel; + use arrayvec::ArrayVec; +-use rust_hawktracer::*; + use std::cmp; + use std::collections::{BTreeMap, BTreeSet}; + use std::env; +@@ -316,7 +315,6 @@ impl ContextInner { + } + } + +- #[hawktracer(send_frame)] + pub fn send_frame( + &mut self, mut frame: Option>>, + params: Option, +@@ -649,7 +647,6 @@ impl ContextInner { + /// `rec_buffer` and `lookahead_rec_buffer` on the `FrameInvariants`. This + /// function must be called after every new `FrameInvariants` is initially + /// computed. +- #[hawktracer(compute_lookahead_motion_vectors)] + fn compute_lookahead_motion_vectors(&mut self, output_frameno: u64) { + let frame_data = self.frame_data.get(&output_frameno).unwrap(); + +@@ -862,7 +859,6 @@ impl ContextInner { + }); + } + +- #[hawktracer(compute_keyframe_placement)] + pub fn compute_keyframe_placement( + lookahead_frames: &[&Arc>], keyframes_forced: &BTreeSet, + keyframe_detector: &mut SceneChangeDetector, +@@ -881,7 +877,6 @@ impl ContextInner { + *next_lookahead_frame += 1; + } + +- #[hawktracer(compute_frame_invariants)] + pub fn compute_frame_invariants(&mut self) { + while self.set_frame_properties(self.next_lookahead_output_frameno).is_ok() + { +@@ -894,7 +889,6 @@ impl ContextInner { + } + } + +- #[hawktracer(update_block_importances)] + fn update_block_importances( + fi: &FrameInvariants, me_stats: &crate::me::FrameMEStats, + frame: &Frame, reference_frame: &Frame, bit_depth: usize, +@@ -1057,7 +1051,6 @@ impl ContextInner { + } + + /// Computes the block importances for the current output frame. +- #[hawktracer(compute_block_importances)] + fn compute_block_importances(&mut self) { + // SEF don't need block importances. + if self.frame_data[&self.output_frameno] +@@ -1281,7 +1274,6 @@ impl ContextInner { + } + } + +- #[hawktracer(encode_show_existing_packet)] + pub fn encode_show_existing_packet( + &mut self, cur_output_frameno: u64, + ) -> Result, EncoderStatus> { +@@ -1317,7 +1309,6 @@ impl ContextInner { + self.finalize_packet(rec, source, input_frameno, frame_type, qp, enc_stats) + } + +- #[hawktracer(encode_normal_packet)] + pub fn encode_normal_packet( + &mut self, cur_output_frameno: u64, + ) -> Result, EncoderStatus> { +@@ -1480,7 +1471,6 @@ impl ContextInner { + } + } + +- #[hawktracer(receive_packet)] + pub fn receive_packet(&mut self) -> Result, EncoderStatus> { + if self.done_processing() { + return Err(EncoderStatus::LimitReached); +@@ -1546,7 +1536,6 @@ impl ContextInner { + }) + } + +- #[hawktracer(garbage_collect)] + fn garbage_collect(&mut self, cur_input_frameno: u64) { + if cur_input_frameno == 0 { + return; +diff --git a/src/api/lookahead.rs b/src/api/lookahead.rs +index 2758d59..fd63293 100644 +--- a/src/api/lookahead.rs ++++ b/src/api/lookahead.rs +@@ -14,7 +14,6 @@ use crate::rayon::iter::*; + use crate::tiling::{Area, PlaneRegion, TileRect}; + use crate::transform::TxSize; + use crate::Pixel; +-use rust_hawktracer::*; + use std::sync::Arc; + use v_frame::frame::Frame; + use v_frame::pixel::CastFromPrimitive; +@@ -26,7 +25,6 @@ pub(crate) const IMP_BLOCK_SIZE_IN_MV_UNITS: i64 = + pub(crate) const IMP_BLOCK_AREA_IN_MV_UNITS: i64 = + IMP_BLOCK_SIZE_IN_MV_UNITS * IMP_BLOCK_SIZE_IN_MV_UNITS; + +-#[hawktracer(estimate_intra_costs)] + pub(crate) fn estimate_intra_costs( + temp_plane: &mut Plane, frame: &Frame, bit_depth: usize, + cpu_feature_level: CpuFeatureLevel, +@@ -120,7 +118,6 @@ pub(crate) fn estimate_intra_costs( + intra_costs.into_boxed_slice() + } + +-#[hawktracer(estimate_importance_block_difference)] + pub(crate) fn estimate_importance_block_difference( + frame: Arc>, ref_frame: Arc>, + ) -> f64 { +@@ -176,7 +173,6 @@ pub(crate) fn estimate_importance_block_difference( + imp_block_costs as f64 / (w_in_imp_b * h_in_imp_b) as f64 + } + +-#[hawktracer(estimate_inter_costs)] + pub(crate) fn estimate_inter_costs( + frame: Arc>, ref_frame: Arc>, bit_depth: usize, + mut config: EncoderConfig, sequence: Arc, buffer: RefMEStats, +@@ -265,7 +261,6 @@ pub(crate) fn estimate_inter_costs( + inter_costs as f64 / (w_in_imp_b * h_in_imp_b) as f64 + } + +-#[hawktracer(compute_motion_vectors)] + pub(crate) fn compute_motion_vectors( + fi: &mut FrameInvariants, fs: &mut FrameState, inter_cfg: &InterConfig, + ) { +diff --git a/src/bin/common.rs b/src/bin/common.rs +index 2c9b120..43bc91f 100644 +--- a/src/bin/common.rs ++++ b/src/bin/common.rs +@@ -22,11 +22,6 @@ use std::io; + use std::io::prelude::*; + use std::path::PathBuf; + +-pub mod built_info { +- // The file has been placed there by the build script. +- include!(concat!(env!("OUT_DIR"), "/built.rs")); +-} +- + #[derive(Clap)] + #[clap( + name = "rav1e", +@@ -273,10 +268,8 @@ fn get_long_version() -> &'static str { + rustflags = "(None)"; + } + format!( +- "{}\n{} {}\nCompiled CPU Features: {}\nAssembly: {}\nThreading: {}\nUnstable Features: {}\nCompiler Flags: {}", ++ "{}\nCompiled CPU Features: {}\nAssembly: {}\nThreading: {}\nUnstable Features: {}\nCompiler Flags: {}", + get_version(), +- built_info::RUSTC_VERSION, +- built_info::TARGET, + option_env!("CARGO_CFG_TARGET_FEATURE").unwrap_or("(None)"), + if cfg!(feature = "asm") { "Enabled" } else { "Disabled" }, + if cfg!(feature = "threading") { "Enabled" } else { "Disabled" }, +diff --git a/src/bin/muxer/ivf.rs b/src/bin/muxer/ivf.rs +index ac26cde..b3a29a6 100644 +--- a/src/bin/muxer/ivf.rs ++++ b/src/bin/muxer/ivf.rs +@@ -12,7 +12,6 @@ use super::Muxer; + use crate::error::*; + use ivf::*; + use rav1e::prelude::*; +-use rust_hawktracer::*; + use std::fs; + use std::fs::File; + use std::io; +@@ -37,7 +36,6 @@ impl Muxer for IvfMuxer { + ); + } + +- #[hawktracer(write_frame)] + fn write_frame(&mut self, pts: u64, data: &[u8], _frame_type: FrameType) { + write_ivf_frame(&mut self.output, pts, data); + } +diff --git a/src/bin/muxer/y4m.rs b/src/bin/muxer/y4m.rs +index fb5db1e..9b5771b 100644 +--- a/src/bin/muxer/y4m.rs ++++ b/src/bin/muxer/y4m.rs +@@ -9,11 +9,9 @@ + + use crate::decoder::VideoDetails; + use rav1e::prelude::*; +-use rust_hawktracer::*; + use std::io::Write; + use std::slice; + +-#[hawktracer(write_y4m_frame)] + pub fn write_y4m_frame( + y4m_enc: &mut y4m::Encoder>, rec: &Frame, + y4m_details: VideoDetails, +diff --git a/src/bin/rav1e-ch.rs b/src/bin/rav1e-ch.rs +index 212d0af..dc411d3 100644 +--- a/src/bin/rav1e-ch.rs ++++ b/src/bin/rav1e-ch.rs +@@ -314,18 +314,8 @@ fn do_encode( + } + + fn main() -> Result<(), Box> { +- #[cfg(feature = "tracing")] +- use rust_hawktracer::*; + init_logger(); + +- #[cfg(feature = "tracing")] +- let instance = HawktracerInstance::new(); +- #[cfg(feature = "tracing")] +- let _listener = instance.create_listener(HawktracerListenerType::ToFile { +- file_path: "trace.bin".into(), +- buffer_size: 4096, +- }); +- + run().map_err(|e| { + error::print_error(&e); + Box::new(e) as Box +diff --git a/src/bin/rav1e.rs b/src/bin/rav1e.rs +index 415acff..d3cf7ee 100644 +--- a/src/bin/rav1e.rs ++++ b/src/bin/rav1e.rs +@@ -54,7 +54,6 @@ use crate::error::*; + use crate::stats::*; + use rav1e::config::CpuFeatureLevel; + use rav1e::prelude::*; +-use rust_hawktracer::*; + + use crate::decoder::{Decoder, FrameBuilder, VideoDetails}; + use crate::muxer::*; +@@ -105,7 +104,6 @@ impl Source { + } + } + +- #[hawktracer(Source_read_frame)] + fn read_frame( + &mut self, ctx: &mut Context, video_info: VideoDetails, + ) -> Result<(), CliError> { +@@ -141,7 +139,6 @@ impl Source { + + // Encode and write a frame. + // Returns frame information in a `Result`. +-#[hawktracer(process_frame)] + fn process_frame( + ctx: &mut Context, output_file: &mut dyn Muxer, source: &mut Source, + pass1file: Option<&mut File>, pass2file: Option<&mut File>, +@@ -306,65 +303,12 @@ fn do_encode( + } + + fn main() { +- #[cfg(feature = "tracing")] +- init_logger(); +- +- #[cfg(feature = "tracing")] +- let instance = HawktracerInstance::new(); +- #[cfg(feature = "tracing")] +- let _listener = instance.create_listener(HawktracerListenerType::ToFile { +- file_path: "trace.bin".into(), +- buffer_size: 4096, +- }); +- + run().unwrap_or_else(|e| { + error::print_error(&e); + exit(1); + }); + } + +-#[cfg(feature = "tracing")] +-fn init_logger() { +- use std::str::FromStr; +- fn level_colored(l: log::Level) -> console::StyledObject<&'static str> { +- use console::style; +- use log::Level; +- match l { +- Level::Trace => style("??").dim(), +- Level::Debug => style("? ").dim(), +- Level::Info => style("> ").green(), +- Level::Warn => style("! ").yellow(), +- Level::Error => style("!!").red(), +- } +- } +- +- let level = std::env::var("RAV1E_LOG") +- .ok() +- .and_then(|l| log::LevelFilter::from_str(&l).ok()) +- .unwrap_or(log::LevelFilter::Info); +- +- fern::Dispatch::new() +- .format(move |out, message, record| { +- out.finish(format_args!( +- "{level} {message}", +- level = level_colored(record.level()), +- message = message, +- )); +- }) +- // set the default log level. to filter out verbose log messages from dependencies, set +- // this to Warn and overwrite the log level for your crate. +- .level(log::LevelFilter::Warn) +- // change log levels for individual modules. Note: This looks for the record's target +- // field which defaults to the module path but can be overwritten with the `target` +- // parameter: +- // `info!(target="special_target", "This log message is about special_target");` +- .level_for("rav1e", level) +- // output to stdout +- .chain(std::io::stderr()) +- .apply() +- .unwrap(); +-} +- + cfg_if::cfg_if! { + if #[cfg(any(target_os = "windows", target_arch = "wasm32"))] { + fn print_rusage() { +diff --git a/src/bin/stats.rs b/src/bin/stats.rs +index 91fca5b..7f8fd1d 100644 +--- a/src/bin/stats.rs ++++ b/src/bin/stats.rs +@@ -12,7 +12,6 @@ use rav1e::data::EncoderStats; + use rav1e::prelude::Rational; + use rav1e::prelude::*; + use rav1e::{Packet, Pixel}; +-use rust_hawktracer::*; + use std::fmt; + use std::time::Instant; + +@@ -30,7 +29,6 @@ pub struct FrameSummary { + pub enc_stats: EncoderStats, + } + +-#[hawktracer(build_frame_summary)] + pub fn build_frame_summary( + packets: Packet, bit_depth: usize, chroma_sampling: ChromaSampling, + metrics_cli: MetricsEnabled, +diff --git a/src/cdef.rs b/src/cdef.rs +index de3fba3..6487b88 100644 +--- a/src/cdef.rs ++++ b/src/cdef.rs +@@ -13,7 +13,6 @@ use crate::encoder::FrameInvariants; + use crate::frame::*; + use crate::tiling::*; + use crate::util::{clamp, msb, CastFromPrimitive, Pixel}; +-use rust_hawktracer::*; + + use crate::cpu_features::CpuFeatureLevel; + use std::cmp; +@@ -322,7 +321,6 @@ fn adjust_strength(strength: i32, var: i32) -> i32 { + } + } + +-#[hawktracer(cdef_analyze_superblock_range)] + pub fn cdef_analyze_superblock_range( + fi: &FrameInvariants, in_frame: &Frame, blocks: &TileBlocks<'_>, + sb_w: usize, sb_h: usize, +@@ -337,7 +335,6 @@ pub fn cdef_analyze_superblock_range( + ret + } + +-#[hawktracer(cdef_analyze_superblock)] + pub fn cdef_analyze_superblock( + fi: &FrameInvariants, in_frame: &Frame, blocks: &TileBlocks<'_>, + sbo: TileSuperBlockOffset, +@@ -398,7 +395,6 @@ pub fn cdef_analyze_superblock( + /// # Panics + /// + /// - If called with invalid parameters +-#[hawktracer(cdef_filter_superblock)] + pub fn cdef_filter_superblock( + fi: &FrameInvariants, input: &Frame, output: &mut TileMut<'_, T>, + blocks: &TileBlocks<'_>, tile_sbo: TileSuperBlockOffset, cdef_index: u8, +@@ -594,7 +590,6 @@ pub fn cdef_filter_superblock( + // tile boundary), the filtering process ignores input pixels that + // don't exist. + +-#[hawktracer(cdef_filter_tile)] + pub fn cdef_filter_tile( + fi: &FrameInvariants, input: &Frame, tb: &TileBlocks, + output: &mut TileMut<'_, T>, +diff --git a/src/context/block_unit.rs b/src/context/block_unit.rs +index 1d53b0d..5d0272f 100644 +--- a/src/context/block_unit.rs ++++ b/src/context/block_unit.rs +@@ -10,7 +10,6 @@ + use super::*; + + use crate::predict::PredictionMode; +-use rust_hawktracer::*; + + pub const MAX_PLANES: usize = 3; + +@@ -1122,7 +1121,6 @@ impl<'a> ContextWriter<'a> { + } + } + +- #[hawktracer(setup_mvref_list)] + fn setup_mvref_list( + &self, bo: TileBlockOffset, ref_frames: [RefType; 2], + mv_stack: &mut ArrayVec, bsize: BlockSize, +diff --git a/src/deblock.rs b/src/deblock.rs +index 775101d..6b8ef51 100644 +--- a/src/deblock.rs ++++ b/src/deblock.rs +@@ -18,7 +18,6 @@ use crate::rayon::iter::*; + use crate::tiling::*; + use crate::util::{clamp, ILog, Pixel}; + use crate::DeblockState; +-use rust_hawktracer::*; + use std::cmp; + + fn deblock_adjusted_level( +@@ -1291,7 +1290,6 @@ fn sse_h_edge( + } + + // Deblocks all edges, vertical and horizontal, in a single plane +-#[hawktracer(deblock_plane)] + pub fn deblock_plane( + deblock: &DeblockState, p: &mut PlaneRegionMut, pli: usize, + blocks: &TileBlocks, crop_w: usize, crop_h: usize, bd: usize, +@@ -1541,7 +1539,6 @@ fn sse_plane( + } + + // Deblocks all edges in all planes of a frame +-#[hawktracer(deblock_filter_frame)] + pub fn deblock_filter_frame( + deblock: &DeblockState, tile: &mut TileMut, blocks: &TileBlocks, + crop_w: usize, crop_h: usize, bd: usize, planes: usize, +@@ -1617,7 +1614,6 @@ fn sse_optimize( + level + } + +-#[hawktracer(deblock_filter_optimize)] + pub fn deblock_filter_optimize( + fi: &FrameInvariants, rec: &Tile, input: &Tile, + blocks: &TileBlocks, crop_w: usize, crop_h: usize, +diff --git a/src/encoder.rs b/src/encoder.rs +index 18c360c..7f846a9 100644 +--- a/src/encoder.rs ++++ b/src/encoder.rs +@@ -41,7 +41,6 @@ use crate::wasm_bindgen::*; + use arg_enum_proc_macro::ArgEnum; + use arrayvec::*; + use bitstream_io::{BigEndian, BitWrite, BitWriter}; +-use rust_hawktracer::*; + + use std::collections::VecDeque; + use std::io::Write; +@@ -570,7 +569,6 @@ pub struct SegmentationState { + } + + impl SegmentationState { +- #[hawktracer(SegmentationState_update_threshold)] + pub fn update_threshold(&mut self, base_q_idx: u8, bd: usize) { + let base_ac_q = ac_q(base_q_idx, 0, bd).get() as u64; + let real_ac_q = ArrayVec::<_, MAX_SEGMENTS>::from_iter( +@@ -748,7 +746,6 @@ impl CodedFrameData { + + // Assumes that we have already computed activity scales and distortion scales + // Returns -0.5 log2(mean(scale)) +- #[hawktracer(compute_spatiotemporal_scores)] + pub fn compute_spatiotemporal_scores(&mut self) -> i64 { + let mut scores = self + .distortion_scales +@@ -774,7 +771,6 @@ impl CodedFrameData { + + // Assumes that we have already computed distortion_scales + // Returns -0.5 log2(mean(scale)) +- #[hawktracer(compute_temporal_scores)] + pub fn compute_temporal_scores(&mut self) -> i64 { + let inv_mean = DistortionScale::inv_mean(&self.distortion_scales); + for scale in self.distortion_scales.iter_mut() { +@@ -1657,7 +1653,6 @@ pub fn encode_tx_block( + /// # Panics + /// + /// - If the block size is invalid for subsampling +-#[hawktracer(motion_compensate)] + pub fn motion_compensate( + fi: &FrameInvariants, ts: &mut TileStateMut<'_, T>, + cw: &mut ContextWriter, luma_mode: PredictionMode, ref_frames: [RefType; 2], +@@ -1886,7 +1881,6 @@ pub fn save_block_motion( + } + } + +-#[hawktracer(encode_block_pre_cdef)] + pub fn encode_block_pre_cdef( + seq: &Sequence, ts: &TileStateMut<'_, T>, cw: &mut ContextWriter, w: &mut W, + bsize: BlockSize, tile_bo: TileBlockOffset, skip: bool, +@@ -1927,7 +1921,6 @@ pub fn encode_block_pre_cdef( + /// + /// - If chroma and luma do not match for inter modes + /// - If an invalid motion vector is found +-#[hawktracer(encode_block_post_cdef)] + pub fn encode_block_post_cdef( + fi: &FrameInvariants, ts: &mut TileStateMut<'_, T>, + cw: &mut ContextWriter, w: &mut W, luma_mode: PredictionMode, +@@ -2552,7 +2545,6 @@ pub fn write_tx_tree( + (partition_has_coeff, tx_dist) + } + +-#[hawktracer(encode_block_with_modes)] + pub fn encode_block_with_modes( + fi: &FrameInvariants, ts: &mut TileStateMut<'_, T>, + cw: &mut ContextWriter, w_pre_cdef: &mut W, w_post_cdef: &mut W, +@@ -2619,7 +2611,6 @@ pub fn encode_block_with_modes( + ); + } + +-#[hawktracer(encode_partition_bottomup)] + fn encode_partition_bottomup( + fi: &FrameInvariants, ts: &mut TileStateMut<'_, T>, + cw: &mut ContextWriter, w_pre_cdef: &mut W, w_post_cdef: &mut W, +@@ -3222,7 +3213,6 @@ fn get_initial_cdfcontext(fi: &FrameInvariants) -> CDFContext { + cdf.unwrap_or_else(|| CDFContext::new(fi.base_q_idx)) + } + +-#[hawktracer(encode_tile_group)] + fn encode_tile_group( + fi: &FrameInvariants, fs: &mut FrameState, inter_cfg: &InterConfig, + ) -> Vec { +@@ -3361,7 +3351,6 @@ pub struct SBSQueueEntry { + pub w_post_cdef: WriterBase, + } + +-#[hawktracer(check_lf_queue)] + fn check_lf_queue( + fi: &FrameInvariants, ts: &mut TileStateMut<'_, T>, + cw: &mut ContextWriter, w: &mut WriterBase, +@@ -3453,7 +3442,6 @@ fn check_lf_queue( + } + } + +-#[hawktracer(encode_tile)] + fn encode_tile<'a, T: Pixel>( + fi: &FrameInvariants, ts: &'a mut TileStateMut<'_, T>, + fc: &'a mut CDFContext, blocks: &'a mut TileBlocksMut<'a>, +@@ -3678,7 +3666,6 @@ fn write_tile_group_header(tile_start_and_end_present_flag: bool) -> Vec { + /// # Panics + /// + /// - If the frame packets cannot be written +-#[hawktracer(encode_show_existing_frame)] + pub fn encode_show_existing_frame( + fi: &FrameInvariants, fs: &mut FrameState, inter_cfg: &InterConfig, + ) -> Vec { +@@ -3753,7 +3740,6 @@ fn get_initial_segmentation( + /// # Panics + /// + /// - If the frame packets cannot be written +-#[hawktracer(encode_frame)] + pub fn encode_frame( + fi: &FrameInvariants, fs: &mut FrameState, inter_cfg: &InterConfig, + ) -> Vec { +diff --git a/src/lib.rs b/src/lib.rs +index 9f23e51..e6df48d 100644 +--- a/src/lib.rs ++++ b/src/lib.rs +@@ -77,11 +77,6 @@ extern crate pretty_assertions; + #[macro_use] + extern crate log; + +-pub(crate) mod built_info { +- // The file has been placed there by the build script. +- include!(concat!(env!("OUT_DIR"), "/built.rs")); +-} +- + mod serialize { + cfg_if::cfg_if! { + if #[cfg(feature="serialize")] { +diff --git a/src/lrf.rs b/src/lrf.rs +index 9c8285d..039dd5e 100644 +--- a/src/lrf.rs ++++ b/src/lrf.rs +@@ -24,7 +24,6 @@ use crate::frame::{ + }; + use crate::tiling::{Area, PlaneRegion, PlaneRegionMut, Rect}; + use crate::util::{clamp, CastFromPrimitive, ILog, Pixel}; +-use rust_hawktracer::*; + use std::cmp; + use std::iter::FusedIterator; + use std::ops::{Index, IndexMut}; +@@ -526,7 +525,6 @@ impl<'a, T: Pixel> Iterator for HorzPaddedIter<'a, T> { + impl ExactSizeIterator for HorzPaddedIter<'_, T> {} + impl FusedIterator for HorzPaddedIter<'_, T> {} + +-#[hawktracer(setup_integral_image)] + pub fn setup_integral_image( + integral_image_buffer: &mut IntegralImageBuffer, + integral_image_stride: usize, crop_w: usize, crop_h: usize, stripe_w: usize, +@@ -626,7 +624,6 @@ pub fn setup_integral_image( + } + } + +-#[hawktracer(sgrproj_stripe_filter)] + pub fn sgrproj_stripe_filter( + set: u8, xqd: [i8; 2], fi: &FrameInvariants, + integral_image_buffer: &IntegralImageBuffer, integral_image_stride: usize, +@@ -843,7 +840,6 @@ pub fn sgrproj_stripe_filter( + + // Input params follow the same rules as sgrproj_stripe_filter. + // Inputs are relative to the colocated slice views. +-#[hawktracer(sgrproj_solve)] + pub fn sgrproj_solve( + set: u8, fi: &FrameInvariants, + integral_image_buffer: &IntegralImageBuffer, input: &PlaneRegion<'_, T>, +@@ -1095,7 +1091,6 @@ pub fn sgrproj_solve( + } + } + +-#[hawktracer(wiener_stripe_filter)] + fn wiener_stripe_filter( + coeffs: [[i8; 3]; 2], fi: &FrameInvariants, crop_w: usize, crop_h: usize, + stripe_w: usize, stripe_h: usize, stripe_x: usize, stripe_y: isize, +@@ -1484,7 +1479,6 @@ impl RestorationState { + } + } + +- #[hawktracer(lrf_filter_frame)] + pub fn lrf_filter_frame( + &mut self, out: &mut Frame, pre_cdef: &Frame, + fi: &FrameInvariants, +diff --git a/src/me.rs b/src/me.rs +index 20fa201..a650985 100644 +--- a/src/me.rs ++++ b/src/me.rs +@@ -24,7 +24,6 @@ use crate::util::{clamp, Pixel}; + use crate::FrameInvariants; + + use arrayvec::*; +-use rust_hawktracer::*; + use std::ops::{Index, IndexMut}; + use std::sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard}; + +@@ -383,7 +382,6 @@ impl MotionEstimationSubsets { + } + } + +-#[hawktracer(get_subset_predictors)] + fn get_subset_predictors( + tile_bo: TileBlockOffset, tile_me_stats: &TileMEStats<'_>, + frame_ref_opt: Option>, ref_frame_id: usize, +@@ -690,7 +688,6 @@ fn refine_subsampled_motion_estimate( + } + } + +-#[hawktracer(full_pixel_me)] + fn full_pixel_me( + fi: &FrameInvariants, ts: &TileStateMut<'_, T>, + org_region: &PlaneRegion, p_ref: &Plane, tile_bo: TileBlockOffset, +@@ -882,7 +879,6 @@ fn sub_pixel_me( + ); + } + +-#[hawktracer(get_best_predictor)] + fn get_best_predictor( + fi: &FrameInvariants, po: PlaneOffset, org_region: &PlaneRegion, + p_ref: &Plane, predictors: &[MotionVector], bit_depth: usize, +@@ -953,7 +949,6 @@ const DIAMOND_R1_PATTERN: [MotionVector; 4] = search_pattern!( + /// For each step size, candidate motion vectors are examined for improvement + /// to the current search location. The search location is moved to the best + /// candidate (if any). This is repeated until the search location stops moving. +-#[hawktracer(fullpel_diamond_search)] + fn fullpel_diamond_search( + fi: &FrameInvariants, po: PlaneOffset, org_region: &PlaneRegion, + p_ref: &Plane, current: &mut MotionSearchResult, bit_depth: usize, +@@ -1053,7 +1048,6 @@ const SQUARE_REFINE_PATTERN: [MotionVector; 8] = search_pattern!( + /// + /// `current` provides the initial search location and serves as + /// the output for the final search results. +-#[hawktracer(hexagon_search)] + fn hexagon_search( + fi: &FrameInvariants, po: PlaneOffset, org_region: &PlaneRegion, + p_ref: &Plane, current: &mut MotionSearchResult, bit_depth: usize, +@@ -1168,7 +1162,6 @@ const UMH_PATTERN: [MotionVector; 16] = search_pattern!( + /// the output for the final search results. + /// + /// `me_range` parameter determines how far these stages can search. +-#[hawktracer(uneven_multi_hex_search)] + fn uneven_multi_hex_search( + fi: &FrameInvariants, po: PlaneOffset, org_region: &PlaneRegion, + p_ref: &Plane, current: &mut MotionSearchResult, bit_depth: usize, +@@ -1309,7 +1302,6 @@ fn uneven_multi_hex_search( + /// For each step size, candidate motion vectors are examined for improvement + /// to the current search location. The search location is moved to the best + /// candidate (if any). This is repeated until the search location stops moving. +-#[hawktracer(subpel_diamond_search)] + fn subpel_diamond_search( + fi: &FrameInvariants, po: PlaneOffset, org_region: &PlaneRegion, + _p_ref: &Plane, bit_depth: usize, pmv: [MotionVector; 2], lambda: u32, +@@ -1462,7 +1454,6 @@ fn compute_mv_rd( + MVCandidateRD { cost: 256 * sad as u64 + rate as u64 * lambda as u64, sad } + } + +-#[hawktracer(full_search)] + fn full_search( + fi: &FrameInvariants, x_lo: isize, x_hi: isize, y_lo: isize, y_hi: isize, + w: usize, h: usize, org_region: &PlaneRegion, p_ref: &Plane, +diff --git a/src/rate.rs b/src/rate.rs +index 16e0598..3ae7b09 100644 +--- a/src/rate.rs ++++ b/src/rate.rs +@@ -14,7 +14,6 @@ use crate::quantize::{ac_q, dc_q, select_ac_qi, select_dc_qi}; + use crate::util::{ + bexp64, bexp_q24, blog64, clamp, q24_to_q57, q57, q57_to_q24, Pixel, + }; +-use rust_hawktracer::*; + use std::cmp; + + // The number of frame sub-types for which we track distinct parameters. +@@ -720,7 +719,6 @@ impl RCState { + } + + // TODO: Separate quantizers for Cb and Cr. +- #[hawktracer(select_qi)] + pub(crate) fn select_qi( + &self, ctx: &ContextInner, output_frameno: u64, fti: usize, + maybe_prev_log_base_q: Option, log_isqrt_mean_scale: i64, +@@ -1069,7 +1067,6 @@ impl RCState { + (log_base_q, log_q) + } + +- #[hawktracer(RCState_update_state)] + pub fn update_state( + &mut self, bits: i64, fti: usize, show_frame: bool, log_target_q: i64, + trial: bool, droppable: bool, +diff --git a/src/rdo.rs b/src/rdo.rs +index 34d751e..03be0b5 100644 +--- a/src/rdo.rs ++++ b/src/rdo.rs +@@ -46,7 +46,6 @@ use crate::{encode_block_post_cdef, encode_block_pre_cdef}; + + use arrayvec::*; + use itertools::izip; +-use rust_hawktracer::*; + use std::fmt; + use std::mem::MaybeUninit; + +@@ -811,7 +810,6 @@ const fn dmv_in_range(mv: MotionVector, ref_mv: MotionVector) -> bool { + } + + #[inline] +-#[hawktracer(luma_chroma_mode_rdo)] + fn luma_chroma_mode_rdo( + luma_mode: PredictionMode, fi: &FrameInvariants, bsize: BlockSize, + tile_bo: TileBlockOffset, ts: &mut TileStateMut<'_, T>, +@@ -958,7 +956,6 @@ fn luma_chroma_mode_rdo( + /// + /// - If the best RD found is negative. + /// This should never happen and indicates a development error. +-#[hawktracer(rdo_mode_decision)] + pub fn rdo_mode_decision( + fi: &FrameInvariants, ts: &mut TileStateMut<'_, T>, + cw: &mut ContextWriter, bsize: BlockSize, tile_bo: TileBlockOffset, +@@ -1116,7 +1113,6 @@ pub fn rdo_mode_decision( + } + } + +-#[hawktracer(inter_frame_rdo_mode_decision)] + fn inter_frame_rdo_mode_decision( + fi: &FrameInvariants, ts: &mut TileStateMut<'_, T>, + cw: &mut ContextWriter, bsize: BlockSize, tile_bo: TileBlockOffset, +@@ -1389,7 +1385,6 @@ fn inter_frame_rdo_mode_decision( + best + } + +-#[hawktracer(intra_frame_rdo_mode_decision)] + fn intra_frame_rdo_mode_decision( + fi: &FrameInvariants, ts: &mut TileStateMut<'_, T>, + cw: &mut ContextWriter, bsize: BlockSize, tile_bo: TileBlockOffset, +@@ -1586,7 +1581,6 @@ fn intra_frame_rdo_mode_decision( + /// # Panics + /// + /// - If the block size is invalid for subsampling. +-#[hawktracer(rdo_cfl_alpha)] + pub fn rdo_cfl_alpha( + ts: &mut TileStateMut<'_, T>, tile_bo: TileBlockOffset, bsize: BlockSize, + luma_tx_size: TxSize, fi: &FrameInvariants, +@@ -1941,7 +1935,6 @@ fn rdo_partition_simple( + /// + /// - If the best RD found is negative. + /// This should never happen, and indicates a development error. +-#[hawktracer(rdo_partition_decision)] + pub fn rdo_partition_decision( + fi: &FrameInvariants, ts: &mut TileStateMut<'_, T>, + cw: &mut ContextWriter, w_pre_cdef: &mut W, w_post_cdef: &mut W, +@@ -2019,7 +2012,6 @@ pub fn rdo_partition_decision( + } + } + +-#[hawktracer(rdo_loop_plane_error)] + fn rdo_loop_plane_error( + base_sbo: TileSuperBlockOffset, offset_sbo: TileSuperBlockOffset, + sb_w: usize, sb_h: usize, fi: &FrameInvariants, ts: &TileStateMut<'_, T>, +@@ -2096,7 +2088,6 @@ fn rdo_loop_plane_error( + /// # Panics + /// + /// - If both CDEF and LRF are disabled. +-#[hawktracer(rdo_loop_decision)] + pub fn rdo_loop_decision( + base_sbo: TileSuperBlockOffset, fi: &FrameInvariants, + ts: &mut TileStateMut<'_, T>, cw: &mut ContextWriter, w: &mut W, +diff --git a/src/scenechange/fast.rs b/src/scenechange/fast.rs +index 8b1dd39..1ca2a0d 100644 +--- a/src/scenechange/fast.rs ++++ b/src/scenechange/fast.rs +@@ -8,7 +8,6 @@ use crate::{ + scenechange::fast_idiv, + }; + use debug_unreachable::debug_unreachable; +-use rust_hawktracer::*; + use v_frame::pixel::Pixel; + + use super::{ScaleFunction, SceneChangeDetector, ScenecutResult}; +@@ -19,7 +18,6 @@ pub(super) const FAST_THRESHOLD: f64 = 18.0; + impl SceneChangeDetector { + /// The fast algorithm detects fast cuts using a raw difference + /// in pixel values between the scaled frames. +- #[hawktracer(fast_scenecut)] + pub(super) fn fast_scenecut( + &mut self, frame1: Arc>, frame2: Arc>, + ) -> ScenecutResult { +@@ -104,7 +102,6 @@ impl SceneChangeDetector { + } + + /// Calculates the average sum of absolute difference (SAD) per pixel between 2 planes +- #[hawktracer(delta_in_planes)] + fn delta_in_planes(&self, plane1: &Plane, plane2: &Plane) -> f64 { + let delta = sad_plane::sad_plane(plane1, plane2, self.cpu_feature_level); + +diff --git a/src/scenechange/mod.rs b/src/scenechange/mod.rs +index 7414f09..aa0184f 100644 +--- a/src/scenechange/mod.rs ++++ b/src/scenechange/mod.rs +@@ -17,7 +17,6 @@ use crate::frame::*; + use crate::me::RefMEStats; + use crate::util::Pixel; + use debug_unreachable::debug_unreachable; +-use rust_hawktracer::*; + use std::collections::BTreeMap; + use std::sync::Arc; + use std::{cmp, u64}; +@@ -164,7 +163,6 @@ impl SceneChangeDetector { + /// to the second frame in `frame_set`. + /// + /// This will gracefully handle the first frame in the video as well. +- #[hawktracer(analyze_next_frame)] + pub fn analyze_next_frame( + &mut self, frame_set: &[&Arc>], input_frameno: u64, + previous_keyframe: u64, +diff --git a/src/segmentation.rs b/src/segmentation.rs +index 454d372..36ee42f 100644 +--- a/src/segmentation.rs ++++ b/src/segmentation.rs +@@ -16,11 +16,9 @@ use crate::tiling::TileStateMut; + use crate::util::Pixel; + use crate::FrameInvariants; + use crate::FrameState; +-use rust_hawktracer::*; + + pub const MAX_SEGMENTS: usize = 8; + +-#[hawktracer(segmentation_optimize)] + pub fn segmentation_optimize( + fi: &FrameInvariants, fs: &mut FrameState, + ) { +@@ -160,7 +158,6 @@ fn segmentation_optimize_inner( + fs.segmentation.update_threshold(fi.base_q_idx, fi.config.bit_depth); + } + +-#[hawktracer(select_segment)] + pub fn select_segment( + fi: &FrameInvariants, ts: &TileStateMut<'_, T>, tile_bo: TileBlockOffset, + bsize: BlockSize, skip: bool, +-- +2.37.3 + + +From 027670d2f017623651d65e50c63064b96bf762b4 Mon Sep 17 00:00:00 2001 +From: Begasus +Date: Sat, 16 Sep 2023 11:50:35 +0200 +Subject: Don't use git-version when using dynamic libgit2 + + +diff --git a/Cargo.toml b/Cargo.toml +index 12e40c1..ce935ee 100644 +--- a/Cargo.toml ++++ b/Cargo.toml +@@ -38,8 +38,7 @@ binaries = [ + "av-metrics", + "nom", + ] +-default = ["binaries", "asm", "threading", "signal_support", "git_version"] +-git_version = ["built/git2"] ++default = ["binaries", "asm", "threading", "signal_support"] + asm = ["nasm-rs", "cc"] + threading = ["rayon/threads"] + signal_support = ["signal-hook"] +-- +2.37.3 + diff --git a/media-video/rav1e/rav1e-0.6.6.recipe b/media-video/rav1e/rav1e-0.6.6.recipe new file mode 100644 index 000000000..0817678be --- /dev/null +++ b/media-video/rav1e/rav1e-0.6.6.recipe @@ -0,0 +1,92 @@ +SUMMARY="The fastest and safest AV1 encoder" +DESCRIPTION="rav1e is an AV1 video encoder. It is designed to eventually cover all use cases, \ +though in its current form it is most suitable for cases where libaom (the reference encoder) is \ +too slow." +HOMEPAGE="https://github.com/xiph/rav1e/" +COPYRIGHT="2017-2021, the rav1e contributors" +LICENSE="BSD (2-clause)" +REVISION="1" +SOURCE_URI="$HOMEPAGE/archive/refs/tags/v$portVersion.tar.gz" +CHECKSUM_SHA256="723696e93acbe03666213fbc559044f3cae5b8b888b2ddae667402403cff51e5" +SOURCE_FILENAME="rav1e-v$portVersion.tar.gz" +SOURCE_URI_2="$HOMEPAGE/releases/download/v$portVersion/Cargo.lock#noarchive" +CHECKSUM_SHA256_2="2014f7d76e7d0d7eaa63158ef5a1a1cea15a095fd5fb79b20b1052015a7fcd0c" +PATCHES="rav1e-0.6.6.patchset" + +ARCHITECTURES="?all !x86_gcc2 x86_64" +SECONDARY_ARCHITECTURES="x86" + +libVersion="$portVersion" +libVersionCompat="$libVersion compat >= ${libVersion%.*}" + +PROVIDES=" + rav1e$secondaryArchSuffix =$portVersion + cmd:rav1e = $portVersion + lib:librav1e$secondaryArchSuffix = $libVersionCompat + " +REQUIRES=" + haiku$secondaryArchSuffix + " + +PROVIDES_devel=" + rav1e${secondaryArchSuffix}_devel = $portVersion + devel:librav1e$secondaryArchSuffix = $libVersionCompat + " +REQUIRES_devel=" + rav1e$secondaryArchSuffix == $portVersion base + " + +BUILD_REQUIRES=" + haiku${secondaryArchSuffix}_devel + devel:libgit2$secondaryArchSuffix + devel:libssh2$secondaryArchSuffix + devel:libssl$secondaryArchSuffix + devel:libz$secondaryArchSuffix + " +BUILD_PREREQUIRES=" + cmd:cargo$secondaryArchSuffix >= 0.74 + cmd:cargo_cbuild + cmd:cargo_cinstall + cmd:gcc$secondaryArchSuffix + cmd:nasm + cmd:pkg_config$secondaryArchSuffix + " + +defineDebugInfoPackage rav1e$secondaryArchSuffix \ + $prefix/bin/rav1e \ + $libDir/librav1e.so.$libVersion + +BUILD() +{ + cp $sourceDir2/Cargo.lock Cargo.lock + cargo fetch +} + +INSTALL() +{ + export CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse + export LIBSSH2_SYS_USE_PKG_CONFIG=1 + export LIBGIT2_SYS_USE_PKG_CONFIG=1 + export PKG_CONFIG_ALLOW_CROSS=1 + + cargo install --locked --root $prefix --path . + cargo cinstall --release --prefix=$prefix \ + --libdir=$libDir \ + --pkgconfigdir=$libDir/pkgconfig \ + --includedir=$includeDir + + rm -f $libDir/*.a + rm -f $prefix/{.crates.toml,.crates2.json} + + prepareInstalledDevelLib librav1e + fixPkgconfig + + #package devel + packageEntries devel \ + $developDir +} + +TEST() +{ + cargo test --release +}