mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-14 06:22:24 +00:00
c2b7dac5a2
craft-video: FilmCraft's later H.264 encoder work (High 10, threads, sub-pel diamond) and its H.264 and ProRes tests * craft-video: H.264 High 10 and High 10 Intra in the encoder The encoder is generic over the sample type (u8 at 8 bits, u16 at 9-10 bits): QP' = QP + QpBdOffset for quantisation and lambdas, mb_qp_delta range and wrap, chroma QP mapping, deblocking thresholds scaled to the bit depth, clipping in prediction, interpolation and reconstruction. SPS bit depths, profile_idc 110, constraint_set3 for High 10 Intra, avcC high-profile fields, the High 10 cpbBrVclFactor for level choice. New YuvFrame16 / Encoder::encode16, EncoderConfig::bit_depth / intra_only. 8-bit output is unchanged. Merged onto craft-video's copy: its input stride checks, B-frame timestamp check, configuration validation, level 6.2 refusal, motion search start candidates and codec_params are kept. Ported from storytold/filmcraft#1580 (commit d24ce15e). * craft-video: the H.264 encoder honours threads: 1 and reuses MbInfo buffers; raw-YUV bench - A pool is built for every thread count, including 1: rayon calls outside install run on the global pool (all cores), so threads: 1 used to run on every core. A pool that cannot be built is an InvalidConfig error. - Up to eight macroblock-info buffers are recycled between pictures and cleared on reuse, instead of allocating one per picture. - examples/h264_h264enc_bench.rs encodes a raw YUV file and reports speed; its argument checks run as tests. Ported from storytold/filmcraft#3205 (merge 08f8075a). * craft-video: H.264 encoder sub-pel refinement on a 4-point diamond; 16x8 and 8x16 only after 8x8 beat 16x16 Sub-pel refinement tries the four axis neighbours instead of all eight, and the 16x8 / 8x16 partitions are searched only when 8x8 beat 16x16: fewer SATD evaluations for about the same decisions. craft-video's own motion search start candidates are kept. Ported from storytold/filmcraft#3207 (merge 8db5334c). * craft-video: FilmCraft's H.264 encoder tests; EncoderConfig::writer names the program in the SEI The encoder had no integration tests here. FilmCraft's come along as the h264_encode test target: ffmpeg/ffprobe oracle decodes (8-bit and High 10, bit-exact against the reconstruction), pinned decisions, CRF level choice and the settings SEI, thread counts and VBR overshoot. EncoderConfig::writer is the program and version the identification SEI names (craft-h264enc and this crate's version by default), so an application's files keep naming it. Two expectations differ from FilmCraft's copy: the pinned slice hashes (this encoder also starts the 16x16 search from the skip, zero and co-located vectors; with those left out and FilmCraft's writer name, it gives FilmCraft's four hashes exactly) and a CRF that is not a number, which this encoder refuses. * craft-video: FilmCraft's ProRes tests (oracle decode and encode, round trip, fuzz, perf) craft-video's ProRes copy came with only its hostile-input test. FilmCraft's ffmpeg oracle decode and encode tests, round trips, mutation fuzz and the ignored throughput tests come along; craft-video's own fuzz_hostile stays. Frame::new returns a Result here, so the tests unwrap it. --------- Co-authored-by: JordyUSA <75485565+JordyUSA@users.noreply.github.com> Co-authored-by: vangel76 <vangel1976@googlemail.com>
42 lines
1.3 KiB
Rust
42 lines
1.3 KiB
Rust
//! The worker-thread count only changes scheduling: with the slice count fixed, 1, 2 and several threads
|
|
//! must produce byte-identical streams (also across the reuse of the per-picture buffers over many frames).
|
|
|
|
use crate::common::synth;
|
|
use craft_video::h264::*;
|
|
|
|
fn encode(rate: RateControl, bframes: u8, threads: usize) -> Vec<u8> {
|
|
let mut c = EncoderConfig::new(320, 192, 24, 1);
|
|
c.rate = rate;
|
|
c.bframes = bframes;
|
|
c.slices = 3;
|
|
c.threads = threads;
|
|
let mut enc = Encoder::new(c).unwrap();
|
|
let mut stream = Vec::new();
|
|
for t in 0..24 {
|
|
let f = synth(320, 192, t);
|
|
for p in enc.encode(&f.frame(), t as i64).unwrap() {
|
|
stream.extend(p.data);
|
|
}
|
|
}
|
|
for p in enc.flush() {
|
|
stream.extend(p.data);
|
|
}
|
|
stream
|
|
}
|
|
|
|
#[test]
|
|
fn stream_does_not_depend_on_thread_count() {
|
|
let cases = [
|
|
("crf, 2 b-frames", RateControl::Crf(23.0), 2),
|
|
("vbr, 2 b-frames", RateControl::Vbr { target_kbps: 800, max_kbps: 1200 }, 2),
|
|
("qp, no b-frames", RateControl::Qp(28), 0),
|
|
];
|
|
for (name, rate, bframes) in cases {
|
|
let one = encode(rate, bframes, 1);
|
|
assert!(!one.is_empty(), "{name}");
|
|
for threads in [2, 4, 0] {
|
|
assert!(one == encode(rate, bframes, threads), "{name}: {threads} threads differ from 1 thread");
|
|
}
|
|
}
|
|
}
|