From d345cbc3074e93edcff14ef0c07f875dd94a1cac Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 04:54:36 +0000 Subject: [PATCH 01/21] docs(ffmpeg): plan local oracle qualification Signed-off-by: gunwooterry --- docs/design/local-oracle-qualification.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 docs/design/local-oracle-qualification.md diff --git a/docs/design/local-oracle-qualification.md b/docs/design/local-oracle-qualification.md new file mode 100644 index 000000000..eadda0e05 --- /dev/null +++ b/docs/design/local-oracle-qualification.md @@ -0,0 +1,17 @@ +# Local oracle qualification + +The FFmpeg integration test must qualify the selected local executable before comparing output or generating fixtures. Executable permissions alone do not prove the shared pin. + +## Plan + +Use the existing `scripts/oracle_pin.py --verify-bin` boundary for the installed FFmpeg and ffprobe pair. Keep the pin file, version matcher, installer, runtime fallback selection and comparison predicates unchanged. + +Require the selected FFmpeg file to resolve to the verified directory's `ffmpeg` file. This prevents a renamed local override from qualifying a different executable in its parent directory. A renamed standalone override without that installed pair is not qualified test evidence. + +Share this check between the generated input-seek refusal verifier and the existing native-copy oracle helper. Preserve the existing optional skip when no local pair is installed; a present but unqualified pair fails. CI still requires the pair. + +Test a valid pair, a wrong version, a malformed or failed version command, a missing sibling and a different selected executable beside a valid pair. Derive positive fake banners from the shared pin rather than adding another version constant. Test failures must identify the oracle-qualification stage before any fixture output is created. + +## Scope + +This is test qualification only. It does not change runtime fallback, native admission, generated media, command registrations, comparison tolerances or measured coverage. The frozen oracle verifier and judging owners remain unchanged. No media corpus or performance round is needed. From 3ba211279adc85b4fc0cb877c1f66626bf937b9c Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 04:58:18 +0000 Subject: [PATCH 02/21] test(ffmpeg): qualify selected local oracles Signed-off-by: gunwooterry --- crates/coreav-cli/tests/ffmpeg.rs | 68 +++++++++++++++++++++++++++++++ docs/agents/ffmpeg-cli.md | 2 +- 2 files changed, 69 insertions(+), 1 deletion(-) diff --git a/crates/coreav-cli/tests/ffmpeg.rs b/crates/coreav-cli/tests/ffmpeg.rs index e39fa9c9e..5cca5a5ce 100644 --- a/crates/coreav-cli/tests/ffmpeg.rs +++ b/crates/coreav-cli/tests/ffmpeg.rs @@ -2089,6 +2089,70 @@ fn input_seek_refusal_contract_keeps_its_exact_command_scope() { } } +fn qualify_local_oracle(pin: &Path) -> Result<(), String> { + let pin = std::path::absolute(pin).map_err(|error| error.to_string())?; + let installed = pin.with_file_name("ffmpeg"); + if std::fs::canonicalize(&pin).map_err(|error| error.to_string())? + != std::fs::canonicalize(&installed).map_err(|error| error.to_string())? + { + return Err("selected FFmpeg differs from the installed oracle pair".into()); + } + let verified = Command::new("python3") + .arg("-I") + .arg(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../scripts/oracle_pin.py")) + .arg("--verify-bin") + .arg(pin.parent().unwrap()) + .output() + .map_err(|error| error.to_string())?; + if !verified.status.success() { + return Err(String::from_utf8_lossy(&verified.stderr).into_owned()); + } + Ok(()) +} + +#[cfg(unix)] +#[test] +fn local_oracle_qualification_rejects_unverified_executables() { + use std::os::unix::fs::PermissionsExt; + + let dir = oracle_scratch("ffmpeg-local-qualification"); + let pin = dir.join("ffmpeg"); + let probe = dir.join("ffprobe"); + let build = include_str!("../../../scripts/oracle-ffmpeg.env") + .lines() + .find_map(|line| line.strip_prefix("BUILD=")) + .unwrap(); + let write = |path: &Path, body: &str| { + std::fs::write(path, format!("#!/bin/sh\n{body}\n")).unwrap(); + std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o700)).unwrap(); + }; + write(&pin, &format!("echo 'ffmpeg version {build}'")); + write(&probe, &format!("echo 'ffprobe version {build}'")); + qualify_local_oracle(&pin).unwrap(); + let other = dir.join("renamed-ffmpeg"); + write(&other, &format!("echo 'ffmpeg version {build}'")); + assert!( + qualify_local_oracle(&other) + .unwrap_err() + .contains("differs") + ); + for body in [ + "echo 'ffmpeg version 0.0.0'".to_owned(), + format!("echo 'ffmpeg version {build}0'"), + "echo malformed".to_owned(), + "exit 1".to_owned(), + ] { + write(&pin, &body); + assert!(qualify_local_oracle(&pin).is_err(), "{body}"); + } + write(&pin, &format!("echo 'ffmpeg version {build}'")); + write(&probe, "echo 'ffprobe version 0.0.0'"); + assert!(qualify_local_oracle(&pin).is_err()); + std::fs::remove_file(&probe).unwrap(); + assert!(qualify_local_oracle(&pin).is_err()); + assert_eq!(std::fs::read_dir(&dir).unwrap().count(), 2); +} + fn verify_input_seek_refusal(args: &[String], output: &Path) { let pin = std::env::var_os("COREAV_FFMPEG") .map(PathBuf::from) @@ -2105,6 +2169,8 @@ fn verify_input_seek_refusal(args: &[String], output: &Path) { coreav_cli::fallback::executable(&pin), "stage=oracle_selection: pinned FFmpeg is not executable" ); + qualify_local_oracle(&pin) + .unwrap_or_else(|error| panic!("stage=oracle_qualification: {error}")); let reference = output.with_file_name("reference.mp4"); let directory = output.parent().unwrap(); assert!(!output.exists(), "refusal left output before verification"); @@ -2913,6 +2979,8 @@ fn oracle() -> Option<(PathBuf, PathBuf)> { .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); let ffprobe = ffmpeg.with_file_name("ffprobe"); if ffmpeg.is_file() && ffprobe.is_file() { + qualify_local_oracle(&ffmpeg) + .unwrap_or_else(|error| panic!("stage=oracle_qualification: {error}")); return Some((ffmpeg, ffprobe)); } let required = diff --git a/docs/agents/ffmpeg-cli.md b/docs/agents/ffmpeg-cli.md index 362f0ab0d..f3c201907 100644 --- a/docs/agents/ffmpeg-cli.md +++ b/docs/agents/ffmpeg-cli.md @@ -46,7 +46,7 @@ CLI and ffprobe behavior, the FFmpeg pin, and fallback names. | Audio-only encoding refuses source offsets, tags and dispositions it cannot preserve, and never treats a concat list as a media file | The shared concat-encoding guard and `audio::plan` own these refusals; `ffmpeg_audio_only_refuses_unpreserved_source_properties` covers positive input origins, delayed audio, custom handlers, forced dispositions and concat in the whole transcode fixture target (`ci.yml`). Types cannot prove source metadata or command semantics | | Image and raw-video dispatch preserves metadata and encoder-option refusals before selecting a frame job | `ffmpeg::plan` owns both guards before `Job::Frames`; `frame_plans_validate_common_options` covers every encoder setting and all metadata modes, and the strict-safe and fallback metadata regressions require refusal before any output is created (`ci.yml`) | | Windows fallback waits for its program, preserves its full exit code and skips CoreAV copies and hard links on PATH | `fallback_cmd::run` owns inherited and replayed process completion; replay carries its spool owner until the child finishes, then drops handles and the spool before the full-code exit. `fallback_windows.rs` and `replayed_fallback_keeps_full_windows_exit_codes_and_cleans_its_spool` exercise native stand-ins, codes above 255, original stdin and cleanup in `ci.yml`'s existing `check-windows` tests. Stable `ExitCode` cannot carry a full Windows code | -| Current comparisons use the shared FFmpeg pin; the historical training extractor stays isolated | `scripts/oracle_pin.py --verify-bin` before oracle use, including cache hits; `--check` restricts historical-extractor references to the training job and its measurement directory (`deny.yml`) | +| Current comparisons use the shared FFmpeg pin; the historical training extractor stays isolated | `scripts/oracle_pin.py --verify-bin` before oracle use, including cache hits; the local copy-test oracle helper consumes that verifier before comparisons and rejects a selected file different from the verified pair. `local_oracle_qualification_rejects_unverified_executables` covers wrong, malformed, failed and missing binaries. `--check` restricts historical-extractor references to the training job and its measurement directory (`deny.yml`). Types cannot establish an external executable's version | | Standalone audio parity executes the native command with global strict-safe mode, rather than allowing fallback to satisfy equality | `standalone_audio_probe_check.py` owns the command and strict-safe environment; its command-capture regression requires `--strict-safe` before `ffprobe`, and real generated default/JSON comparisons run in `ci.yml`. A mocked subprocess alone cannot prove the command parses | | The fallback name lists match the pinned FFmpeg listings and CoreAV's printed keys, not boolean match-return values | `scripts/fallback_names.py --check DIR` in `ci.yml`'s `check` job fails on drift and names the regeneration command; `test_boolean_match_values_are_not_printed_keys` rejects stereo and unit values without dropping boolean field names | | The unsupported ffprobe format diagnostic names every accepted forced format | `unsupported_format_message_lists_accepted_formats` in `ffprobe::args::tests` checks acceptance and diagnostic coverage together. Rust types cannot prove a user-facing sentence lists the accepted names | From 894de689cb08e44ee6182ce3edefdd29e9e95e7f Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 05:17:47 +0000 Subject: [PATCH 03/21] docs(ffmpeg): plan shared oracle qualification Signed-off-by: gunwooterry --- docs/design/local-oracle-qualification.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/design/local-oracle-qualification.md b/docs/design/local-oracle-qualification.md index eadda0e05..d746d3324 100644 --- a/docs/design/local-oracle-qualification.md +++ b/docs/design/local-oracle-qualification.md @@ -1,17 +1,17 @@ # Local oracle qualification -The FFmpeg integration test must qualify the selected local executable before comparing output or generating fixtures. Executable permissions alone do not prove the shared pin. +Every non-frozen Rust and Python oracle consumer must qualify its selected executable before comparing output or generating fixtures. Executable permissions alone do not prove the shared pin. ## Plan -Use the existing `scripts/oracle_pin.py --verify-bin` boundary for the installed FFmpeg and ffprobe pair. Keep the pin file, version matcher, installer, runtime fallback selection and comparison predicates unchanged. +Use one Python selection and qualification owner, `scripts/test_oracle.py`, which delegates the predicates to the existing platform verifier. A shared Rust source adapter invokes this owner once per test process and retains its result in `OnceLock`. Python serializes initial qualification and retains both success and failure. Selection cannot change within a process. Keep the pin file, version matcher, installer, runtime fallback selection and comparison predicates unchanged. Require the selected FFmpeg file to resolve to the verified directory's `ffmpeg` file. This prevents a renamed local override from qualifying a different executable in its parent directory. A renamed standalone override without that installed pair is not qualified test evidence. -Share this check between the generated input-seek refusal verifier and the existing native-copy oracle helper. Preserve the existing optional skip when no local pair is installed; a present but unqualified pair fails. CI still requires the pair. +Migrate every non-frozen real oracle entry point. Missing, incomplete or unverified selections fail; they never become passing skips. Keep mock-only tests explicitly oracle-free. Fixture or backend test selection is separate from oracle availability. Provision the pin before real Python discovery. Platforms without a registered oracle run an explicitly oracle-free selection rather than unsetting CI to permit silent skips. -Test a valid pair, a wrong version, a malformed or failed version command, a missing sibling and a different selected executable beside a valid pair. Derive positive fake banners from the shared pin rather than adding another version constant. Test failures must identify the oracle-qualification stage before any fixture output is created. +Test a valid pair, a wrong version, a malformed or failed version command, a missing sibling and a different selected executable beside a valid pair. Check concurrent single initialization, cached failure after repair, recovery in a fresh process and rejection of a second selection. Derive positive fake banners from the shared pin rather than adding another version constant. Test failures must identify the oracle-qualification stage before any fixture output is created. Run the non-frozen suites with system FFmpeg first on PATH and require qualification failures, then require success with the pin. ## Scope -This is test qualification only. It does not change runtime fallback, native admission, generated media, command registrations, comparison tolerances or measured coverage. The frozen oracle verifier and judging owners remain unchanged. No media corpus or performance round is needed. +This is oracle qualification only. It does not change runtime fallback, native admission, generated media, command registrations, comparison tolerances or measured coverage. The registered frozen harness and Python driver retain workflow-level verification because their dependency closure is immutable. FROZEN, JUDGING, their registered hashes and all their source files remain unchanged. No media corpus or performance round is needed. From 08de86505b58b59a6ef6d9528022def22ce3136d Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 11:45:23 +0000 Subject: [PATCH 04/21] test(ffmpeg): centralize oracle qualification Signed-off-by: gunwooterry --- .github/workflows/ci.yml | 75 +++--- .github/workflows/codec-coverage.yml | 3 + .github/workflows/deny.yml | 17 ++ bench/npx/run.py | 3 + bench/range-audio/gaps.py | 3 + bench/range-audio/run.py | 3 + crates/coreav-audio/src/convert/oracle.rs | 24 +- crates/coreav-audio/tests/flac_encode.rs | 11 +- crates/coreav-backend-dav1d/tests/decode.rs | 9 +- crates/coreav-backend-ffmpeg/tests/decode.rs | 9 +- crates/coreav-backend-h264/tests/decode.rs | 9 +- crates/coreav-backend-h264/tests/memory.rs | 9 +- crates/coreav-backend-h264/tests/one_idr.rs | 5 +- crates/coreav-backend-libvpx/tests/decode.rs | 9 +- crates/coreav-cli/tests/decode_audio.rs | 12 +- crates/coreav-cli/tests/decoder_host.rs | 12 +- crates/coreav-cli/tests/ffmpeg.rs | 68 ------ crates/coreav-cli/tests/ffmpeg_aac_filter.rs | 17 +- crates/coreav-cli/tests/ffmpeg_frames.rs | 15 +- crates/coreav-cli/tests/ffmpeg_input_seek.rs | 17 +- crates/coreav-cli/tests/ffmpeg_matroska.rs | 18 +- crates/coreav-cli/tests/ffmpeg_pcm.rs | 22 +- crates/coreav-cli/tests/ffmpeg_wav.rs | 32 +-- .../coreav-cli/tests/ffprobe_format_span.rs | 105 ++++----- crates/coreav-cli/tests/legacy_encoders.rs | 5 +- .../coreav-cli/tests/oracle_qualification.rs | 100 ++++++++ crates/coreav-cli/tests/probe_tuning.rs | 14 +- crates/coreav-cli/tests/strict_safe.rs | 11 +- crates/coreav-cli/tests/thumbnail.rs | 7 +- crates/coreav-cli/tests/transcode.rs | 14 +- crates/coreav-frame/tests/ffmpeg_scale.rs | 15 +- crates/coreav-isobmff-write/tests/replace.rs | 7 +- crates/coreav-mkv/tests/write_oracle.rs | 23 +- crates/coreav-transcode/tests/common/mod.rs | 21 +- crates/coreav-transcode/tests/encoders.rs | 14 +- crates/coreav-transcode/tests/sandboxed.rs | 17 +- crates/coreav-worker/tests/ffmpeg.rs | 9 +- docs/agents/ffmpeg-cli.md | 3 +- docs/design/local-oracle-qualification.md | 8 + scripts/aac_agreement.py | 2 + scripts/aac_pcm_eligibility.py | 3 +- scripts/audio_copy_check.py | 2 + scripts/audio_source_diagnostic.py | 3 +- scripts/avi_fixture_check.py | 3 +- scripts/avi_v2_check.py | 3 +- scripts/bench_guard.py | 10 +- scripts/codec_coverage_gcp.py | 6 +- scripts/composed_audio_selftest.py | 3 + scripts/exact_skip_check.py | 2 + scripts/fallback_names.py | 3 +- scripts/ffv1_check.py | 3 +- scripts/flac_output_check.py | 2 +- scripts/flac_output_measure.py | 2 +- scripts/gen-v2-fixtures.py | 6 + scripts/h264_agreement.py | 3 + scripts/h264_deblock_conformance.py | 2 +- scripts/h264_g1.py | 3 +- scripts/h264_g1_conformance.py | 3 +- scripts/h264_modes_identity.py | 3 + scripts/h264_p_conformance.py | 2 +- scripts/h264_parity.py | 5 + scripts/h264_parity_gcp.py | 23 +- scripts/h264_parity_gcp_selftest.py | 17 +- scripts/h264_parity_selftest.py | 16 +- scripts/h264_speed.py | 3 + scripts/h264_synth.py | 4 + scripts/he_aac_agreement.py | 3 + scripts/hevc_conformance.py | 7 +- scripts/hevc_fixture.py | 2 + scripts/input_summary_check.py | 4 +- scripts/input_summary_development.py | 3 +- scripts/opus_encode_check.py | 2 + scripts/opus_matroska_padding.py | 2 +- scripts/opus_mp4_presentation.py | 2 +- scripts/opus_pcm_eligibility.py | 2 +- scripts/oracle.py | 4 + scripts/oracle_free.py | 32 +++ scripts/oracle_negative.py | 57 +++++ scripts/pcm_output_check.py | 2 +- scripts/policy_check.py | 3 + scripts/raw_audio_pipe_check.py | 5 +- scripts/raw_pcm_check.py | 2 +- scripts/seek_check.py | 3 + scripts/standalone_audio_probe_check.py | 10 +- scripts/stsd_craft.py | 3 + scripts/swr_characterize.py | 2 +- scripts/test_oracle.py | 137 +++++++++++ scripts/tests/test_audio_source_diagnostic.py | 3 +- scripts/tests/test_bar_sources.py | 9 +- scripts/tests/test_bench_guard.py | 2 +- scripts/tests/test_fallback_names.py | 2 +- scripts/tests/test_ffv1_check.py | 3 + scripts/tests/test_gcp_vm_job.py | 2 +- scripts/tests/test_gen_v2_fixtures.py | 10 +- scripts/tests/test_h264_deblock.py | 4 +- scripts/tests/test_h264_p.py | 4 +- scripts/tests/test_hevc_conformance.py | 4 +- scripts/tests/test_hevc_exclusions.py | 2 +- scripts/tests/test_hevc_fixture.py | 2 + scripts/tests/test_input_summary_check.py | 8 +- .../tests/test_input_summary_development.py | 8 +- scripts/tests/test_oracle_audio.py | 6 +- scripts/tests/test_oracle_free.py | 34 +++ .../test_standalone_audio_probe_check.py | 6 +- scripts/tests/test_test_oracle.py | 201 ++++++++++++++++ scripts/tests/test_v2_fixture_inputs.py | 5 +- scripts/tests/test_wasm_thumbnail_fixtures.py | 2 +- scripts/text_check.py | 3 + scripts/thumbnail_oracle.py | 5 + scripts/transcode_check.py | 2 + scripts/transcode_decoder_host.py | 5 +- scripts/transcode_speed.py | 2 + scripts/transcode_speed_gcp.py | 8 +- scripts/ts_speed.py | 4 + scripts/ts_speed_gcp.py | 7 +- scripts/v2_fixture_check.py | 7 +- scripts/vp9_corpus.py | 8 + scripts/vp9_speed.py | 2 + scripts/vp9_speed_gcp.py | 10 +- scripts/wasm-thumbnail-fixtures.py | 3 +- test-support/oracle-dependent.json | 219 ++++++++++++++++++ test-support/oracle.rs | 51 ++++ tools/compat-corpus/corpus_kd.py | 3 +- tools/compat-corpus/current_ci.py | 3 +- tools/compat-corpus/decode_breadth.py | 4 + tools/compat-corpus/encode_breadth.py | 3 +- tools/compat-corpus/frames.py | 3 + tools/compat-corpus/r4_scan.py | 4 + tools/compat-corpus/tests/test_corpus_kd.py | 3 +- tools/compat-corpus/tests/test_current_ci.py | 4 +- tools/decode-oracle/src/main.rs | 20 +- tools/decode-oracle/tests/stream.rs | 16 +- tools/hostile/generate.py | 4 + tools/isobmff-adapter/corpus/harvest.py | 4 + tools/mediainfo-oracle/corpus.py | 4 + tools/mediarecorder/generate.py | 5 +- tools/mkv-adapter/bench.py | 3 + tools/mkv-adapter/corpus.py | 6 +- tools/mkv-adapter/remux_corpus.py | 2 + tools/oracle/tests/test_kd_mkv.py | 45 +--- tools/oracle/writer_kd_audit_cli.py | 2 + tools/stage3-report/run.py | 6 +- tools/videotoolbox-identities/capture.py | 3 +- 143 files changed, 1439 insertions(+), 560 deletions(-) create mode 100644 crates/coreav-cli/tests/oracle_qualification.rs create mode 100644 scripts/oracle_free.py create mode 100644 scripts/oracle_negative.py create mode 100644 scripts/test_oracle.py create mode 100644 scripts/tests/test_oracle_free.py create mode 100644 scripts/tests/test_test_oracle.py create mode 100644 test-support/oracle-dependent.json create mode 100644 test-support/oracle.rs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7e4f1d53e..4917d25f4 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -121,6 +121,12 @@ jobs: crates/coreav-worker/** crates/coreav-transcode/** crates/coreav-cli/** + test-support/** + scripts/test_oracle.py + scripts/oracle_free.py + scripts/oracle_pin*.py + scripts/oracle-ffmpeg*.env + scripts/install-oracle-ffmpeg-macos.sh crates/coreav-backend-dav1d/** crates/coreav-backend-libvpx/** crates/coreav-isobmff/src/source.rs @@ -229,6 +235,30 @@ jobs: - run: python3 -I -m unittest discover -s .github/workflows/tests -p 'test_*.py' env: PYTHONDONTWRITEBYTECODE: '1' + # The encoder programs of `coreav transcode`, black boxes for + # coreav-transcode's tests (docs/design/transcode.md): the pinned + # FFmpeg and an x264 program built from the commit of its libx264 + # (scripts/oracle-ffmpeg.env), its source deleted after the build. + # With `CI` set the tests + # fail instead of skipping when either is missing. + - name: Cache the encoder programs + id: encoders-cache + uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3 + with: + path: ${{ runner.temp }}/coreav-encoders + key: linux-x64-encoders-${{ hashFiles('scripts/oracle-ffmpeg.env', 'scripts/install-oracle-ffmpeg.sh', 'scripts/install-x264.sh') }} + - name: Install the pinned FFmpeg and build x264 + if: steps.encoders-cache.outputs.cache-hit != 'true' + run: | + sudo apt-get install -y --no-install-recommends nasm + scripts/install-oracle-ffmpeg.sh "$RUNNER_TEMP/coreav-encoders" + scripts/install-x264.sh "$RUNNER_TEMP/coreav-encoders" + - name: Verify the pinned encoder oracle + run: | + python3 -I scripts/oracle_pin.py --verify-bin "$RUNNER_TEMP/coreav-encoders" + echo "COREAV_FFMPEG=$RUNNER_TEMP/coreav-encoders/ffmpeg" >> "$GITHUB_ENV" + echo "COREAV_FFPROBE=$RUNNER_TEMP/coreav-encoders/ffprobe" >> "$GITHUB_ENV" + echo "$RUNNER_TEMP/coreav-encoders" >> "$GITHUB_PATH" - run: cargo clippy --workspace --all-targets -- -D warnings # The H.264 decoder's safe mode, without its default feature `fast` # (docs/design/h264.md). @@ -276,26 +306,6 @@ jobs: cargo clippy -p coreav-decode-oracle --features native-vp9,native-h264 --all-targets -- -D warnings cargo test -p coreav-backend-libopus --features libopus cargo test -p coreav-worker --features libopus - # The encoder programs of `coreav transcode`, black boxes for - # coreav-transcode's tests (docs/design/transcode.md): the pinned - # FFmpeg and an x264 program built from the commit of its libx264 - # (scripts/oracle-ffmpeg.env), its source deleted after the build. - # With `CI` set the tests - # fail instead of skipping when either is missing. - - name: Cache the encoder programs - id: encoders-cache - uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3 - with: - path: ${{ runner.temp }}/coreav-encoders - key: linux-x64-encoders-${{ hashFiles('scripts/oracle-ffmpeg.env', 'scripts/install-oracle-ffmpeg.sh', 'scripts/install-x264.sh') }} - - name: Install the pinned FFmpeg and build x264 - if: steps.encoders-cache.outputs.cache-hit != 'true' - run: | - sudo apt-get install -y --no-install-recommends nasm - scripts/install-oracle-ffmpeg.sh "$RUNNER_TEMP/coreav-encoders" - scripts/install-x264.sh "$RUNNER_TEMP/coreav-encoders" - - name: Verify the pinned encoder oracle - run: python3 -I scripts/oracle_pin.py --verify-bin "$RUNNER_TEMP/coreav-encoders" - name: Require exact native FFV1 pixels and probe fields timeout-minutes: 15 run: | @@ -423,6 +433,15 @@ jobs: - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2 with: save-if: ${{ github.ref == 'refs/heads/main' }} + - name: Provision the registered macOS oracle or select oracle-free tests + run: | + if [[ "$(uname -m)" == arm64 ]]; then + scripts/install-oracle-ffmpeg-macos.sh "$RUNNER_TEMP/coreav-test-oracle" + echo "COREAV_FFMPEG=$RUNNER_TEMP/coreav-test-oracle/ffmpeg" >> "$GITHUB_ENV" + echo "COREAV_FFPROBE=$RUNNER_TEMP/coreav-test-oracle/ffprobe" >> "$GITHUB_ENV" + else + echo 'No registered oracle on this architecture; run the explicit oracle-free selection' + fi - run: cargo clippy --workspace --all-targets -- -D warnings - run: cargo clippy -p coreav-h264 --no-default-features --all-targets -- -D warnings - run: cargo clippy -p coreav-cli --features ffmpeg-fallback --all-targets -- -D warnings @@ -438,12 +457,12 @@ jobs: --features coreav-cli/libvpx,coreav-backend-libvpx/libvpx,coreav-worker/libvpx,coreav-decode-oracle/libvpx \ --all-targets -- -D warnings cargo clippy -p coreav-cli --features libvpx,dav1d,ffmpeg-fallback --all-targets -- -D warnings - env -u CI cargo test -p coreav-backend-dav1d --features dav1d - env -u CI cargo test -p coreav-backend-libvpx --features libvpx - - run: env -u CI cargo test --workspace + env -u CI python3 -I scripts/oracle_free.py cargo test -p coreav-backend-dav1d --features dav1d + env -u CI python3 -I scripts/oracle_free.py cargo test -p coreav-backend-libvpx --features libvpx + - run: env -u CI python3 -I scripts/oracle_free.py cargo test --workspace - run: | - env -u CI cargo test -p coreav-cli --features ffmpeg-fallback --test strict_safe --test strict_safe_limit - env -u CI cargo test -p coreav-cli --features native-h264 --test strict_safe --test strict_safe_limit + env -u CI python3 -I scripts/oracle_free.py cargo test -p coreav-cli --features ffmpeg-fallback --test strict_safe --test strict_safe_limit + env -u CI python3 -I scripts/oracle_free.py cargo test -p coreav-cli --features native-h264 --test strict_safe --test strict_safe_limit - run: cargo test -p coreav-cli --features ffmpeg-fallback --test docs_site --test transcode_selection - run: | cargo test --release -p coreav-isobmff --test hostile -- --ignored @@ -496,11 +515,11 @@ jobs: run: cargo clippy -p coreav-py --features thumbnail --all-targets -- -D warnings - name: Test workspace including Windows fallback if: ${{ !cancelled() }} - run: env -u CI cargo test --workspace --no-fail-fast + run: env -u CI python3 -I scripts/oracle_free.py cargo test --workspace --no-fail-fast - if: ${{ !cancelled() }} run: | - env -u CI cargo test -p coreav-cli --features ffmpeg-fallback --test strict_safe --test strict_safe_limit - env -u CI cargo test -p coreav-cli --features native-h264 --test strict_safe --test strict_safe_limit + env -u CI python3 -I scripts/oracle_free.py cargo test -p coreav-cli --features ffmpeg-fallback --test strict_safe --test strict_safe_limit + env -u CI python3 -I scripts/oracle_free.py cargo test -p coreav-cli --features native-h264 --test strict_safe --test strict_safe_limit - if: ${{ !cancelled() }} run: cargo test -p coreav-cli --features ffmpeg-fallback --test docs_site --test transcode_selection - if: ${{ !cancelled() }} diff --git a/.github/workflows/codec-coverage.yml b/.github/workflows/codec-coverage.yml index 763db0fa9..412d5db12 100644 --- a/.github/workflows/codec-coverage.yml +++ b/.github/workflows/codec-coverage.yml @@ -64,6 +64,7 @@ on: - docs/design/png-bmp-yuv-actions.md - scripts/tests/test_registered_candidate.py - scripts/oracle-ffmpeg.env + - scripts/oracle-ffmpeg-macos.env - scripts/install-oracle-ffmpeg.sh - scripts/install-x264.sh - scripts/clip_check.py @@ -81,6 +82,8 @@ on: - scripts/opus_encode_check.py - scripts/oracle_audio.py - scripts/oracle_pin.py + - scripts/oracle_pin_macos.py + - scripts/test_oracle.py - scripts/oracle-audio-args.txt - scripts/thumbnail_oracle.py - scripts/remux_check.py diff --git a/.github/workflows/deny.yml b/.github/workflows/deny.yml index 2568862e0..25fb47bd2 100644 --- a/.github/workflows/deny.yml +++ b/.github/workflows/deny.yml @@ -123,6 +123,23 @@ jobs: # docs/measurements/compat-ffprobe.md says what its JSON evidence # holds (tools/compat-corpus/record.py). It runs here, not in ci.yml, # because the notes it reads are behind that workflow's path filter. + - name: Cache the pinned test oracle + if: steps.result.outputs.reuse != 'true' + id: test-oracle-cache + uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3 + with: + path: ${{ runner.temp }}/coreav-test-oracle + key: linux-x64-test-oracle-${{ hashFiles('scripts/oracle-ffmpeg.env', 'scripts/install-oracle-ffmpeg.sh') }} + - name: Install the pinned test oracle + if: steps.result.outputs.reuse != 'true' && steps.test-oracle-cache.outputs.cache-hit != 'true' + run: scripts/install-oracle-ffmpeg.sh "$RUNNER_TEMP/coreav-test-oracle" + - name: Verify the test oracle before real Python discovery + if: steps.result.outputs.reuse != 'true' + run: | + python3 -I scripts/oracle_pin.py --verify-bin "$RUNNER_TEMP/coreav-test-oracle" + echo "COREAV_FFMPEG=$RUNNER_TEMP/coreav-test-oracle/ffmpeg" >> "$GITHUB_ENV" + echo "COREAV_FFPROBE=$RUNNER_TEMP/coreav-test-oracle/ffprobe" >> "$GITHUB_ENV" + echo "$RUNNER_TEMP/coreav-test-oracle" >> "$GITHUB_PATH" - name: Check the command-coverage set against its rules if: steps.result.outputs.reuse != 'true' env: diff --git a/bench/npx/run.py b/bench/npx/run.py index 8549bd15a..72c84db02 100644 --- a/bench/npx/run.py +++ b/bench/npx/run.py @@ -28,6 +28,8 @@ HERE = Path(__file__).resolve().parent ROOT = HERE.parent.parent +sys.path.insert(0, str(ROOT / 'scripts')) +import test_oracle sys.path.insert(0, str(HERE.parent / 'shared')) from benchlib import R2, append_jsonl, download, machine, sha256_file, write_json # noqa: E402 @@ -215,6 +217,7 @@ def main(): parser.add_argument('--cache', default='/tmp/npx-cache') parser.add_argument('--path', choices=('native', 'wasi'), default='native') args = parser.parse_args() + test_oracle.require('ffmpeg', 'ffprobe') native = os.environ.get('COREAV_BIN') if not native or not MODULE.exists() or not (NATIVE_PACKAGE / 'bin' / 'coreav').exists(): raise SystemExit('needs COREAV_BIN, packages/cli/scripts/build.sh and scripts/platform.sh linux-x64') diff --git a/bench/range-audio/gaps.py b/bench/range-audio/gaps.py index f2dae80a5..bcbea82f5 100644 --- a/bench/range-audio/gaps.py +++ b/bench/range-audio/gaps.py @@ -17,6 +17,8 @@ HERE = Path(__file__).resolve().parent sys.path.insert(0, str(HERE.parent / 'shared')) from benchlib import R2 # noqa: E402 +sys.path.insert(0, str(HERE.parents[1] / 'scripts')) +import test_oracle WINDOW = 64 << 10 @@ -55,6 +57,7 @@ def main(): parser.add_argument('--stream', type=int, default=None) parser.add_argument('--only', default='') args = parser.parse_args() + test_oracle.require('ffmpeg', 'ffprobe') files = json.loads(Path(args.inputs).read_text())['files'] if args.only: files = [f for f in files if any(f['sha256'].startswith(p) for p in args.only.split(','))] diff --git a/bench/range-audio/run.py b/bench/range-audio/run.py index a2b9da0cb..e8dfc1313 100644 --- a/bench/range-audio/run.py +++ b/bench/range-audio/run.py @@ -44,6 +44,8 @@ EXTRA = {} NATIVE = ROOT / 'target' / 'edge' / 'edge-native' +sys.path.insert(0, str(ROOT / 'scripts')) +import test_oracle CLI = ROOT / 'target' / 'dist' / 'coreav' # R2 requests one object may cost the CLI at most: the warm-up and the # trials, each under its reader's cap of 10,000. @@ -126,6 +128,7 @@ def main(): parser.add_argument('--max-requests', type=int, default=400_000, help='R2 requests the whole run may make (Class B, 0.36 USD per million)') args = parser.parse_args() + test_oracle.require('ffmpeg', 'ffprobe') data = json.loads(Path(args.inputs).read_text()) files = (data['held_out'] if args.held_out else data['files'])[:args.limit] if args.only: diff --git a/crates/coreav-audio/src/convert/oracle.rs b/crates/coreav-audio/src/convert/oracle.rs index 7ecc4fb4a..e9874d8b1 100644 --- a/crates/coreav-audio/src/convert/oracle.rs +++ b/crates/coreav-audio/src/convert/oracle.rs @@ -1,8 +1,11 @@ #![allow(clippy::indexing_slicing, clippy::unwrap_used)] +#[path = "../../../../test-support/oracle.rs"] +mod test_oracle; + use super::*; use std::io::Write; -use std::path::{Path, PathBuf}; +use std::path::Path; use std::process::{Command, Stdio}; fn format(format: SampleFormat) -> (&'static str, &'static str) { @@ -61,24 +64,7 @@ fn reference( #[test] fn sample_conversion_is_exact_against_the_pinned_oracle() { - let Some(ffmpeg) = std::env::var_os("COREAV_FFMPEG").map(PathBuf::from) else { - assert!( - std::env::var_os("CI").is_none(), - "CI requires COREAV_FFMPEG" - ); - eprintln!("skipping sample conversion oracle; set COREAV_FFMPEG"); - return; - }; - let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); - assert!( - Command::new("python3") - .arg(root.join("scripts/oracle_pin.py")) - .arg("--verify-bin") - .arg(ffmpeg.parent().unwrap()) - .status() - .unwrap() - .success() - ); + let ffmpeg = test_oracle::require().ffmpeg().to_path_buf(); let formats = [ SampleFormat::S16, SampleFormat::S24, diff --git a/crates/coreav-audio/tests/flac_encode.rs b/crates/coreav-audio/tests/flac_encode.rs index 92eeee646..58327f4d3 100644 --- a/crates/coreav-audio/tests/flac_encode.rs +++ b/crates/coreav-audio/tests/flac_encode.rs @@ -8,6 +8,9 @@ mod support; +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use coreav_audio::flac::encode::FlacSink; use coreav_audio::{Error, LimitKind, Limits, OutputFormat, SampleFormat, Sink}; @@ -103,13 +106,7 @@ fn complete_roundtrips_include_all_channels_widths_and_block_tails() { #[test] fn escaped_and_five_bit_files_decode_completely_with_the_independent_oracle() { - let Some(program) = std::env::var_os("COREAV_FFMPEG") else { - assert!( - std::env::var_os("COREAV_REQUIRE_FFMPEG").is_none(), - "set COREAV_FFMPEG to the verified oracle" - ); - return; - }; + let program = test_oracle::require().ffmpeg().to_path_buf(); for bits in [16, 24] { let samples: Vec = (0..4096i64) .flat_map(|index| { diff --git a/crates/coreav-backend-dav1d/tests/decode.rs b/crates/coreav-backend-dav1d/tests/decode.rs index cac045cb3..f0afa9276 100644 --- a/crates/coreav-backend-dav1d/tests/decode.rs +++ b/crates/coreav-backend-dav1d/tests/decode.rs @@ -11,6 +11,9 @@ clippy::indexing_slicing )] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::Command; @@ -21,11 +24,7 @@ use coreav_decode::{ use coreav_isobmff::{Allowlist, Budget, FileSource, Source, probe}; fn ffmpeg() -> PathBuf { - let path = std::env::var_os("PATH").expect("PATH"); - std::env::split_paths(&path) - .map(|d| d.join("ffmpeg")) - .find(|p| p.is_file()) - .expect("ffmpeg on PATH") + test_oracle::require().ffmpeg().to_path_buf() } fn generate(dir: &Path, name: &str, size: &str, pix_fmt: &str, extra: &[&str]) -> PathBuf { diff --git a/crates/coreav-backend-ffmpeg/tests/decode.rs b/crates/coreav-backend-ffmpeg/tests/decode.rs index 980213402..36e5002f1 100644 --- a/crates/coreav-backend-ffmpeg/tests/decode.rs +++ b/crates/coreav-backend-ffmpeg/tests/decode.rs @@ -10,6 +10,9 @@ clippy::indexing_slicing )] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::Command; @@ -18,11 +21,7 @@ use coreav_decode::{Codec, CodecConfig, ConfigKind, Decoder, Limits, Packet, Str use coreav_isobmff::{Allowlist, Budget, FileSource, Source, probe}; fn ffmpeg() -> PathBuf { - let path = std::env::var_os("PATH").expect("PATH"); - std::env::split_paths(&path) - .map(|d| d.join("ffmpeg")) - .find(|p| p.is_file()) - .expect("ffmpeg on PATH") + test_oracle::require().ffmpeg().to_path_buf() } fn generate(dir: &Path, name: &str, args: &[&str]) -> PathBuf { diff --git a/crates/coreav-backend-h264/tests/decode.rs b/crates/coreav-backend-h264/tests/decode.rs index 086fc2845..38782515b 100644 --- a/crates/coreav-backend-h264/tests/decode.rs +++ b/crates/coreav-backend-h264/tests/decode.rs @@ -14,6 +14,9 @@ clippy::indexing_slicing )] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::Command; @@ -25,11 +28,7 @@ use coreav_decode::{ use coreav_isobmff::{Allowlist, Budget, FileSource, Source, probe}; fn ffmpeg() -> PathBuf { - let path = std::env::var_os("PATH").expect("PATH"); - std::env::split_paths(&path) - .map(|d| d.join("ffmpeg")) - .find(|p| p.is_file()) - .expect("ffmpeg on PATH") + test_oracle::require().ffmpeg().to_path_buf() } fn generate(dir: &Path, name: &str, args: &[&str]) -> PathBuf { diff --git a/crates/coreav-backend-h264/tests/memory.rs b/crates/coreav-backend-h264/tests/memory.rs index d8bd7c41a..1b7146b97 100644 --- a/crates/coreav-backend-h264/tests/memory.rs +++ b/crates/coreav-backend-h264/tests/memory.rs @@ -15,6 +15,9 @@ clippy::indexing_slicing )] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::Command; @@ -27,11 +30,7 @@ use coreav_isobmff::{Allowlist, Budget, FileSource, Source, probe}; static ALLOC: CountingAllocator = CountingAllocator; fn ffmpeg() -> PathBuf { - let path = std::env::var_os("PATH").expect("PATH"); - std::env::split_paths(&path) - .map(|d| d.join("ffmpeg")) - .find(|p| p.is_file()) - .expect("ffmpeg on PATH") + test_oracle::require().ffmpeg().to_path_buf() } fn run_ffmpeg(args: &[&str]) { diff --git a/crates/coreav-backend-h264/tests/one_idr.rs b/crates/coreav-backend-h264/tests/one_idr.rs index f4f2cf953..8bc537ab9 100644 --- a/crates/coreav-backend-h264/tests/one_idr.rs +++ b/crates/coreav-backend-h264/tests/one_idr.rs @@ -1,6 +1,9 @@ //! One-IDR admission and requested-allocation bounds, including packed transfer. #![allow(clippy::expect_used, clippy::unwrap_used, clippy::indexing_slicing)] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use coreav_backend_h264::NativeH264; use coreav_counting_alloc::{CountingAllocator, measure, report}; use coreav_decode::{Backend, Codec, ErrorKind, Limits, Packet, StreamConfig}; @@ -516,7 +519,7 @@ fn generated_entropy_modes_and_pcm_fit_the_same_bound() { for (width, height) in [(640, 360), (1280, 720), (1920, 1080), (1080, 1920)] { let input = format!("testsrc2=size={width}x{height}:rate=1"); let params = format!("cabac={cabac}:slices=4:keyint=1"); - let output = std::process::Command::new("ffmpeg") + let output = std::process::Command::new(test_oracle::require().ffmpeg()) .args([ "-hide_banner", "-loglevel", diff --git a/crates/coreav-backend-libvpx/tests/decode.rs b/crates/coreav-backend-libvpx/tests/decode.rs index 6b0479972..3e4c5dfcc 100644 --- a/crates/coreav-backend-libvpx/tests/decode.rs +++ b/crates/coreav-backend-libvpx/tests/decode.rs @@ -12,6 +12,9 @@ clippy::indexing_slicing )] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::Command; @@ -26,11 +29,7 @@ use coreav_thumbnail::{ThumbnailOptions, first_packets}; use md5::{Digest, Md5}; fn ffmpeg() -> PathBuf { - let path = std::env::var_os("PATH").expect("PATH"); - std::env::split_paths(&path) - .map(|d| d.join("ffmpeg")) - .find(|p| p.is_file()) - .expect("ffmpeg on PATH") + test_oracle::require().ffmpeg().to_path_buf() } /// One second of `testsrc2` at 25 frames a second, encoded with diff --git a/crates/coreav-cli/tests/decode_audio.rs b/crates/coreav-cli/tests/decode_audio.rs index 6fd195220..cffd6d85f 100644 --- a/crates/coreav-cli/tests/decode_audio.rs +++ b/crates/coreav-cli/tests/decode_audio.rs @@ -12,6 +12,9 @@ #[path = "schema/mod.rs"] mod schema; +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use serde_json::Value; use std::path::{Path, PathBuf}; use std::process::Command; @@ -483,14 +486,7 @@ fn decodes_an_aac_track() { #[cfg(feature = "aac")] #[test] fn decodes_an_mp4_aac_track_as_ffmpeg_does() { - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); - if !ffmpeg.is_file() { - assert!(std::env::var_os("CI").is_none(), "no pinned ffmpeg"); - eprintln!("skipping: no pinned ffmpeg (set COREAV_FFMPEG)"); - return; - } + let ffmpeg = test_oracle::require().ffmpeg().to_path_buf(); let input = path("da_aac.m4a"); let status = Command::new(&ffmpeg) .args(["-v", "error", "-f", "lavfi", "-i"]) diff --git a/crates/coreav-cli/tests/decoder_host.rs b/crates/coreav-cli/tests/decoder_host.rs index bee4d1e55..5c446f6b0 100644 --- a/crates/coreav-cli/tests/decoder_host.rs +++ b/crates/coreav-cli/tests/decoder_host.rs @@ -1,6 +1,9 @@ #![doc = "Synthetic transcodes preserve complete pixels across diagnostic decoder hosts."] #![cfg(feature = "transcode")] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::Command; @@ -53,14 +56,7 @@ fn hosting_pair( encoder: &str, backend: &str, ) -> Result<(), Box> { - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); - if !ffmpeg.is_file() { - assert!(std::env::var_os("CI").is_none(), "missing pinned FFmpeg"); - eprintln!("skipping diagnostic fixture without pinned FFmpeg"); - return Ok(()); - } + let ffmpeg = test_oracle::require().ffmpeg().to_path_buf(); let dir = directory(codec)?; let input = dir.join("input.mkv"); let generated = Command::new(&ffmpeg) diff --git a/crates/coreav-cli/tests/ffmpeg.rs b/crates/coreav-cli/tests/ffmpeg.rs index 5cca5a5ce..e39fa9c9e 100644 --- a/crates/coreav-cli/tests/ffmpeg.rs +++ b/crates/coreav-cli/tests/ffmpeg.rs @@ -2089,70 +2089,6 @@ fn input_seek_refusal_contract_keeps_its_exact_command_scope() { } } -fn qualify_local_oracle(pin: &Path) -> Result<(), String> { - let pin = std::path::absolute(pin).map_err(|error| error.to_string())?; - let installed = pin.with_file_name("ffmpeg"); - if std::fs::canonicalize(&pin).map_err(|error| error.to_string())? - != std::fs::canonicalize(&installed).map_err(|error| error.to_string())? - { - return Err("selected FFmpeg differs from the installed oracle pair".into()); - } - let verified = Command::new("python3") - .arg("-I") - .arg(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../scripts/oracle_pin.py")) - .arg("--verify-bin") - .arg(pin.parent().unwrap()) - .output() - .map_err(|error| error.to_string())?; - if !verified.status.success() { - return Err(String::from_utf8_lossy(&verified.stderr).into_owned()); - } - Ok(()) -} - -#[cfg(unix)] -#[test] -fn local_oracle_qualification_rejects_unverified_executables() { - use std::os::unix::fs::PermissionsExt; - - let dir = oracle_scratch("ffmpeg-local-qualification"); - let pin = dir.join("ffmpeg"); - let probe = dir.join("ffprobe"); - let build = include_str!("../../../scripts/oracle-ffmpeg.env") - .lines() - .find_map(|line| line.strip_prefix("BUILD=")) - .unwrap(); - let write = |path: &Path, body: &str| { - std::fs::write(path, format!("#!/bin/sh\n{body}\n")).unwrap(); - std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o700)).unwrap(); - }; - write(&pin, &format!("echo 'ffmpeg version {build}'")); - write(&probe, &format!("echo 'ffprobe version {build}'")); - qualify_local_oracle(&pin).unwrap(); - let other = dir.join("renamed-ffmpeg"); - write(&other, &format!("echo 'ffmpeg version {build}'")); - assert!( - qualify_local_oracle(&other) - .unwrap_err() - .contains("differs") - ); - for body in [ - "echo 'ffmpeg version 0.0.0'".to_owned(), - format!("echo 'ffmpeg version {build}0'"), - "echo malformed".to_owned(), - "exit 1".to_owned(), - ] { - write(&pin, &body); - assert!(qualify_local_oracle(&pin).is_err(), "{body}"); - } - write(&pin, &format!("echo 'ffmpeg version {build}'")); - write(&probe, "echo 'ffprobe version 0.0.0'"); - assert!(qualify_local_oracle(&pin).is_err()); - std::fs::remove_file(&probe).unwrap(); - assert!(qualify_local_oracle(&pin).is_err()); - assert_eq!(std::fs::read_dir(&dir).unwrap().count(), 2); -} - fn verify_input_seek_refusal(args: &[String], output: &Path) { let pin = std::env::var_os("COREAV_FFMPEG") .map(PathBuf::from) @@ -2169,8 +2105,6 @@ fn verify_input_seek_refusal(args: &[String], output: &Path) { coreav_cli::fallback::executable(&pin), "stage=oracle_selection: pinned FFmpeg is not executable" ); - qualify_local_oracle(&pin) - .unwrap_or_else(|error| panic!("stage=oracle_qualification: {error}")); let reference = output.with_file_name("reference.mp4"); let directory = output.parent().unwrap(); assert!(!output.exists(), "refusal left output before verification"); @@ -2979,8 +2913,6 @@ fn oracle() -> Option<(PathBuf, PathBuf)> { .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); let ffprobe = ffmpeg.with_file_name("ffprobe"); if ffmpeg.is_file() && ffprobe.is_file() { - qualify_local_oracle(&ffmpeg) - .unwrap_or_else(|error| panic!("stage=oracle_qualification: {error}")); return Some((ffmpeg, ffprobe)); } let required = diff --git a/crates/coreav-cli/tests/ffmpeg_aac_filter.rs b/crates/coreav-cli/tests/ffmpeg_aac_filter.rs index 7f20fd0b2..918d5f46a 100644 --- a/crates/coreav-cli/tests/ffmpeg_aac_filter.rs +++ b/crates/coreav-cli/tests/ffmpeg_aac_filter.rs @@ -1,6 +1,9 @@ //! AAC concat filtering stays refused until complete output is byte-exact. #![allow(clippy::unwrap_used, clippy::indexing_slicing, clippy::panic)] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use serde_json::Value; use std::path::{Path, PathBuf}; use std::process::Command; @@ -15,17 +18,9 @@ impl Drop for FixtureDir { #[test] fn aac_filter_is_an_exact_concat_identity_or_preserved_fallback() { - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); - let ffprobe = ffmpeg.with_file_name("ffprobe"); - if !ffmpeg.is_file() || !ffprobe.is_file() { - assert!( - std::env::var_os("CI").is_none() && std::env::var_os("COREAV_REQUIRE_FFMPEG").is_none(), - "set COREAV_FFMPEG to the pin" - ); - return; - } + let pair = test_oracle::require(); + let ffmpeg = pair.ffmpeg().to_path_buf(); + let ffprobe = pair.ffprobe().to_path_buf(); let path = Path::new(env!("CARGO_TARGET_TMPDIR")) .join(format!("ffmpeg-aac-filter-{}", std::process::id())); std::fs::create_dir(&path).unwrap(); diff --git a/crates/coreav-cli/tests/ffmpeg_frames.rs b/crates/coreav-cli/tests/ffmpeg_frames.rs index de4fcc8e8..a0a6e59bd 100644 --- a/crates/coreav-cli/tests/ffmpeg_frames.rs +++ b/crates/coreav-cli/tests/ffmpeg_frames.rs @@ -8,6 +8,9 @@ clippy::panic )] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::{Command, Output, Stdio}; @@ -28,17 +31,7 @@ fn checked(command: &mut Command) -> Vec { } fn fixture(name: &str) -> Option { - let oracle = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); - if !oracle.is_file() { - assert!( - std::env::var_os("CI").is_none() && std::env::var_os("COREAV_REQUIRE_FFMPEG").is_none(), - "install the pinned oracle or set COREAV_FFMPEG" - ); - eprintln!("skipping: no pinned oracle (set COREAV_FFMPEG)"); - return None; - } + let oracle = test_oracle::require().ffmpeg().to_path_buf(); let dir = Path::new(env!("CARGO_TARGET_TMPDIR")).join(format!("ffmpeg-frames-{name}")); let _ = std::fs::remove_dir_all(&dir); std::fs::create_dir_all(&dir).unwrap(); diff --git a/crates/coreav-cli/tests/ffmpeg_input_seek.rs b/crates/coreav-cli/tests/ffmpeg_input_seek.rs index daa0826ed..48ad7d764 100644 --- a/crates/coreav-cli/tests/ffmpeg_input_seek.rs +++ b/crates/coreav-cli/tests/ffmpeg_input_seek.rs @@ -1,6 +1,9 @@ //! Input-seek copies retain exact packet timing or refuse before publication. #![allow(clippy::unwrap_used, clippy::indexing_slicing, clippy::panic)] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use serde_json::Value; use std::path::{Path, PathBuf}; use std::process::Command; @@ -53,17 +56,9 @@ fn pixels(path: &Path, ffmpeg: &Path) -> Vec { #[test] fn input_seek_copy_keeps_only_exact_packet_timelines() { - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); - let ffprobe = ffmpeg.with_file_name("ffprobe"); - if !ffmpeg.is_file() || !ffprobe.is_file() { - assert!( - std::env::var_os("CI").is_none() && std::env::var_os("COREAV_REQUIRE_FFMPEG").is_none(), - "no pinned ffmpeg and ffprobe (set COREAV_FFMPEG)" - ); - return; - } + let pair = test_oracle::require(); + let ffmpeg = pair.ffmpeg().to_path_buf(); + let ffprobe = pair.ffprobe().to_path_buf(); let path = Path::new(env!("CARGO_TARGET_TMPDIR")) .join(format!("ffmpeg-input-seek-{}", std::process::id())); std::fs::create_dir(&path).unwrap(); diff --git a/crates/coreav-cli/tests/ffmpeg_matroska.rs b/crates/coreav-cli/tests/ffmpeg_matroska.rs index 6aa6441f5..4cd054961 100644 --- a/crates/coreav-cli/tests/ffmpeg_matroska.rs +++ b/crates/coreav-cli/tests/ffmpeg_matroska.rs @@ -6,6 +6,9 @@ clippy::indexing_slicing )] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use serde_json::Value; use std::path::{Path, PathBuf}; use std::process::{Command, Output}; @@ -28,19 +31,8 @@ fn run(command: &mut Command) -> Vec { } fn tools() -> Option<(PathBuf, PathBuf)> { - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| "/opt/coreav-oracle-bin/ffmpeg".into()); - let ffprobe = ffmpeg.with_file_name("ffprobe"); - if ffmpeg.is_file() && ffprobe.is_file() { - return Some((ffmpeg, ffprobe)); - } - assert!( - std::env::var_os("CI").is_none() && std::env::var_os("COREAV_REQUIRE_FFMPEG").is_none(), - "the pinned FFmpeg oracle is required" - ); - eprintln!("skipping: set COREAV_FFMPEG to the pinned oracle"); - None + let pair = test_oracle::require(); + Some((pair.ffmpeg().to_path_buf(), pair.ffprobe().to_path_buf())) } fn scratch(name: &str) -> PathBuf { diff --git a/crates/coreav-cli/tests/ffmpeg_pcm.rs b/crates/coreav-cli/tests/ffmpeg_pcm.rs index 132c04401..bc8a31f49 100644 --- a/crates/coreav-cli/tests/ffmpeg_pcm.rs +++ b/crates/coreav-cli/tests/ffmpeg_pcm.rs @@ -6,6 +6,9 @@ clippy::panic )] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::{Command, Output}; @@ -41,23 +44,8 @@ fn scratch(name: &str) -> PathBuf { #[test] fn aac_raw_output_refuses_with_exact_pinned_fallback() { - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); - if !ffmpeg.is_file() { - assert!( - std::env::var_os("CI").is_none() && std::env::var_os("COREAV_REQUIRE_FFMPEG").is_none(), - "set COREAV_FFMPEG to the pin" - ); - return; - } - let verified = Command::new("python3") - .arg(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../scripts/oracle_pin.py")) - .arg("--verify-bin") - .arg(ffmpeg.parent().unwrap()) - .output() - .unwrap(); - assert!(verified.status.success(), "{verified:?}"); + let ffmpeg = test_oracle::require().ffmpeg().to_path_buf(); + let dir = scratch(&format!("aac-raw-refusal-{}", std::process::id())); let source = dir.join("source.mp4"); let generated = Command::new(&ffmpeg) diff --git a/crates/coreav-cli/tests/ffmpeg_wav.rs b/crates/coreav-cli/tests/ffmpeg_wav.rs index 91e53a407..85825da5f 100644 --- a/crates/coreav-cli/tests/ffmpeg_wav.rs +++ b/crates/coreav-cli/tests/ffmpeg_wav.rs @@ -3,6 +3,9 @@ #![allow(clippy::unwrap_used, clippy::indexing_slicing, clippy::panic)] use std::io::Write; +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::{Command, Stdio}; @@ -57,23 +60,8 @@ fn info_tag(tag: &[u8; 4], text: &[u8]) -> Vec { #[test] fn integer_wav_output_matches_complete_pinned_files() { - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); - if !ffmpeg.is_file() { - assert!( - std::env::var_os("CI").is_none() && std::env::var_os("COREAV_REQUIRE_FFMPEG").is_none(), - "set COREAV_FFMPEG to the pin" - ); - return; - } - let verified = Command::new("python3") - .arg(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../scripts/oracle_pin.py")) - .arg("--verify-bin") - .arg(ffmpeg.parent().unwrap()) - .output() - .unwrap(); - assert!(verified.status.success(), "{verified:?}"); + let ffmpeg = test_oracle::require().ffmpeg().to_path_buf(); + let dir = scratch("output-oracle"); for bits in [8u16, 16, 24, 32] { for channels in [1u16, 2] { @@ -414,15 +402,7 @@ fn unregistered_wav_output_preserves_destinations() { fn wave_wav_stdout_refuses_without_literal_files_and_matches_fallback() { let dir = scratch("wav-stdout"); std::fs::write(dir.join("input.wav"), wav(1, 16, 1, &[0; 12])).unwrap(); - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); - if !ffmpeg.is_file() { - assert!( - std::env::var_os("CI").is_none() && std::env::var_os("COREAV_REQUIRE_FFMPEG").is_none(), - "set COREAV_FFMPEG to the pin" - ); - } + let ffmpeg = test_oracle::require().ffmpeg().to_path_buf(); for destination in ["-", "pipe:1"] { for existing in [false, true] { if existing && cfg!(windows) && destination == "pipe:1" { diff --git a/crates/coreav-cli/tests/ffprobe_format_span.rs b/crates/coreav-cli/tests/ffprobe_format_span.rs index 5f1a52193..ba7a665ad 100644 --- a/crates/coreav-cli/tests/ffprobe_format_span.rs +++ b/crates/coreav-cli/tests/ffprobe_format_span.rs @@ -4,6 +4,9 @@ #[path = "../../coreav-isobmff/tests/common/text_movie.rs"] mod common; +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::Command; @@ -179,9 +182,7 @@ fn output_span_does_not_change_copy_planning_or_trimmed_bytes() { "4064dba9ec64429a954c8492f77e7934b63348a6bc4d77ea2fb1346511d49c92" ); std::fs::remove_file(&output).unwrap(); - let pin = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); + let pin = test_oracle::require().ffmpeg().to_path_buf(); for existing in [false, true] { if existing { std::fs::write(&output, b"existing output").unwrap(); @@ -205,43 +206,36 @@ fn output_span_does_not_change_copy_planning_or_trimmed_bytes() { } else { assert!(!output.exists()); } - if pin.is_file() { - let expected = Command::new(&pin) - .args(["-nostdin", "-hide_banner"]) - .args(args) - .arg(&input) - .args(tail) - .arg(&output) - .output() - .unwrap(); - assert!(expected.status.success()); - let bytes = std::fs::read(&output).unwrap(); - if existing { - std::fs::write(&output, b"existing output").unwrap(); - } else { - std::fs::remove_file(&output).unwrap(); - } - let fallback = Command::new(env!("CARGO_BIN_EXE_coreav")) - .arg("ffmpeg") - .args(args) - .arg(&input) - .args(tail) - .arg(&output) - .env("COREAV_FALLBACK", &pin) - .env_remove("COREAV_STRICT_SAFE") - .env_remove("COREAV_FALLBACK_ACTIVE") - .output() - .unwrap(); - assert_eq!(fallback.status.code(), expected.status.code()); - assert_eq!(fallback.stdout, expected.stdout); - assert_eq!(std::fs::read(&output).unwrap(), bytes); + let expected = Command::new(&pin) + .args(["-nostdin", "-hide_banner"]) + .args(args) + .arg(&input) + .args(tail) + .arg(&output) + .output() + .unwrap(); + assert!(expected.status.success()); + let bytes = std::fs::read(&output).unwrap(); + if existing { + std::fs::write(&output, b"existing output").unwrap(); } else { - assert!( - std::env::var_os("CI").is_none() - && std::env::var_os("COREAV_REQUIRE_FFMPEG").is_none(), - "set COREAV_FFMPEG to the pin" - ); + std::fs::remove_file(&output).unwrap(); } + let fallback = Command::new(env!("CARGO_BIN_EXE_coreav")) + .arg("ffmpeg") + .args(args) + .arg(&input) + .args(tail) + .arg(&output) + .env("COREAV_FALLBACK", &pin) + .env_remove("COREAV_STRICT_SAFE") + .env_remove("COREAV_FALLBACK_ACTIVE") + .output() + .unwrap(); + assert_eq!(fallback.status.code(), expected.status.code()); + assert_eq!(fallback.stdout, expected.stdout); + assert_eq!(std::fs::read(&output).unwrap(), bytes); + if output.exists() { std::fs::remove_file(&output).unwrap(); } @@ -290,26 +284,21 @@ fn format_output_counts_all_cover_picture_streams() { for writer in ["json", "csv=p=0", "default=noprint_wrappers=1:nokey=1"] { let output = run(&path, writer, "format=nb_streams"); assert!(output.status.success()); - let oracle = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")) - .with_file_name("ffprobe"); - if oracle.is_file() { - let reference = Command::new(oracle) - .args([ - "-v", - "error", - "-of", - writer, - "-show_entries", - "format=nb_streams", - ]) - .arg(&path) - .output() - .unwrap(); - assert!(reference.status.success()); - assert_eq!(output.stdout, reference.stdout); - } + let oracle = test_oracle::require().ffprobe().to_path_buf(); + let reference = Command::new(oracle) + .args([ + "-v", + "error", + "-of", + writer, + "-show_entries", + "format=nb_streams", + ]) + .arg(&path) + .output() + .unwrap(); + assert!(reference.status.success()); + assert_eq!(output.stdout, reference.stdout); } } } diff --git a/crates/coreav-cli/tests/legacy_encoders.rs b/crates/coreav-cli/tests/legacy_encoders.rs index c04fc870f..fb4a64eaf 100644 --- a/crates/coreav-cli/tests/legacy_encoders.rs +++ b/crates/coreav-cli/tests/legacy_encoders.rs @@ -6,6 +6,9 @@ #[path = "support/bounded.rs"] mod bounded; +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::Command; use std::time::Duration; @@ -66,7 +69,7 @@ fn legacy_encoder_choices_keep_media_summaries_errors_and_exit_codes() { std::fs::write(&invalid, b"not a media header").unwrap(); let _ = std::fs::remove_file(&absent); let lossless = directory.join("lossless.mkv"); - let mut make = Command::new(std::env::var_os("COREAV_FFMPEG").unwrap()); + let mut make = Command::new(test_oracle::require().ffmpeg()); make.args(["-nostdin", "-v", "error", "-y", "-i"]) .arg(&valid) .args([ diff --git a/crates/coreav-cli/tests/oracle_qualification.rs b/crates/coreav-cli/tests/oracle_qualification.rs new file mode 100644 index 000000000..08a8a7eb9 --- /dev/null +++ b/crates/coreav-cli/tests/oracle_qualification.rs @@ -0,0 +1,100 @@ +//! Oracle-free process-cache contracts using Linux banner stand-ins. +#![cfg(target_os = "linux")] +#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] + +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + +use std::os::unix::fs::PermissionsExt; +use std::path::{Path, PathBuf}; +use std::process::Command; + +struct Fixture(PathBuf); + +impl Drop for Fixture { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } +} + +fn pair(root: &Path, version: &str) { + for name in ["ffmpeg", "ffprobe"] { + let binary = root.join(name); + std::fs::write( + &binary, + format!( + "#!/bin/sh\nprintf '%s\\n' {name} >> '{}'\nprintf '%s\\n' '{name} version {version}'\n", + root.join("calls").display() + ), + ) + .unwrap(); + std::fs::set_permissions(binary, std::fs::Permissions::from_mode(0o700)).unwrap(); + } +} + +fn build() -> &'static str { + include_str!("../../../scripts/oracle-ffmpeg.env") + .lines() + .find_map(|line| line.strip_prefix("BUILD=")) + .unwrap() +} + +#[test] +#[ignore = "oracle-free child process of the cache contract"] +fn cache_child() { + let mode = std::env::var("COREAV_ORACLE_CACHE_CHILD").unwrap(); + if mode == "success" { + let threads: Vec<_> = (0..8) + .map(|_| std::thread::spawn(|| test_oracle::require() as *const _ as usize)) + .collect(); + let addresses: Vec<_> = threads + .into_iter() + .map(|thread| thread.join().unwrap()) + .collect(); + assert!( + addresses + .iter() + .all(|address| Some(address) == addresses.first()) + ); + } else { + assert!(std::panic::catch_unwind(test_oracle::require).is_err()); + let root = PathBuf::from(std::env::var_os("COREAV_FFMPEG").unwrap()); + pair(root.parent().unwrap(), build()); + assert!(std::panic::catch_unwind(test_oracle::require).is_err()); + } +} + +#[test] +fn rust_owner_caches_success_and_failure_once_per_process() { + let root = + Path::new(env!("CARGO_TARGET_TMPDIR")).join(format!("oracle-cache-{}", std::process::id())); + std::fs::create_dir(&root).unwrap(); + let owner = Fixture(root); + for (version, mode) in [ + (build(), "success"), + ("0.0.0", "failure"), + (build(), "success"), + ] { + pair(&owner.0, version); + let _ = std::fs::remove_file(owner.0.join("calls")); + let result = Command::new(std::env::current_exe().unwrap()) + .args(["--ignored", "--exact", "cache_child"]) + .env("COREAV_ORACLE_CACHE_CHILD", mode) + .env("COREAV_FFMPEG", owner.0.join("ffmpeg")) + .env("COREAV_FFPROBE", owner.0.join("ffprobe")) + .output() + .unwrap(); + assert!( + result.status.success(), + "{}", + String::from_utf8_lossy(&result.stderr) + ); + assert_eq!( + std::fs::read_to_string(owner.0.join("calls")) + .unwrap() + .lines() + .count(), + 2 + ); + } +} diff --git a/crates/coreav-cli/tests/probe_tuning.rs b/crates/coreav-cli/tests/probe_tuning.rs index 576950c26..4161897c6 100644 --- a/crates/coreav-cli/tests/probe_tuning.rs +++ b/crates/coreav-cli/tests/probe_tuning.rs @@ -1,18 +1,16 @@ #![allow(missing_docs, clippy::unwrap_used, clippy::expect_used, clippy::panic)] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::PathBuf; use std::process::Command; #[test] fn probe_defaults_leave_pinned_output_byte_identical() { - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); - let ffprobe = ffmpeg.with_file_name("ffprobe"); - if !ffmpeg.is_file() || !ffprobe.is_file() { - eprintln!("Set COREAV_FFMPEG to the pinned ffmpeg to compare probe tuning defaults"); - return; - } + let pair = test_oracle::require(); + let ffmpeg = pair.ffmpeg().to_path_buf(); + let ffprobe = pair.ffprobe().to_path_buf(); let dir = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("probe-tuning"); std::fs::create_dir_all(&dir).unwrap(); for extension in ["mp4", "mkv", "ts"] { diff --git a/crates/coreav-cli/tests/strict_safe.rs b/crates/coreav-cli/tests/strict_safe.rs index ccb8627c3..798b3054f 100644 --- a/crates/coreav-cli/tests/strict_safe.rs +++ b/crates/coreav-cli/tests/strict_safe.rs @@ -25,6 +25,9 @@ clippy::panic )] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use serde_json::Value; use std::os::unix::fs::PermissionsExt; use std::path::{Path, PathBuf}; @@ -87,13 +90,7 @@ fn source(dir: &Path) -> Option { /// An H.264 MP4 with `audio` (the audio input and codec options) in `dir`, /// as [`source`] makes it. fn made(dir: &Path, name: &str, audio: &[&str]) -> Option { - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .or_else(|| { - let pinned = PathBuf::from("/opt/coreav-oracle-bin/ffmpeg"); - pinned.is_file().then_some(pinned) - }) - .unwrap_or_else(|| PathBuf::from("ffmpeg")); + let ffmpeg = test_oracle::require().ffmpeg().to_path_buf(); let path = dir.join(name); let made = Command::new(&ffmpeg) .args(["-nostdin", "-v", "error", "-y", "-f", "lavfi", "-i"]) diff --git a/crates/coreav-cli/tests/thumbnail.rs b/crates/coreav-cli/tests/thumbnail.rs index 677ef5c8a..50a3d0703 100644 --- a/crates/coreav-cli/tests/thumbnail.rs +++ b/crates/coreav-cli/tests/thumbnail.rs @@ -16,6 +16,9 @@ #[allow(dead_code)] mod schema; +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use serde_json::Value; use std::path::{Path, PathBuf}; use std::process::Command; @@ -74,7 +77,7 @@ mod with_ffmpeg { use super::*; fn ffmpeg(args: &[&str]) { - let status = Command::new("ffmpeg") + let status = Command::new(test_oracle::require().ffmpeg()) .args(["-hide_banner", "-loglevel", "error", "-y"]) .args(args) .status() @@ -83,7 +86,7 @@ mod with_ffmpeg { } fn rgb(path: &Path) -> Vec { - let out = Command::new("ffmpeg") + let out = Command::new(test_oracle::require().ffmpeg()) .args(["-v", "error", "-i"]) .arg(path) .args(["-f", "rawvideo", "-pix_fmt", "rgb24", "-"]) diff --git a/crates/coreav-cli/tests/transcode.rs b/crates/coreav-cli/tests/transcode.rs index 8980098a7..aa596e963 100644 --- a/crates/coreav-cli/tests/transcode.rs +++ b/crates/coreav-cli/tests/transcode.rs @@ -7,8 +7,8 @@ //! each summary validated against `docs/schema/transcode-v1.schema.json`, //! and the output checked against `ffprobe` of the source: the frame count //! and every frame's time from the first, the audio packets' data and -//! times, and a clean decode. Each check skips, with a line saying why, -//! when a program or the fixtures are missing. +//! times, and a clean decode. Fixture and optional encoder selection may +//! skip; real FFmpeg work requires the shared qualified pair. #![cfg(feature = "transcode")] #![allow( clippy::indexing_slicing, @@ -25,6 +25,9 @@ mod bounded; #[path = "../../coreav-isobmff/tests/common/mod.rs"] mod iso_movies; +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use serde_json::Value; use std::path::{Path, PathBuf}; use std::process::Command; @@ -52,11 +55,8 @@ fn dir(name: &str) -> PathBuf { /// The pinned FFmpeg and its ffprobe. fn ffmpeg() -> Option<(PathBuf, PathBuf)> { - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); - let ffprobe = ffmpeg.with_file_name("ffprobe"); - (ffmpeg.is_file() && ffprobe.is_file()).then_some((ffmpeg, ffprobe)) + let pair = test_oracle::require(); + Some((pair.ffmpeg().to_path_buf(), pair.ffprobe().to_path_buf())) } /// The pinned x264. diff --git a/crates/coreav-frame/tests/ffmpeg_scale.rs b/crates/coreav-frame/tests/ffmpeg_scale.rs index f6eb8047c..25afb458f 100644 --- a/crates/coreav-frame/tests/ffmpeg_scale.rs +++ b/crates/coreav-frame/tests/ffmpeg_scale.rs @@ -20,6 +20,9 @@ clippy::indexing_slicing )] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::io::Write; use std::path::{Path, PathBuf}; use std::process::{Command, Stdio}; @@ -34,17 +37,7 @@ fn max_diff(depth: u8) -> u32 { } fn ffmpeg() -> Option { - if let Some(path) = std::env::var_os("COREAV_FFMPEG") { - return Some(PathBuf::from(path)); - } - let pinned = Path::new("/opt/coreav-oracle-bin/ffmpeg"); - if pinned.is_file() { - return Some(pinned.to_path_buf()); - } - let path = std::env::var_os("PATH")?; - std::env::split_paths(&path) - .map(|d| d.join("ffmpeg")) - .find(|p| p.is_file()) + Some(test_oracle::require().ffmpeg().to_path_buf()) } fn ffmpeg_or_skip(what: &str) -> Option { diff --git a/crates/coreav-isobmff-write/tests/replace.rs b/crates/coreav-isobmff-write/tests/replace.rs index 69dd536e6..479634da4 100644 --- a/crates/coreav-isobmff-write/tests/replace.rs +++ b/crates/coreav-isobmff-write/tests/replace.rs @@ -22,6 +22,9 @@ mod common; mod mkv; mod movies; +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use coreav_isobmff::{ Allowlist, Budget, Codec, EditList, Error, LimitKind, Limits, Movie, Packet, Rational, SliceSource, Source, TrackKind, probe, @@ -1116,7 +1119,7 @@ const FIXTURES: [(&str, usize); 10] = [ ]; fn ffprobe(path: &Path, args: &[&str]) -> String { - let out = Command::new("ffprobe") + let out = Command::new(test_oracle::require().ffprobe()) .args(["-v", "error"]) .args(args) .arg(path) @@ -1281,7 +1284,7 @@ fn fixtures_present_as_the_plain_remux() { assert!(unsupported(replaced(&source, &own)).contains("simple model")); // H.264 with B-frames and AAC in Matroska, made by the oracle ffmpeg. let mkv_path = out.join("h264_aac.mkv"); - let status = Command::new("ffmpeg") + let status = Command::new(test_oracle::require().ffmpeg()) .args(["-hide_banner", "-loglevel", "error", "-y"]) .args([ "-f", diff --git a/crates/coreav-mkv/tests/write_oracle.rs b/crates/coreav-mkv/tests/write_oracle.rs index 293c7c19b..9e996b1f2 100644 --- a/crates/coreav-mkv/tests/write_oracle.rs +++ b/crates/coreav-mkv/tests/write_oracle.rs @@ -6,9 +6,12 @@ clippy::panic )] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use coreav_mkv::write::{CodecId, Media, Options, Packet, Track, plan}; use coreav_mkv::{Allowlist, DocType, Error, Limits, SliceSource, probe}; -use std::path::{Path, PathBuf}; +use std::path::Path; use std::process::{Command, Output}; fn run(command: &mut Command) -> Vec { @@ -186,21 +189,9 @@ fn rewrite(source: &[u8], doc_type: DocType) -> Vec { #[test] fn encoded_video_and_audio_decode_unchanged() { - let Some(ffmpeg) = std::env::var_os("COREAV_FFMPEG").map(PathBuf::from) else { - eprintln!("skipping generated oracle test; set COREAV_FFMPEG to the pinned oracle"); - return; - }; - let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); - assert!( - Command::new("python3") - .arg(root.join("scripts/oracle_pin.py")) - .arg("--verify-bin") - .arg(ffmpeg.parent().unwrap()) - .status() - .unwrap() - .success() - ); - let ffprobe = ffmpeg.with_file_name("ffprobe"); + let pair = test_oracle::require(); + let ffmpeg = pair.ffmpeg().to_path_buf(); + let ffprobe = pair.ffprobe().to_path_buf(); let dir = std::env::temp_dir().join(format!("coreav-mkv-write-{}", std::process::id())); std::fs::create_dir_all(&dir).unwrap(); for (video, audio, doc_type, ext) in [ diff --git a/crates/coreav-transcode/tests/common/mod.rs b/crates/coreav-transcode/tests/common/mod.rs index 522ddfc92..cd4d4b15d 100644 --- a/crates/coreav-transcode/tests/common/mod.rs +++ b/crates/coreav-transcode/tests/common/mod.rs @@ -9,6 +9,9 @@ clippy::indexing_slicing )] +#[path = "../../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::Command; use std::time::{Duration, Instant}; @@ -29,24 +32,14 @@ pub fn x264() -> Option { .filter(|p| p.is_file()) } -/// The pinned FFmpeg: `COREAV_FFMPEG`, else the oracle's, else `PATH`. +/// The process-cached FFmpeg selection from the shared qualification owner. pub fn ffmpeg() -> Option { - if let Some(named) = std::env::var_os("COREAV_FFMPEG") { - return Some(PathBuf::from(named)).filter(|p| p.is_file()); - } - let oracle = PathBuf::from("/opt/coreav-oracle-bin/ffmpeg"); - if oracle.is_file() { - return Some(oracle); - } - coreav_worker::find_on_path("ffmpeg") + Some(test_oracle::require().ffmpeg().to_path_buf()) } -/// `ffprobe` next to [`ffmpeg`], else on `PATH`. +/// The matching ffprobe of the same qualified selection. pub fn ffprobe() -> Option { - ffmpeg() - .and_then(|f| f.parent().map(|d| d.join("ffprobe"))) - .filter(|p| p.is_file()) - .or_else(|| coreav_worker::find_on_path("ffprobe")) + Some(test_oracle::require().ffprobe().to_path_buf()) } /// Whether a missing program fails the test instead of skipping it: in CI diff --git a/crates/coreav-transcode/tests/encoders.rs b/crates/coreav-transcode/tests/encoders.rs index 80763f13a..618ab5dcf 100644 --- a/crates/coreav-transcode/tests/encoders.rs +++ b/crates/coreav-transcode/tests/encoders.rs @@ -10,12 +10,9 @@ //! must give every frame once, in order, and the `avcC` must equal the one //! FFmpeg writes for the same stream (`-c copy` to MP4). //! -//! The programs are found through `COREAV_X264` and `COREAV_FFMPEG`, the -//! pinned paths (`/opt/coreav-oracle-bin/x264`, `/opt/coreav-oracle-bin/ffmpeg`) -//! or `PATH`; a test whose program is missing (or an `ffmpeg` without -//! libx264) prints why and passes, unless `COREAV_REQUIRE_FFMPEG=1` (the -//! fixtures workflow, which installs the pinned FFmpeg) makes a missing -//! `ffmpeg` a failure. A missing `x264` is always a skip. +//! FFmpeg uses the shared process-cached qualified pair; a missing or +//! unverified selection fails before generation. The separate x264 program +//! uses `COREAV_X264`, the pinned path or `PATH`; a missing x264 is a skip. #![allow( clippy::expect_used, clippy::unwrap_used, @@ -23,6 +20,9 @@ clippy::indexing_slicing )] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::io::Write; use std::path::{Path, PathBuf}; use std::process::{Command, Stdio}; @@ -51,7 +51,7 @@ fn x264() -> Option { } fn ffmpeg() -> Option { - program("COREAV_FFMPEG", "/opt/coreav-oracle-bin/ffmpeg", "ffmpeg") + Some(test_oracle::require().ffmpeg().to_path_buf()) } /// A missing `ffmpeg`: a skip, or a failure where it must be present. diff --git a/crates/coreav-transcode/tests/sandboxed.rs b/crates/coreav-transcode/tests/sandboxed.rs index f3cf75f54..83c6ccf56 100644 --- a/crates/coreav-transcode/tests/sandboxed.rs +++ b/crates/coreav-transcode/tests/sandboxed.rs @@ -84,11 +84,20 @@ fn main() -> ExitCode { if std::env::args().any(|a| a == "--list") { return ExitCode::SUCCESS; } - let filter: Vec = std::env::args() - .skip(1) - .filter(|a| !a.starts_with('-')) - .collect(); + let mut filter = Vec::new(); + let mut excluded = Vec::new(); + let mut arguments = std::env::args().skip(1); + while let Some(argument) = arguments.next() { + if argument == "--skip" { + excluded.push(arguments.next().expect("--skip requires a test name")); + } else if !argument.starts_with('-') { + filter.push(argument); + } + } for (name, case) in cases { + if excluded.iter().any(|f| name.contains(f.as_str())) { + continue; + } if !filter.is_empty() && !filter.iter().any(|f| name.contains(f.as_str())) { continue; } diff --git a/crates/coreav-worker/tests/ffmpeg.rs b/crates/coreav-worker/tests/ffmpeg.rs index 7653083a1..8a2f52675 100644 --- a/crates/coreav-worker/tests/ffmpeg.rs +++ b/crates/coreav-worker/tests/ffmpeg.rs @@ -10,18 +10,19 @@ )] #![cfg(feature = "ffmpeg")] +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::Command; use coreav_decode::{Codec, CodecConfig, ConfigKind, Decoder, Limits, Packet, StreamConfig}; use coreav_frame::Pixels; use coreav_isobmff::{Allowlist, Budget, FileSource, Source, probe}; -use coreav_worker::{ - SandboxedDecoder, TransferMode, WorkerBackend, WorkerCommand, WorkerOptions, find_on_path, -}; +use coreav_worker::{SandboxedDecoder, TransferMode, WorkerBackend, WorkerCommand, WorkerOptions}; fn ffmpeg() -> PathBuf { - find_on_path("ffmpeg").expect("ffmpeg on PATH") + test_oracle::require().ffmpeg().to_path_buf() } fn reference(file: &Path) -> Vec { diff --git a/docs/agents/ffmpeg-cli.md b/docs/agents/ffmpeg-cli.md index f3c201907..396c4122c 100644 --- a/docs/agents/ffmpeg-cli.md +++ b/docs/agents/ffmpeg-cli.md @@ -46,7 +46,8 @@ CLI and ffprobe behavior, the FFmpeg pin, and fallback names. | Audio-only encoding refuses source offsets, tags and dispositions it cannot preserve, and never treats a concat list as a media file | The shared concat-encoding guard and `audio::plan` own these refusals; `ffmpeg_audio_only_refuses_unpreserved_source_properties` covers positive input origins, delayed audio, custom handlers, forced dispositions and concat in the whole transcode fixture target (`ci.yml`). Types cannot prove source metadata or command semantics | | Image and raw-video dispatch preserves metadata and encoder-option refusals before selecting a frame job | `ffmpeg::plan` owns both guards before `Job::Frames`; `frame_plans_validate_common_options` covers every encoder setting and all metadata modes, and the strict-safe and fallback metadata regressions require refusal before any output is created (`ci.yml`) | | Windows fallback waits for its program, preserves its full exit code and skips CoreAV copies and hard links on PATH | `fallback_cmd::run` owns inherited and replayed process completion; replay carries its spool owner until the child finishes, then drops handles and the spool before the full-code exit. `fallback_windows.rs` and `replayed_fallback_keeps_full_windows_exit_codes_and_cleans_its_spool` exercise native stand-ins, codes above 255, original stdin and cleanup in `ci.yml`'s existing `check-windows` tests. Stable `ExitCode` cannot carry a full Windows code | -| Current comparisons use the shared FFmpeg pin; the historical training extractor stays isolated | `scripts/oracle_pin.py --verify-bin` before oracle use, including cache hits; the local copy-test oracle helper consumes that verifier before comparisons and rejects a selected file different from the verified pair. `local_oracle_qualification_rejects_unverified_executables` covers wrong, malformed, failed and missing binaries. `--check` restricts historical-extractor references to the training job and its measurement directory (`deny.yml`). Types cannot establish an external executable's version | +| Current comparisons use the shared FFmpeg pin; the historical training extractor stays isolated | `test_oracle.require` owns non-frozen selection and cached success/failure through the unchanged platform verifier; the Rust adapter shares one `OnceLock` per test process. Owner/cache contracts, actual wrong-pin whole-suite failures and pinned passes cover missing, partial, renamed and unverified selections. Frozen consumers retain workflow verification; their immutable closure prevents deleting the old verifier API. `oracle_pin.py --check` keeps historical-extractor references isolated. Types cannot establish an external executable's version | +| Relocated oracle consumers retain the shared owner, its unchanged pins and their local imports | `test_oracle.bundle` copies the transitive Python closure into its normal `scripts` layout with the common support files. The relocated-bundle regression qualifies a fresh process against the copied pin and checks imported helper bytes; remote runner tests cover the complete pair and unchanged launch contracts. A path alone cannot establish a copied file's identity | | Standalone audio parity executes the native command with global strict-safe mode, rather than allowing fallback to satisfy equality | `standalone_audio_probe_check.py` owns the command and strict-safe environment; its command-capture regression requires `--strict-safe` before `ffprobe`, and real generated default/JSON comparisons run in `ci.yml`. A mocked subprocess alone cannot prove the command parses | | The fallback name lists match the pinned FFmpeg listings and CoreAV's printed keys, not boolean match-return values | `scripts/fallback_names.py --check DIR` in `ci.yml`'s `check` job fails on drift and names the regeneration command; `test_boolean_match_values_are_not_printed_keys` rejects stereo and unit values without dropping boolean field names | | The unsupported ffprobe format diagnostic names every accepted forced format | `unsupported_format_message_lists_accepted_formats` in `ffprobe::args::tests` checks acceptance and diagnostic coverage together. Rust types cannot prove a user-facing sentence lists the accepted names | diff --git a/docs/design/local-oracle-qualification.md b/docs/design/local-oracle-qualification.md index d746d3324..69bea62f9 100644 --- a/docs/design/local-oracle-qualification.md +++ b/docs/design/local-oracle-qualification.md @@ -15,3 +15,11 @@ Test a valid pair, a wrong version, a malformed or failed version command, a mis ## Scope This is oracle qualification only. It does not change runtime fallback, native admission, generated media, command registrations, comparison tolerances or measured coverage. The registered frozen harness and Python driver retain workflow-level verification because their dependency closure is immutable. FROZEN, JUDGING, their registered hashes and all their source files remain unchanged. No media corpus or performance round is needed. + +## Implemented boundaries + +Real callers use the common owner before fixture generation or comparison. Literal-only generated fixtures and mocked subprocess tests stay oracle-free; optional fixture and non-FFmpeg backend selection remains separate from oracle availability. The Linux CI job provisions its pair before any real backend test, and Python discovery provisions it before real fixture consumers. Registered macOS arm64 tests provision the existing macOS pair; other platform selections name and exclude their real oracle-dependent tests explicitly instead of treating a missing executable as a passing comparison. + +The owner retains both success and failure for the process, rejects a changed selection and delegates all version predicates to the existing platform verifier. The Rust adapter retains that result once per test binary. Remote source bundles retain the normal repository-relative `scripts` layout, both pin files, the common owner and its transitive local imports. Their binary selection and comparison arguments do not change. Bundle checks run with synthetic banner-only programs; no remote media or performance run is required. + +Registered measurement drivers remain exceptions: B4's `b4_round10.TOOL_FILES`, VP9's `CAPTURE_SCRIPTS`, audio-decode's `JUDGING_INPUTS`, and the registered H.264 PGO diagnostic and acquisition sources keep their existing pin, provenance and workflow verification. Their code and registered source rosters are unchanged. Adding an owner dependency to those drivers would change a registered source closure. diff --git a/scripts/aac_agreement.py b/scripts/aac_agreement.py index 0119b9152..056b6ac03 100755 --- a/scripts/aac_agreement.py +++ b/scripts/aac_agreement.py @@ -27,6 +27,7 @@ ROOT = pathlib.Path(__file__).resolve().parent.parent sys.path.insert(0, str(ROOT / 'scripts')) +import test_oracle from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT # noqa: E402 SECONDS = 10 @@ -314,6 +315,7 @@ def main(): j.add_argument('--work', type=pathlib.Path, required=True) j.add_argument('--out', type=pathlib.Path, required=True) a = parser.parse_args() + test_oracle.require(a.ffmpeg, getattr(a, "ffprobe", None)) return prepare(a) if a.command == 'prepare' else judge(a) diff --git a/scripts/aac_pcm_eligibility.py b/scripts/aac_pcm_eligibility.py index 3dc31328f..39df6b6f3 100644 --- a/scripts/aac_pcm_eligibility.py +++ b/scripts/aac_pcm_eligibility.py @@ -13,7 +13,8 @@ sys.path.insert(0, str(Path(__file__).resolve().parent)) from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT -from oracle_pin import load, verify_bin +from oracle_pin import load +from test_oracle import verify_bin def run(args, *, env=None): diff --git a/scripts/audio_copy_check.py b/scripts/audio_copy_check.py index 0a07fc2d9..dee322bbf 100755 --- a/scripts/audio_copy_check.py +++ b/scripts/audio_copy_check.py @@ -42,6 +42,7 @@ from fractions import Fraction sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) +import test_oracle from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT # noqa: E402 @@ -265,6 +266,7 @@ def main(): parser.add_argument("--work", required=True, type=pathlib.Path) parser.add_argument("--report", type=pathlib.Path) tools = parser.parse_args() + test_oracle.require(tools.ffmpeg, tools.ffprobe) sources, out = tools.work / "sources", tools.work / "outputs" shutil.rmtree(tools.work, ignore_errors=True) sources.mkdir(parents=True) diff --git a/scripts/audio_source_diagnostic.py b/scripts/audio_source_diagnostic.py index c6312fef8..e64d5edc1 100644 --- a/scripts/audio_source_diagnostic.py +++ b/scripts/audio_source_diagnostic.py @@ -13,6 +13,7 @@ HERE = Path(__file__).resolve().parent sys.path.insert(0, str(HERE)) from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT +import test_oracle def run(command, *, data=None, env=None): @@ -167,7 +168,7 @@ def main(): report = {'diagnostic_only': True, 'completed': False, 'results': []} report_path = args.out / 'report.json' try: - run([sys.executable, '-I', HERE / 'oracle_pin.py', '--verify-bin', args.ffmpeg.parent]) + test_oracle.require(args.ffmpeg) manifest = (args.fixtures / 'MANIFEST').read_text().splitlines() if 'generated browser.webm' not in manifest: raise ValueError('browser fixture is not registered as generated') diff --git a/scripts/avi_fixture_check.py b/scripts/avi_fixture_check.py index 884535abc..2810c92b3 100644 --- a/scripts/avi_fixture_check.py +++ b/scripts/avi_fixture_check.py @@ -12,6 +12,7 @@ sys.path.insert(0, str(ROOT / 'tools/compat-corpus')) import decoded_output import oracle_pin +import test_oracle from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT @@ -86,7 +87,7 @@ def main(): parser.add_argument('--' + name, type=Path, required=True) opts = parser.parse_args() opts.coreav, opts.ffmpeg, opts.ffprobe = (p.resolve() for p in (opts.coreav, opts.ffmpeg, opts.ffprobe)) - problems = list(oracle_pin.verify_bin(opts.ffmpeg.parent)) + problems = list(test_oracle.verify_bin(opts.ffmpeg.parent)) if problems: raise RuntimeError('\n'.join(problems)) opts.work.mkdir(parents=True, exist_ok=True) diff --git a/scripts/avi_v2_check.py b/scripts/avi_v2_check.py index 13a23f8e4..5aa421204 100644 --- a/scripts/avi_v2_check.py +++ b/scripts/avi_v2_check.py @@ -11,6 +11,7 @@ sys.path[:0] = [str(ROOT / 'tools/compat-corpus'), str(ROOT / 'scripts')] import encode_breadth as v2 import oracle_pin +import test_oracle def digest(path): @@ -24,7 +25,7 @@ def main(): opts = parser.parse_args() for name in ('coreav', 'ffmpeg', 'ffprobe', 'x264', 'fixtures', 'work'): setattr(opts, name, getattr(opts, name).resolve()) - problems = list(oracle_pin.verify_bin(opts.ffmpeg.parent)) + problems = list(test_oracle.verify_bin(opts.ffmpeg.parent)) if problems: raise RuntimeError('\n'.join(problems)) assert opts.ffprobe.parent == opts.ffmpeg.parent diff --git a/scripts/bench_guard.py b/scripts/bench_guard.py index c2aef7a45..9cf791fc4 100755 --- a/scripts/bench_guard.py +++ b/scripts/bench_guard.py @@ -66,6 +66,8 @@ import time ROOT = pathlib.Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT / 'scripts')) +import test_oracle POLICY = ROOT / "docs/schema/policy-examples/web-upload.json" # name: (fixture, command arguments with {} for the fixture's path, @@ -314,9 +316,7 @@ def required_refusal(coreav, command): command = [command[0], "-y", *command[1:]] environment = {k: v for k, v in os.environ.items() if k not in {"COREAV_STRICT_SAFE", "COREAV_FALLBACK_ACTIVE"}} - pin = shutil.which("ffmpeg") - if pin is None: - return "pinned ffmpeg missing" + pin = str(test_oracle.require().ffmpeg) output = pathlib.Path(command[-1]) reference = output.with_name("reference.mp4") sentinel = b"preserve existing destination" @@ -396,7 +396,7 @@ def derive(fixtures, work): whose source is missing or that ffmpeg cannot write is left out.""" for name, (source, form, how) in DERIVED.items(): if (fixtures / source).is_file(): - subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", str(fixtures / source), *how, + subprocess.run([str(test_oracle.require().ffmpeg), "-v", "error", "-y", "-i", str(fixtures / source), *how, "-fflags", "+bitexact", "-f", form, str(work / name)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=120, check=False) @@ -425,7 +425,7 @@ def generate(work): errors = {} for name, encode in GENERATED.items(): try: - done = subprocess.run(["ffmpeg", "-nostdin", "-v", "error", "-y", *encode, str(work / name)], + done = subprocess.run([str(test_oracle.require().ffmpeg), "-nostdin", "-v", "error", "-y", *encode, str(work / name)], stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, text=True, timeout=600, check=False) except subprocess.TimeoutExpired: diff --git a/scripts/codec_coverage_gcp.py b/scripts/codec_coverage_gcp.py index 5f6d41a04..a1e43b7f3 100755 --- a/scripts/codec_coverage_gcp.py +++ b/scripts/codec_coverage_gcp.py @@ -49,6 +49,8 @@ HERE = pathlib.Path(__file__).resolve().parent ROOT = HERE.parent +sys.path.insert(0, str(HERE)) +import test_oracle MACHINE = 'c4-standard-16' USD_PER_HOUR = 1.20 # an upper bound on the on-demand price of c4-standard-16 and its disk CAP_USD = 10.0 # the per-task spend limit @@ -61,7 +63,8 @@ UPLOADED = ['scripts/codec_coverage_gcp.py', 'scripts/thumbnail_oracle.py', 'tools/compat-corpus/decode_breadth.py', 'tools/compat-corpus/decode_reasons.json', 'tools/compat-corpus/round_files.py', - 'tools/compat-corpus/release_round.py', 'tools/stage3-report/r2pool.py'] + 'tools/compat-corpus/release_round.py', 'tools/stage3-report/r2pool.py'] \ + + ['scripts/' + name for name in test_oracle.SUPPORT] def sha256(path): @@ -196,6 +199,7 @@ def check_binaries(bin_dir, manifest_): def build(args, up, pending): + test_oracle.bundle(up / 'repo', ['thumbnail_oracle.py']) for rel in UPLOADED: (up / 'repo' / rel).parent.mkdir(parents=True, exist_ok=True) shutil.copy2(ROOT / rel, up / 'repo' / rel) diff --git a/scripts/composed_audio_selftest.py b/scripts/composed_audio_selftest.py index e403bfaae..19e3ee67d 100644 --- a/scripts/composed_audio_selftest.py +++ b/scripts/composed_audio_selftest.py @@ -13,6 +13,7 @@ import composed_audio as composed from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT import transcode_check as checker +import test_oracle def main(): @@ -20,6 +21,8 @@ def main(): for name in ('coreav', 'ffmpeg', 'ffprobe', 'opus-compare', 'fixtures'): parser.add_argument('--' + name, required=True) args = parser.parse_args() + oracle = test_oracle.require(args.ffmpeg, args.ffprobe) + args.ffmpeg, args.ffprobe = str(oracle.ffmpeg), str(oracle.ffprobe) env = checker.child_env(args.ffmpeg) | {'COREAV_X264': 'none'} checker.ENV = env composed.check_policy() diff --git a/scripts/exact_skip_check.py b/scripts/exact_skip_check.py index 006e0cf63..5775bb636 100644 --- a/scripts/exact_skip_check.py +++ b/scripts/exact_skip_check.py @@ -23,6 +23,7 @@ import tempfile sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) +import test_oracle import thumbnail_oracle # noqa: E402 CODECS = ('h264', 'hevc') @@ -104,6 +105,7 @@ def main(): p.add_argument('--report', type=pathlib.Path) p.add_argument('files', nargs='*', type=pathlib.Path) a = p.parse_args() + test_oracle.require(a.ffmpeg, a.ffprobe) files = list(a.files) if a.fixtures: files += sorted(f for f in a.fixtures.iterdir() diff --git a/scripts/fallback_names.py b/scripts/fallback_names.py index 1614675bd..cde1fb3d0 100644 --- a/scripts/fallback_names.py +++ b/scripts/fallback_names.py @@ -29,6 +29,7 @@ ROOT = pathlib.Path(__file__).resolve().parent.parent sys.path.insert(0, str(ROOT / 'scripts')) import oracle_pin # noqa: E402 +import test_oracle OUT = ROOT / 'crates/coreav-cli/src/fallback/names.rs' SOURCE = ROOT / 'crates/coreav-cli/src/ffprobe' @@ -122,7 +123,7 @@ def rust_options(tool, name, found): def generate(bin_dir): - problems = list(oracle_pin.verify_bin(bin_dir)) + problems = list(test_oracle.verify_bin(bin_dir)) if problems: sys.exit('\n'.join(problems)) ffmpeg, ffprobe = bin_dir / 'ffmpeg', bin_dir / 'ffprobe' diff --git a/scripts/ffv1_check.py b/scripts/ffv1_check.py index 84a3a7817..171885cae 100644 --- a/scripts/ffv1_check.py +++ b/scripts/ffv1_check.py @@ -16,6 +16,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent)) import oracle_pin +import test_oracle MAX_BYTES = 64 * 1024 * 1024 MAX_CASES = 128 @@ -65,7 +66,7 @@ def verify_oracles(ffmpeg, ffprobe): ffmpeg, ffprobe = Path(ffmpeg).resolve(), Path(ffprobe).resolve() require(ffmpeg.name == 'ffmpeg' and ffprobe.name == 'ffprobe' and ffmpeg.parent == ffprobe.parent, 'supply ffmpeg and ffprobe from the same pinned installation') - problems = list(oracle_pin.verify_bin(ffmpeg.parent)) + problems = list(test_oracle.verify_bin(ffmpeg.parent)) require(not problems, '\n'.join(problems)) for executable in (ffmpeg, ffprobe): run([executable, '-version'], output_limit=65536) diff --git a/scripts/flac_output_check.py b/scripts/flac_output_check.py index 144e8d3a4..74fd6a06c 100644 --- a/scripts/flac_output_check.py +++ b/scripts/flac_output_check.py @@ -13,7 +13,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent)) from oracle_audio import INPUT_ARGS as AUDIO_INPUT -from oracle_pin import verify_bin +from test_oracle import verify_bin FIELDS = ("codec_name", "sample_fmt", "sample_rate", "channels", "channel_layout", diff --git a/scripts/flac_output_measure.py b/scripts/flac_output_measure.py index b7a909bf4..8df196ba2 100644 --- a/scripts/flac_output_measure.py +++ b/scripts/flac_output_measure.py @@ -17,7 +17,7 @@ from flac_output_check import make_source, probe, run from oracle_audio import INPUT_ARGS as AUDIO_INPUT -from oracle_pin import verify_bin +from test_oracle import verify_bin from speed import timed diff --git a/scripts/gen-v2-fixtures.py b/scripts/gen-v2-fixtures.py index 47eaa3d36..8dc75c3a9 100644 --- a/scripts/gen-v2-fixtures.py +++ b/scripts/gen-v2-fixtures.py @@ -11,6 +11,9 @@ import sys import tempfile +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import test_oracle + COMMAND_TIMEOUT = 180 PROBE_TIMEOUT = 30 @@ -175,6 +178,9 @@ def main(argv=None): parser.add_argument('--out', required=True, type=Path) parser.add_argument('--only', nargs='+', action='extend', choices=FILES) args = parser.parse_args(argv) + if any(RECIPES[name].length is None and RECIPES[name].text is None + for name in selection(args.only)): + test_oracle.require(args.ffmpeg, args.ffprobe) try: names = generate(args.ffmpeg, args.ffprobe, args.out, args.only) except (GenerationError, OSError) as error: diff --git a/scripts/h264_agreement.py b/scripts/h264_agreement.py index 6622de5e4..aca739184 100644 --- a/scripts/h264_agreement.py +++ b/scripts/h264_agreement.py @@ -22,6 +22,8 @@ import subprocess import sys import time +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import test_oracle def ffmpeg_frames(ffmpeg, stream, frames): @@ -70,6 +72,7 @@ def main(): ap.add_argument("--report") ap.add_argument("streams", nargs="+") args = ap.parse_args() + args.ffmpeg = str(test_oracle.require(args.ffmpeg).ffmpeg) results = [] agree = 0 diff --git a/scripts/h264_deblock_conformance.py b/scripts/h264_deblock_conformance.py index 614c8918e..3d8815498 100644 --- a/scripts/h264_deblock_conformance.py +++ b/scripts/h264_deblock_conformance.py @@ -67,7 +67,7 @@ def main(argv=None): try: if os.environ.get('GITHUB_ACTIONS') != 'true' or sys.platform != 'linux': raise ValueError('media conformance runs only in Linux Actions, not on developer machines') - problems = list(g1.oracle_pin.verify_bin(ffmpeg.parent)) + problems = list(g1.test_oracle.verify_bin(ffmpeg.parent)) if problems: raise ValueError('; '.join(problems)) report['tools'] = {name: {'sha256': g1.digest(path)} for name, path in diff --git a/scripts/h264_g1.py b/scripts/h264_g1.py index b31e9eb48..2a0d4673c 100644 --- a/scripts/h264_g1.py +++ b/scripts/h264_g1.py @@ -15,6 +15,7 @@ sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) from h264_g1_conformance import capture, compare, digest, require, same_planes, inspect_anchor import oracle_pin +import test_oracle QPS = (16, 22, 28, 34, 40) METRICS = ('ssimulacra2', 'xpsnr_y') @@ -373,7 +374,7 @@ def measure(args, manifest): require(str(pathlib.Path(tools['ffmpeg']).with_name('ffprobe')), tools['ffprobe'], 'paired pinned FFmpeg tools') for name, pin in manifest['tools'].items(): require(digest(tools[name]), pin['sha256'], f'{name} executable') - problems = list(oracle_pin.verify_bin(pathlib.Path(tools['ffmpeg']).parent)) + problems = list(test_oracle.verify_bin(pathlib.Path(tools['ffmpeg']).parent)) if problems: raise ValueError('; '.join(problems)) for clip in manifest['clips']: diff --git a/scripts/h264_g1_conformance.py b/scripts/h264_g1_conformance.py index 6eac0c6cb..b915adab8 100644 --- a/scripts/h264_g1_conformance.py +++ b/scripts/h264_g1_conformance.py @@ -11,6 +11,7 @@ sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) import oracle_pin +import test_oracle def digest(path): @@ -277,7 +278,7 @@ def main(): args.fixtures = args.fixtures.resolve() if os.environ.get('GITHUB_ACTIONS') != 'true' or sys.platform != 'linux': raise ValueError('media conformance runs only in Linux Actions, not on developer machines') - problems = list(oracle_pin.verify_bin(args.ffmpeg.parent)) + problems = list(test_oracle.verify_bin(args.ffmpeg.parent)) if problems: raise ValueError('; '.join(problems)) out = args.output.resolve() diff --git a/scripts/h264_modes_identity.py b/scripts/h264_modes_identity.py index eb43114f2..724efe54f 100644 --- a/scripts/h264_modes_identity.py +++ b/scripts/h264_modes_identity.py @@ -23,6 +23,8 @@ import subprocess import sys import time +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import test_oracle # (name, size, frames, extra filters, x264 parameters): CABAC and CAVLC, P and B slices, both direct modes, # explicit and implicit weighted prediction, 8x8 transforms, several slices a picture, a cropped height, and @@ -120,6 +122,7 @@ def main(): ap.add_argument("--report") args = ap.parse_args() if args.generate: + args.generate = str(test_oracle.require(args.generate).ffmpeg) generate(args.generate, args.streams) streams = sorted(f for f in os.listdir(args.streams) if f.endswith(".h264")) if not streams: diff --git a/scripts/h264_p_conformance.py b/scripts/h264_p_conformance.py index 6e189bcf3..73bd02de3 100644 --- a/scripts/h264_p_conformance.py +++ b/scripts/h264_p_conformance.py @@ -540,7 +540,7 @@ def verify_tools(driver, ffmpeg, jm, decoder): for _, path in paths: if not path.is_file() or not os.access(path, os.X_OK): raise ValueError('required executable missing or not executable') - problems = list(g1.oracle_pin.verify_bin(ffmpeg.parent)) + problems = list(g1.test_oracle.verify_bin(ffmpeg.parent)) if problems: raise ValueError('; '.join(problems)) pin = dict(line.split('=', 1) for line in (ROOT / 'scripts/jm-decoder.env').read_text().splitlines() if line) diff --git a/scripts/h264_parity.py b/scripts/h264_parity.py index def432f90..ce210a9fd 100644 --- a/scripts/h264_parity.py +++ b/scripts/h264_parity.py @@ -110,6 +110,10 @@ INCOMPLETE = 3 +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import test_oracle + class CommandFailed(Exception): """A command of a stream exited with an error: the stream has no time.""" @@ -388,6 +392,7 @@ def main(): help='frames of the gate stream (default 300)') ap.add_argument('streams', nargs='+') args = ap.parse_args() + test_oracle.require(args.ffmpeg) host = machine() print(f"machine: {host['cpu_model']} (family {host['cpu_family']}, model " f"{host['cpu_model_number']}, stepping {host['cpu_stepping']}), {host['cpu_mhz']} MHz, " diff --git a/scripts/h264_parity_gcp.py b/scripts/h264_parity_gcp.py index f37d4c69f..adfb3a120 100644 --- a/scripts/h264_parity_gcp.py +++ b/scripts/h264_parity_gcp.py @@ -53,6 +53,8 @@ import tempfile HERE = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, HERE) +import test_oracle FRAMES = {'sd': 1800, '720p': 900, '1080p': 300, '4k': 150} CLASSES = tuple(FRAMES) MACHINE = 'c4-standard-16' @@ -64,6 +66,9 @@ ref: one measurement (FFmpeg, taskset -c , -threads 1, median of 3, each reference stream) appended to out/gate-refs.json. check: a measurement compared with the median of the references, appended to out/gate-checks.log; exit 0 on PASS (all within 5%).""" import json, os, statistics, subprocess, sys, time +sys.path.insert(0, 'scripts') +import test_oracle +test_oracle.require('./ffmpeg', './ffprobe') R = json.load(open('refs/refs.json')) S, CORE = R['streams'], str(R['core']) def measure(): @@ -117,9 +122,9 @@ def measure(): def job_script_1t(args, calls, decoders): """The `job.sh` of the one-thread class: host facts, three references five minutes apart, then per class a gate check, the call, a gate check; a call whose after-check fails is run again (GATE_ATTEMPTS).""" - lines = ['set -u', 'mkdir -p out', 'chmod +x decode-* ffmpeg', + lines = ['set -u', 'mkdir -p out', 'chmod +x decode-* ffmpeg ffprobe', '{ lscpu; nproc; uname -a; echo "smt active: $(cat /sys/devices/system/cpu/smt/active 2>&1)";' - ' python3 --version; sha256sum decode-* ffmpeg h264_parity.py gate1t.py gate.h264 refs/* es/*; } > out/host.txt 2>&1', + ' python3 --version; sha256sum decode-* ffmpeg ffprobe scripts/* gate1t.py gate.h264 refs/* es/*; } > out/host.txt 2>&1', # perf for the frequency samples (Debian's package; its counters need perf_event_paranoid at most 2) '[ "${PERF_INSTALL:-1}" = 0 ] || { sudo apt-get -q update && sudo DEBIAN_FRONTEND=noninteractive apt-get -q -y install ' 'linux-perf && sudo sysctl -q kernel.perf_event_paranoid=1; } > out/perf-install.log 2>&1', @@ -140,7 +145,7 @@ def job_script_1t(args, calls, decoders): # a call does not start on a host that fails its gate (HOST-GATE.md) f' if [ $ok = 0 ]; then echo "{tag} attempt $attempt: the host failed its gate, no call" >> out/progress.txt; continue; fi', f' echo "{tag} attempt $attempt $(date -u +%T)" >> out/progress.txt', - f' python3 h264_parity.py {decoders} {flags} --report out/{tag}.json ' + f' python3 scripts/h264_parity.py {decoders} {flags} --report out/{tag}.json ' + ' '.join(shlex.quote(f) for f in files) + f' > out/{tag}.log 2>&1', f' echo "{tag} rc=$? $(date -u +%T)" >> out/progress.txt', f' ok=0; [ -f out/{tag}.json ] && python3 gate1t.py check "after {cls} #$attempt" && ok=1', @@ -161,8 +166,9 @@ def job_script(args, calls): return job_script_1t(args, calls, decoders) ref = ('python3 - "$1" <<\'PY\'\n' 'import argparse, json, sys\n' - 'sys.path.insert(0, ".")\n' + 'sys.path.insert(0, "scripts")\n' 'import h264_parity as h\n' + 'h.test_oracle.require("./ffmpeg", "./ffprobe")\n' 'ns = argparse.Namespace(ffmpeg="./ffmpeg", gate_stream="gate.h264", gate_frames=' f'{args.gate_frames}, gate_threads=8, gate_pin=None, prefix=[], min_seconds={args.min_seconds})\n' 'median, repeat = h.gate_sample(ns)\n' @@ -173,9 +179,9 @@ def job_script(args, calls): 'd[sys.argv[1]] = {"median": median, "repeat": repeat}\n' 'json.dump(d, open("out/ref.json", "w"), indent=1)\n' 'PY\n') - lines = ['set -u', 'mkdir -p out', 'chmod +x decode-* ffmpeg', + lines = ['set -u', 'mkdir -p out', 'chmod +x decode-* ffmpeg ffprobe', '{ lscpu; nproc; uname -a; echo "smt active: $(cat /sys/devices/system/cpu/smt/active 2>&1)";' - ' python3 --version; sha256sum decode-* ffmpeg h264_parity.py gate.h264 es/*; } > out/host.txt 2>&1', + ' python3 --version; sha256sum decode-* ffmpeg ffprobe scripts/* gate.h264 es/*; } > out/host.txt 2>&1', 'ref() {', ref.rstrip('\n'), '}', 'ref before'] for cls, files in calls: @@ -194,7 +200,7 @@ def job_script(args, calls): flags += f' --require-cpu {shlex.quote(args.cpu_match)}' tag = f't{args.threads}.{cls}' lines.append(f'echo "{tag} $(date -u +%T)" >> out/progress.txt') - lines.append(f'python3 h264_parity.py {decoders} {flags} --report out/{tag}.json ' + lines.append(f'python3 scripts/h264_parity.py {decoders} {flags} --report out/{tag}.json ' + ' '.join(shlex.quote(f) for f in files) + f' > out/{tag}.log 2>&1') lines.append(f'echo "{tag} rc=$?" >> out/progress.txt') lines += ['ref after', 'echo "end $(date -u +%T)" >> out/progress.txt'] @@ -469,8 +475,9 @@ def main(): for n, path in args.decoders: shutil.copy(path, os.path.join(up, f'decode-{n}')) shutil.copy(args.ffmpeg, os.path.join(up, 'ffmpeg')) + shutil.copy(os.path.join(os.path.dirname(os.path.abspath(args.ffmpeg)), 'ffprobe'), os.path.join(up, 'ffprobe')) shutil.copy(args.gate_stream, os.path.join(up, 'gate.h264')) - shutil.copy(os.path.join(HERE, 'h264_parity.py'), os.path.join(up, 'h264_parity.py')) + test_oracle.bundle(up, ['h264_parity.py']) if args.one_thread_class: os.makedirs(os.path.join(up, 'refs'), exist_ok=True) names = {} diff --git a/scripts/h264_parity_gcp_selftest.py b/scripts/h264_parity_gcp_selftest.py index abad72e29..ffc5bbef9 100644 --- a/scripts/h264_parity_gcp_selftest.py +++ b/scripts/h264_parity_gcp_selftest.py @@ -17,13 +17,20 @@ HERE = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, HERE) import h264_parity_gcp as gcp # noqa: E402 +import oracle_pin FAKE = '#!/bin/sh\nsleep 0.2\n' +def versioned(program, name='ffmpeg'): + build = oracle_pin.load()['BUILD'] + return program.replace('#!/bin/sh\n', f'#!/bin/sh\nif [ "$1" = "-version" ]; then echo "{name} version {build}"; exit 0; fi\n') + + def fake(path): with open(path, 'w') as f: - f.write(FAKE) + name = os.path.basename(path) + f.write(versioned(FAKE, 'ffprobe' if name == 'ffprobe' else 'ffmpeg') if name in ('ff', 'ffprobe') else FAKE) os.chmod(path, os.stat(path).st_mode | stat.S_IXUSR) @@ -38,6 +45,12 @@ def setUp(self): self.dec, self.ff, self.gate = (os.path.join(r, n) for n in ('dec', 'ff', 'gate.h264')) fake(self.dec) fake(self.ff) + fake(os.path.join(r, 'ffprobe')) + environment = mock.patch.dict(os.environ) + environment.start() + self.addCleanup(environment.stop) + os.environ.pop('COREAV_FFMPEG', None) + os.environ.pop('COREAV_FFPROBE', None) open(self.gate, 'w').close() self.up = os.path.join(r, 'up') self.out = os.path.join(r, 'out') @@ -313,7 +326,7 @@ def run_1t_job(self, ff_script=None): self.build_1t('--rounds', '2') if ff_script: with open(os.path.join(self.up, 'ffmpeg'), 'w') as f: - f.write(ff_script) + f.write(versioned(ff_script)) env = dict(os.environ, REF_SLEEP='1', CHECK_SLEEP='1', PERF_INSTALL='0') subprocess.run(['bash', 'job.sh'], cwd=self.up, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, env=env) diff --git a/scripts/h264_parity_selftest.py b/scripts/h264_parity_selftest.py index cda160475..1a4e2bce6 100644 --- a/scripts/h264_parity_selftest.py +++ b/scripts/h264_parity_selftest.py @@ -26,6 +26,7 @@ sys.path.insert(0, HERE) import h264_parity # noqa: E402 import h264_parity_gcp # noqa: E402 +import oracle_pin PARITY = os.path.join(HERE, 'h264_parity.py') FAKE = '''#!/bin/sh @@ -49,9 +50,17 @@ def fake(root, name): d = os.path.join(root, name) os.makedirs(d) - path = os.path.join(d, 'run') + path = os.path.join(d, 'ffmpeg' if name == 'ff' else 'run') + program = FAKE + if name == 'ff': + build = oracle_pin.load()['BUILD'] + program = FAKE.replace('#!/bin/sh\n', f'#!/bin/sh\nif [ "$1" = "-version" ]; then echo "ffmpeg version {build}"; exit 0; fi\n') + probe = os.path.join(d, 'ffprobe') + with open(probe, 'w') as f: + f.write(f'#!/bin/sh\necho "ffprobe version {build}"\n') + os.chmod(probe, 0o700) with open(path, 'w') as f: - f.write(FAKE) + f.write(program) os.chmod(path, os.stat(path).st_mode | stat.S_IXUSR) return d, path @@ -61,6 +70,9 @@ def setUp(self): self.tmp = tempfile.TemporaryDirectory() root = self.tmp.name self.ff_dir, self.ff = fake(root, 'ff') + environment = mock.patch.dict(os.environ, COREAV_FFPROBE=os.path.join(self.ff_dir, 'ffprobe')) + environment.start() + self.addCleanup(environment.stop) self.dec_dir, self.dec = fake(root, 'dec') self.streams = [] for n in ('a.sd.264', 'b.sd.264'): diff --git a/scripts/h264_speed.py b/scripts/h264_speed.py index decc83373..2435a0251 100644 --- a/scripts/h264_speed.py +++ b/scripts/h264_speed.py @@ -41,6 +41,8 @@ import subprocess import sys import time +sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) +import test_oracle RESAMPLES = 2_000 @@ -77,6 +79,7 @@ def main(): p.add_argument('--seed', type=int, default=20261021) p.add_argument('--report') args = p.parse_args() + args.ffmpeg = str(test_oracle.require(args.ffmpeg).ffmpeg) rows = [] for stream in args.streams: name = pathlib.Path(stream).name diff --git a/scripts/h264_synth.py b/scripts/h264_synth.py index 575de6461..4c2f72695 100755 --- a/scripts/h264_synth.py +++ b/scripts/h264_synth.py @@ -9,6 +9,9 @@ import json import os import subprocess +import sys +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import test_oracle FFMPEG = os.environ.get('FFMPEG_BIN', '/opt/coreav-oracle-bin/ffmpeg') @@ -56,6 +59,7 @@ def main(): ap.add_argument('--out', required=True, help='directory for the streams') ap.add_argument('--frames', type=int, default=300) args = ap.parse_args() + test_oracle.require(FFMPEG) os.makedirs(args.out, exist_ok=True) made = [] diff --git a/scripts/he_aac_agreement.py b/scripts/he_aac_agreement.py index 2cd1851e5..5858929c9 100755 --- a/scripts/he_aac_agreement.py +++ b/scripts/he_aac_agreement.py @@ -39,6 +39,7 @@ ROOT = pathlib.Path(__file__).resolve().parent.parent sys.path.insert(0, str(ROOT / 'scripts')) +import test_oracle from aac_agreement import source # noqa: E402 from decode_audio_check import wav_data # noqa: E402 from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT # noqa: E402 @@ -861,6 +862,8 @@ def main(): j.add_argument('--work', type=pathlib.Path, required=True) j.add_argument('--out', type=pathlib.Path, required=True) a = parser.parse_args() + if a.command != "encode": + test_oracle.require(a.ffmpeg, getattr(a, "ffprobe", None)) return {'sources': sources, 'encode': encode, 'select': select, 'prepare': prepare, 'judge': judge}[a.command](a) diff --git a/scripts/hevc_conformance.py b/scripts/hevc_conformance.py index 95dc592e6..3962866b9 100644 --- a/scripts/hevc_conformance.py +++ b/scripts/hevc_conformance.py @@ -25,6 +25,7 @@ ROOT = pathlib.Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT / 'scripts')) import oracle_pin +import test_oracle import hevc_oracle_input from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT @@ -1067,7 +1068,7 @@ def run(args): exclusions_sha = digest(ROOT / 'bench/hevc-conformance/known-exclusions.json') if exclusions else None require(all('archive_sha256' in c and 'extracted' in c for c in data['archives']), 'run requires the SHA-bound manifest produced by the manifest command') - require(not list(oracle_pin.verify_bin(args.oracle_bin)), 'pinned oracle binaries are required') + require(not list(test_oracle.verify_bin(args.oracle_bin)), 'pinned oracle binaries are required') oracle = {name: digest(args.oracle_bin / name) for name in ('ffmpeg', 'ffprobe')} oracle['pin_sha256'] = digest(ROOT / oracle_pin.PIN) acquisition = read_json(args.data / 'acquisition.json') @@ -1186,7 +1187,7 @@ def fetch_corpus(args, inspect=False): import round_files files = roster() if inspect: - require(not list(oracle_pin.verify_bin(args.oracle_bin)), 'pinned oracle binaries are required') + require(not list(test_oracle.verify_bin(args.oracle_bin)), 'pinned oracle binaries are required') pool = round_files.pool() from r2pool import Limits pool.limits = Limits(requests=4000, bytes_=32 << 30) @@ -1277,7 +1278,7 @@ def corpus_result(records): def corpus(args): - require(not list(oracle_pin.verify_bin(args.oracle_bin)), 'pinned oracle binaries are required') + require(not list(test_oracle.verify_bin(args.oracle_bin)), 'pinned oracle binaries are required') files = roster() records = [dict(item, status='not_run') for item in files] for index, item in enumerate(files): diff --git a/scripts/hevc_fixture.py b/scripts/hevc_fixture.py index f1dec5956..7728afdc7 100644 --- a/scripts/hevc_fixture.py +++ b/scripts/hevc_fixture.py @@ -16,6 +16,7 @@ import time sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) +import test_oracle import oracle_pin ROOT = pathlib.Path(__file__).resolve().parents[1] @@ -384,6 +385,7 @@ def main(): parser.add_argument('--output', required=True, type=pathlib.Path) parser.add_argument('--registration', type=pathlib.Path, default=REGISTRATION) args = parser.parse_args() + test_oracle.require(args.ffmpeg, args.ffprobe) expected = None if args.mode == 'verify': expected = json.loads(args.registration.read_text()) diff --git a/scripts/input_summary_check.py b/scripts/input_summary_check.py index f6dda37e4..e9bbabda4 100644 --- a/scripts/input_summary_check.py +++ b/scripts/input_summary_check.py @@ -22,6 +22,7 @@ import oracle_pin import oracle_pin_macos +import test_oracle import standalone_audio_probe_check as audio_probe import mkv_craft import stsd_craft @@ -55,9 +56,8 @@ def run(command, case, *, env=None): class Oracle: def __init__(self, directory): self.directory = Path(directory).resolve() - verifier = oracle_pin_macos if sys.platform == "darwin" else oracle_pin try: - problems = list(verifier.verify_bin(self.directory)) + problems = list(test_oracle.verify_bin(self.directory)) except (OSError, subprocess.SubprocessError, ValueError, SystemExit): raise CheckFailure("oracle-pin") from None if problems: diff --git a/scripts/input_summary_development.py b/scripts/input_summary_development.py index c61de5c49..719235c55 100644 --- a/scripts/input_summary_development.py +++ b/scripts/input_summary_development.py @@ -19,6 +19,7 @@ import round_files sys.path.insert(0, str(ROOT / 'scripts')) import oracle_pin +import test_oracle def select(manifests): @@ -163,7 +164,7 @@ def main(): selected = [] stage = 'preparation' try: - if list(oracle_pin.verify_bin(args.oracle_dir)): + if list(test_oracle.verify_bin(args.oracle_dir)): raise CaptureFailure('oracle-pin', 'verification', []) selected = select({name: round_files.manifest(name, None) for name in ('v1', 'v1-ts-audio')}) if not selected: diff --git a/scripts/opus_encode_check.py b/scripts/opus_encode_check.py index d7b3fa8b8..22bda9bf3 100755 --- a/scripts/opus_encode_check.py +++ b/scripts/opus_encode_check.py @@ -27,6 +27,7 @@ import time sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import test_oracle from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT # noqa: E402 DURATION = 10 @@ -194,6 +195,7 @@ def main(): parser.add_argument('--check-libopus', action='store_true', help='only check and print the libopus each binary links') args = parser.parse_args() + test_oracle.require(args.ffmpeg, args.ffprobe) if not args.check_libopus and None in (args.ffprobe, args.work, args.out): parser.error('--ffprobe, --work and --out are required to judge the bars') libopus = {'pinned': pinned_libopus(), 'coreav': linked_libopus(args.coreav), diff --git a/scripts/opus_matroska_padding.py b/scripts/opus_matroska_padding.py index e1dfc1635..c618b0a1b 100644 --- a/scripts/opus_matroska_padding.py +++ b/scripts/opus_matroska_padding.py @@ -12,7 +12,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent)) from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT -from oracle_pin import verify_bin +from test_oracle import verify_bin def run(args): diff --git a/scripts/opus_mp4_presentation.py b/scripts/opus_mp4_presentation.py index ca155a908..f4111106c 100644 --- a/scripts/opus_mp4_presentation.py +++ b/scripts/opus_mp4_presentation.py @@ -12,7 +12,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent)) from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT -from oracle_pin import verify_bin +from test_oracle import verify_bin def run(args): diff --git a/scripts/opus_pcm_eligibility.py b/scripts/opus_pcm_eligibility.py index 3dd3834f6..f7a008278 100644 --- a/scripts/opus_pcm_eligibility.py +++ b/scripts/opus_pcm_eligibility.py @@ -17,7 +17,7 @@ from opus_matroska_padding import matroska, run, wav_samples from opus_mp4_presentation import boxes, metadata from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT -from oracle_pin import verify_bin +from test_oracle import verify_bin def native(coreav, source, after, output='pipe:', threads=1, strict=True): diff --git a/scripts/oracle.py b/scripts/oracle.py index 4c9f3d1ce..069ed30f2 100755 --- a/scripts/oracle.py +++ b/scripts/oracle.py @@ -20,6 +20,9 @@ } +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import test_oracle + def integer(value): return None if value is None or value == "N/A" else int(value) @@ -231,6 +234,7 @@ def main(): candidate.add_argument("--candidate-exe", type=Path) candidate.add_argument("--candidate-dir", type=Path) args = parser.parse_args() + test_oracle.require(args.ffmpeg, args.ffprobe) if args.timeout <= 0: parser.error("--timeout must be positive") if args.command == "run" and not (args.candidate_exe or args.candidate_dir): diff --git a/scripts/oracle_free.py b/scripts/oracle_free.py new file mode 100644 index 000000000..9a870c3c6 --- /dev/null +++ b/scripts/oracle_free.py @@ -0,0 +1,32 @@ +"""Run the explicitly oracle-free selection on an unregistered platform.""" +import json +from pathlib import Path +import platform +import subprocess +import sys + + +ROOT = Path(__file__).resolve().parent.parent + + +def command(arguments): + if arguments[:2] != ['cargo', 'test']: + raise ValueError('oracle-free selection requires cargo test') + selected = json.loads((ROOT / 'test-support/oracle-dependent.json').read_text()) + filters = sorted({name for names in selected.values() for name in names}) + if not filters: + raise ValueError('oracle-dependent test selection is empty') + result = list(arguments) + if '--' not in result: + result.append('--') + result.append('--exact') + for name in filters: + result.extend(('--skip', name)) + return result + + +if __name__ == '__main__': + arguments = sys.argv[1:] + if sys.platform != 'darwin' or platform.machine() != 'arm64': + arguments = command(arguments) + sys.exit(subprocess.run(arguments, check=False).returncode) diff --git a/scripts/oracle_negative.py b/scripts/oracle_negative.py new file mode 100644 index 000000000..f105d35fa --- /dev/null +++ b/scripts/oracle_negative.py @@ -0,0 +1,57 @@ +"""Require a complete suite to reject the system FFmpeg 6.1.1 selection.""" +import argparse +import os +from pathlib import Path +import subprocess +import sys +import tempfile + + +def check(command, directory, log): + versions = [] + for name in ('ffmpeg', 'ffprobe'): + binary = directory / name + result = subprocess.run([str(binary), '-version'], capture_output=True, + text=True, check=True, timeout=10) + line = result.stdout.splitlines()[0] + if not line.startswith(f'{name} version 6.1.1'): + raise ValueError(f'negative control requires system {name} 6.1.1') + versions.append(line) + log.parent.mkdir(parents=True, exist_ok=True) + with tempfile.TemporaryDirectory(prefix='unverified-oracle-') as temporary: + selected = Path(temporary) + for name in ('ffmpeg', 'ffprobe'): + (selected / name).symlink_to(directory / name) + env = dict(os.environ, PATH=str(selected) + os.pathsep + os.environ.get('PATH', '')) + for name in ('COREAV_FFMPEG', 'COREAV_FFPROBE', 'COREAV_V2_FFMPEG', 'COREAV_V2_FFPROBE'): + env.pop(name, None) + with log.open('wb') as output: + result = subprocess.run(command, env=env, stdout=output, stderr=subprocess.STDOUT, + check=False) + diagnostic = log.read_text(errors='replace') + if result.returncode == 0 or 'stage=oracle_qualification' not in diagnostic: + raise ValueError('unverified suite did not fail at oracle qualification') + for line in versions: + print(line) + print(f'Negative suite exit {result.returncode}; oracle-qualification failures confirmed') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--system-dir', type=Path, default=Path('/usr/bin')) + parser.add_argument('--log', type=Path, required=True) + parser.add_argument('command', nargs=argparse.REMAINDER) + args = parser.parse_args() + command = args.command[1:] if args.command[:1] == ['--'] else args.command + if not command: + parser.error('a suite command is required') + try: + check(command, args.system_dir.resolve(), args.log) + except (OSError, ValueError, subprocess.SubprocessError) as error: + print(f'oracle-negative: {error}', file=sys.stderr) + return 1 + return 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/scripts/pcm_output_check.py b/scripts/pcm_output_check.py index d3b322456..114a5398f 100644 --- a/scripts/pcm_output_check.py +++ b/scripts/pcm_output_check.py @@ -12,7 +12,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent)) from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT -from oracle_pin import verify_bin +from test_oracle import verify_bin FIELDS = ( diff --git a/scripts/policy_check.py b/scripts/policy_check.py index 29780e8c7..827fcf709 100644 --- a/scripts/policy_check.py +++ b/scripts/policy_check.py @@ -55,6 +55,7 @@ sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) import policy_ref # noqa: E402 +import test_oracle TIMEOUT = 10 MEMORY = 1 << 30 @@ -330,6 +331,8 @@ def main(): help='decode every frame with ffprobe for the oracle sizes (small files)') parser.add_argument('--report', type=pathlib.Path) args = parser.parse_args() + if args.ffprobe: + args.ffprobe = str(test_oracle.require(pathlib.Path(args.ffprobe).with_name('ffmpeg'), args.ffprobe).ffprobe) if args.media: files = sorted(p for p in args.media.iterdir() if p.is_file() and p.name not in ('MANIFEST', 'manifest.json')) diff --git a/scripts/raw_audio_pipe_check.py b/scripts/raw_audio_pipe_check.py index fa24702a0..f9f5854c0 100644 --- a/scripts/raw_audio_pipe_check.py +++ b/scripts/raw_audio_pipe_check.py @@ -503,10 +503,7 @@ def main(): parser.add_argument("--oracle-bin", type=Path, required=True) parser.add_argument("--smoke", action="store_true") args = parser.parse_args() - if sys.platform == "darwin": - from oracle_pin_macos import verify_bin - else: - from oracle_pin import verify_bin + from test_oracle import verify_bin problems = list(verify_bin(args.oracle_bin)) if problems: raise SystemExit("\n".join(problems)) diff --git a/scripts/raw_pcm_check.py b/scripts/raw_pcm_check.py index a980fbaaa..577ebe30e 100644 --- a/scripts/raw_pcm_check.py +++ b/scripts/raw_pcm_check.py @@ -11,7 +11,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent)) from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT -from oracle_pin import verify_bin +from test_oracle import verify_bin from pcm_output_check import fields, native_command, run from swr_characterize import RATES, pcm, signal diff --git a/scripts/seek_check.py b/scripts/seek_check.py index 51dae1d44..955648ebd 100644 --- a/scripts/seek_check.py +++ b/scripts/seek_check.py @@ -18,6 +18,8 @@ import shutil import subprocess import sys +sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) +import test_oracle EXTS = ('mp4', 'mov', 'm4v', '3gp') @@ -86,6 +88,7 @@ def main(): p.add_argument('--report') p.add_argument('files', nargs='*') a = p.parse_args() + a.ffprobe = str(test_oracle.require(pathlib.Path(a.ffprobe).with_name('ffmpeg'), a.ffprobe).ffprobe) paths = [pathlib.Path(f) for f in a.files] if a.fixtures: paths += sorted(q for q in pathlib.Path(a.fixtures).iterdir() if q.suffix.lstrip('.').lower() in EXTS) diff --git a/scripts/standalone_audio_probe_check.py b/scripts/standalone_audio_probe_check.py index 3469704c6..0d8f591e0 100644 --- a/scripts/standalone_audio_probe_check.py +++ b/scripts/standalone_audio_probe_check.py @@ -5,7 +5,6 @@ import json import os from pathlib import Path -import platform import struct import subprocess import sys @@ -13,6 +12,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent)) from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT +import test_oracle TIMEOUT = 30 @@ -276,11 +276,9 @@ def main(argv=None): args = parser.parse_args(argv) coreav, oracle = args.coreav.resolve(), args.oracle_dir.resolve() try: - system = platform.system() - if system not in ("Darwin", "Linux"): - raise CheckFailure("oracle verification supports Darwin and Linux only") - verifier = Path(__file__).with_name("oracle_pin_macos.py" if system == "Darwin" else "oracle_pin.py") - run([sys.executable, verifier, "--verify-bin", oracle]) + problems = list(test_oracle.verify_bin(oracle)) + if problems: + raise CheckFailure('; '.join(problems)) if args.directory: directory = args.directory.resolve() directory.mkdir(parents=True, exist_ok=True) diff --git a/scripts/stsd_craft.py b/scripts/stsd_craft.py index 351349c11..b6576a17d 100755 --- a/scripts/stsd_craft.py +++ b/scripts/stsd_craft.py @@ -26,6 +26,8 @@ import subprocess import sys import tempfile +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import test_oracle def boxes(data, start, end): @@ -188,6 +190,7 @@ def craft(output, paths): def fixture(ffmpeg, directory): + ffmpeg = str(test_oracle.require(ffmpeg).ffmpeg) video = os.path.join(directory, FIXTURE + '.mp4') with tempfile.TemporaryDirectory() as work: sources = [] diff --git a/scripts/swr_characterize.py b/scripts/swr_characterize.py index e060cd6a1..f19342091 100644 --- a/scripts/swr_characterize.py +++ b/scripts/swr_characterize.py @@ -10,7 +10,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent)) from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT -from oracle_pin import verify_bin +from test_oracle import verify_bin RATES = [(44100, 48000), (44100, 22050), (44100, 16000), (48000, 44100), (48000, 22050), (48000, 16000), diff --git a/scripts/test_oracle.py b/scripts/test_oracle.py new file mode 100644 index 000000000..37ab3d2ef --- /dev/null +++ b/scripts/test_oracle.py @@ -0,0 +1,137 @@ +"""Resolve and qualify the immutable oracle selection of one test process.""" +import argparse +import ast +from dataclasses import dataclass +import os +from pathlib import Path +import shutil +import subprocess +import sys +import threading + +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +import oracle_pin +import oracle_pin_macos + + +@dataclass(frozen=True) +class Oracle: + ffmpeg: Path + ffprobe: Path + + +class QualificationError(RuntimeError): + pass + + +_lock = threading.Lock() +_selection = None +_result = None +SUPPORT = ('test_oracle.py', 'oracle_pin.py', 'oracle_pin_macos.py', + 'oracle-ffmpeg.env', 'oracle-ffmpeg-macos.env', 'oracle-audio-args.txt') + + +def bundle(root, entries): + source = Path(__file__).resolve().parent + target = Path(root) / 'scripts' + target.mkdir(parents=True, exist_ok=True) + pending = [*entries, *(name for name in SUPPORT if name.endswith('.py'))] + copied = set() + while pending: + name = pending.pop() + if name in copied: + continue + copied.add(name) + path = source / name + shutil.copyfile(path, target / name) + for node in ast.walk(ast.parse(path.read_text())): + modules = [item.name for item in node.names] if isinstance(node, ast.Import) else \ + [node.module] if isinstance(node, ast.ImportFrom) and node.level == 0 else [] + for module in modules: + dependency = module.split('.')[0] + '.py' + if (source / dependency).is_file(): + pending.append(dependency) + for name in SUPPORT: + if not name.endswith('.py'): + shutil.copyfile(source / name, target / name) + if 'composed_audio.py' in copied: + for relative in ('docs/design/composed-opus-aac-v2.json', 'docs/design/audio-decode.md', + 'crates/coreav-audio/src/convert.rs', 'scripts/composed_audio_fixtures.py'): + destination = Path(root) / relative + destination.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(source.parent / relative, destination) + + +def _path(value): + value = os.fspath(value) + if Path(value).name == value: + value = shutil.which(value) or value + return Path(value).absolute() + + +def require(ffmpeg=None, ffprobe=None): + global _selection, _result + selected = ffmpeg if ffmpeg is not None else os.environ.get('COREAV_FFMPEG') + if selected is None: + selected = shutil.which('ffmpeg') or '/opt/coreav-oracle-bin/ffmpeg' + selected = _path(selected) + probe = ffprobe if ffprobe is not None else os.environ.get('COREAV_FFPROBE') + probe = _path(probe) if probe is not None else selected.with_name('ffprobe') + requested = (selected.resolve(), probe.resolve()) + with _lock: + if _result is not None: + if requested != _selection: + raise QualificationError('stage=oracle_qualification: selection changed within process') + if isinstance(_result, QualificationError): + raise _result + return _result + _selection = requested + try: + directory = selected.parent.resolve() + if requested != ((directory / 'ffmpeg').resolve(), (directory / 'ffprobe').resolve()): + raise QualificationError('selected executables differ from the installed oracle pair') + if sys.platform not in ('linux', 'darwin'): + raise QualificationError('no registered oracle for this platform') + verifier = oracle_pin_macos if sys.platform == 'darwin' else oracle_pin + problems = tuple(verifier.verify_bin(directory)) + if problems: + raise QualificationError('; '.join(problems)) + if any('\n' in str(path) or '\r' in str(path) for path in requested): + raise QualificationError('oracle paths contain a line separator') + _result = Oracle(*requested) + except (OSError, ValueError, RuntimeError, subprocess.SubprocessError, SystemExit) as error: + _result = QualificationError(f'stage=oracle_qualification: {error}') + if isinstance(_result, QualificationError): + raise _result + return _result + + +def verify_bin(directory, root=oracle_pin.ROOT): + try: + if Path(root).resolve() != oracle_pin.ROOT: + raise QualificationError('stage=oracle_qualification: alternate pin root') + require(Path(directory) / 'ffmpeg', Path(directory) / 'ffprobe') + except QualificationError as error: + return (str(error),) + return () + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--resolve', action='store_true', required=True) + parser.add_argument('--ffmpeg') + parser.add_argument('--ffprobe') + args = parser.parse_args() + try: + oracle = require(args.ffmpeg, args.ffprobe) + except QualificationError as error: + print(error, file=sys.stderr) + return 1 + print(oracle.ffmpeg) + print(oracle.ffprobe) + return 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/scripts/tests/test_audio_source_diagnostic.py b/scripts/tests/test_audio_source_diagnostic.py index 3f2ac979b..3c172b0ba 100644 --- a/scripts/tests/test_audio_source_diagnostic.py +++ b/scripts/tests/test_audio_source_diagnostic.py @@ -48,7 +48,8 @@ def failing_run(command, **kwargs): argv = ['audio_source_diagnostic.py', '--coreav', str(root / 'coreav'), '--ffmpeg', str(root / 'ffmpeg'), '--fixtures', str(root), '--out', str(output)] - with mock.patch.object(sys, 'argv', argv), mock.patch.object(diagnostic, 'run', failing_run): + with mock.patch.object(sys, 'argv', argv), mock.patch.object(diagnostic, 'run', failing_run), \ + mock.patch.object(diagnostic.test_oracle, 'require'): with self.assertRaises((RuntimeError, FileNotFoundError)): diagnostic.main() report = diagnostic.json.loads((output / 'report.json').read_text()) diff --git a/scripts/tests/test_bar_sources.py b/scripts/tests/test_bar_sources.py index 770ffb539..35b110228 100644 --- a/scripts/tests/test_bar_sources.py +++ b/scripts/tests/test_bar_sources.py @@ -1,8 +1,8 @@ """The pinned FFmpeg makes every source of the Opus bars' set (scripts/opus_encode_check.py; docs/design/transcode.md, "Opus bars"), which the AAC bars share, at one second each, so a source its filter -parser refuses fails here and not in a judged run. Needs COREAV_FFMPEG, -which ci.yml's check job sets to the pinned FFmpeg; skipped without it. +parser refuses fails here and not in a judged run. The shared oracle +owner requires the pinned pair before any source is generated. COREAV_FFMPEG=FFMPEG python3 -I -m unittest discover -s scripts/tests -p 'test_bar_sources.py' """ @@ -15,13 +15,12 @@ ROOT = pathlib.Path(__file__).resolve().parents[2] sys.path.insert(0, str(ROOT / 'scripts')) import opus_encode_check # noqa: E402 +import test_oracle class Sources(unittest.TestCase): def test_the_pinned_ffmpeg_makes_every_source(self): - ffmpeg = os.environ.get('COREAV_FFMPEG') - if not ffmpeg: - self.skipTest('COREAV_FFMPEG is not set') + ffmpeg = test_oracle.require().ffmpeg with tempfile.TemporaryDirectory() as work: paths = opus_encode_check.make_sources(ffmpeg, work, duration=1) self.assertEqual(sorted(paths), [s[0] for s in opus_encode_check.SOURCES]) diff --git a/scripts/tests/test_bench_guard.py b/scripts/tests/test_bench_guard.py index a0f94ecfe..467caabaf 100644 --- a/scripts/tests/test_bench_guard.py +++ b/scripts/tests/test_bench_guard.py @@ -96,7 +96,7 @@ def run(argv, **kwargs): output.write_bytes(b"wrong" if fault == "bytes" else b"exact pinned output") return SimpleNamespace(returncode=1 if fault == "status" else 0, stdout=b"") - with patch.object(bench_guard.shutil, "which", return_value="/pin/ffmpeg"), \ + with patch.object(bench_guard.test_oracle, "require", return_value=SimpleNamespace(ffmpeg=pathlib.Path('/pin/ffmpeg'))), \ patch.object(bench_guard.subprocess, "run", side_effect=run): error = bench_guard.required_refusal("coreav", command) if fault is None: diff --git a/scripts/tests/test_fallback_names.py b/scripts/tests/test_fallback_names.py index 3960c06cb..6ee1d8fde 100644 --- a/scripts/tests/test_fallback_names.py +++ b/scripts/tests/test_fallback_names.py @@ -24,7 +24,7 @@ def setUp(self): self.directory = self.root / 'oracle bin' for attribute, value in [('ROOT', self.root), ('OUT', self.out), ('SOURCE', self.source)]: self.enterContext(patch.object(names, attribute, value)) - self.verify = self.enterContext(patch.object(names.oracle_pin, 'verify_bin', return_value=[])) + self.verify = self.enterContext(patch.object(names.test_oracle, 'verify_bin', return_value=[])) self.listing = self.enterContext(patch.object(names, 'run', side_effect=self.listings)) vocabulary = SimpleNamespace(FFMPEG_VALUE=set(), FFMPEG_CODEC=set(), FFMPEG_FLAG=set(), FFPROBE_VALUE=set(), FFPROBE_FLAG=set()) diff --git a/scripts/tests/test_ffv1_check.py b/scripts/tests/test_ffv1_check.py index 15ce5b864..6547dabc8 100644 --- a/scripts/tests/test_ffv1_check.py +++ b/scripts/tests/test_ffv1_check.py @@ -140,6 +140,9 @@ def setUp(self): self.temporary = tempfile.TemporaryDirectory() self.addCleanup(self.temporary.cleanup) self.root = Path(self.temporary.name) + verifier = patch.object(gate.test_oracle, 'verify_bin', side_effect=gate.oracle_pin.verify_bin) + verifier.start() + self.addCleanup(verifier.stop) def executable(self, name, body): path = self.root / name diff --git a/scripts/tests/test_gcp_vm_job.py b/scripts/tests/test_gcp_vm_job.py index 2473e7d3c..300b02957 100644 --- a/scripts/tests/test_gcp_vm_job.py +++ b/scripts/tests/test_gcp_vm_job.py @@ -278,7 +278,7 @@ def test_a_run_writes_what_collect_needs(self): es = self.r / 'es' es.mkdir() (es / 'a.0.sd.h264').touch() - for n in ('dec', 'ff', 'gate.h264'): + for n in ('dec', 'ff', 'ffprobe', 'gate.h264'): (self.r / n).touch() status, cmds = self.main('--out', str(self.out), '--es-dir', str(es), '--decoder', f'base={self.r / "dec"}', '--ffmpeg', str(self.r / 'ff'), '--gate-stream', str(self.r / 'gate.h264'), diff --git a/scripts/tests/test_gen_v2_fixtures.py b/scripts/tests/test_gen_v2_fixtures.py index 892c96cc6..ca1afe431 100644 --- a/scripts/tests/test_gen_v2_fixtures.py +++ b/scripts/tests/test_gen_v2_fixtures.py @@ -14,6 +14,7 @@ from unittest.mock import patch +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) SCRIPT = Path(__file__).resolve().parents[1] / 'gen-v2-fixtures.py' SPEC = importlib.util.spec_from_file_location('gen_v2_fixtures', SCRIPT) generator = importlib.util.module_from_spec(SPEC) @@ -160,7 +161,8 @@ def test_failed_generation_preserves_existing_outputs_and_cleans_staging(self): target = out / 'v2_still_rgba.png' target.write_bytes(b'previous complete fixture') stdout, stderr = io.StringIO(), io.StringIO() - with patch.object(generator.subprocess, 'run', side_effect=subprocess.TimeoutExpired( + with patch.object(generator.test_oracle, 'require'), \ + patch.object(generator.subprocess, 'run', side_effect=subprocess.TimeoutExpired( 'ffmpeg', 180, stderr=b'partial encoder diagnostic')): with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr): status = generator.main([ @@ -190,11 +192,11 @@ def child(command, **settings): self.assertEqual(list(Path(temporary).iterdir()), []) -@unittest.skipUnless(os.environ.get('COREAV_V2_FFMPEG') and os.environ.get('COREAV_V2_FFPROBE'), - 'optional short smoke requires caller-verified oracle paths') class OracleSmoke(unittest.TestCase): def test_stills_and_multitrack_match_the_recipe_and_repeat_bytes(self): - ffmpeg, ffprobe = os.environ['COREAV_V2_FFMPEG'], os.environ['COREAV_V2_FFPROBE'] + import test_oracle + oracle = test_oracle.require(os.environ.get('COREAV_V2_FFMPEG'), os.environ.get('COREAV_V2_FFPROBE')) + ffmpeg, ffprobe = oracle.ffmpeg, oracle.ffprobe names = ('v2_still_rgba.png', 'v2_still_rgb.jpg', 'v2_multi_audio_eng.mp4', 'v2_still_rgba%03d.png') hashes = [] diff --git a/scripts/tests/test_h264_deblock.py b/scripts/tests/test_h264_deblock.py index fbd1b4268..8933f26ae 100644 --- a/scripts/tests/test_h264_deblock.py +++ b/scripts/tests/test_h264_deblock.py @@ -119,7 +119,7 @@ def setUp(self): self.platform = patch.object(deblock.sys, 'platform', 'linux') self.platform.start() self.addCleanup(self.platform.stop) - self.pin = patch.object(g1.oracle_pin, 'verify_bin', return_value=[]) + self.pin = patch.object(g1.test_oracle, 'verify_bin', return_value=[]) self.pin.start() self.addCleanup(self.pin.stop) @@ -193,7 +193,7 @@ def interrupted(*args, **kwargs): self.assertEqual(len(self.report()['cells']), 2) def test_pin_and_provenance_failures_retain_incomplete_report(self): - with patch.object(g1.oracle_pin, 'verify_bin', return_value=['wrong oracle']): + with patch.object(g1.test_oracle, 'verify_bin', return_value=['wrong oracle']): with self.assertRaisesRegex(ValueError, 'wrong oracle'): deblock.main(self.argv) self.assertFalse(self.report()['complete']) diff --git a/scripts/tests/test_h264_p.py b/scripts/tests/test_h264_p.py index 65f09f14c..63c98c399 100644 --- a/scripts/tests/test_h264_p.py +++ b/scripts/tests/test_h264_p.py @@ -721,7 +721,7 @@ def test_real_missing_tools_and_jm_receipt_hash_binding(self): receipt += "BUILD_COMMAND=make -C JM/ldecod -j2 CC='cc -fcommon'\nsynthetic compiler\n" receipt += f'{p.g1.digest(paths[3])} {paths[3]}\n' (self.root / 'jm-build.txt').write_text(receipt) - with patch.object(p.g1.oracle_pin, 'verify_bin', return_value=[]): + with patch.object(p.g1.test_oracle, 'verify_bin', return_value=[]): tools = p.verify_tools(paths[0], paths[1], paths[3], paths[4]) self.assertEqual(set(tools['executables']), {'driver', 'ffmpeg', 'ffprobe', 'jm', 'decoder'}) paths[3].write_bytes(b'changed') @@ -730,7 +730,7 @@ def test_real_missing_tools_and_jm_receipt_hash_binding(self): (self.root / 'jm-build.txt').write_text(receipt.replace('JM_VERSION=', 'WRONG=')) with self.assertRaisesRegex(ValueError, 'receipt'): p.verify_tools(paths[0], paths[1], paths[3], paths[4]) - with patch.object(p.g1.oracle_pin, 'verify_bin', return_value=['wrong FFmpeg pin']): + with patch.object(p.g1.test_oracle, 'verify_bin', return_value=['wrong FFmpeg pin']): with self.assertRaisesRegex(ValueError, 'wrong FFmpeg pin'): p.verify_tools(paths[0], paths[1], paths[3], paths[4]) diff --git a/scripts/tests/test_hevc_conformance.py b/scripts/tests/test_hevc_conformance.py index 96258d374..49fb3ebfa 100644 --- a/scripts/tests/test_hevc_conformance.py +++ b/scripts/tests/test_hevc_conformance.py @@ -745,7 +745,7 @@ def test_run_confirms_the_published_hash_before_comparing_or_crediting_a_count(s with mock.patch.object(runner, 'registration', return_value=data), \ mock.patch.object(runner, 'read_json', side_effect=[acquisition, inventory]), \ mock.patch.object(runner, 'digest', return_value='f' * 64), \ - mock.patch.object(runner.oracle_pin, 'verify_bin', return_value=[]), \ + mock.patch.object(runner.test_oracle, 'verify_bin', return_value=[]), \ mock.patch.object(runner, 'child', return_value=(0, self.root / 'native', None)), \ mock.patch.object(runner, 'native_rows', return_value=fixture[2:5]), \ mock.patch.object(runner, 'probe', side_effect=[fixture[5], dict(frames=fixture[6])]), \ @@ -903,7 +903,7 @@ def inspect(item, path, out, oracle_bin): manifests=manifests) with mock.patch.dict(sys.modules, {'round_files': round_files, 'r2pool': limits}), \ mock.patch.object(runner, 'roster', return_value=files), \ - mock.patch.object(runner.oracle_pin, 'verify_bin', return_value=[]), \ + mock.patch.object(runner.test_oracle, 'verify_bin', return_value=[]), \ mock.patch.object(runner, 'corpus_record', side_effect=inspect): runner.fetch_corpus(args, inspect=True) self.assertEqual(list(dest.iterdir()), [keep]) diff --git a/scripts/tests/test_hevc_exclusions.py b/scripts/tests/test_hevc_exclusions.py index 608598f30..9ddaf8aa6 100644 --- a/scripts/tests/test_hevc_exclusions.py +++ b/scripts/tests/test_hevc_exclusions.py @@ -118,7 +118,7 @@ def identity(path): mock.patch.object(harness, 'known_exclusions', return_value=exclusions), \ mock.patch.object(harness, 'read_json', side_effect=[acquisition, inventory]), \ mock.patch.object(harness, 'digest', side_effect=identity), \ - mock.patch.object(harness.oracle_pin, 'verify_bin', return_value=[]), \ + mock.patch.object(harness.test_oracle, 'verify_bin', return_value=[]), \ mock.patch.object(harness, 'child', return_value=(0, root / 'native', None)) as child, \ mock.patch.object(harness, 'native_rows', return_value=(dict(complete=True), [], [])), \ mock.patch.object(harness, 'probe') as probe, \ diff --git a/scripts/tests/test_hevc_fixture.py b/scripts/tests/test_hevc_fixture.py index cd68a23ea..a125add72 100644 --- a/scripts/tests/test_hevc_fixture.py +++ b/scripts/tests/test_hevc_fixture.py @@ -152,6 +152,7 @@ def test_changed_registered_digest_or_recipe_fails_verification(self): args = ['hevc_fixture.py', 'verify', '--ffmpeg', '/ffmpeg', '--ffprobe', '/ffprobe', '--output', directory, '--registration', str(registration)] with mock.patch.object(sys, 'argv', args), \ + mock.patch.object(runner.test_oracle, 'require'), \ mock.patch.object(runner, 'binary_identity', return_value=expected['oracle']), \ mock.patch.object(runner, 'prepare', return_value=expected), \ self.assertRaisesRegex(ValueError, 'expected hashes differ'): @@ -162,6 +163,7 @@ def test_registered_binary_mismatch_stops_before_generation(self): args = ['hevc_fixture.py', 'verify', '--ffmpeg', '/ffmpeg', '--ffprobe', '/ffprobe', '--output', directory] with mock.patch.object(sys, 'argv', args), \ + mock.patch.object(runner.test_oracle, 'require'), \ mock.patch.object(runner, 'binary_identity', return_value={}), \ mock.patch.object(runner, 'prepare') as prepare, \ self.assertRaisesRegex(ValueError, 'oracle identity differs'): diff --git a/scripts/tests/test_input_summary_check.py b/scripts/tests/test_input_summary_check.py index ed9e4a6fd..619687766 100644 --- a/scripts/tests/test_input_summary_check.py +++ b/scripts/tests/test_input_summary_check.py @@ -152,12 +152,12 @@ def test_refusal_requires_exit_four_empty_stdout_and_no_partial_input(self): class Commands(unittest.TestCase): def oracle(self): - with patch.object(check.oracle_pin_macos, "verify_bin", return_value=[]), \ - patch.object(check.oracle_pin, "verify_bin", return_value=[]): + with patch.object(check.test_oracle, "verify_bin", return_value=[]), \ + patch.object(check.test_oracle, "verify_bin", return_value=[]): return check.Oracle(Path("oracle")) def test_platform_pin_is_verified_on_construction(self): - for platform, module in (("darwin", check.oracle_pin_macos), ("linux", check.oracle_pin)): + for platform, module in (("darwin", check.test_oracle), ("linux", check.test_oracle)): with self.subTest(platform=platform), patch.object(check.sys, "platform", platform), \ patch.object(module, "verify_bin", return_value=[]) as verify: oracle = check.Oracle(Path("oracle")) @@ -169,7 +169,7 @@ def test_pin_failure_stops_before_generation_and_hides_verifier_content(self): options = {"side_effect": failure} if isinstance(failure, BaseException) else {"return_value": failure} output = io.StringIO() with self.subTest(failure=failure), patch.object(check.sys, "platform", "darwin"), \ - patch.object(check.oracle_pin_macos, "verify_bin", **options), \ + patch.object(check.test_oracle, "verify_bin", **options), \ patch.object(check, "generate_fixtures") as generate, \ contextlib.redirect_stderr(output): self.assertEqual(check.main(["--coreav", "coreav", "--oracle-dir", "oracle", diff --git a/scripts/tests/test_input_summary_development.py b/scripts/tests/test_input_summary_development.py index 47af833d5..cbc24c930 100644 --- a/scripts/tests/test_input_summary_development.py +++ b/scripts/tests/test_input_summary_development.py @@ -48,7 +48,7 @@ def encrypt(command, **options): return subprocess.CompletedProcess(command, 0, b'', b'') stdout, stderr = io.StringIO(), io.StringIO() with patch.object(CHECK.sys, 'argv', arguments), patch.object(CHECK.sys, 'platform', 'linux'), \ - patch.object(CHECK.oracle_pin, 'verify_bin', return_value=diagnostics), \ + patch.object(CHECK.test_oracle, 'verify_bin', return_value=diagnostics), \ patch.object(CHECK.round_files, 'manifest', side_effect=manifests), \ patch.object(CHECK.round_files, 'pool') as pool, \ patch.object(CHECK.subprocess, 'run', side_effect=encrypt), \ @@ -118,7 +118,7 @@ def encrypt(command, **options): return subprocess.CompletedProcess(command, 0, b'', b'') stdout, stderr = io.StringIO(), io.StringIO() with patch.object(CHECK.sys, 'argv', arguments), patch.object(CHECK.sys, 'platform', 'linux'), \ - patch.object(CHECK.oracle_pin, 'verify_bin', return_value=[]), \ + patch.object(CHECK.test_oracle, 'verify_bin', return_value=[]), \ patch.object(CHECK.round_files, 'manifest', side_effect=[rows or [row()], []]), \ patch.object(CHECK.round_files, 'pool', return_value=MagicMock()), \ patch.object(CHECK.round_files, 'fetch_one', side_effect=fetch), \ @@ -231,7 +231,7 @@ def encrypt(command, **options): stdout, stderr = io.StringIO(), io.StringIO() fault = subprocess.TimeoutExpired([marker], 30, output=marker.encode(), stderr=marker.encode()) with patch.object(CHECK.sys, 'argv', arguments), patch.object(CHECK.sys, 'platform', 'linux'), \ - patch.object(CHECK.oracle_pin, 'verify_bin', return_value=[]), \ + patch.object(CHECK.test_oracle, 'verify_bin', return_value=[]), \ patch.object(CHECK.round_files, 'manifest', side_effect=[[row()], []]), \ patch.object(CHECK.round_files, 'pool', return_value=MagicMock()), \ patch.object(CHECK.round_files, 'fetch_one', side_effect=fault), \ @@ -267,7 +267,7 @@ def fail_encryption(command, **options): stdout, stderr = io.StringIO(), io.StringIO() with patch.object(CHECK.sys, 'argv', arguments), patch.object(CHECK.sys, 'platform', 'linux'), \ - patch.object(CHECK.oracle_pin, 'verify_bin', return_value=[]), \ + patch.object(CHECK.test_oracle, 'verify_bin', return_value=[]), \ patch.object(CHECK.round_files, 'manifest', side_effect=[[row()], []]), \ patch.object(CHECK.round_files, 'pool', return_value=MagicMock()), \ patch.object(CHECK.round_files, 'fetch_one', return_value=root / 'not-opened.mp4'), \ diff --git a/scripts/tests/test_oracle_audio.py b/scripts/tests/test_oracle_audio.py index 0b40388d3..2c4b48729 100644 --- a/scripts/tests/test_oracle_audio.py +++ b/scripts/tests/test_oracle_audio.py @@ -147,10 +147,10 @@ def test_shell_and_rust_read_the_shared_file_before_input(self): rust = (ROOT / 'crates/coreav-cli/tests/decode_audio.rs').read_text() self.assertIn('.args(include_str!("../../../' + oracle_audio.ARG_FILE + '").split_whitespace())\n .arg("-i")', rust) - @unittest.skipUnless(os.environ.get('COREAV_FIXTURES') and os.environ.get('COREAV_FFMPEG'), - 'needs existing fixtures and the pinned FFmpeg') + @unittest.skipUnless(os.environ.get('COREAV_FIXTURES'), 'needs existing fixtures') def test_clipped_lossless_fixtures_decode_the_source_samples(self): - ffmpeg = os.environ['COREAV_FFMPEG'] + import test_oracle + ffmpeg = test_oracle.require().ffmpeg self.addCleanup(clip_check.clear_cache) extract_run = extract_check.run with tempfile.TemporaryDirectory() as tmp, patch.object(clip_check, 'THREADS', ['-threads', '8']): diff --git a/scripts/tests/test_oracle_free.py b/scripts/tests/test_oracle_free.py new file mode 100644 index 000000000..5e4c84da2 --- /dev/null +++ b/scripts/tests/test_oracle_free.py @@ -0,0 +1,34 @@ +import json +from pathlib import Path +import re +import sys +import unittest + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT / 'scripts')) +import oracle_free + + +class ExplicitSelection(unittest.TestCase): + def test_roster_names_only_real_tests_not_helpers(self): + roster = json.loads((ROOT / 'test-support/oracle-dependent.json').read_text()) + for file, names in roster.items(): + source = (ROOT / file).read_text() + tests = set(re.findall(r'#\[test\](?:\s*#\[[^\]]+\])*\s*fn\s+(\w+)', source)) + if file.endswith('/sandboxed.rs'): + tests = {'real encoders through the launcher'} + for name in names: + self.assertIn(name.rsplit('::', 1)[-1], tests, (file, name)) + + def test_filter_is_explicit_and_exact_without_excluding_mock_helpers(self): + args = oracle_free.command(['cargo', 'test', '--workspace']) + self.assertIn('--exact', args) + self.assertNotIn('ffmpeg', args) + self.assertIn('convert::oracle::sample_conversion_is_exact_against_the_pinned_oracle', args) + self.assertIn('--skip', args) + with self.assertRaises(ValueError): + oracle_free.command(['cargo', 'check']) + + +if __name__ == '__main__': + unittest.main() diff --git a/scripts/tests/test_standalone_audio_probe_check.py b/scripts/tests/test_standalone_audio_probe_check.py index 9c7d72577..29b180339 100644 --- a/scripts/tests/test_standalone_audio_probe_check.py +++ b/scripts/tests/test_standalone_audio_probe_check.py @@ -202,14 +202,12 @@ def test_command_failure_and_timeout_have_bounded_diagnostics(self): check.run(["program"]) def test_pin_failure_prevents_fixture_generation(self): - with patch.object(check.platform, "system", return_value="Darwin"), \ - patch.object(check, "run", side_effect=check.CheckFailure("bad pin")) as verify, \ + with patch.object(check.test_oracle, "verify_bin", return_value=("bad pin",)) as verify, \ patch.object(check, "generate") as generate, contextlib.redirect_stderr(io.StringIO()) as stderr: result = check.main(["--coreav", "coreav", "--oracle-dir", "oracle", "--directory", str(self.root)]) self.assertEqual(result, 1) self.assertIn("bad pin", stderr.getvalue()) - self.assertEqual(Path(verify.call_args.args[0][1]).name, "oracle_pin_macos.py") - self.assertIn("--verify-bin", verify.call_args.args[0]) + verify.assert_called_once_with(Path("oracle").resolve()) generate.assert_not_called() diff --git a/scripts/tests/test_test_oracle.py b/scripts/tests/test_test_oracle.py new file mode 100644 index 000000000..93b4fd90c --- /dev/null +++ b/scripts/tests/test_test_oracle.py @@ -0,0 +1,201 @@ +"""Oracle-free Linux owner/cache contracts using banner-only stand-ins.""" +import os +from pathlib import Path +import subprocess +import sys +import tempfile +import unittest + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT / 'scripts')) +import oracle_pin +import test_oracle + + +@unittest.skipUnless(sys.platform == 'linux', 'Linux banner-only stand-in contracts') +class Qualification(unittest.TestCase): + def setUp(self): + directory = tempfile.TemporaryDirectory() + self.addCleanup(directory.cleanup) + self.root = Path(directory.name) + self.log = self.root / 'calls' + self.build = oracle_pin.load()['BUILD'] + self.pair(self.root) + + def pair(self, directory, *, version=None): + directory.mkdir(exist_ok=True) + for name in ('ffmpeg', 'ffprobe'): + path = directory / name + path.write_text('#!/bin/sh\n' + + f'printf "%s\\n" {name} >> "{self.log}"\n' + + f'printf "%s\\n" "{name} version {version or self.build}"\n') + path.chmod(0o700) + + def child(self, code, *, directory=None): + directory = directory or self.root + env = dict(os.environ, COREAV_FFMPEG=str(directory / 'ffmpeg'), + COREAV_FFPROBE=str(directory / 'ffprobe')) + prelude = 'import sys; sys.path.insert(0, sys.argv[1]); import test_oracle as owner\n' + result = subprocess.run([sys.executable, '-I', '-c', prelude + code, + str(ROOT / 'scripts'), str(self.root)], + env=env, capture_output=True, text=True, timeout=30) + self.assertEqual(result.returncode, 0, result.stderr) + return result.stdout + + def test_concurrent_and_repeated_success_verifies_each_program_once(self): + self.child('from concurrent.futures import ThreadPoolExecutor\n' + 'with ThreadPoolExecutor(8) as pool:\n' + ' found = list(pool.map(lambda _: owner.require(), range(20)))\n' + 'assert all(item is found[0] for item in found)\n' + 'assert owner.require() is found[0]\n') + self.assertCountEqual(self.log.read_text().splitlines(), ['ffmpeg', 'ffprobe']) + + def test_failed_selection_stays_failed_after_repair_until_a_fresh_process(self): + self.pair(self.root, version='0.0.0') + self.child('from pathlib import Path\n' + 'for attempt in range(2):\n' + ' try:\n' + ' owner.require()\n' + ' except owner.QualificationError:\n' + ' pass\n' + ' else:\n' + ' raise AssertionError("unverified oracle accepted")\n' + ' if attempt == 0:\n' + f' build = {self.build!r}\n' + ' for name in ("ffmpeg", "ffprobe"):\n' + ' (Path(sys.argv[2]) / name).write_text("#!/bin/sh\\necho \'" + name + " version " + build + "\'\\n")\n') + self.assertEqual(len(self.log.read_text().splitlines()), 2) + self.child('owner.require()\n') + + def test_second_selection_is_rejected_without_running_it(self): + other = self.root / 'other' + self.pair(other) + self.child('owner.require()\n' + 'from pathlib import Path\n' + 'try:\n' + ' owner.require(Path(sys.argv[2]) / "other/ffmpeg")\n' + 'except owner.QualificationError as error:\n' + ' assert "selection changed" in str(error)\n' + 'else:\n' + ' raise AssertionError("second selection accepted")\n') + self.assertEqual(len(self.log.read_text().splitlines()), 2) + + def test_missing_siblings_and_malformed_or_failed_versions_fail(self): + for name in ('ffmpeg', 'ffprobe'): + with self.subTest(missing=name): + self.pair(self.root) + (self.root / name).unlink() + self.child('try:\n owner.require()\n' + 'except owner.QualificationError:\n pass\n' + 'else:\n raise AssertionError("missing oracle accepted")\n') + for body in ('echo malformed', 'exit 1'): + with self.subTest(body=body): + self.pair(self.root) + (self.root / 'ffmpeg').write_text('#!/bin/sh\n' + body + '\n') + self.child('try:\n owner.require()\n' + 'except owner.QualificationError:\n pass\n' + 'else:\n raise AssertionError("invalid oracle accepted")\n') + + def test_verifier_failure_is_cached(self): + self.child('from unittest.mock import patch\n' + 'import subprocess\n' + 'with patch.object(owner.oracle_pin, "verify_bin", side_effect=subprocess.TimeoutExpired("oracle", 10)) as verify:\n' + ' for _ in range(2):\n' + ' try:\n owner.require()\n' + ' except owner.QualificationError:\n pass\n' + ' else:\n raise AssertionError("timeout accepted")\n' + ' assert verify.call_count == 1\n') + self.assertFalse(self.log.exists()) + + def test_symlink_only_selection_does_not_borrow_its_targets_sibling(self): + selected = self.root / 'selected' + selected.mkdir() + (selected / 'ffmpeg').symlink_to(self.root / 'ffmpeg') + self.child('import os\n' + 'os.environ.pop("COREAV_FFPROBE", None)\n' + 'try:\n owner.require()\n' + 'except owner.QualificationError:\n pass\n' + 'else:\n raise AssertionError("incomplete selected installation accepted")\n', + directory=selected) + + def test_macos_delegates_once_to_the_existing_platform_verifier(self): + self.child('from unittest.mock import patch\n' + 'from pathlib import Path\n' + 'with patch.object(owner.sys, "platform", "darwin"), \\\n' + ' patch.object(owner.oracle_pin, "verify_bin", side_effect=AssertionError("Linux verifier used")), \\\n' + ' patch.object(owner.oracle_pin_macos, "verify_bin", return_value=("bad pin",)) as verify:\n' + ' for _ in range(2):\n' + ' try:\n owner.require()\n' + ' except owner.QualificationError:\n pass\n' + ' else:\n raise AssertionError("bad macOS pin accepted")\n' + ' verify.assert_called_once_with(Path(sys.argv[2]))\n') + + def test_relocated_bundle_keeps_the_same_pin_and_complete_import_closure(self): + root = self.root / 'bundle' + test_oracle.bundle(root, ['transcode_speed.py', 'vp9_speed.py', 'h264_parity.py', 'ts_speed.py']) + copied = root / 'scripts' + for name in ('oracle_pin.py', 'oracle_pin_macos.py', 'test_oracle.py', 'oracle_audio.py', + 'oracle-audio-args.txt', 'composed_audio.py', 'composed_audio_source.py'): + self.assertEqual((copied / name).read_bytes(), (ROOT / 'scripts' / name).read_bytes()) + self.assertFalse((copied / 'hevc_intra.py').exists()) + for name in ('transcode_speed.py', 'vp9_speed.py', 'h264_parity.py', 'ts_speed.py'): + help_result = subprocess.run([sys.executable, '-I', str(copied / name), '--help'], + capture_output=True, text=True, timeout=30) + self.assertEqual(help_result.returncode, 0, help_result.stderr) + result = subprocess.run([sys.executable, '-I', str(copied / 'test_oracle.py'), '--resolve', + '--ffmpeg', str(self.root / 'ffmpeg'), + '--ffprobe', str(self.root / 'ffprobe')], + capture_output=True, text=True, timeout=30) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.stdout.splitlines(), + [str(self.root / 'ffmpeg'), str(self.root / 'ffprobe')]) + + def test_active_entry_points_reject_before_creating_fixture_or_report_output(self): + self.pair(self.root, version='0.0.0') + ffmpeg, ffprobe = str(self.root / 'ffmpeg'), str(self.root / 'ffprobe') + output = str(self.root / 'uncreated') + commands = ( + ('scripts/h264_agreement.py', '--ffmpeg', ffmpeg, 'missing.h264'), + ('scripts/h264_modes_identity.py', '--streams', 'missing', '--generate', ffmpeg), + ('scripts/h264_speed.py', '--ffmpeg', ffmpeg, 'missing.h264'), + ('scripts/h264_synth.py', '--source', 'missing', '--out', output), + ('scripts/seek_check.py', '--decode-oracle', 'missing', '--ffprobe', ffprobe, + '--report', output, 'missing.mp4'), + ('scripts/ts_speed.py', '--coreav', 'missing', '--null', 'missing', '--lav', 'missing', + '--coreav-cli', 'missing', '--ffprobe', ffprobe, '--report', output, 'missing.ts'), + ('scripts/composed_audio_selftest.py', '--coreav', 'missing', '--ffmpeg', ffmpeg, + '--ffprobe', ffprobe, '--opus-compare', 'missing', '--fixtures', 'missing'), + ('scripts/standalone_audio_probe_check.py', '--coreav', 'missing', '--oracle-dir', + str(self.root), '--directory', output), + ('scripts/stsd_craft.py', '--fixture', ffmpeg, output), + ('scripts/policy_check.py', '--coreav', 'missing', '--policy', 'missing', + '--media', 'missing', '--ffprobe', ffprobe), + ('scripts/text_check.py', '--coreav', 'missing', '--media', 'missing', + '--ffmpeg', ffmpeg, '--ffprobe', ffprobe), + ('scripts/vp9_corpus.py', 'run', '--files', 'missing', '--native', 'missing', + '--ffmpeg', ffmpeg, '--ffprobe', ffprobe, '--private', output, '--summary', output), + ('tools/hostile/generate.py', output, 'missing', ffmpeg, '--parts', 'pixelsmash'), + ('tools/stage3-report/run.py', '--work', output, '--steps', 'fixtures'), + ('tools/mediarecorder/generate.py', '--out', output), + ('tools/compat-corpus/frames.py', '--coreav', 'missing', '--ffprobe', ffprobe, + '--media', 'missing'), + ('tools/mkv-adapter/bench.py', '--media', 'missing', '--out', output), + ('tools/mkv-adapter/corpus.py', 'run', '--work', 'missing', '--out', output), + ('tools/mkv-adapter/remux_corpus.py', 'run', '--work', 'missing', '--out', output), + ('bench/range-audio/gaps.py', 'missing', output), + ('bench/range-audio/run.py', 'missing', output), + ('bench/npx/run.py', 'missing', output), + ) + env = dict(os.environ, COREAV_FFMPEG=ffmpeg, COREAV_FFPROBE=ffprobe, + FFMPEG_BIN=ffmpeg, PATH=str(self.root) + os.pathsep + os.environ.get('PATH', '')) + for script, *arguments in commands: + with self.subTest(script=script): + result = subprocess.run([sys.executable, '-I', str(ROOT / script), *arguments], + env=env, capture_output=True, text=True, timeout=30) + self.assertNotEqual(result.returncode, 0) + self.assertIn('stage=oracle_qualification', result.stderr) + self.assertFalse(Path(output).exists()) + + +if __name__ == '__main__': + unittest.main() diff --git a/scripts/tests/test_v2_fixture_inputs.py b/scripts/tests/test_v2_fixture_inputs.py index 4d905cbcc..7d47f9a03 100644 --- a/scripts/tests/test_v2_fixture_inputs.py +++ b/scripts/tests/test_v2_fixture_inputs.py @@ -20,6 +20,7 @@ import v2_fixture_check as check import avi_v2_check as avi import oracle_pin_macos +import test_oracle class Registration(unittest.TestCase): @@ -173,8 +174,8 @@ def test_an_unexpected_reference_failure_still_fails_the_cli_and_keeps_its_repor '--work', str(root / 'work'), '--report', str(report), '--only', '17'] stderr = io.StringIO() with mock.patch.object(sys, 'argv', argv), \ - mock.patch.object(check.oracle_pin, 'verify_bin', return_value=[]), \ - mock.patch.object(oracle_pin_macos, 'verify_bin', return_value=[]), \ + mock.patch.object(check.test_oracle, 'verify_bin', return_value=[]), \ + mock.patch.object(test_oracle, 'verify_bin', return_value=[]), \ mock.patch.object(check, 'verify', return_value=result), \ contextlib.redirect_stderr(stderr): self.assertEqual(check.main(), 1) diff --git a/scripts/tests/test_wasm_thumbnail_fixtures.py b/scripts/tests/test_wasm_thumbnail_fixtures.py index 350064146..70af0afd4 100644 --- a/scripts/tests/test_wasm_thumbnail_fixtures.py +++ b/scripts/tests/test_wasm_thumbnail_fixtures.py @@ -27,7 +27,7 @@ def test_generation_keeps_the_failed_command_stage_and_private_cause(self): cause = ValueError("private-marker") with mock.patch.object(FIXTURES.sys, "platform", "linux"), \ mock.patch.object(FIXTURES, "hostile_rows", return_value=[]), \ - mock.patch.object(FIXTURES.oracle_pin, "verify_bin", return_value=[]), \ + mock.patch.object(FIXTURES.test_oracle, "verify_bin", return_value=[]), \ mock.patch.object(FIXTURES.oracle_pin, "load", return_value={"X264_COMMIT": "1234567"}), \ mock.patch.object(FIXTURES, "commands", return_value=[{"kind": "inspect-sps", "argv": ["tool"]}]), \ mock.patch.object(FIXTURES, "execute", side_effect=[b"x264 1234567", cause]): diff --git a/scripts/text_check.py b/scripts/text_check.py index e65404899..5e12da922 100644 --- a/scripts/text_check.py +++ b/scripts/text_check.py @@ -54,6 +54,7 @@ sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) import clip_check as cc # noqa: E402 import track_boxes # noqa: E402 +import test_oracle IN_SCOPE = (".mp4", ".mov", ".m4a", ".m4b", ".m4v", ".3gp", ".3g2") TIMEOUT = 600 @@ -1125,6 +1126,8 @@ def main(): "(the fixture run; a corpus directory holds no source for them)") parser.add_argument("--report") args = parser.parse_args() + oracle = test_oracle.require(args.ffmpeg, args.ffprobe) + args.ffmpeg, args.ffprobe = str(oracle.ffmpeg), str(oracle.ffprobe) entries = known_divergences() strict = strict_files(args.kd_overlay) diff --git a/scripts/thumbnail_oracle.py b/scripts/thumbnail_oracle.py index 7d4f3ae16..ec8dfa547 100644 --- a/scripts/thumbnail_oracle.py +++ b/scripts/thumbnail_oracle.py @@ -55,6 +55,10 @@ BACKEND_CODECS = {'dav1d': ('av1',), 'libvpx': ('vp9', 'vp8')} +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import test_oracle + def default_video(path, ffprobe='ffprobe'): """The index of the video stream FFmpeg (and CoreAV) use by default: the highest resolution, the first on a tie; attached pictures left out.""" @@ -437,6 +441,7 @@ def main(): p.add_argument('--report') p.add_argument('files', nargs='*') a = p.parse_args() + test_oracle.require(a.ffmpeg, a.ffprobe) if a.fixtures: return fixtures(a) for f in a.files: diff --git a/scripts/transcode_check.py b/scripts/transcode_check.py index 628cb5278..ffeca782e 100644 --- a/scripts/transcode_check.py +++ b/scripts/transcode_check.py @@ -144,6 +144,7 @@ class gets no verdict. The exit status is 1 when an arm misses a bar, a class or HERE = pathlib.Path(__file__).resolve().parent sys.path.insert(0, str(HERE)) +import test_oracle from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT import composed_audio @@ -1911,6 +1912,7 @@ def main(): p.error('--coreav and at least one --arm are required') if not args.ffmpeg or not args.ffprobe: p.error('ffmpeg and ffprobe are required (--ffmpeg, --ffprobe)') + test_oracle.require(args.ffmpeg, args.ffprobe) global ENV ENV = child_env(args.ffmpeg) if identity is not None: diff --git a/scripts/transcode_decoder_host.py b/scripts/transcode_decoder_host.py index 1f88023c9..b54345261 100644 --- a/scripts/transcode_decoder_host.py +++ b/scripts/transcode_decoder_host.py @@ -25,6 +25,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent)) import oracle_pin +import test_oracle from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT import transcode_check as tc import transcode_speed as speed @@ -347,7 +348,7 @@ def run(args): build_receipt = json.loads(Path(args.build).read_text()) require(build_receipt['commit'] == commit and build_receipt['command'] == BUILD and build_receipt['coreav_sha256'] == digest(coreav), 'build receipt does not match source and executable') - require(not list(oracle_pin.verify_bin(tools)), 'oracle pin verification failed') + require(not list(test_oracle.verify_bin(tools)), 'oracle pin verification failed') registered = roster() report.update(inputs=registered, inputs_sha256=digest(INPUTS), build=build_receipt, host=host(tmp, json.loads(Path(args.instance).read_text())), @@ -402,7 +403,7 @@ def run(args): def smoke(args): tools = Path(args.tools).resolve() - require(not list(oracle_pin.verify_bin(tools)), 'oracle pin verification failed') + require(not list(test_oracle.verify_bin(tools)), 'oracle pin verification failed') tmp = Path(args.tmp).resolve() tmp.mkdir(parents=True, exist_ok=False) executor = Executor(300) diff --git a/scripts/transcode_speed.py b/scripts/transcode_speed.py index 391d5af1d..4cf6aeb6d 100644 --- a/scripts/transcode_speed.py +++ b/scripts/transcode_speed.py @@ -60,6 +60,7 @@ HERE = pathlib.Path(__file__).resolve().parent sys.path.insert(0, str(HERE)) +import test_oracle import transcode_check as tc # noqa: E402 SALT = 'coreav-transcode-speed-v1:' @@ -448,6 +449,7 @@ def main(): rep = summarize(args.out, sel, args.classes) print(table(rep)) return status(rep) + test_oracle.require(args.ffmpeg, args.ffprobe) args.arms = tc.parse_arms(args.arm, p) for need in ('selection', 'files', 'coreav', 'gate', 'out'): if not getattr(args, need): diff --git a/scripts/transcode_speed_gcp.py b/scripts/transcode_speed_gcp.py index 708746b01..c0416814d 100644 --- a/scripts/transcode_speed_gcp.py +++ b/scripts/transcode_speed_gcp.py @@ -47,6 +47,7 @@ sys.path.insert(0, str(HERE)) import transcode_check as tc # noqa: E402 import transcode_speed as ts # noqa: E402 +import test_oracle MACHINE = 'c4-standard-8' USD_PER_HOUR = 0.60 @@ -67,12 +68,12 @@ def job_script(gate_name, classes): '> out/apt.log 2>&1', '{ lscpu; nproc; free -g; uname -a; df -h /dev/shm; echo "smt active: ' '$(cat /sys/devices/system/cpu/smt/active 2>&1)"; python3 --version; ldd bin/coreav; ' - 'sha256sum bin/* transcode_speed.py transcode_check.py; bin/ffmpeg -version | head -1; } ' + 'sha256sum bin/* scripts/*; bin/ffmpeg -version | head -1; } ' '> out/host.txt 2>&1', 'if ldd bin/coreav | grep -q "not found"; then echo "missing libraries" >> out/progress.txt; exit 2; fi', 'export PATH="$PWD/bin:$PATH"', 'echo "start $(date -u +%T)" >> out/progress.txt', - f'python3 -I transcode_speed.py run --selection selection.json --files files --coreav bin/coreav ' + f'python3 -I scripts/transcode_speed.py run --selection selection.json --files files --coreav bin/coreav ' f'--ffmpeg bin/ffmpeg --ffprobe bin/ffprobe {arms} --gate {shlex.quote(gate_name)} --out out ' f'--tmp /dev/shm/transcode-speed --classes {",".join(classes)} > out/speed.log 2>&1', 'echo "rc=$? end $(date -u +%T)" >> out/progress.txt', @@ -155,8 +156,7 @@ def main(): (up / 'files').mkdir(exist_ok=True) for name, path in (('coreav', a.coreav), ('ffmpeg', a.ffmpeg), ('ffprobe', a.ffprobe), ('x264', a.x264)): shutil.copy(path, up / 'bin' / name) - for name in ('transcode_speed.py', 'transcode_check.py'): - shutil.copy(HERE / name, up / name) + test_oracle.bundle(up, ['transcode_speed.py']) gate_name = 'gate' + pathlib.Path(a.gate).suffix shutil.copy(a.gate, up / gate_name) tc.ENV = tc.child_env(a.ffmpeg) diff --git a/scripts/ts_speed.py b/scripts/ts_speed.py index 3d741338b..c1be4cdad 100644 --- a/scripts/ts_speed.py +++ b/scripts/ts_speed.py @@ -27,6 +27,8 @@ import subprocess import sys import time +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import test_oracle LISTING = ('coreav', 'null', 'lav') COMMANDS = ('probe-coreav', 'probe-ffprobe') @@ -99,6 +101,8 @@ def main(): ap.add_argument('--tmp', default='/dev/shm') ap.add_argument('files', nargs='+') args = ap.parse_args() + if args.ffprobe: + args.ffprobe = str(test_oracle.require(os.path.join(os.path.dirname(args.ffprobe), 'ffmpeg'), args.ffprobe).ffprobe) if (args.coreav_cli is None) != (args.ffprobe is None): ap.error('--coreav-cli and --ffprobe go together') if args.rounds < 1: diff --git a/scripts/ts_speed_gcp.py b/scripts/ts_speed_gcp.py index d45b3a323..566f8e14d 100644 --- a/scripts/ts_speed_gcp.py +++ b/scripts/ts_speed_gcp.py @@ -42,6 +42,7 @@ HERE = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, HERE) import ts_speed_bars # noqa: E402 +import test_oracle MACHINE = 'c4-standard-8' USD_PER_HOUR = 0.60 @@ -54,7 +55,7 @@ def job_script(run): - command = ['python3', 'ts_speed.py', '--coreav', './ts-speed', '--null', './ts-speed-null', '--lav', './lav/lav_ts', + command = ['python3', 'scripts/ts_speed.py', '--coreav', './ts-speed', '--null', './ts-speed-null', '--lav', './lav/lav_ts', '--core', str(CORE), '--rounds', str(run['rounds']), '--tmp', '/dev/shm', '--report', 'out/report.json'] if run['commands']: command += ['--coreav-cli', './coreav', '--ffprobe', './lav/bin/ffprobe'] @@ -62,7 +63,7 @@ def job_script(run): return '\n'.join([ 'set -u', 'mkdir -p out', 'chmod +x ts-speed ts-speed-null lav/lav_ts' + (' coreav lav/bin/ffprobe' if run['commands'] else ''), '{ lscpu; nproc; uname -a; echo "smt active: $(cat /sys/devices/system/cpu/smt/active 2>&1)"; python3 --version;' - ' lav/lav_ts --identity; sha256sum ts-speed ts-speed-null lav/lav_ts lav/lib/* ts_speed.py' + ' lav/lav_ts --identity; sha256sum ts-speed ts-speed-null lav/lav_ts lav/lib/* scripts/*' + (' coreav lav/bin/ffprobe' if run['commands'] else '') + '; } > out/host.txt 2>&1', '{ sudo apt-get -q update && sudo DEBIAN_FRONTEND=noninteractive apt-get -q -y install linux-perf' ' && sudo sysctl -q kernel.perf_event_paranoid=1; } > out/perf-install.log 2>&1', @@ -211,7 +212,7 @@ def main(): shutil.copytree(args.lav_dir, os.path.join(up, 'lav'), symlinks=True) if args.coreav_cli: shutil.copy(args.coreav_cli, os.path.join(up, 'coreav')) - shutil.copy(os.path.join(HERE, 'ts_speed.py'), os.path.join(up, 'ts_speed.py')) + test_oracle.bundle(up, ['ts_speed.py']) os.makedirs(os.path.join(up, 'files')) for path in args.files: shutil.copy(path, os.path.join(up, 'files', os.path.basename(path))) diff --git a/scripts/v2_fixture_check.py b/scripts/v2_fixture_check.py index f11447976..75ee5d1bc 100644 --- a/scripts/v2_fixture_check.py +++ b/scripts/v2_fixture_check.py @@ -11,6 +11,7 @@ sys.path[:0] = [str(ROOT / 'scripts'), str(ROOT / 'tools/compat-corpus')] import encode_breadth as v2 import oracle_pin +import test_oracle import v2_fixture_inputs as inputs @@ -45,11 +46,7 @@ def main(): opts = parser.parse_args() for name in ('ffmpeg', 'fixtures', 'work', 'report'): setattr(opts, name, getattr(opts, name).resolve()) - if sys.platform == 'darwin': - import oracle_pin_macos - problems = list(oracle_pin_macos.verify_bin(opts.ffmpeg.parent)) - else: - problems = list(oracle_pin.verify_bin(opts.ffmpeg.parent)) + problems = list(test_oracle.verify_bin(opts.ffmpeg.parent)) if opts.ffmpeg.name != 'ffmpeg' or problems: raise ValueError('reference fixture verification requires the pinned oracle: ' + '; '.join(problems)) rows = [r for r in inputs.DOCUMENT['cases'] if r['assignments']] diff --git a/scripts/vp9_corpus.py b/scripts/vp9_corpus.py index 382ec0717..62c41815a 100644 --- a/scripts/vp9_corpus.py +++ b/scripts/vp9_corpus.py @@ -18,6 +18,8 @@ import sys ROOT = pathlib.Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'scripts')) +import test_oracle ROSTER = ROOT / 'docs/measurements/vp9-native/roster.json' CONDITION = ROOT / 'docs/measurements/vp9-native/file-condition.json' PACKETS = 120 @@ -451,7 +453,13 @@ def main(): report.add_argument('--shards', type=int, required=True) args = parser.parse_args() try: + if args.mode in ('run', 'preflight'): + oracle = test_oracle.require(args.ffmpeg, args.ffprobe) + args.ffmpeg, args.ffprobe = str(oracle.ffmpeg), str(oracle.ffprobe) return {'fetch': bounded_fetch, 'run': run, 'preflight': preflight, 'summarize': summarize}[args.mode](args) + except test_oracle.QualificationError as error: + print(str(error), file=sys.stderr) + return 1 except Exception as error: print(f'vp9-corpus: {args.mode} failed ({type(error).__name__})', file=sys.stderr) return 1 diff --git a/scripts/vp9_speed.py b/scripts/vp9_speed.py index ad2fba311..eaba79c06 100644 --- a/scripts/vp9_speed.py +++ b/scripts/vp9_speed.py @@ -82,6 +82,7 @@ HERE = pathlib.Path(__file__).resolve().parent sys.path.insert(0, str(HERE)) +import test_oracle import thumbnail_oracle as to # noqa: E402 import transcode_check as tc # noqa: E402 @@ -785,6 +786,7 @@ def main(): for need in ('selection', 'files', 'out', 'ffmpeg', 'ffprobe'): if not getattr(args, need): p.error(f'{args.command} needs --{need.replace("_", "-")}') + test_oracle.require(args.ffmpeg, args.ffprobe) args.ffmpeg, args.ffprobe = os.path.abspath(args.ffmpeg), os.path.abspath(args.ffprobe) tc.ENV = tc.child_env(args.ffmpeg) to.ENV = tc.ENV diff --git a/scripts/vp9_speed_gcp.py b/scripts/vp9_speed_gcp.py index c858133b8..a47094622 100644 --- a/scripts/vp9_speed_gcp.py +++ b/scripts/vp9_speed_gcp.py @@ -48,6 +48,7 @@ sys.path.insert(0, str(HERE)) import transcode_check as tc # noqa: E402 import vp9_speed as vs # noqa: E402 +import test_oracle MACHINE = 'c4-standard-8' USD_PER_HOUR = 0.60 @@ -77,7 +78,7 @@ def job_script(args, gate_name, first_name): '{ lscpu; nproc; free -g; uname -a; df -h /dev/shm; echo "smt active: ' '$(cat /sys/devices/system/cpu/smt/active 2>&1)"; python3 --version; dpkg-query -W libvpx9 libdav1d7; ' f'for b in {bins}; do echo "== $b"; ldd $b; done; ' - 'sha256sum bin/* vp9_speed.py thumbnail_oracle.py transcode_check.py; bin/ffmpeg -version | head -1; ' + 'sha256sum bin/* scripts/*; bin/ffmpeg -version | head -1; ' 'bin/ffmpeg -hide_banner -decoders | grep -E " (vp9|libvpx-vp9) "; ' f'echo "default decoder for VP9:"; bin/ffmpeg -hide_banner -v verbose -i files/{shlex.quote(first_name)} ' '-frames:v 1 -f null - 2>&1 | grep -E "Stream #0:[0-9]+ -> #0:[0-9]+ \\(vp9"; } > out/host.txt 2>&1', @@ -89,13 +90,13 @@ def job_script(args, gate_name, first_name): if phase == 'speed': decode = ('--no-decode' if args.no_decode else f'--decode-oracle $PWD/bin/decode-oracle --decode-rounds {args.decode_rounds}') - lines.append(f'python3 -I vp9_speed.py run --selection selection.json --files files ' + lines.append(f'python3 -I scripts/vp9_speed.py run --selection selection.json --files files ' f'--coreav libvpx=$PWD/bin/coreav-libvpx --coreav fallback=$PWD/bin/coreav-fallback ' f'{tools} --gate files/{shlex.quote(gate_name)} --out out --tmp /dev/shm/vp9-speed ' f'{decode}{expect} ' f'> out/speed.log 2>&1') else: - lines.append(f'python3 -I vp9_speed.py oracle --selection selection.json --files files ' + lines.append(f'python3 -I scripts/vp9_speed.py oracle --selection selection.json --files files ' f'--decode-oracle $PWD/bin/decode-oracle {tools} --out out --jobs 2 > out/oracle.log 2>&1') lines.append(f'echo "{phase} rc=$? end $(date -u +%T)" >> out/progress.txt') return '\n'.join(lines) + '\n' @@ -196,8 +197,7 @@ def main(): (up / 'files').mkdir(exist_ok=True) for name, path in zip(PROGRAMS, (a.coreav_libvpx, a.coreav_fallback, a.decode_oracle, a.ffmpeg, a.ffprobe)): shutil.copy(path, up / 'bin' / name) - for name in SCRIPTS: - shutil.copy(HERE / name, up / name) + test_oracle.bundle(up, SCRIPTS) for f in upload: name = f'{f["sha256"]}.{f["ext"]}' src = pathlib.Path(a.work) / 'files' / name diff --git a/scripts/wasm-thumbnail-fixtures.py b/scripts/wasm-thumbnail-fixtures.py index abfc3c65b..8a48a249c 100644 --- a/scripts/wasm-thumbnail-fixtures.py +++ b/scripts/wasm-thumbnail-fixtures.py @@ -15,6 +15,7 @@ import sys import oracle_pin +import test_oracle ROOT = pathlib.Path(__file__).resolve().parent.parent ROSTER = ROOT / "packages/wasm-h264/test/installed/roster.json" @@ -209,7 +210,7 @@ def generate(oracle, x264, output, hostile_manifest=None): if output.exists() and any(output.iterdir()): raise ValueError("output directory must be empty") output.mkdir(parents=True, exist_ok=True) - problems = list(oracle_pin.verify_bin(oracle)) + problems = list(test_oracle.verify_bin(oracle)) if problems: raise ValueError("the pinned oracle programs are required") logs = [] diff --git a/test-support/oracle-dependent.json b/test-support/oracle-dependent.json new file mode 100644 index 000000000..22907e231 --- /dev/null +++ b/test-support/oracle-dependent.json @@ -0,0 +1,219 @@ +{ + "crates/coreav-audio/src/convert/oracle.rs": [ + "convert::oracle::sample_conversion_is_exact_against_the_pinned_oracle" + ], + "crates/coreav-audio/tests/flac_encode.rs": [ + "escaped_and_five_bit_files_decode_completely_with_the_independent_oracle" + ], + "crates/coreav-backend-dav1d/tests/decode.rs": [ + "discarded_packets_give_no_frame_and_limits_hold", + "frames_match_ffmpeg_libdav1d" + ], + "crates/coreav-backend-ffmpeg/tests/decode.rs": [ + "h264_left_crop_is_applied_as_the_bitstream_says", + "h264_with_b_frames_matches_ffmpeg" + ], + "crates/coreav-backend-h264/tests/decode.rs": [ + "a_broken_stream_gives_the_same_frames_whatever_the_thread_count", + "a_container_that_trims_the_padding_is_followed", + "a_stream_outside_the_decoder_is_left_to_another_backend", + "a_stream_over_the_limits_is_refused_before_a_packet", + "an_interlaced_stream_is_left_to_another_backend_before_a_packet", + "every_frame_of_a_stream_with_b_frames_matches_ffmpeg", + "skipping_the_non_reference_access_units_leaves_the_later_frames_alone", + "the_keyframe_mode_returns_the_keyframes_of_the_full_run" + ], + "crates/coreav-backend-h264/tests/memory.rs": [ + "decoding_allocates_no_more_than_the_memory_budget" + ], + "crates/coreav-backend-h264/tests/one_idr.rs": [ + "generated_entropy_modes_and_pcm_fit_the_same_bound" + ], + "crates/coreav-backend-libvpx/tests/decode.rs": [ + "discarded_packets_give_no_frame_and_limits_hold", + "frames_after_the_first_in_an_unindexed_packet_are_checked", + "frames_match_ffmpeg_vp8", + "frames_match_ffmpeg_vp9", + "stated_sizes_are_the_decoded_sizes", + "vp8_key_frames_state_the_decoded_size" + ], + "crates/coreav-cli/tests/decode_audio.rs": [ + "decodes_an_mp4_aac_track_as_ffmpeg_does" + ], + "crates/coreav-cli/tests/decoder_host.rs": [ + "av1_hosting_preserves_complete_pixels", + "vp9_hosting_preserves_complete_pixels" + ], + "crates/coreav-cli/tests/ffmpeg.rs": [ + "concat_audio_gaps_are_refused_with_exact_pinned_fallback", + "contributing_inputs_preserve_complete_packet_order_and_decoded_output", + "copied_video_reconstructs_conflicting_declared_media_durations", + "copied_video_refuses_a_later_sample_before_its_first_composition", + "cover_selections_agree_with_the_pinned_ffmpeg", + "first_input_only_maps_reuse_ordinary_copy_timing", + "leading_negative_maps_preserve_destinations_and_match_pinned_fallback", + "mapped_inputs_agree_with_the_pinned_ffmpeg", + "ordinary_copy_preserves_complete_packet_order", + "ordinary_copy_rebuilds_declared_durations_for_video_and_audio", + "ordinary_copy_refuses_trimmed_simple_edits", + "picture_by_picture_selections_agree_with_the_pinned_ffmpeg", + "plain_extraction_metadata_agrees_with_the_pinned_ffmpeg", + "raw_s16_fifo_refuses_and_preserves_exact_pinned_fallback", + "raw_s16_linked_outputs_refuse_and_fall_back_through_the_target", + "raw_s16_unwritable_targets_preserve_the_pinned_exit_status", + "stream_metadata_agrees_with_the_pinned_ffmpeg", + "stripped_metadata_agrees_with_the_pinned_ffmpeg", + "the_0_1_0_commands_on_the_fixtures", + "unedited_audiovisual_concat_matches_the_pinned_ffmpeg", + "unedited_video_copy_normalizes_its_origin_without_losing_frames" + ], + "crates/coreav-cli/tests/ffmpeg_aac_filter.rs": [ + "aac_filter_is_an_exact_concat_identity_or_preserved_fallback" + ], + "crates/coreav-cli/tests/ffmpeg_frames.rs": [ + "dropping_frames_matches_the_oracles_raw_samples", + "image_names_limits_seeking_and_update_are_codec_independent", + "image_output_inherits_h264_container_colour_without_vui_signalling", + "images_and_raw_output_never_replace_the_input", + "raw_file_pipe_and_y4m_keep_every_decoded_sample", + "raw_stdout_keeps_the_closed_pipe_exit_status", + "raw_stdout_reports_a_final_flush_failure", + "seeking_counts_leading_empty_edits_on_the_input_timeline", + "the_oracle_recovers_every_sample_of_the_image_encoders", + "unavailable_decoders_refuse_before_output_and_allow_normal_fallback", + "unsupported_conversion_and_duplication_create_no_output", + "y4m_refuses_autorotation_that_would_misstate_chroma_siting" + ], + "crates/coreav-cli/tests/ffmpeg_input_seek.rs": [ + "input_seek_copy_keeps_only_exact_packet_timelines" + ], + "crates/coreav-cli/tests/ffmpeg_matroska.rs": [ + "aac_copy_keeps_interior_samples_when_the_container_clock_shortens_a_packet", + "audio_replacements_keep_sample_exact_priming_and_padding_in_matroska", + "automatic_text_subtitles_are_refused_unless_explicitly_excluded", + "bitmap_subtitles_follow_the_oracles_automatic_and_explicit_selection", + "copy_to_matroska_and_webm_matches_the_oracle", + "explicit_formats_and_audio_only_extension_select_the_container", + "h264_transcode_writes_matroska_with_copied_audio", + "iso_opus_keeps_the_declared_edit_end_instead_of_decoding_the_padded_tail", + "matroska_container_colour_survives_copy_without_changing_packets", + "matroska_default_video_encoder_matches_the_explicit_selection", + "unsupported_webm_codecs_and_trimming_leave_no_output" + ], + "crates/coreav-cli/tests/ffprobe_format_span.rs": [ + "format_output_counts_all_cover_picture_streams", + "output_span_does_not_change_copy_planning_or_trimmed_bytes" + ], + "crates/coreav-cli/tests/legacy_encoders.rs": [ + "legacy_encoder_choices_keep_media_summaries_errors_and_exit_codes" + ], + "crates/coreav-cli/tests/probe_tuning.rs": [ + "probe_defaults_leave_pinned_output_byte_identical" + ], + "crates/coreav-cli/tests/strict_safe.rs": [ + "ffmpeg_libx264_lines_run_no_ffmpeg", + "opus_audio_runs_no_ffmpeg", + "thumbnail_runs_no_ffmpeg", + "transcode_runs_no_ffmpeg" + ], + "crates/coreav-cli/tests/thumbnail.rs": [ + "image_to_standard_output", + "thumbnails_of_generated_files_agree_with_ffmpeg" + ], + "crates/coreav-cli/tests/transcode.rs": [ + "a_single_frame_encodes_as_ffmpeg_does", + "an_edit_list_that_trims_the_start", + "an_hevc_window_that_leaves_no_picture_is_rejected", + "audio_encodes_preserve_the_decoders_presented_samples", + "audio_the_aac_encode_does_not_take_is_refused_first", + "audio_the_opus_encode_does_not_take_is_refused_first", + "ffmpeg_aac_lines_encode_the_audio", + "ffmpeg_aac_sources_use_the_build_decoder", + "ffmpeg_audio_only_encodes_match_the_oracle_timeline", + "ffmpeg_audio_only_refusals_do_not_publish_output", + "ffmpeg_audio_only_refuses_unpreserved_source_properties", + "ffmpeg_avi_mp3_keeps_the_previous_complete_file_bytes", + "ffmpeg_default_codecs_match_the_oracle", + "ffmpeg_libopus_lines_encode_the_audio", + "ffmpeg_libx264_commands_run_the_pipeline", + "ffmpeg_libx264_keeps_a_cover_picture_only_when_it_is_copied", + "ffmpeg_libx264_refuses_a_matrix_ffmpeg_would_apply", + "ffmpeg_libx264_refuses_before_encoding", + "ffmpeg_libx264_refuses_video_no_decoder_takes", + "ffmpeg_mp3_eof_guard_preserves_exact_boundary_lengths", + "ffmpeg_mp3_outputs_keep_the_source_samples_and_quality", + "ffmpeg_mp3_sources_and_refusals_are_build_aware", + "ffmpeg_strict_safe_authorizes_resolved_audio_before_discovery", + "fixtures_keep_their_frames_times_and_audio", + "hostile_encoders_end_in_an_error_and_leave_nothing", + "opus_audio_takes_the_place_of_the_source_audio", + "repeated_webm_times_keep_every_frame", + "rotation_is_kept", + "scale_bitrate_and_no_audio", + "the_aac_encode_takes_opus_before_a_flac_stream", + "the_aac_encode_takes_the_place_of_the_source_audio", + "the_audio_encodes_keep_a_matroska_audio_start", + "the_minimum_gop_follows_the_rate_ffmpeg_finds", + "the_opus_encode_selects_the_first_decoded_stream_before_flac", + "the_opus_encode_takes_opus_before_a_flac_stream", + "times_in_decode_order_keep_every_frame", + "unsnapped_h264_times_keep_the_vui_rate", + "variable_rate_sources_encode_as_ffmpeg_does" + ], + "crates/coreav-frame/tests/ffmpeg_scale.rs": [ + "resolution_change_fixture_matches_ffmpeg_scale", + "test_pictures_match_ffmpeg_scale" + ], + "crates/coreav-isobmff-write/tests/replace.rs": [ + "fixtures_present_as_the_plain_remux" + ], + "crates/coreav-mkv/tests/write_oracle.rs": [ + "encoded_video_and_audio_decode_unchanged" + ], + "crates/coreav-transcode/tests/encoder.rs": [ + "a_frame_that_differs_from_the_settings_is_refused", + "colour_description_comes_out_as_asked", + "formats_keep_their_depth_and_chroma", + "full_range_is_not_converted", + "sample_aspect_ratio_comes_out_as_asked", + "the_minimum_gop_length_is_the_one_x264_chooses", + "thirty_frames_come_out" + ], + "crates/coreav-transcode/tests/sandboxed.rs": [ + "real encoders through the launcher" + ], + "crates/coreav-transcode/tests/encoders.rs": [ + "ffmpeg_libx264_high10", + "ffmpeg_libx264_medium", + "ffmpeg_libx264_ultrafast", + "x264_422", + "x264_444", + "x264_access_unit_delimiters", + "x264_four_slices", + "x264_high10", + "x264_interlaced_mbaff", + "x264_medium", + "x264_open_gop", + "x264_short_keyint", + "x264_sixteen_b_frames", + "x264_ultrafast" + ], + "crates/coreav-worker/tests/ffmpeg.rs": [ + "fallback_through_the_worker_matches_ffmpeg", + "frames_come_while_no_packet_does", + "packets_past_the_pending_limit_fail_with_limit", + "running_into_the_memory_limit_fails_with_limit", + "slow_consumer_after_the_end_of_input" + ], + "tools/decode-oracle/tests/stream.rs": [ + "a_stream_outside_the_decoder_fails_at_open_with_exit_1", + "frames_equal_framemd5" + ], + "crates/coreav-cli/tests/ffmpeg_pcm.rs": [ + "aac_raw_output_refuses_with_exact_pinned_fallback" + ], + "crates/coreav-cli/tests/ffmpeg_wav.rs": [ + "integer_wav_output_matches_complete_pinned_files", + "wave_wav_stdout_refuses_without_literal_files_and_matches_fallback" + ] +} diff --git a/test-support/oracle.rs b/test-support/oracle.rs new file mode 100644 index 000000000..e670880b4 --- /dev/null +++ b/test-support/oracle.rs @@ -0,0 +1,51 @@ +#![allow(dead_code, clippy::panic)] + +use std::path::{Path, PathBuf}; +use std::process::Command; +use std::sync::OnceLock; + +pub struct Oracle { + ffmpeg: PathBuf, + ffprobe: PathBuf, +} + +impl Oracle { + pub fn ffmpeg(&self) -> &Path { + &self.ffmpeg + } + + pub fn ffprobe(&self) -> &Path { + &self.ffprobe + } +} + +pub fn require() -> &'static Oracle { + static ORACLE: OnceLock> = OnceLock::new(); + let result = ORACLE.get_or_init(|| { + let result = Command::new("python3") + .arg("-I") + .arg(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../scripts/test_oracle.py")) + .arg("--resolve") + .output() + .map_err(|error| format!("cannot start oracle verifier: {error}"))?; + if !result.status.success() { + return Err(String::from_utf8_lossy(&result.stderr).into_owned()); + } + let paths = String::from_utf8(result.stdout) + .map_err(|error| format!("invalid oracle paths: {error}"))?; + let mut paths = paths.lines(); + let ffmpeg = paths.next().ok_or("missing verified FFmpeg path")?; + let ffprobe = paths.next().ok_or("missing verified ffprobe path")?; + if ffmpeg.is_empty() || ffprobe.is_empty() || paths.next().is_some() { + return Err("invalid verified oracle pair".into()); + } + Ok(Oracle { + ffmpeg: ffmpeg.into(), + ffprobe: ffprobe.into(), + }) + }); + match result { + Ok(oracle) => oracle, + Err(error) => panic!("stage=oracle_qualification: {error}"), + } +} diff --git a/tools/compat-corpus/corpus_kd.py b/tools/compat-corpus/corpus_kd.py index bc65c43c8..f3cb2290b 100644 --- a/tools/compat-corpus/corpus_kd.py +++ b/tools/compat-corpus/corpus_kd.py @@ -1010,7 +1010,8 @@ def main(): raise ValueError('inventory no longer matches its cutoff or oracle pin') sys.path.insert(0, str(ROOT / 'scripts')) import oracle_pin - problems = list(oracle_pin.verify_bin(args.oracle_dir)) + import test_oracle + problems = list(test_oracle.verify_bin(args.oracle_dir)) if problems: raise ValueError('; '.join(problems)) os.environ['PATH'] = str(args.oracle_dir.resolve()) + os.pathsep + os.environ['PATH'] diff --git a/tools/compat-corpus/current_ci.py b/tools/compat-corpus/current_ci.py index e681f2b05..4eb117a46 100644 --- a/tools/compat-corpus/current_ci.py +++ b/tools/compat-corpus/current_ci.py @@ -14,6 +14,7 @@ sys.path[:0] = [str(HERE), str(HERE.parents[1] / 'scripts')] import decoded_output import oracle_pin +import test_oracle def reporter(): @@ -177,7 +178,7 @@ def main(): ffmpeg, ffprobe = shutil.which('ffmpeg'), shutil.which('ffprobe') if (not ffmpeg or not ffprobe or pathlib.Path(ffprobe).resolve() != (pathlib.Path(ffmpeg).parent / 'ffprobe').resolve() - or list(oracle_pin.verify_bin(pathlib.Path(ffmpeg).parent))): + or list(test_oracle.verify_bin(pathlib.Path(ffmpeg).parent))): parser.error('install the pinned ffmpeg and ffprobe with scripts/install-oracle-ffmpeg.sh') legacy = reporter() records = [] diff --git a/tools/compat-corpus/decode_breadth.py b/tools/compat-corpus/decode_breadth.py index fd3e35d09..6ed56eaeb 100644 --- a/tools/compat-corpus/decode_breadth.py +++ b/tools/compat-corpus/decode_breadth.py @@ -72,6 +72,7 @@ HERE = pathlib.Path(__file__).resolve().parent sys.path[:0] = [str(HERE), str(HERE.parent.parent / 'scripts')] import thumbnail_oracle # noqa: E402 +import test_oracle BAR = 74 GROUPS = ('h264', 'av1', 'vp9', 'vp8', 'other') @@ -517,6 +518,9 @@ def main(): p.add_argument('--files', required=name == 'summarize') p.add_argument(out, required=True) opts = parser.parse_args() + if opts.mode == 'run': + oracle = test_oracle.require(opts.ffmpeg, opts.ffprobe) + opts.ffmpeg, opts.ffprobe = str(oracle.ffmpeg), str(oracle.ffprobe) if opts.mode == 'run' and opts.fetch: import round_files pool = round_files.pool() diff --git a/tools/compat-corpus/encode_breadth.py b/tools/compat-corpus/encode_breadth.py index d55c7d92c..be8022c13 100755 --- a/tools/compat-corpus/encode_breadth.py +++ b/tools/compat-corpus/encode_breadth.py @@ -60,6 +60,7 @@ import classify # noqa: E402 import decoded_output import oracle_pin +import test_oracle import opus_encode_check as opus # noqa: E402 import r3 # noqa: E402 import release_round # noqa: E402 @@ -867,7 +868,7 @@ def oracle_programs(opts): raise ValueError('ffmpeg must be the pinned installation executable') if pathlib.Path(opts.ffprobe).resolve() != (directory / 'ffprobe').resolve(): raise ValueError('ffprobe must be installed beside the pinned ffmpeg') - problems = list(oracle_pin.verify_bin(directory)) + problems = list(test_oracle.verify_bin(directory)) if problems: raise ValueError('; '.join(problems)) return {name: {'version': subprocess.run([str(getattr(opts, name)), '-version'], capture_output=True, diff --git a/tools/compat-corpus/frames.py b/tools/compat-corpus/frames.py index 95ea2f7e4..9d4c16751 100644 --- a/tools/compat-corpus/frames.py +++ b/tools/compat-corpus/frames.py @@ -28,6 +28,8 @@ import pathlib import subprocess import sys +sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[2] / 'scripts')) +import test_oracle TIMEOUT = 600 ENV = {**os.environ, 'COREAV_STRICT_SAFE': '1'} @@ -152,6 +154,7 @@ def main(): ap.add_argument('--report') ap.add_argument('--jobs', type=int, default=os.cpu_count() or 4) opts = ap.parse_args() + opts.ffprobe = str(test_oracle.require(pathlib.Path(opts.ffprobe).with_name('ffmpeg'), opts.ffprobe).ffprobe) native = NATIVE | ({f'h264 {f}' for f in H264_PIX_FMTS} if opts.native_h264 else set()) files = media_files(opts.media) names = set() diff --git a/tools/compat-corpus/r4_scan.py b/tools/compat-corpus/r4_scan.py index ba2bc04be..c901dc29f 100755 --- a/tools/compat-corpus/r4_scan.py +++ b/tools/compat-corpus/r4_scan.py @@ -33,6 +33,8 @@ sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent)) import release_round # noqa: E402 import speed # noqa: E402 +sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[2] / 'scripts')) +import test_oracle def cause(line): if line.get('not_run') != 'strict_safe': @@ -129,6 +131,8 @@ def main(): ap.add_argument('--records') ap.add_argument('--jobs', type=int, default=2) opts = ap.parse_args() + oracle = test_oracle.require(opts.ffmpeg, opts.ffprobe) + opts.ffmpeg, opts.ffprobe = str(oracle.ffmpeg), str(oracle.ffprobe) files = speed.r4_files(opts) pairs = speed.r4_pairs(opts, files, release_round.environment()) if not pairs: diff --git a/tools/compat-corpus/tests/test_corpus_kd.py b/tools/compat-corpus/tests/test_corpus_kd.py index fc4088802..b4d17310b 100644 --- a/tools/compat-corpus/tests/test_corpus_kd.py +++ b/tools/compat-corpus/tests/test_corpus_kd.py @@ -467,12 +467,13 @@ def freeze_selection(self): def execute(self): sys.path.insert(0, str(kd.ROOT / 'scripts')) import oracle_pin + import test_oracle args = ['corpus_kd.py', 'compare', '--inventory', str(self.inventory), '--files', str(self.files), '--coreav', str(self.root / 'coreav'), '--oracle-dir', str(self.root), '--out', str(self.output)] with mock.patch.object(sys, 'argv', args), mock.patch.dict(os.environ), \ mock.patch.object(run, 'ENV', run.ENV.copy()), \ mock.patch.object(kd, 'inventory', return_value=self.frozen), \ - mock.patch.object(oracle_pin, 'verify_bin', return_value=[]) as checked: + mock.patch.object(test_oracle, 'verify_bin', return_value=[]) as checked: result = kd.main() checked.assert_called_once_with(self.root) return result diff --git a/tools/compat-corpus/tests/test_current_ci.py b/tools/compat-corpus/tests/test_current_ci.py index db96aca1c..68f73e869 100644 --- a/tools/compat-corpus/tests/test_current_ci.py +++ b/tools/compat-corpus/tests/test_current_ci.py @@ -100,7 +100,7 @@ def refusals(*args): mock.patch.object(current_ci, 'reporter', return_value=legacy), \ mock.patch.object(current_ci, 'refusals', side_effect=refusals), \ mock.patch.object(current_ci.shutil, 'which', side_effect=lambda n: '/oracle/' + n), \ - mock.patch.object(current_ci.oracle_pin, 'verify_bin', return_value=[]): + mock.patch.object(current_ci.test_oracle, 'verify_bin', return_value=[]): self.assertEqual(current_ci.main(), 1) def test_the_frozen_judging_files_keep_their_registered_hashes(self): @@ -350,7 +350,7 @@ def setUpClass(cls): cls.ffmpeg, cls.ffprobe = shutil.which('ffmpeg'), shutil.which('ffprobe') if not cls.ffmpeg or not cls.ffprobe: raise AssertionError('fixture CI must install the pinned oracle') - problems = list(current_ci.oracle_pin.verify_bin(pathlib.Path(cls.ffmpeg).parent)) + problems = list(current_ci.test_oracle.verify_bin(pathlib.Path(cls.ffmpeg).parent)) if problems: raise AssertionError(problems) cls.env = {'PATH': os.environ.get('PATH', ''), 'GCONV_PATH': '/nonexistent/gconv'} diff --git a/tools/decode-oracle/src/main.rs b/tools/decode-oracle/src/main.rs index d0aeebf00..67602c3c4 100644 --- a/tools/decode-oracle/src/main.rs +++ b/tools/decode-oracle/src/main.rs @@ -23,6 +23,9 @@ mod stream; +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::PathBuf; use std::process::ExitCode; @@ -161,6 +164,9 @@ fn run(args: &[String]) -> Result { args: vec![coreav_worker::WORKER_ARG.into()], }); worker.transfer = transfer; + if !native && backend == WorkerBackend::Ffmpeg { + worker.ffmpeg = Some(test_oracle::require().ffmpeg().to_path_buf()); + } // The worker options' cap would otherwise hold the budget below it. if max_memory.is_some() { worker.address_space = max_memory; @@ -185,7 +191,7 @@ fn run(args: &[String]) -> Result { } else if in_process && backend == WorkerBackend::Libvpx { in_process_libvpx(&stream, &options.decode_limits)? } else if in_process { - let program = coreav_worker::find_ffmpeg().ok_or("no ffmpeg")?; + let program = test_oracle::require().ffmpeg().to_path_buf(); let options = coreav_backend_ffmpeg::FfmpegOptions { program, threads: None, @@ -326,10 +332,14 @@ fn run_thumbnail(args: &[String]) -> Result { let program = std::env::current_exe().map_err(|e| e.to_string())?; let sandboxed = SandboxedBackend { backend, - options: WorkerOptions::new(WorkerCommand { - program, - args: vec![coreav_worker::WORKER_ARG.into()], - }), + options: WorkerOptions { + ffmpeg: (backend == WorkerBackend::Ffmpeg && !in_process) + .then(|| test_oracle::require().ffmpeg().to_path_buf()), + ..WorkerOptions::new(WorkerCommand { + program, + args: vec![coreav_worker::WORKER_ARG.into()], + }) + }, }; let in_process_backend = in_process_dav1d_backend()?; let backends: [&dyn Backend; 1] = if in_process { diff --git a/tools/decode-oracle/tests/stream.rs b/tools/decode-oracle/tests/stream.rs index 792e4542b..334442dff 100644 --- a/tools/decode-oracle/tests/stream.rs +++ b/tools/decode-oracle/tests/stream.rs @@ -7,6 +7,9 @@ //! backends (dav1d, libvpx) are compared only where the sandbox enforces its //! memory limit (Linux). +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + use std::path::{Path, PathBuf}; use std::process::Command; @@ -23,13 +26,12 @@ struct Case { } fn ffmpeg() -> Option { - let program = std::env::var("COREAV_FFMPEG").unwrap_or_else(|_| "ffmpeg".into()); - Command::new(&program) - .arg("-version") - .output() - .ok() - .filter(|o| o.status.success()) - .map(|_| program) + Some( + test_oracle::require() + .ffmpeg() + .to_string_lossy() + .into_owned(), + ) } fn scratch(test: &str) -> Option { diff --git a/tools/hostile/generate.py b/tools/hostile/generate.py index 138080615..c6606b223 100644 --- a/tools/hostile/generate.py +++ b/tools/hostile/generate.py @@ -41,6 +41,8 @@ import subprocess import sys import zlib +sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[2] / 'scripts')) +import test_oracle def box(kind: bytes, payload: bytes) -> bytes: @@ -732,6 +734,8 @@ def main(): if len(args) != 3 or any(p not in PARTS for p in parts): sys.exit('usage: generate.py OUT_DIR FIXTURE_DIR FFMPEG ' '[--parts structural,mutation,pixelsmash,cve,matroska,mpegts,limits]') + if set(parts) & {'pixelsmash', 'cve', 'limits'}: + args[2] = str(test_oracle.require(args[2]).ffmpeg) out = pathlib.Path(args[0]) out.mkdir(parents=True, exist_ok=True) fixtures = pathlib.Path(args[1]) diff --git a/tools/isobmff-adapter/corpus/harvest.py b/tools/isobmff-adapter/corpus/harvest.py index 60dc99829..5c6026773 100644 --- a/tools/isobmff-adapter/corpus/harvest.py +++ b/tools/isobmff-adapter/corpus/harvest.py @@ -21,6 +21,9 @@ import os import subprocess import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[3] / 'scripts')) +import test_oracle import boto3 from botocore.config import Config @@ -84,6 +87,7 @@ def sparse(path, target): def main(): ffprobe, env_file, out = sys.argv[1:4] + ffprobe = str(test_oracle.require(Path(ffprobe).with_name('ffmpeg'), ffprobe).ffprobe) bucket, s3 = client(env_file) with open(f'{out}/manifest.json') as handle: files = development_files(json.load(handle)) diff --git a/tools/mediainfo-oracle/corpus.py b/tools/mediainfo-oracle/corpus.py index 77dfe1afe..99e851c1e 100644 --- a/tools/mediainfo-oracle/corpus.py +++ b/tools/mediainfo-oracle/corpus.py @@ -31,6 +31,8 @@ HERE = pathlib.Path(__file__).resolve().parent ROOT = HERE.parent.parent +sys.path.insert(0, str(ROOT / 'scripts')) +import test_oracle sys.path.insert(0, str(HERE)) import mediainfo_oracle as mo # noqa: E402 @@ -172,6 +174,8 @@ def check_provenance(captures, current): def cmd_run(args): + probe = pathlib.Path(os.environ.get('FFPROBE', 'ffprobe')) + test_oracle.require(probe.with_name('ffmpeg'), probe) entries = select(args.manifest, args.split, args.set.split(',')) if args.limit: entries = entries[:args.limit] diff --git a/tools/mediarecorder/generate.py b/tools/mediarecorder/generate.py index cdcb46465..38f0133c2 100644 --- a/tools/mediarecorder/generate.py +++ b/tools/mediarecorder/generate.py @@ -23,6 +23,8 @@ from pathlib import Path HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE.parents[1] / 'scripts')) +import test_oracle VP8 = "video/webm;codecs=vp8,opus" VP9 = "video/webm;codecs=vp9,opus" @@ -169,7 +171,7 @@ def kill(proc): def ffprobe(path): p = subprocess.run( - ["ffprobe", "-v", "error", "-show_streams", "-show_format", "-of", "json", str(path)], + [str(test_oracle.require('ffmpeg', 'ffprobe').ffprobe), "-v", "error", "-show_streams", "-show_format", "-of", "json", str(path)], capture_output=True, text=True) info = {"exit": p.returncode, "stderr": p.stderr.strip()[:2000], "codecs": []} try: @@ -239,6 +241,7 @@ def main(): ap.add_argument("--chrome", default="google-chrome") ap.add_argument("--only", help="comma-separated config names to run") args = ap.parse_args() + test_oracle.require('ffmpeg', 'ffprobe') args.out.mkdir(parents=True, exist_ok=True) matrix = MATRIX diff --git a/tools/mkv-adapter/bench.py b/tools/mkv-adapter/bench.py index 2c65cb1d7..12a1d5b96 100644 --- a/tools/mkv-adapter/bench.py +++ b/tools/mkv-adapter/bench.py @@ -25,6 +25,8 @@ import time ROOT = pathlib.Path(__file__).resolve().parent.parent.parent +sys.path.insert(0, str(ROOT / 'scripts')) +import test_oracle TIMEOUT = 300 @@ -67,6 +69,7 @@ def main(): parser.add_argument('--coreav', default=str(ROOT / 'target' / 'release' / 'coreav')) parser.add_argument('--adapter', default=str(ROOT / 'target' / 'release' / 'mkv-adapter')) args = parser.parse_args() + test_oracle.require('ffmpeg', 'ffprobe') files = sorted(p for d in args.media for p in pathlib.Path(d).iterdir() if p.suffix in ('.mkv', '.webm')) rows = [] diff --git a/tools/mkv-adapter/corpus.py b/tools/mkv-adapter/corpus.py index d879131b9..daff20639 100644 --- a/tools/mkv-adapter/corpus.py +++ b/tools/mkv-adapter/corpus.py @@ -37,6 +37,8 @@ HERE = pathlib.Path(__file__).resolve().parent ROOT = HERE.parent.parent +sys.path.insert(0, str(ROOT / 'scripts')) +import test_oracle sys.path.insert(0, str(ROOT / 'tools' / 'mediainfo-oracle')) import mediainfo_oracle as mo # noqa: E402 @@ -155,12 +157,14 @@ def process(entry, args, env, endpoint): def cmd_run(args): + probe = pathlib.Path(os.environ.get('FFPROBE', 'ffprobe')) + ffprobe = str(test_oracle.require(probe.with_name('ffmpeg'), probe).ffprobe) out = pathlib.Path(args.out) for sub in ('reference', 'candidate', 'mediainfo', 'runs'): (out / sub).mkdir(parents=True, exist_ok=True) pathlib.Path(args.work).mkdir(parents=True, exist_ok=True) provenance = out / 'PROVENANCE.json' - current = {'ffprobe': subprocess.run(['ffprobe', '-version'], capture_output=True, text=True).stdout.split('\n')[0], + current = {'ffprobe': subprocess.run([ffprobe, '-version'], capture_output=True, text=True).stdout.split('\n')[0], 'mediainfo': subprocess.run([args.mediainfo, '--Version'], capture_output=True, text=True).stdout.strip().split('\n')[-1]} if provenance.exists() and json.loads(provenance.read_text()) != current: diff --git a/tools/mkv-adapter/remux_corpus.py b/tools/mkv-adapter/remux_corpus.py index bb59c0f6d..4fde435f9 100644 --- a/tools/mkv-adapter/remux_corpus.py +++ b/tools/mkv-adapter/remux_corpus.py @@ -42,6 +42,7 @@ sys.path.insert(0, str(ROOT / 'scripts')) import corpus # noqa: E402 import mkv_remux_check as checker # noqa: E402 +import test_oracle TIMEOUT = 3600 @@ -207,6 +208,7 @@ def process(entry, args, env, endpoint, disk): def cmd_run(args): + test_oracle.require('ffmpeg', os.environ.get('FFPROBE', 'ffprobe')) out = pathlib.Path(args.out) (out / 'runs').mkdir(parents=True, exist_ok=True) pathlib.Path(args.work).mkdir(parents=True, exist_ok=True) diff --git a/tools/oracle/tests/test_kd_mkv.py b/tools/oracle/tests/test_kd_mkv.py index 48bf0750e..1b1b7ec26 100644 --- a/tools/oracle/tests/test_kd_mkv.py +++ b/tools/oracle/tests/test_kd_mkv.py @@ -8,11 +8,14 @@ import re import shutil import subprocess +import sys import tempfile import unittest from unittest import mock ROOT = pathlib.Path(__file__).resolve().parents[3] +sys.path.insert(0, str(ROOT / "scripts")) +import test_oracle SPEC = importlib.util.spec_from_file_location('oracle_kd_mkv', ROOT / 'scripts' / 'oracle_kd_mkv.py') kd = importlib.util.module_from_spec(SPEC) SPEC.loader.exec_module(kd) @@ -183,17 +186,6 @@ def ebml(eid, payload=b''): return eid.to_bytes((eid.bit_length() + 7) // 8, 'big') + (1 << 56 | len(payload)).to_bytes(8, 'big') + payload -def pinned(tool): - """Whether the `tool` (`ffmpeg` or `ffprobe`) on the path is the pinned - oracle build.""" - spec = importlib.util.spec_from_file_location('oracle_pin', ROOT / 'scripts' / 'oracle_pin.py') - pin = importlib.util.module_from_spec(spec) - spec.loader.exec_module(pin) - try: - version = subprocess.run([tool, '-version'], capture_output=True, timeout=60, check=False).stdout - except (OSError, subprocess.TimeoutExpired): - return False - return version.startswith(f"{tool} version {pin.load()['BUILD']}-".encode()) def ac3_frame(bsid=6, acmod=7, xbsi1e=1, mode=1, levels=(4, 4, 4, 4), crc=True): @@ -336,13 +328,12 @@ def test_block_offsets_and_frame_sizes_are_taken_from_the_file(self): self.assertEqual(data[offset], 0x82) self.assertEqual(data[offset + len(payload) - sum(map(len, frames)):offset + len(payload)], b''.join(frames)) - if pinned('ffprobe'): - listed = subprocess.run(['ffprobe', '-v', 'error', '-of', 'json', '-show_streams', '-show_packets', - str(path)], capture_output=True, timeout=60, check=True).stdout - document = json.loads(listed) - (stream,) = document['streams'] - self.assertEqual((stream['index'], stream['codec_name']), (0, 'ac3')) - self.assertEqual(tuple((int(p['pos']), int(p['size'])) for p in document['packets']), found.spans) + listed = subprocess.run([test_oracle.require().ffprobe, '-v', 'error', '-of', 'json', '-show_streams', '-show_packets', + str(path)], capture_output=True, timeout=60, check=True).stdout + document = json.loads(listed) + (stream,) = document['streams'] + self.assertEqual((stream['index'], stream['codec_name']), (0, 'ac3')) + self.assertEqual(tuple((int(p['pos']), int(p['size'])) for p in document['packets']), found.spans) def test_values_only_where_annex_d_defines_them(self): # No surround channels (3/0) keeps no surround level; no centre @@ -428,18 +419,17 @@ def recorded(path, mode='r'): with mock.patch.object(kd.policy_ref, 'MAX_BLOCK', 3 + len(frame)): self.assertEqual(self.evidence(whole), []) - @unittest.skipUnless(pinned('ffmpeg') and pinned('ffprobe'), 'needs the pinned ffmpeg and ffprobe on the path') def test_the_pinned_oracle_still_prints_no_downmix(self): directory = pathlib.Path(tempfile.mkdtemp()) self.addCleanup(shutil.rmtree, directory) path = directory / 'f.mkv' - subprocess.run(['ffmpeg', '-v', 'error', '-f', 'lavfi', '-i', 'sine=duration=0.2', '-af', + subprocess.run([test_oracle.require().ffmpeg, '-v', 'error', '-f', 'lavfi', '-i', 'sine=duration=0.2', '-af', 'pan=5.1|c0=c0|c1=c0|c2=c0|c3=c0|c4=c0|c5=c0', '-c:a', 'ac3', '-dmix_mode', 'ltrt', '-ltrt_cmixlev', '0.707', '-ltrt_surmixlev', '0.5', '-loro_cmixlev', '0.595', '-loro_surmixlev', '0.707', str(path)], check=True, timeout=120) (found,) = kd.annex_d_downmix(path) self.assertEqual(found.coreav, ('1', '0.707107', '0.500000', '0.594604', '0.707107')) - listed = subprocess.run(['ffprobe', '-v', 'error', '-of', 'json', '-show_entries', + listed = subprocess.run([test_oracle.require().ffprobe, '-v', 'error', '-of', 'json', '-show_entries', 'stream=' + ','.join(kd.DOWNMIX_KEYS), str(path)], capture_output=True, timeout=60, check=True).stdout (stream,) = json.loads(listed)['streams'] @@ -510,16 +500,6 @@ def av1_matroska(private, colour=None, codec=b'V_AV1', encoded=False, before=b'' + ebml(0x1F43B675, ebml(0xE7, b'\x00') + block))) -def pinned_ffprobe(): - """Whether the `ffprobe` on the path is the pinned oracle build.""" - spec = importlib.util.spec_from_file_location('oracle_pin', ROOT / 'scripts' / 'oracle_pin.py') - pin = importlib.util.module_from_spec(spec) - spec.loader.exec_module(pin) - try: - version = subprocess.run(['ffprobe', '-version'], capture_output=True, timeout=60, check=False).stdout - except (OSError, subprocess.TimeoutExpired): - return False - return version.startswith(f"ffprobe version {pin.load()['BUILD']}-".encode()) # Range 1 is studio swing; ChromaSitingHorz 1 and ChromaSitingVert 2 are @@ -631,13 +611,12 @@ def test_a_sequence_header_without_its_mandatory_tail_gives_no_evidence(self): private[-1] |= 1 self.assertEqual(self.evidence(av1_matroska(bytes(private)))[1:], ([], []), 'a set bit after the trailing one') - @unittest.skipUnless(pinned_ffprobe(), 'needs the pinned ffprobe on the path') def test_the_pinned_oracle_still_gives_its_string(self): for name, (private, colour, record, _, _) in self.SHAPES.items(): path, *_ = self.evidence(av1_matroska(private, colour)) (found,) = record(path) record = RECORDS[record] - listed = subprocess.run(['ffprobe', '-v', 'error', '-of', 'json', '-show_entries', + listed = subprocess.run([test_oracle.require().ffprobe, '-v', 'error', '-of', 'json', '-show_entries', 'stream=mime_codec_string', str(path)], capture_output=True, timeout=60, check=True).stdout strings = [s.get('mime_codec_string') for s in json.loads(listed)['streams']] diff --git a/tools/oracle/writer_kd_audit_cli.py b/tools/oracle/writer_kd_audit_cli.py index b96f48fb7..8c37b3b55 100644 --- a/tools/oracle/writer_kd_audit_cli.py +++ b/tools/oracle/writer_kd_audit_cli.py @@ -54,6 +54,7 @@ ROOT = Path(__file__).resolve().parents[2] sys.path.insert(0, str(ROOT / "scripts")) +import test_oracle WRAPPER = r'''#!/usr/bin/env python3 import json, os, re, subprocess, sys @@ -540,6 +541,7 @@ def main(): parser.add_argument("--mediainfo") parser.add_argument("--report") args = parser.parse_args() + test_oracle.require('ffmpeg', 'ffprobe') work = Path(tempfile.mkdtemp(prefix="writer-kd-audit-cli-")) atexit.register(shutil.rmtree, work, True) wrapper = work / "coreav" diff --git a/tools/stage3-report/run.py b/tools/stage3-report/run.py index ca305c7f4..839379f5f 100644 --- a/tools/stage3-report/run.py +++ b/tools/stage3-report/run.py @@ -32,6 +32,8 @@ HERE = pathlib.Path(__file__).resolve().parent ROOT = HERE.parent.parent +sys.path.insert(0, str(ROOT / 'scripts')) +import test_oracle sys.path.insert(0, str(HERE)) import causes # noqa: E402 import corpus # noqa: E402 @@ -437,11 +439,13 @@ def main(): extra_hostile.options(parser) args = parser.parse_args() work = pathlib.Path(args.work).resolve() - work.mkdir(parents=True, exist_ok=True) steps = args.steps.split(',') for step in steps: if step not in STEPS: sys.exit(f'unknown step {step}; steps: {", ".join(STEPS)}') + if set(steps) & {'fixtures', 'corpus', 'hostile'}: + test_oracle.require('ffmpeg', 'ffprobe') + work.mkdir(parents=True, exist_ok=True) for step in STEPS: if step in steps: print(f'== {step}', flush=True) diff --git a/tools/videotoolbox-identities/capture.py b/tools/videotoolbox-identities/capture.py index 620e50286..50db68bcc 100644 --- a/tools/videotoolbox-identities/capture.py +++ b/tools/videotoolbox-identities/capture.py @@ -19,6 +19,7 @@ sys.path.insert(0, str(ROOT / "scripts")) import oracle_pin_macos +import test_oracle BOTTLE_SHA = "71ea80f43e78935336818c646b4561db14301e5590d0e726f221a944cb9efb73" BINARY_SHA = "bbb048645b448aea89db45c7331a09598c82da9941c41ce478b05d52b4c15bb2" @@ -91,7 +92,7 @@ def capture(oracle, output): sys.platform == "darwin" and not output.exists(), "capture_platform_or_output" ) oracle = oracle.resolve(strict=True) - problems = list(oracle_pin_macos.verify_bin(oracle, ROOT)) + problems = list(test_oracle.verify_bin(oracle, ROOT)) require(not problems, "baseline_pin") pin = oracle_pin_macos.load(ROOT) ffmpeg = oracle / "ffmpeg" From 45ba1538d3b1056ad0913597a0f6f10156592948 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 12:17:08 +0000 Subject: [PATCH 05/21] fix(ffmpeg): retain qualified oracle paths Signed-off-by: gunwooterry --- docs/agents/ffmpeg-cli.md | 2 ++ scripts/aac_agreement.py | 5 +++-- scripts/audio_copy_check.py | 3 ++- scripts/audio_source_diagnostic.py | 4 ++-- scripts/exact_skip_check.py | 3 ++- scripts/gen-v2-fixtures.py | 3 ++- scripts/h264_parity.py | 2 +- scripts/h264_synth.py | 3 ++- scripts/he_aac_agreement.py | 3 ++- scripts/hevc_fixture.py | 3 ++- scripts/opus_encode_check.py | 5 ++++- scripts/oracle.py | 3 ++- scripts/tests/test_audio_source_diagnostic.py | 3 ++- scripts/tests/test_gen_v2_fixtures.py | 3 ++- scripts/tests/test_hevc_fixture.py | 6 ++++-- scripts/tests/test_test_oracle.py | 21 +++++++++++++++++++ scripts/thumbnail_oracle.py | 3 ++- scripts/transcode_check.py | 3 ++- scripts/transcode_speed.py | 3 ++- scripts/vp9_speed.py | 4 ++-- .../tests/test_decode_breadth.py | 5 ++++- .../tests/test_decode_breadth_fixtures.py | 17 ++++++++------- .../tests/test_encode_breadth.py | 7 ++++++- tools/compat-corpus/tests/test_r4_scan.py | 7 ++++++- 24 files changed, 89 insertions(+), 32 deletions(-) diff --git a/docs/agents/ffmpeg-cli.md b/docs/agents/ffmpeg-cli.md index 396c4122c..ab3c376ff 100644 --- a/docs/agents/ffmpeg-cli.md +++ b/docs/agents/ffmpeg-cli.md @@ -5,6 +5,8 @@ CLI and ffprobe behavior, the FFmpeg pin, and fallback names. | Rule | Enforced by | |---|---| | Standalone FLAC raw output validates the complete bounded immutable payload before publication and refuses explicit speaker-mask declarations | `flac::prepare_stream` separates validation from emission with an immutable borrow and preallocated packing/planar scratch. `ffmpeg_flac` compares complete pinned bytes, corrupt-tail preservation and real fallback; source-loader tests cover metadata-end reads, masks, remaining work/memory and terminal I/O/limit errors | +| A qualified Python consumer executes the returned paths rather than resolving the original spelling again | The shared owner returns absolute executable identities. `test_vp9_main_retains_the_qualified_path_pair_despite_cwd_shadowing` runs the CLI boundary with a valid PATH pair and conflicting cwd programs, then checks the actual selected pair. Python subprocess APIs accept ordinary strings, so a path type cannot prevent a caller from resolving an earlier string again | +| Real oracle tests outside the main scripts discovery also qualify before creating fixtures; unavailable or unverified oracles do not select a passing skip | `test_decode_breadth_fixtures` requires the shared owner before either real-fixture class creates its directory. Only native-backend selection remains optional. The system-version negative control and pinned positive control execute the non-conversion fixture test directly | | Standalone WAVE to WAV refuses stdout during planning rather than passing descriptor syntax to the regular-file writer | `raw_audio::plan` uses the shared `args::stdout` owner after identifying the WAVE source. `wave_wav_stdout_refuses_without_literal_files_and_matches_fallback` checks `-` and `pipe:1`, absent/existing literal paths, zero native stdout, no staging and complete pinned fallback. Runtime source kind distinguishes this file-only contract from registered AAC WAV stdout | | The AAC qualification driver derives native input threads from the shared audio policy rather than maintaining a second count | `native` adapts the shared audio selector to the existing native option spelling; `test_native_input_threads_inherit_the_shared_audio_policy` changes the shared value and checks the resulting command. The actual-script oracle-policy regression checks oracle calls without an exemption; Python types cannot govern command contents | | The map-order and first-input-copy oracle regressions own exclusive per-invocation directories and remove only their own artifacts on exit | `oracle_scratch` creates process/call-qualified paths with `create_dir`, and `FixtureDir` owns cleanup. `oracle_scratch_owns_isolated_directories_until_drop` rejects the former shared-path deletion and proves independent lifetimes. The legacy generated-fixture directory contract retains its existing owner and is not changed by this regression-fixture lifetime fix | diff --git a/scripts/aac_agreement.py b/scripts/aac_agreement.py index 056b6ac03..efa3da867 100755 --- a/scripts/aac_agreement.py +++ b/scripts/aac_agreement.py @@ -115,7 +115,7 @@ def prepare(a): for f in sorted((a.conformance / 'compressedMp4').glob('al*.mp4')): mp4s.append((f'conf-{f.stem}', f)) refs = {} - probe = a.ffmpeg.rsplit('ffmpeg', 1)[0] + 'ffprobe' + probe = a.ffprobe for key, path in mp4s: ref = work / 'ref' / f'{key}.f32' dec = run([a.ffmpeg, '-v', 'error', '-ignore_editlist', '1', *AUDIO_DECODE_INPUT, '-i', path, '-map', '0:a:0', '-f', 'f32le', ref]) @@ -315,7 +315,8 @@ def main(): j.add_argument('--work', type=pathlib.Path, required=True) j.add_argument('--out', type=pathlib.Path, required=True) a = parser.parse_args() - test_oracle.require(a.ffmpeg, getattr(a, "ffprobe", None)) + qualified = test_oracle.require(a.ffmpeg, getattr(a, "ffprobe", None)) + a.ffmpeg, a.ffprobe = str(qualified.ffmpeg), str(qualified.ffprobe) return prepare(a) if a.command == 'prepare' else judge(a) diff --git a/scripts/audio_copy_check.py b/scripts/audio_copy_check.py index dee322bbf..651c55d0b 100755 --- a/scripts/audio_copy_check.py +++ b/scripts/audio_copy_check.py @@ -266,7 +266,8 @@ def main(): parser.add_argument("--work", required=True, type=pathlib.Path) parser.add_argument("--report", type=pathlib.Path) tools = parser.parse_args() - test_oracle.require(tools.ffmpeg, tools.ffprobe) + qualified = test_oracle.require(tools.ffmpeg, tools.ffprobe) + tools.ffmpeg, tools.ffprobe = str(qualified.ffmpeg), str(qualified.ffprobe) sources, out = tools.work / "sources", tools.work / "outputs" shutil.rmtree(tools.work, ignore_errors=True) sources.mkdir(parents=True) diff --git a/scripts/audio_source_diagnostic.py b/scripts/audio_source_diagnostic.py index e64d5edc1..4b6e6ff3c 100644 --- a/scripts/audio_source_diagnostic.py +++ b/scripts/audio_source_diagnostic.py @@ -163,12 +163,12 @@ def main(): parser.add_argument('--fixtures', type=Path, required=True) parser.add_argument('--out', type=Path, required=True) args = parser.parse_args() - args.coreav, args.ffmpeg = args.coreav.resolve(), args.ffmpeg.resolve() + args.coreav = args.coreav.resolve() args.out.mkdir(parents=True, exist_ok=False) report = {'diagnostic_only': True, 'completed': False, 'results': []} report_path = args.out / 'report.json' try: - test_oracle.require(args.ffmpeg) + args.ffmpeg = test_oracle.require(args.ffmpeg).ffmpeg manifest = (args.fixtures / 'MANIFEST').read_text().splitlines() if 'generated browser.webm' not in manifest: raise ValueError('browser fixture is not registered as generated') diff --git a/scripts/exact_skip_check.py b/scripts/exact_skip_check.py index 5775bb636..07f89e917 100644 --- a/scripts/exact_skip_check.py +++ b/scripts/exact_skip_check.py @@ -105,7 +105,8 @@ def main(): p.add_argument('--report', type=pathlib.Path) p.add_argument('files', nargs='*', type=pathlib.Path) a = p.parse_args() - test_oracle.require(a.ffmpeg, a.ffprobe) + qualified = test_oracle.require(a.ffmpeg, a.ffprobe) + a.ffmpeg, a.ffprobe = str(qualified.ffmpeg), str(qualified.ffprobe) files = list(a.files) if a.fixtures: files += sorted(f for f in a.fixtures.iterdir() diff --git a/scripts/gen-v2-fixtures.py b/scripts/gen-v2-fixtures.py index 8dc75c3a9..f312477d8 100644 --- a/scripts/gen-v2-fixtures.py +++ b/scripts/gen-v2-fixtures.py @@ -180,7 +180,8 @@ def main(argv=None): args = parser.parse_args(argv) if any(RECIPES[name].length is None and RECIPES[name].text is None for name in selection(args.only)): - test_oracle.require(args.ffmpeg, args.ffprobe) + qualified = test_oracle.require(args.ffmpeg, args.ffprobe) + args.ffmpeg, args.ffprobe = qualified.ffmpeg, qualified.ffprobe try: names = generate(args.ffmpeg, args.ffprobe, args.out, args.only) except (GenerationError, OSError) as error: diff --git a/scripts/h264_parity.py b/scripts/h264_parity.py index ce210a9fd..2fe449ccf 100644 --- a/scripts/h264_parity.py +++ b/scripts/h264_parity.py @@ -392,7 +392,7 @@ def main(): help='frames of the gate stream (default 300)') ap.add_argument('streams', nargs='+') args = ap.parse_args() - test_oracle.require(args.ffmpeg) + args.ffmpeg = str(test_oracle.require(args.ffmpeg).ffmpeg) host = machine() print(f"machine: {host['cpu_model']} (family {host['cpu_family']}, model " f"{host['cpu_model_number']}, stepping {host['cpu_stepping']}), {host['cpu_mhz']} MHz, " diff --git a/scripts/h264_synth.py b/scripts/h264_synth.py index 4c2f72695..c3a5a01f0 100755 --- a/scripts/h264_synth.py +++ b/scripts/h264_synth.py @@ -59,7 +59,8 @@ def main(): ap.add_argument('--out', required=True, help='directory for the streams') ap.add_argument('--frames', type=int, default=300) args = ap.parse_args() - test_oracle.require(FFMPEG) + global FFMPEG + FFMPEG = str(test_oracle.require(FFMPEG).ffmpeg) os.makedirs(args.out, exist_ok=True) made = [] diff --git a/scripts/he_aac_agreement.py b/scripts/he_aac_agreement.py index 5858929c9..841df4d30 100755 --- a/scripts/he_aac_agreement.py +++ b/scripts/he_aac_agreement.py @@ -863,7 +863,8 @@ def main(): j.add_argument('--out', type=pathlib.Path, required=True) a = parser.parse_args() if a.command != "encode": - test_oracle.require(a.ffmpeg, getattr(a, "ffprobe", None)) + qualified = test_oracle.require(a.ffmpeg, getattr(a, "ffprobe", None)) + a.ffmpeg, a.ffprobe = str(qualified.ffmpeg), str(qualified.ffprobe) return {'sources': sources, 'encode': encode, 'select': select, 'prepare': prepare, 'judge': judge}[a.command](a) diff --git a/scripts/hevc_fixture.py b/scripts/hevc_fixture.py index 7728afdc7..39822ca33 100644 --- a/scripts/hevc_fixture.py +++ b/scripts/hevc_fixture.py @@ -385,7 +385,8 @@ def main(): parser.add_argument('--output', required=True, type=pathlib.Path) parser.add_argument('--registration', type=pathlib.Path, default=REGISTRATION) args = parser.parse_args() - test_oracle.require(args.ffmpeg, args.ffprobe) + qualified = test_oracle.require(args.ffmpeg, args.ffprobe) + args.ffmpeg, args.ffprobe = qualified.ffmpeg, qualified.ffprobe expected = None if args.mode == 'verify': expected = json.loads(args.registration.read_text()) diff --git a/scripts/opus_encode_check.py b/scripts/opus_encode_check.py index 22bda9bf3..69a90ccba 100755 --- a/scripts/opus_encode_check.py +++ b/scripts/opus_encode_check.py @@ -195,7 +195,10 @@ def main(): parser.add_argument('--check-libopus', action='store_true', help='only check and print the libopus each binary links') args = parser.parse_args() - test_oracle.require(args.ffmpeg, args.ffprobe) + qualified = test_oracle.require(args.ffmpeg, args.ffprobe) + args.ffmpeg = str(qualified.ffmpeg) + if args.ffprobe is not None: + args.ffprobe = str(qualified.ffprobe) if not args.check_libopus and None in (args.ffprobe, args.work, args.out): parser.error('--ffprobe, --work and --out are required to judge the bars') libopus = {'pinned': pinned_libopus(), 'coreav': linked_libopus(args.coreav), diff --git a/scripts/oracle.py b/scripts/oracle.py index 069ed30f2..7c18ac758 100755 --- a/scripts/oracle.py +++ b/scripts/oracle.py @@ -234,7 +234,8 @@ def main(): candidate.add_argument("--candidate-exe", type=Path) candidate.add_argument("--candidate-dir", type=Path) args = parser.parse_args() - test_oracle.require(args.ffmpeg, args.ffprobe) + qualified = test_oracle.require(args.ffmpeg, args.ffprobe) + args.ffmpeg, args.ffprobe = str(qualified.ffmpeg), str(qualified.ffprobe) if args.timeout <= 0: parser.error("--timeout must be positive") if args.command == "run" and not (args.candidate_exe or args.candidate_dir): diff --git a/scripts/tests/test_audio_source_diagnostic.py b/scripts/tests/test_audio_source_diagnostic.py index 3c172b0ba..400b72a8d 100644 --- a/scripts/tests/test_audio_source_diagnostic.py +++ b/scripts/tests/test_audio_source_diagnostic.py @@ -49,7 +49,8 @@ def failing_run(command, **kwargs): argv = ['audio_source_diagnostic.py', '--coreav', str(root / 'coreav'), '--ffmpeg', str(root / 'ffmpeg'), '--fixtures', str(root), '--out', str(output)] with mock.patch.object(sys, 'argv', argv), mock.patch.object(diagnostic, 'run', failing_run), \ - mock.patch.object(diagnostic.test_oracle, 'require'): + mock.patch.object(diagnostic.test_oracle, 'require', side_effect=lambda path: + diagnostic.test_oracle.Oracle(path, path.with_name('ffprobe'))): with self.assertRaises((RuntimeError, FileNotFoundError)): diagnostic.main() report = diagnostic.json.loads((output / 'report.json').read_text()) diff --git a/scripts/tests/test_gen_v2_fixtures.py b/scripts/tests/test_gen_v2_fixtures.py index ca1afe431..7936097f2 100644 --- a/scripts/tests/test_gen_v2_fixtures.py +++ b/scripts/tests/test_gen_v2_fixtures.py @@ -161,7 +161,8 @@ def test_failed_generation_preserves_existing_outputs_and_cleans_staging(self): target = out / 'v2_still_rgba.png' target.write_bytes(b'previous complete fixture') stdout, stderr = io.StringIO(), io.StringIO() - with patch.object(generator.test_oracle, 'require'), \ + with patch.object(generator.test_oracle, 'require', return_value=generator.test_oracle.Oracle( + Path('/oracle/ffmpeg'), Path('/oracle/ffprobe'))), \ patch.object(generator.subprocess, 'run', side_effect=subprocess.TimeoutExpired( 'ffmpeg', 180, stderr=b'partial encoder diagnostic')): with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr): diff --git a/scripts/tests/test_hevc_fixture.py b/scripts/tests/test_hevc_fixture.py index a125add72..55249e56e 100644 --- a/scripts/tests/test_hevc_fixture.py +++ b/scripts/tests/test_hevc_fixture.py @@ -152,7 +152,8 @@ def test_changed_registered_digest_or_recipe_fails_verification(self): args = ['hevc_fixture.py', 'verify', '--ffmpeg', '/ffmpeg', '--ffprobe', '/ffprobe', '--output', directory, '--registration', str(registration)] with mock.patch.object(sys, 'argv', args), \ - mock.patch.object(runner.test_oracle, 'require'), \ + mock.patch.object(runner.test_oracle, 'require', return_value=runner.test_oracle.Oracle( + pathlib.Path('/ffmpeg'), pathlib.Path('/ffprobe'))), \ mock.patch.object(runner, 'binary_identity', return_value=expected['oracle']), \ mock.patch.object(runner, 'prepare', return_value=expected), \ self.assertRaisesRegex(ValueError, 'expected hashes differ'): @@ -163,7 +164,8 @@ def test_registered_binary_mismatch_stops_before_generation(self): args = ['hevc_fixture.py', 'verify', '--ffmpeg', '/ffmpeg', '--ffprobe', '/ffprobe', '--output', directory] with mock.patch.object(sys, 'argv', args), \ - mock.patch.object(runner.test_oracle, 'require'), \ + mock.patch.object(runner.test_oracle, 'require', return_value=runner.test_oracle.Oracle( + pathlib.Path('/ffmpeg'), pathlib.Path('/ffprobe'))), \ mock.patch.object(runner, 'binary_identity', return_value={}), \ mock.patch.object(runner, 'prepare') as prepare, \ self.assertRaisesRegex(ValueError, 'oracle identity differs'): diff --git a/scripts/tests/test_test_oracle.py b/scripts/tests/test_test_oracle.py index 93b4fd90c..ece1515ad 100644 --- a/scripts/tests/test_test_oracle.py +++ b/scripts/tests/test_test_oracle.py @@ -150,6 +150,27 @@ def test_relocated_bundle_keeps_the_same_pin_and_complete_import_closure(self): self.assertEqual(result.stdout.splitlines(), [str(self.root / 'ffmpeg'), str(self.root / 'ffprobe')]) + def test_vp9_main_retains_the_qualified_path_pair_despite_cwd_shadowing(self): + shadow = self.root / 'shadow' + self.pair(shadow, version='0.0.0') + self.child('import os\n' + 'from pathlib import Path\n' + 'from unittest.mock import patch\n' + 'import vp9_speed\n' + 'root = Path(sys.argv[2])\n' + 'os.chdir(root / "shadow")\n' + 'os.environ["PATH"] = str(root) + os.pathsep + os.environ.get("PATH", "")\n' + 'sys.argv = ["vp9_speed.py", "oracle", "--ffmpeg", "ffmpeg", "--ffprobe", "ffprobe",\n' + ' "--selection", "missing", "--files", "missing", "--out", "uncreated",\n' + ' "--decode-oracle", "missing"]\n' + 'def inspect_selected(args):\n' + ' assert args.ffmpeg == str(root / "ffmpeg"), args.ffmpeg\n' + ' assert args.ffprobe == str(root / "ffprobe"), args.ffprobe\n' + ' return 0\n' + 'with patch.object(vp9_speed, "oracle", side_effect=inspect_selected) as run:\n' + ' assert vp9_speed.main() == 0\n' + ' assert run.call_count == 1\n') + def test_active_entry_points_reject_before_creating_fixture_or_report_output(self): self.pair(self.root, version='0.0.0') ffmpeg, ffprobe = str(self.root / 'ffmpeg'), str(self.root / 'ffprobe') diff --git a/scripts/thumbnail_oracle.py b/scripts/thumbnail_oracle.py index ec8dfa547..94a67d4ae 100644 --- a/scripts/thumbnail_oracle.py +++ b/scripts/thumbnail_oracle.py @@ -441,7 +441,8 @@ def main(): p.add_argument('--report') p.add_argument('files', nargs='*') a = p.parse_args() - test_oracle.require(a.ffmpeg, a.ffprobe) + qualified = test_oracle.require(a.ffmpeg, a.ffprobe) + a.ffmpeg, a.ffprobe = str(qualified.ffmpeg), str(qualified.ffprobe) if a.fixtures: return fixtures(a) for f in a.files: diff --git a/scripts/transcode_check.py b/scripts/transcode_check.py index ffeca782e..691df0273 100644 --- a/scripts/transcode_check.py +++ b/scripts/transcode_check.py @@ -1912,7 +1912,8 @@ def main(): p.error('--coreav and at least one --arm are required') if not args.ffmpeg or not args.ffprobe: p.error('ffmpeg and ffprobe are required (--ffmpeg, --ffprobe)') - test_oracle.require(args.ffmpeg, args.ffprobe) + qualified = test_oracle.require(args.ffmpeg, args.ffprobe) + args.ffmpeg, args.ffprobe = str(qualified.ffmpeg), str(qualified.ffprobe) global ENV ENV = child_env(args.ffmpeg) if identity is not None: diff --git a/scripts/transcode_speed.py b/scripts/transcode_speed.py index 4cf6aeb6d..d25b28c5f 100644 --- a/scripts/transcode_speed.py +++ b/scripts/transcode_speed.py @@ -449,7 +449,8 @@ def main(): rep = summarize(args.out, sel, args.classes) print(table(rep)) return status(rep) - test_oracle.require(args.ffmpeg, args.ffprobe) + qualified = test_oracle.require(args.ffmpeg, args.ffprobe) + args.ffmpeg, args.ffprobe = str(qualified.ffmpeg), str(qualified.ffprobe) args.arms = tc.parse_arms(args.arm, p) for need in ('selection', 'files', 'coreav', 'gate', 'out'): if not getattr(args, need): diff --git a/scripts/vp9_speed.py b/scripts/vp9_speed.py index eaba79c06..71fea8668 100644 --- a/scripts/vp9_speed.py +++ b/scripts/vp9_speed.py @@ -786,8 +786,8 @@ def main(): for need in ('selection', 'files', 'out', 'ffmpeg', 'ffprobe'): if not getattr(args, need): p.error(f'{args.command} needs --{need.replace("_", "-")}') - test_oracle.require(args.ffmpeg, args.ffprobe) - args.ffmpeg, args.ffprobe = os.path.abspath(args.ffmpeg), os.path.abspath(args.ffprobe) + qualified = test_oracle.require(args.ffmpeg, args.ffprobe) + args.ffmpeg, args.ffprobe = str(qualified.ffmpeg), str(qualified.ffprobe) tc.ENV = tc.child_env(args.ffmpeg) to.ENV = tc.ENV to.DECODE_ORACLE_ARGS = ['--max-memory-gib', str(args.decode_memory_gib)] if args.decode_memory_gib else [] diff --git a/tools/compat-corpus/tests/test_decode_breadth.py b/tools/compat-corpus/tests/test_decode_breadth.py index 69f95ee0a..9c7162bdd 100644 --- a/tools/compat-corpus/tests/test_decode_breadth.py +++ b/tools/compat-corpus/tests/test_decode_breadth.py @@ -28,6 +28,9 @@ tool = os.path.basename(sys.argv[0]) argv = sys.argv[1:] +if argv == ['-version'] and tool in ('ffmpeg', 'ffprobe'): + print(tool + ' version %(build)s') + sys.exit(0) path = argv[argv.index('-i') + 1] if tool == 'ffmpeg' else argv[-1] spec = json.load(open(path + '.spec')).get({'ffprobe': 'probe', 'ffmpeg': 'reference', 'decode-oracle': 'coreav'}[tool], {}) with open(path + '.calls', 'a') as log: @@ -82,7 +85,7 @@ def setUp(self): self.addCleanup(__import__('shutil').rmtree, self.dir, True) for tool in ('ffprobe', 'ffmpeg', 'decode-oracle'): path = self.dir / tool - path.write_text(STUB % {'python': sys.executable}) + path.write_text(STUB % {'python': sys.executable, 'build': decode_breadth.test_oracle.oracle_pin.load()['BUILD']}) path.chmod(path.stat().st_mode | stat.S_IXUSR) self.entries = [] diff --git a/tools/compat-corpus/tests/test_decode_breadth_fixtures.py b/tools/compat-corpus/tests/test_decode_breadth_fixtures.py index d2989a926..677b2a207 100644 --- a/tools/compat-corpus/tests/test_decode_breadth_fixtures.py +++ b/tools/compat-corpus/tests/test_decode_breadth_fixtures.py @@ -2,7 +2,8 @@ pinned ffmpeg: V1's fixture check in CI (docs/measurements/compat-0.1.0/ codec-coverage-plan.md, "The tools"). Set COREAV_DECODE_ORACLE, COREAV_FFMPEG and COREAV_FFPROBE to the built decode-oracle (features native-h264,dav1d,libvpx -on Linux) and the pinned ffmpeg and ffprobe; without them every test skips. +on Linux) and the pinned ffmpeg and ffprobe. Backend-specific checks are +selected by COREAV_DECODE_ORACLE; real oracle work always requires a qualified pair. Streams CoreAV's build does not decode here (no sandbox off Linux) and codecs the ffmpeg has no encoder for are left out. Synthetic media only.""" import argparse @@ -21,6 +22,7 @@ sys.path.insert(0, str(HERE)) import decode_breadth # noqa: E402 +import test_oracle PROGRAMS = {k: os.environ.get(v) for k, v in (('decode_oracle', 'COREAV_DECODE_ORACLE'), ('ffmpeg', 'COREAV_FFMPEG'), ('ffprobe', 'COREAV_FFPROBE'))} @@ -28,10 +30,12 @@ FRAMES = '40' -@unittest.skipUnless(all(PROGRAMS.values()), 'COREAV_DECODE_ORACLE, COREAV_FFMPEG and COREAV_FFPROBE are not set') +@unittest.skipUnless(PROGRAMS['decode_oracle'], 'COREAV_DECODE_ORACLE is not set') class Fixtures(unittest.TestCase): @classmethod def setUpClass(cls): + oracle = test_oracle.require(PROGRAMS['ffmpeg'], PROGRAMS['ffprobe']) + PROGRAMS.update(ffmpeg=str(oracle.ffmpeg), ffprobe=str(oracle.ffprobe)) cls.dir = pathlib.Path(tempfile.mkdtemp(prefix='decode-breadth-fixtures-')) cls.entries = [] cls.made = {} @@ -115,7 +119,6 @@ def test_the_summary_of_the_run_is_complete(self): self.assertEqual(s['denominator'], len(self.entries)) -FFMPEG = PROGRAMS['ffmpeg'] T709 = 'colorprim=bt709:transfer=bt709:colormatrix=bt709' T601 = 'colorprim=smpte170m:transfer=smpte170m:colormatrix=smpte170m' V709 = ['-colorspace', 'bt709', '-color_primaries', 'bt709', '-color_trc', 'bt709'] @@ -123,7 +126,6 @@ def test_the_summary_of_the_run_is_complete(self): VP9 = ['-c:v', 'libvpx-vp9', '-b:v', '500k', '-g', '25', '-auto-alt-ref', '0'] -@unittest.skipUnless(FFMPEG, 'COREAV_FFMPEG is not set') class UnconvertedReference(unittest.TestCase): """The reference's no-conversion pin (codec-coverage-plan.md, "The reference"): a stream whose colour description, range, pixel format or size changes mid-stream gives the MD5s of its segments decoded one at a time, @@ -132,6 +134,7 @@ class UnconvertedReference(unittest.TestCase): @classmethod def setUpClass(cls): + cls.ffmpeg = str(test_oracle.require(PROGRAMS['ffmpeg'], PROGRAMS['ffprobe']).ffmpeg) cls.dir = pathlib.Path(tempfile.mkdtemp(prefix='decode-breadth-unconverted-')) (cls.dir / 'gconv').mkdir() cls.env = {'PATH': os.environ.get('PATH', ''), 'HOME': os.environ.get('HOME', ''), @@ -142,7 +145,7 @@ def tearDownClass(cls): __import__('shutil').rmtree(cls.dir, ignore_errors=True) def ff(self, *args): - done = subprocess.run([FFMPEG, '-nostdin', '-v', 'error', '-y', *args], capture_output=True, text=True, + done = subprocess.run([self.ffmpeg, '-nostdin', '-v', 'error', '-y', *args], capture_output=True, text=True, env=self.env) self.assertEqual(done.returncode, 0, done.stderr) @@ -177,7 +180,7 @@ def vp9(self, name, segments): def md5s(self, path, unconverted, codec='h264', pix_fmt='yuv420p', decoder=None): backend = 'libvpx' if codec == 'vp9' and not decoder else 'ffmpeg' - cmd = decode_breadth.thumbnail_oracle.framemd5_command(FFMPEG, path, path.suffix[1:], 0, None, backend, codec, + cmd = decode_breadth.thumbnail_oracle.framemd5_command(self.ffmpeg, path, path.suffix[1:], 0, None, backend, codec, pix_fmt, unconverted=unconverted) if decoder: cmd[cmd.index('-i'):cmd.index('-i')] = ['-c:v', decoder] @@ -246,7 +249,7 @@ def test_the_alpha_path_never_reaches_a_codec_v1_counts(self): self.ff(*self.source(64, 48, 0), '-pix_fmt', 'yuva420p', *encoder, '-auto-alt-ref', '0', str(path)) self.assertEqual(self.pix_fmt(path), 'yuv420p', name) self.assertNotIn('-pix_fmt', decode_breadth.thumbnail_oracle.framemd5_command( - FFMPEG, path, 'webm', 0, None, 'libvpx', name, self.pix_fmt(path), unconverted=True)) + self.ffmpeg, path, 'webm', 0, None, 'libvpx', name, self.pix_fmt(path), unconverted=True)) parts = [] for i, (profile, pix_fmt) in enumerate((('4444', 'yuva444p10le'), ('standard', 'yuv422p10le'))): part = self.dir / f'prores.{i}.mov' diff --git a/tools/compat-corpus/tests/test_encode_breadth.py b/tools/compat-corpus/tests/test_encode_breadth.py index 98428c6a7..6f8c86234 100644 --- a/tools/compat-corpus/tests/test_encode_breadth.py +++ b/tools/compat-corpus/tests/test_encode_breadth.py @@ -950,7 +950,12 @@ def pinned_stand_ins(self): def test_preflight_records_the_supplied_pinned_executables(self): self.pinned_stand_ins() - programs = eb.oracle_programs(self.opts) + program = ('import sys, json, types; sys.path.insert(0, sys.argv[1]); ' + 'import encode_breadth as eb; ' + 'print(json.dumps(eb.oracle_programs(types.SimpleNamespace(' + 'ffmpeg=sys.argv[2], ffprobe=sys.argv[3]))))') + programs = json.loads(subprocess.check_output( + [sys.executable, '-I', '-c', program, str(HERE), self.opts.ffmpeg, self.opts.ffprobe], text=True)) for name in ('ffmpeg', 'ffprobe'): self.assertEqual(programs[name], {'version': name + ' version ' + eb.oracle_pin.load()['BUILD'], 'sha256': eb.sha256(getattr(self.opts, name))}) diff --git a/tools/compat-corpus/tests/test_r4_scan.py b/tools/compat-corpus/tests/test_r4_scan.py index a63a75a75..ad3995616 100644 --- a/tools/compat-corpus/tests/test_r4_scan.py +++ b/tools/compat-corpus/tests/test_r4_scan.py @@ -13,6 +13,8 @@ sys.path.insert(0, str(HERE)) import release_round # noqa: E402 +sys.path.insert(0, str(HERE.parents[1] / 'scripts')) +import oracle_pin # ffprobe lists one video and one audio stream; ffmpeg writes its output and fails on WebM; coreav refuses a # command that seeks (an option), refuses every ffmpeg command on WebM (the file), and crashes on @@ -20,6 +22,9 @@ FAKE = r'''#!/usr/bin/env python3 import json, os, pathlib, sys name, args = pathlib.Path(sys.argv[0]).name, sys.argv[1:] +if args == ['-version'] and name in ('ffmpeg', 'ffprobe'): + print(name + ' version ORACLE_BUILD') + sys.exit(0) assert os.environ['GCONV_PATH'] == '/nonexistent/gconv' and os.environ['COREAV_STRICT_SAFE'] == '1' def refuse(reason): with open(os.environ['COREAV_FALLBACK_LOG'], 'a') as f: @@ -52,7 +57,7 @@ def setUpClass(cls): cls.bin = d / 'bin' cls.bin.mkdir() for name in ('coreav', 'ffmpeg', 'ffprobe'): - (cls.bin / name).write_text(FAKE) + (cls.bin / name).write_text(FAKE.replace('ORACLE_BUILD', oracle_pin.load()['BUILD'])) (cls.bin / name).chmod(0o755 | stat.S_IEXEC) media = d / 'media' media.mkdir() From 19f0ccfa63f6bbf6b1625edf9bb2496ace9f8b1c Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 13:03:55 +0000 Subject: [PATCH 06/21] docs(ffmpeg): plan invocation discovery Signed-off-by: gunwooterry --- docs/design/local-oracle-qualification.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/docs/design/local-oracle-qualification.md b/docs/design/local-oracle-qualification.md index 69bea62f9..8e776aa80 100644 --- a/docs/design/local-oracle-qualification.md +++ b/docs/design/local-oracle-qualification.md @@ -23,3 +23,13 @@ Real callers use the common owner before fixture generation or comparison. Liter The owner retains both success and failure for the process, rejects a changed selection and delegates all version predicates to the existing platform verifier. The Rust adapter retains that result once per test binary. Remote source bundles retain the normal repository-relative `scripts` layout, both pin files, the common owner and its transitive local imports. Their binary selection and comparison arguments do not change. Bundle checks run with synthetic banner-only programs; no remote media or performance run is required. Registered measurement drivers remain exceptions: B4's `b4_round10.TOOL_FILES`, VP9's `CAPTURE_SCRIPTS`, audio-decode's `JUDGING_INPUTS`, and the registered H.264 PGO diagnostic and acquisition sources keep their existing pin, provenance and workflow verification. Their code and registered source rosters are unchanged. Adding an owner dependency to those drivers would change a registered source closure. + +## Invocation discovery plan + +Discover process boundaries and oracle command construction across the tracked source tree, including separate tests, generated programs, qualified Rust constructor names, shell command substitutions and workflow run blocks. Do not use an owner import or an executable's variable name as a qualification proof. Retain opaque boundaries until their actual caller and selected executable have been traced. + +Historical measurement records under `docs/measurements/` retain their exact bytes because they record what earlier runs executed. Record the complete path set and SHA-256 digests outside that boundary. Check the current files against that record before excluding historical source from invocation discovery. A missing, added, renamed or edited file fails; a directory prefix alone never grants an exception. Keep the separately registered protected source files and their rosters unchanged. + +Classify each remaining discovery hit as a confirmed bypass, already routed through qualification, or a false positive, with the actual boundary and the evidence for its disposition. Keep unknown hits failing rather than counting them as bypasses or qualified calls. Bind reviewed dispositions to their source and qualification dependencies so a new invocation or changed proof requires review. Cover explicit executable identity, early dispatch, source bundles and relocated production adapters separately from local source-pattern matches. + +Report the confirmed-bypass count before changing any consumers. If the remaining migration cannot stay coherent with the existing deployment and dispatch repairs, split only after a scope decision. Run only short local source and generated regression checks during discovery; no media corpus, performance or remote infrastructure run is required. From eaf1fb07b3eacdb1652442065b6d9505dd57ff95 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 13:27:43 +0000 Subject: [PATCH 07/21] test(ffmpeg): inventory oracle process boundaries Signed-off-by: gunwooterry --- scripts/oracle_invocation_check.py | 408 ++ scripts/tests/test_oracle_invocation_check.py | 112 + test-support/oracle-historical-records.json | 4888 +++++++++++++++++ 3 files changed, 5408 insertions(+) create mode 100644 scripts/oracle_invocation_check.py create mode 100644 scripts/tests/test_oracle_invocation_check.py create mode 100644 test-support/oracle-historical-records.json diff --git a/scripts/oracle_invocation_check.py b/scripts/oracle_invocation_check.py new file mode 100644 index 000000000..05040cdd3 --- /dev/null +++ b/scripts/oracle_invocation_check.py @@ -0,0 +1,408 @@ +"""Discover execution boundaries and require source-bound review dispositions.""" +import argparse +import ast +from collections import Counter +import hashlib +import json +from pathlib import Path +import re +import shlex +import shutil +import subprocess + +ROOT = Path(__file__).resolve().parent.parent +HISTORICAL_BOUNDARY = 'docs/measurements' +HISTORICAL_RECORD = 'test-support/oracle-historical-records.json' + + +def historical_records(root, record): + if record.get('schema') != 1 or record.get('boundary') != HISTORICAL_BOUNDARY: + raise ValueError('restore the recorded historical boundary and schema') + expected = record.get('files') + if not isinstance(expected, dict) or not expected or not all(isinstance(key, str) for key in expected): + raise ValueError('restore the nonempty historical path and digest record') + boundary = root / HISTORICAL_BOUNDARY + actual = {path.relative_to(root).as_posix(): path for path in boundary.rglob('*') + if path.is_file() or path.is_symlink()} + problems = [] + for path in sorted(expected.keys() | actual.keys()): + if not path.startswith(HISTORICAL_BOUNDARY + '/') or '..' in Path(path).parts: + problems.append('invalid historical path: ' + path) + elif path not in expected: + problems.append('added historical file: ' + path) + elif path not in actual: + problems.append('missing historical file: ' + path) + elif actual[path].is_symlink(): + problems.append('historical file is a symbolic link: ' + path) + elif not isinstance(expected[path], str) or not re.fullmatch('[0-9a-f]{64}', expected[path]): + problems.append('invalid historical digest: ' + path) + elif hashlib.sha256(actual[path].read_bytes()).hexdigest() != expected[path]: + problems.append('edited historical file: ' + path) + if problems: + raise ValueError('\n'.join(problems)) + return set(expected) + +ROLE = re.compile(r'(?i)(?:ffmpeg|ffprobe|\bff\b|\bprobe\b)') +FLAGS = {'-show_streams', '-show_format', '-show_packets', '-select_streams', + '-hide_banner', '-nostdin', '-c:v', '-c:a', '-lavfi', '-filter_complex'} +PROCESS = {'run', 'Popen', 'call', 'check_call', 'check_output', 'getoutput', 'getstatusoutput'} +OTHER = {'git', 'cargo', 'rustc', 'rustup', 'python', 'python3', 'node', 'npm', 'npx', + 'bash', 'sh', 'curl', 'tar', 'gcc', 'clang', 'pkg-config', 'ast-grep', 'uname', + 'lscpu', 'perf', 'taskset', 'sudo', 'true', 'false', 'sleep', 'mediainfo'} +BOOTSTRAP = {'scripts/oracle_pin.py', 'scripts/oracle_pin_macos.py', 'scripts/test_oracle.py'} +RUNTIME = {'crates/coreav-cli/src/fallback_cmd.rs', 'crates/coreav-worker/src/main.rs', + 'crates/coreav-backend-ffmpeg/src/lib.rs'} + + +def frozen_files(root, paths): + values = {} + for rel in ('scripts/compat_sources.py', 'tools/compat-corpus/b4_round10.py', + 'scripts/vp9_pixel_round.py', 'bench/audio-decode/capacity.py', + 'scripts/h264_pgo_diagnostics.py'): + local = {} + for node in ast.parse((root / rel).read_text()).body: + if not isinstance(node, ast.Assign) or len(node.targets) != 1 or not isinstance(node.targets[0], ast.Name): + continue + try: + value = (tuple(local[item.id] if isinstance(item, ast.Name) else ast.literal_eval(item) + for item in node.value.elts) if isinstance(node.value, ast.Tuple) + else ast.literal_eval(node.value)) + local[node.targets[0].id] = value + except (ValueError, TypeError, KeyError): + pass + values[rel] = local + compatibility = values['scripts/compat_sources.py'] + protected = set(compatibility['FROZEN']) | set(compatibility['JUDGING']) + protected.add(compatibility['JUDGING_REGISTRATION']) + protected.update(values['tools/compat-corpus/b4_round10.py']['TOOL_FILES']) + protected.update('scripts/' + name for name in values['scripts/vp9_pixel_round.py']['CAPTURE_SCRIPTS']) + protected.update(values['bench/audio-decode/capacity.py']['SCRIPT_INPUTS']) + protected.update('bench/audio-decode/' + name + '.py' + for name in ('capacity', 'run', 'receipts', 'oracle', 'agreement')) + protected.update(values['scripts/h264_pgo_diagnostics.py']['TOOLS']) + protected.add('scripts/h264_pgo_acquire.py') + return {path for path in paths if any(path == name or path.startswith(name + '/') for name in protected)} + + +class PythonSites: + def __init__(self, text, path): + self.tree = ast.parse(text) + self.path = path + self.sites = {} + self.process_names = set() + self.process_modules = {'subprocess', 'os', 'asyncio'} + self.owners = set() + for node in ast.walk(self.tree): + if isinstance(node, ast.ImportFrom) and node.module == 'subprocess': + self.process_names.update(item.asname or item.name for item in node.names if item.name in PROCESS) + if isinstance(node, ast.ImportFrom) and node.module == 'test_oracle': + self.owners.update(item.asname or item.name for item in node.names if item.name == 'require') + if isinstance(node, ast.Import): + for item in node.names: + if item.name in ('subprocess', 'os', 'asyncio'): + self.process_modules.add(item.asname or item.name) + if item.name == 'test_oracle': + self.owners.add((item.asname or item.name) + '.require') + for _ in range(len(list(ast.walk(self.tree)))): + before = len(self.process_names) + for node in ast.walk(self.tree): + if isinstance(node, ast.Assign): + name = ast.unparse(node.value) + if name in self.process_names or name.split('.', 1)[0] in self.process_modules and name.rsplit('.', 1)[-1] in PROCESS: + self.process_names.update(target.id for target in node.targets if isinstance(target, ast.Name)) + if len(self.process_names) == before: + break + + def owner(self, node): + name = ast.unparse(node) + return name in self.owners + + def value(self, node, state): + key = ast.unparse(node) + if key in state: + return state[key] + if isinstance(node, ast.Constant) and isinstance(node.value, str): + if 'literal:' + node.value in state: + return state['literal:' + node.value] + return 'oracle' if ROLE.search(Path(node.value).name) else 'other' + if isinstance(node, (ast.List, ast.Tuple)): + if not node.elts: + return 'argv:other' + if isinstance(node.elts[0], ast.Constant) and isinstance(node.elts[0].value, str) and node.elts[0].value.startswith('-'): + return 'argv:other' + first = self.value(node.elts[0], state) + flags = {n.value for n in node.elts if isinstance(n, ast.Constant) and isinstance(n.value, str)} + program = ast.unparse(node.elts[0]) + if first != 'verified' and flags & FLAGS and 'coreav' not in program: + first = 'oracle' + return 'argv:' + first + if isinstance(node, ast.Attribute) and node.attr in ('ffmpeg', 'ffprobe'): + return 'verified' if self.value(node.value, state) == 'pair' else 'oracle' + if isinstance(node, ast.Call): + if self.owner(node.func): + return 'pair' + name = ast.unparse(node.func) + if name in ('str', 'Path', 'pathlib.Path', 'os.path.abspath', 'os.fspath') and node.args: + value = self.value(node.args[0], state) + return value if not value.startswith('argv:') else 'unknown' + if isinstance(node.func, ast.Attribute) and node.func.attr in ('resolve', 'absolute'): + value = self.value(node.func.value, state) + return value if value == 'verified' else 'oracle' if ROLE.search(key) else 'unknown' + if name == 'getattr' and len(node.args) > 1 and isinstance(node.args[1], ast.Constant): + return self.value(ast.Attribute(value=node.args[0], attr=node.args[1].value, ctx=ast.Load()), state) + return 'oracle' if ROLE.search(key) else 'unknown' + + def add(self, node, state, scope, kind): + if isinstance(node, (ast.List, ast.Tuple)): + expression = ast.unparse(node.elts[0]) if node.elts else '[]' + else: + expression = ast.unparse(node) + tag = self.value(node, state).removeprefix('argv:') + if tag == 'other': + return + key = (node.lineno, scope, expression) + self.sites[key] = dict(path=self.path, line=node.lineno, scope=scope, kind=kind, + program=expression, status='qualified' if tag == 'verified' else 'unproven', + role='oracle' if tag in ('oracle', 'verified') else 'opaque') + + def expression(self, node, state, scope): + if isinstance(node, ast.Call): + name = ast.unparse(node.func) + leaf = name.rsplit('.', 1)[-1] + process = (name in self.process_names or name.split('.', 1)[0] in self.process_modules + and (leaf in PROCESS or leaf.startswith(('exec', 'spawn', 'posix_spawn')) or leaf in ('system', 'popen', 'create_subprocess_exec', + 'create_subprocess_shell'))) + if process and node.args: + self.add(node.args[0], state, scope, 'process') + if name in ('eval', 'exec', 'compile') and node.args: + self.add(node.args[0], {}, scope, 'generated-execution') + if isinstance(node.func, ast.Attribute) and node.func.attr == 'update': + for keyword in node.keywords: + if keyword.arg: + state[ast.unparse(node.func.value) + '[' + repr(keyword.arg) + ']'] = self.value(keyword.value, state) + if name in ('os.chdir', 'os.fchdir', 'os.putenv'): + for key in list(state): + if key.startswith('literal:'): + del state[key] + if isinstance(node, (ast.List, ast.Tuple)) and node.elts: + tag = self.value(node, state) + flags = any(isinstance(item, ast.Starred) or isinstance(item, ast.Constant) + and isinstance(item.value, str) and item.value.startswith('-') for item in node.elts[1:]) + if tag in ('argv:oracle', 'argv:verified') and flags: + self.add(node, state, scope, 'command') + for child in ast.iter_child_nodes(node): + self.expression(child, state, scope) + + def bind(self, target, value, state): + if isinstance(target, (ast.Tuple, ast.List)) and isinstance(value, (ast.Tuple, ast.List)): + for left, right in zip(target.elts, value.elts): + self.bind(left, right, state) + else: + state[ast.unparse(target)] = self.value(value, state) + if isinstance(value, ast.Call) and ast.unparse(value.func).endswith(('Namespace', 'SimpleNamespace')): + for keyword in value.keywords: + if keyword.arg: + state[ast.unparse(target) + '.' + keyword.arg] = self.value(keyword.value, state) + + def block(self, statements, state, scope): + for statement in statements: + if isinstance(statement, (ast.FunctionDef, ast.AsyncFunctionDef)): + self.block(statement.body, dict(state), scope + '.' + statement.name) + continue + if isinstance(statement, ast.ClassDef): + initial = dict(state) + setup = next((n for n in statement.body if isinstance(n, ast.FunctionDef) and n.name == 'setUpClass'), None) + if setup: + prepared = self.block(setup.body, dict(initial), scope + '.' + statement.name + '.setUpClass') + initial.update({key.replace('cls.', 'self.', 1): value for key, value in prepared.items() + if key.startswith('cls.')}) + self.block(statement.body, initial, scope + '.' + statement.name) + continue + if isinstance(statement, ast.If): + self.expression(statement.test, state, scope) + left = self.block(statement.body, dict(state), scope) + right = self.block(statement.orelse, dict(state), scope) + state = {key: value for key, value in left.items() if right.get(key) == value} + continue + if isinstance(statement, (ast.For, ast.AsyncFor, ast.While)): + self.expression(statement.iter if hasattr(statement, 'iter') else statement.test, state, scope) + self.block(statement.body, dict(state), scope) + self.block(statement.orelse, dict(state), scope) + continue + if isinstance(statement, (ast.Try, ast.With, ast.AsyncWith)): + bodies = [statement.body, *([handler.body for handler in statement.handlers] if isinstance(statement, ast.Try) else [])] + branches = [self.block(body, dict(state), scope) for body in bodies] + state = {key: value for key, value in branches[0].items() if all(b.get(key) == value for b in branches[1:])} + if isinstance(statement, ast.Try): + state = self.block(statement.finalbody, state, scope) + continue + self.expression(statement, state, scope) + if isinstance(statement, ast.Assign): + for target in statement.targets: + self.bind(target, statement.value, state) + elif isinstance(statement, ast.AnnAssign) and statement.value: + self.bind(statement.target, statement.value, state) + return state + + def collect(self): + self.block(self.tree.body, {}, '') + for node in ast.walk(self.tree): + if not isinstance(node, ast.Constant) or not isinstance(node.value, str) or '\n' not in node.value: + continue + if ROLE.search(node.value) and any(token in node.value for token in ('subprocess.', 'Command::new', '#!/bin/sh', '#!/bin/bash')): + self.sites[(node.lineno, 'embedded', '')] = dict(path=self.path, line=node.lineno, scope='embedded', + kind='embedded-source', program='', + status='unproven', role='opaque') + return list(self.sites.values()) + + +def shell_sites(text, path, offset=0): + found = [] + result = subprocess.run(['ast-grep', 'run', '--lang', 'Bash', '--kind', 'command', '--stdin', '--json=stream'], + input=text, capture_output=True, text=True, check=False) + if result.returncode not in (0, 1): + raise RuntimeError('shell syntax discovery failed') + for row in result.stdout.splitlines(): + node = json.loads(row) + line = node['range']['start']['line'] + offset + 1 + source = node['text'] + try: + tokens = shlex.split(source, comments=True) + except ValueError: + tokens = source.split() + if not tokens: + continue + first = tokens[0] + if first in ('echo', 'printf', 'export'): + continue + oracle = bool(ROLE.search(first)) and not first.endswith(('.py', '.sh', '.rs', '.json')) + dynamic = first.startswith(('$', '"$')) and '=' not in first + if oracle or dynamic: + found.append(dict(path=path, line=line, scope='', kind='shell', program=source.strip(), + status='unproven', role='oracle' if oracle else 'opaque')) + return found + + +def structural_sites(root, paths, language, pattern, variable, accepted, constructor=None): + if not paths: + return [] + command = ['ast-grep', 'run', '--lang', language, '--pattern', pattern] + if constructor: + rule = {'id': 'oracle-constructor', 'language': language, 'rule': {'pattern': pattern}, + 'constraints': {'CALL': {'regex': constructor}}} + command = ['ast-grep', 'scan', '--inline-rules', json.dumps(rule)] + result = subprocess.run([*command, '--json=stream', *paths], + cwd=root, capture_output=True, text=True, check=False) + if result.returncode not in (0, 1): + raise RuntimeError(result.stderr) + found = [] + for line in result.stdout.splitlines(): + item = json.loads(line) + if accepted and not accepted(item): + continue + program = item['metaVariables']['single'][variable]['text'] + name = program.strip('"\' ') + if name in OTHER or 'current_exe(' in program: + continue + qualified = bool(re.search(r'(?:test_oracle|oracle_support)::require\(\)\s*\.\s*ff(?:mpeg|probe)\(\)', program)) + found.append(dict(path=item['file'], line=item['range']['start']['line'] + 1, scope='', + kind=language, program=program, status='qualified' if qualified else 'unproven', + role='oracle' if ROLE.search(program) else 'opaque')) + return found + + +def workflow_sites(text, path): + reader = '''require 'psych'; require 'json' +rows = [] +walk = lambda do |node| + if node.is_a?(Psych::Nodes::Mapping) + node.children.each_slice(2) do |key, value| + if key.is_a?(Psych::Nodes::Scalar) && key.value == 'run' && value.is_a?(Psych::Nodes::Scalar) + rows << [value.value, value.start_line + ([4, 5].include?(value.style) ? 1 : 0)] + end + end + end + (node.respond_to?(:children) && node.children || []).each { |child| walk.call(child) } +end +walk.call(Psych.parse_stream(STDIN.read)) +puts JSON.generate(rows) +''' + result = subprocess.run(['ruby', '-e', reader], input=text, capture_output=True, text=True, check=False) + if result.returncode: + raise ValueError('workflow run blocks could not be parsed: ' + path) + sites = [] + for command, offset in json.loads(result.stdout): + command = re.sub(r'\$\{\{[^}]*\}\}', '$GITHUB_VALUE', command) + sites.extend(shell_sites(command, path, offset)) + return sites + + +def inventory(root): + paths = sorted(set(filter(None, subprocess.check_output( + ['git', '-C', str(root), 'ls-files', '-z', '--cached', '--others', '--exclude-standard'], text=True).split('\0')))) + frozen = frozen_files(root, paths) + historical = historical_records(root, json.loads((root / HISTORICAL_RECORD).read_text())) + found = [] + for path in paths: + if path in historical: + continue + if path == 'scripts/oracle_invocation_check.py' or path == 'scripts/tests/test_oracle_invocation_check.py': + continue + file = root / path + if file.suffix == '.py': + found.extend(PythonSites(file.read_text(), path).collect()) + elif file.suffix in ('.sh', '.bash'): + found.extend(shell_sites(file.read_text(), path)) + elif file.suffix in ('.yml', '.yaml'): + found.extend(workflow_sites(file.read_text(), path)) + rust = [path for path in paths if path.endswith('.rs') and path not in historical] + aliases = {'Command'} + for path in rust: + aliases.update(re.findall(r'\bCommand\s+as\s+(\w+)', (root / path).read_text())) + if rust and not shutil.which('ast-grep'): + raise RuntimeError('ast-grep is required: Rust boundaries must not be silently omitted') + constructor = r'(^|::)(' + '|'.join(re.escape(alias) for alias in sorted(aliases)) + r')::new$' + found.extend(structural_sites(root, rust, 'Rust', '$CALL($PROGRAM)', 'PROGRAM', None, constructor)) + for method in ('spawn', 'exec', 'output', 'status'): + found.extend(structural_sites(root, rust, 'Rust', '$PROGRAM.' + method + '()', 'PROGRAM', None)) + for path in rust: + source = (root / path).read_text() + if path.startswith('tools/') and '/src/' in path and 'test-support/oracle.rs' in source: + found.append(dict(path=path, line=source[:source.index('test-support/oracle.rs')].count('\n') + 1, + scope='', kind='deployment', program='', + status='unproven', role='oracle')) + for language, suffixes in (('JavaScript', ('.js', '.mjs', '.cjs')), ('TypeScript', ('.ts',)), ('Tsx', ('.tsx',))): + selected = [path for path in paths if path.endswith(suffixes) and path not in historical] + found.extend(structural_sites(root, selected, language, '$FUNCTION($PROGRAM, $$$ARGS)', 'PROGRAM', + lambda item: bool(re.search(r'(?:^|\.)(?:spawn|spawnSync|execFile|execFileSync|execSync)$', + item['metaVariables']['single']['FUNCTION']['text'])))) + for site in found: + site['owner_path_hint'] = site['status'] == 'qualified' + site['status'] = 'unclassified' + if site['path'] in frozen: + site['status'] = 'frozen' + elif site['path'] in BOOTSTRAP: + site['status'] = 'bootstrap' + elif site['path'] in RUNTIME: + site['status'] = 'runtime-boundary' + return sorted(found, key=lambda site: (site['path'], site['line'], site['kind'], site['program'])) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--root', type=Path, default=ROOT) + parser.add_argument('--json', type=Path) + args = parser.parse_args() + sites = inventory(args.root.resolve()) + counts = Counter(site['status'] for site in sites) + unproven = [site for site in sites if site['status'] == 'unclassified'] + report = dict(counts=dict(counts), unproven_files=len({site['path'] for site in unproven}), sites=sites, + proof='ownership hints are not verdicts; unclassified boundaries fail closed') + if args.json: + args.json.write_text(json.dumps(report, indent=2) + '\n') + print(json.dumps({key: value for key, value in report.items() if key != 'sites'}, sort_keys=True)) + return int(bool(unproven)) + + +if __name__ == '__main__': + raise SystemExit(main()) diff --git a/scripts/tests/test_oracle_invocation_check.py b/scripts/tests/test_oracle_invocation_check.py new file mode 100644 index 000000000..826d83ce0 --- /dev/null +++ b/scripts/tests/test_oracle_invocation_check.py @@ -0,0 +1,112 @@ +import hashlib +from pathlib import Path +import sys +import tempfile +import unittest + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +import oracle_invocation_check as check + + +class HistoricalRecords(unittest.TestCase): + def fixture(self, root): + source = root / 'docs/measurements/past/run.py' + source.parent.mkdir(parents=True) + source.write_text('historical source\n') + record = {'schema': 1, 'boundary': 'docs/measurements', + 'files': {source.relative_to(root).as_posix(): hashlib.sha256(source.read_bytes()).hexdigest()}} + return source, record + + def test_exact_record_is_the_only_historical_exception(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + source, record = self.fixture(root) + self.assertEqual(check.historical_records(root, record), {source.relative_to(root).as_posix()}) + + def test_edited_historical_source_fails(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + source, record = self.fixture(root) + source.write_text('new oracle invocation\n') + with self.assertRaisesRegex(ValueError, 'edited historical file'): + check.historical_records(root, record) + + def test_added_historical_source_fails(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + source, record = self.fixture(root) + source.with_name('bypass.py').write_text('new source\n') + with self.assertRaisesRegex(ValueError, 'added historical file'): + check.historical_records(root, record) + + def test_missing_or_renamed_historical_source_fails(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + source, record = self.fixture(root) + source.rename(source.with_name('new-name.py')) + with self.assertRaisesRegex(ValueError, 'missing historical file'): + check.historical_records(root, record) + + def test_boundary_cannot_be_broadened(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + _, record = self.fixture(root) + record['boundary'] = 'scripts' + with self.assertRaisesRegex(ValueError, 'restore the recorded historical boundary'): + check.historical_records(root, record) + + def test_a_symlink_cannot_substitute_for_recorded_bytes(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + source, record = self.fixture(root) + copy = root / 'copy' + copy.write_bytes(source.read_bytes()) + source.unlink() + source.symlink_to(copy) + with self.assertRaisesRegex(ValueError, 'symbolic link'): + check.historical_records(root, record) + + +class Discovery(unittest.TestCase): + def test_shell_commands_are_not_confused_with_copy_operands(self): + sites = check.shell_sites('ffmpeg -i in out\nmv ffmpeg dest\necho ffmpeg\n', 'run.sh') + self.assertEqual(len(sites), 1) + self.assertEqual(sites[0]['program'], 'ffmpeg -i in out') + + def test_shell_command_substitutions_are_discovered(self): + sites = check.shell_sites('ENCODERS="$(ffmpeg -encoders)"', 'run.sh') + self.assertEqual(len(sites), 1) + self.assertEqual(sites[0]['program'], 'ffmpeg -encoders') + + def test_namespaced_rust_constructor_is_discovered(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + (root / 'consumer.rs').write_text('fn f() { std::process::Command::new("ffmpeg"); }') + sites = check.structural_sites(root, ['consumer.rs'], 'Rust', '$CALL($PROGRAM)', 'PROGRAM', None, + r'(^|::)Command::new$') + self.assertEqual(len(sites), 1) + self.assertEqual(sites[0]['program'], '"ffmpeg"') + + def test_owner_import_does_not_prove_executable_identity(self): + sites = check.PythonSites('import test_oracle, subprocess\n' + 'test_oracle.require(args.ffmpeg)\n' + 'subprocess.run([args.ffmpeg, "-version"])\n', 'consumer.py').collect() + self.assertTrue(sites) + self.assertTrue(all(site['status'] == 'unproven' for site in sites)) + + def test_an_assigned_process_alias_is_discovered(self): + sites = check.PythonSites('import subprocess\nlaunch = subprocess.run\nlaunch(command)\n', + 'consumer.py').collect() + self.assertTrue(sites) + self.assertEqual(sites[0]['role'], 'opaque') + + def test_workflow_environment_fields_are_not_commands(self): + source = 'steps:\n - run: |\n ffprobe -version\n env:\n COREAV_FFMPEG: /bin/ffmpeg\n' + sites = check.workflow_sites(source, 'workflow.yml') + self.assertEqual(len(sites), 1) + self.assertEqual(sites[0]['program'], 'ffprobe -version') + self.assertEqual(sites[0]['line'], 3) + + +if __name__ == '__main__': + unittest.main() diff --git a/test-support/oracle-historical-records.json b/test-support/oracle-historical-records.json new file mode 100644 index 000000000..c6a24ed48 --- /dev/null +++ b/test-support/oracle-historical-records.json @@ -0,0 +1,4888 @@ +{ + "schema": 1, + "boundary": "docs/measurements", + "files": { + "docs/measurements/0001-baselines.cpu-environment.json": "dc1cb2f53c7ac03633d69227fffe621f1b12b4bb3b3e82e658d8c2f5ead158f2", + "docs/measurements/0001-baselines.cpu-status.json": "3b04cbeeb70bac5beaaff1e8b5ac40851ce1cb12e8e98b3e6bbb0cb6e1a19006", + "docs/measurements/0001-baselines.gpu.first.oracle.json": "f083b951aa7857129fee444c28ae4eab5c8e2c77e0e036b3f1bb8c5aeae03333", + "docs/measurements/0001-baselines.gpu.first.raw.json": "f0596648df35629ecc4c8da7613022ab931263ccdbbcdb96df0d7c6c5f623d3d", + "docs/measurements/0001-baselines.gpu.oracle.json": "f083b951aa7857129fee444c28ae4eab5c8e2c77e0e036b3f1bb8c5aeae03333", + "docs/measurements/0001-baselines.gpu.raw.json": "0db2ee56c547537a141a369471b05c4348271b8de1c288459a7779c779df5d16", + "docs/measurements/0001-baselines.md": "199edf6b5ae832548d483feda3513b89f8d0606ca55b48db918403cbf5f3c5fd", + "docs/measurements/0001-baselines.oracle.json": "0738a50422d5894a91f066f716cf4fa29e0aa1bf6525085ad7d7f1e9d534a364", + "docs/measurements/0001-baselines.raw.json": "93d55d82d2985b9457288c9de2e7e4d697cf9a470b1fe8f99d0a53b0acb5ec12", + "docs/measurements/0001-baselines.traces.json.gz": "dfe5f5082bfb5fb626280d5db0991941c4388099102949147825f0ee7ce7b286", + "docs/measurements/0004-limit-bounds.md": "d35febad703250f996cb60f2fd11a5ccdbee57c063fc3a18075aa6ffe736699f", + "docs/measurements/0004-limit-bounds/after-trun-count-check/measurements.jsonl": "e8efe47b149c63f0754a2bb6e9b6a77b9bbdedcce4e551373c4799459964804d", + "docs/measurements/0004-limit-bounds/after-trun-count-check/run.txt": "4cd264a9c6284cd2b4640dfa77c6d54ce82ff4fdf8fa984f8b3ff3d517c586b3", + "docs/measurements/0004-limit-bounds/measurements.jsonl": "9aaed742fe6ce47970fa786a937dd68098b0498a9665d867834fadad63362e93", + "docs/measurements/0004-limit-bounds/run.txt": "32206e5ac6f7ce90faf53b775f485d20056ae08142368888a592028f46d77669", + "docs/measurements/0025-probe-metadata.md": "b6eef039a9f17939ad67121c3347967bc30ee6a1013aafff1fec970ab1e733ea", + "docs/measurements/0025-probe-metadata/metadata-report.json": "9c5b74bc39c9990eea1a48587cc5ef43331d062161045e82183c3273a673a5bd", + "docs/measurements/0025-probe-metadata/summary.json": "e1cb4a95aedcb94732a713a45f1bddb5dbf18bdb715c5a6e957068b11b6a2ad5", + "docs/measurements/0025-probe-metadata/tables.json": "1349b4637f5f5d81af127ac98853b48d0ba322328ce0a7ad1588bcde1f353ecf", + "docs/measurements/README.md": "7681ba4304a99276e24929140fe7c1bb382a1245d72650fee323b706a3ee3c27", + "docs/measurements/av1-thumbnail-fixed-cost.md": "23545f987883a61205df5e354f03047dd4960e3b9039ec37f824e1e7d82e2c98", + "docs/measurements/av1-thumbnail-fixed-cost/arms.jsonl": "892d8f12067c44c3204b2667ca8de0e275a23559ba53ed5a3b59aca726ca7912", + "docs/measurements/av1-thumbnail-fixed-cost/arms.py": "f992554b2e369049cd632c5e29b74c6992ebad866dea7ab749e56f95dcefcad0", + "docs/measurements/av1-thumbnail-fixed-cost/corpus_from_upload.py": "b800a4e487dfa8d7d2cb954edd5ad5757b9aafcde930dfce4486e6341385630a", + "docs/measurements/av1-thumbnail-fixed-cost/host.txt": "b313c0cff076cf11bf4c91c23d5f52e9cb90bc5e18a8e9393dc444b5f495e293", + "docs/measurements/av1-thumbnail-fixed-cost/job.log": "a97f601d4f7209ce66425053a4362c958ecafd19dc92d3bbc819f7c38a71bc1e", + "docs/measurements/av1-thumbnail-fixed-cost/job.sh": "0d40c29ab9f30bd857d57c5ee7adc78c431b73df9de25e590dc8e7b8a7130e35", + "docs/measurements/av1-thumbnail-fixed-cost/speed-dev.jsonl": "29fb2669aac74f30c64723702d14e624e18983a52e4cf8bb2dc28a8e90c43579", + "docs/measurements/av1-thumbnail-fixed-cost/speed-holdout.jsonl": "4682152f178d26b1f2007ef3f27b526c2c3f071375a8a0108e1756e21bcd910d", + "docs/measurements/av1-thumbnail-fixed-cost/summarize.py": "ac4bca5d2c924f613d505b8ecbf5ac22727f320b4d8fb6722442329ca8035e28", + "docs/measurements/ci-main-load/README.md": "f891b9405842e2364c0d42a3279b36e0d4982aecd7c89fa2532b785e3e3b6461", + "docs/measurements/ci-main-load/sample.json": "6a0d0259bbb9e175095132c2d9f1b11f381f27d3d36e8d263653911517468efd", + "docs/measurements/cli-stdout/analyze.py": "96b4087b6397c4aa00caf8dcd421e16a9bfacf65830e06e83a55fdb4d0c6fa6a", + "docs/measurements/cli-stdout/bench.py": "615efbe07da2c48acfa54ef8fdd82459b763c7637d6a613b06f5e180f0d9ea51", + "docs/measurements/cli-stdout/buffer-ab.md": "977467178411a6ce9692ecf0fde5ba8a4486440c901c665139e4adf899c89c50", + "docs/measurements/cli-stdout/run-01/VOID.txt": "deefb47634f49257ec9722d52975bdcf40eb3939363b484c81ca6b0eb614f93a", + "docs/measurements/cli-stdout/run-01/gate.json": "76583e96600dd51b0d961446b61f66ef55a591f837c187e95af3b24818608d58", + "docs/measurements/cli-stdout/run-01/inputs.json": "c10b2fc404bcac362831531c2ea9d18ef00550bfa2cdde35d99c90f71792d975", + "docs/measurements/cli-stdout/run-01/provenance.txt": "a70474baa3c29a78e5620855f0aafa66b5b31928f6551da2b080a4445a55f75d", + "docs/measurements/cli-stdout/run-01/summary-without-d94f05a6ef4b.md": "343353cb1b8a115ae359ba8d95659a37e70d4943d067883a709cc7c457415fda", + "docs/measurements/cli-stdout/run-01/summary.md": "465f2936451f3422da2171c4cc16cb9ac8a0b0d07d4e54cfb72668e713d468ae", + "docs/measurements/cli-stdout/run-01/times.json": "2c1117ff85edcc857bd2a4faaa2218e6b6fb1e518850483ea31c41a909ae8a98", + "docs/measurements/cli-stdout/run-02/VOID.txt": "deefb47634f49257ec9722d52975bdcf40eb3939363b484c81ca6b0eb614f93a", + "docs/measurements/cli-stdout/run-02/gate.json": "4101dacac6a8ed62ccc83bb235eec2f8fc8d72716a7ef23e0b3be9e5d53f8663", + "docs/measurements/cli-stdout/run-02/inputs.json": "cb6e38e9b6af1e0f0daba1c26036d1e27eb1a97ae04fb4f1df849cf80780b75e", + "docs/measurements/cli-stdout/run-02/summary.md": "9226eec2d0d7d05e7c80d93d16cf46e94289958135f6dfb67fc7121c4cae89a9", + "docs/measurements/cli-stdout/run-02/times.json": "f7ceb10b843bcac699acbee79915b18271d21ff8c204f5bdde54256567e2c386", + "docs/measurements/cli-stdout/run-03/VOID.txt": "deefb47634f49257ec9722d52975bdcf40eb3939363b484c81ca6b0eb614f93a", + "docs/measurements/cli-stdout/run-03/gate.json": "c9e185d2f0712e7203dd650a0eb1274adffd65e16c7a49b28b152c4938255dbd", + "docs/measurements/cli-stdout/run-03/inputs.json": "cb6e38e9b6af1e0f0daba1c26036d1e27eb1a97ae04fb4f1df849cf80780b75e", + "docs/measurements/cli-stdout/run-03/summary.md": "98d996f10e473c8e1aba8fb16ddba489cc17f92c203038a94d81714479021c9f", + "docs/measurements/cli-stdout/run-03/times.json": "c603d3ca4b1155a747b20bed104f8a40569baa5d2240f598348495eebd49e2d8", + "docs/measurements/cli-stdout/run-04/gate.json": "0c016b0c636e1f0b973cc89069b315eecd1055fb97c31ba66f10589721acb862", + "docs/measurements/cli-stdout/run-04/inputs.json": "cb6e38e9b6af1e0f0daba1c26036d1e27eb1a97ae04fb4f1df849cf80780b75e", + "docs/measurements/cli-stdout/run-04/provenance.txt": "068c79c4e40ae5f4570f24e031f64a2ccccb33f625ac71ef9393f20b321bd6ef", + "docs/measurements/cli-stdout/run-04/summary.md": "66a52166b6fc7985d099fefaf90f185f1d309d705026e4f17a9b7fe33ef1792a", + "docs/measurements/cli-stdout/run-04/times.json": "d4923abc9807f38773bae84936fc36c41b61e4720472c5f2de877a927ebda8c5", + "docs/measurements/cli-stdout/run-05/gate.json": "2b9f800cb6ec35435bdb634ec3712a28a159235183ceec3486bbc4b30cfe446f", + "docs/measurements/cli-stdout/run-05/inputs.json": "ede5e8ec485cec422efd9105f95f745a77792b24ae87bf68eea46956a455a1d9", + "docs/measurements/cli-stdout/run-05/provenance.txt": "6c1a24d0104af1e2b643a7774660b8dff6ca2c192b823eaf297624d07a6c040c", + "docs/measurements/cli-stdout/run-05/summary.md": "736f610aed8e2fa4aa3b9c460b9a2f8e808e2bea13f880d93de38cb06a446ece", + "docs/measurements/cli-stdout/run-05/times.json": "211a8d3a21f6df3ea57ed07211b9889b363165ccff447258f2eb7d5fd2d24ffd", + "docs/measurements/codec-v2-images.md": "530d2eab7884f5d596288230c59a51eb2f84b7dc468ddb11ce261f04682091b3", + "docs/measurements/codec-v2-images/build.json": "2f3621800fffc1ded2902736864e826075e069a70567fe0dbfe2c7caa1bb7235", + "docs/measurements/codec-v2-images/evidence-digests.json": "820a8d21c08cc5e2b1a82e7214e2905ca8b1abe4cfb05c19af0cd912c49c24ee", + "docs/measurements/codec-v2-images/fixture-reference.json.gz": "6757c42aa965b1eab1f710da6851e42eec175a558b33555f4d64816d2161f7e3", + "docs/measurements/codec-v2-images/host.json": "03c875a23aa43fc6afe801830e9a9a5faf3823565ff7e59a094a0ee710a89354", + "docs/measurements/codec-v2-images/manifest.json": "46581b4d2ca46c031dbed13d345bb1a9adb14da18ae9312971d9595cfdd2e453", + "docs/measurements/codec-v2-images/records.jsonl": "3faf75cab98a99c06c1fcd983a31899503b16a25dd203b772c8f92542188a264", + "docs/measurements/codec-v2-images/retention.json": "5a29692572a4105c819b7743d4ff9ce2cc965dd0cb6555f18d029b65dc5c0c14", + "docs/measurements/codec-v2-images/summary.json": "33592f331f5abb9d797b3f5b86ab02d1b8600182caaeaeffd670e63887799dab", + "docs/measurements/compat-0.1.0/README.md": "3fbcc0d0a26a4ffb8b8344d97810553cd57f5496298317a3773f4bba13f5cc85", + "docs/measurements/compat-0.1.0/codec-coverage-plan.md": "722de736d9d46c516fdec7eb30773773b8eb67b0cc3068cbd78e1d86ddcfed80", + "docs/measurements/compat-0.1.0/judging.json": "4b31ec8809f792c5f57d079782280ad0f34eeaba19389ed3e92992e95e206dc9", + "docs/measurements/compat-0.1.0/r4-refusal-plan.md": "3fa09b8f9354a8ca66ce645bb5128aa1442a554d81b6301d17a711c1874f47fc", + "docs/measurements/compat-ffprobe.md": "210cc9fe2bccc4a8e0cbc80a9783d8a5d54fadf60a621206bc20b4a1a6793b57", + "docs/measurements/compat-ffprobe/b3a-round1.json": "05f3f8dfbc64a3d31a7ae5397bef7a9151b72610ce0ab4a8e8af00996c7fcc73", + "docs/measurements/compat-ffprobe/b3a-round2.json": "cc869e4e2fb63c1d30354ac0b585c4f7de29bdfbae77107c6da8bd4d31c67eb6", + "docs/measurements/compat-ffprobe/b3a-round3.json": "38e929f77956ba6ef77bed7eb70becdd52f8f8e652fd9ad513cd2ff902fca746", + "docs/measurements/compat-ffprobe/b3a-round4.json": "5d2296283791196580fc0da2dd5ac8fb86a2dfcbe12a3e50ca6ba02d947065e9", + "docs/measurements/compat-ffprobe/b3a-round5.json": "edcddaca5c74ebba64ac814a22455f8812ce4ccc5feeea61be411fcd83411e69", + "docs/measurements/compat-ffprobe/b3a-round6.json": "3c555b84ceda60ab4a4b210bcce679c23d54c26362fde56dc4e4aa8945a61094", + "docs/measurements/compat-ffprobe/b3a-round7.json": "7ac9a2de3339c344ca449bb3b06a9004baf1d67b6b07fc77c15eba622958bac1", + "docs/measurements/compat-ffprobe/b4-round1.json": "2f7aafff96222627d8c7a5529d5d00e26f43fc71911001e8962851ec070ba4c0", + "docs/measurements/compat-ffprobe/b4-round10-calibration.calls.json.gz": "1bda3ff06d26cf35f15da779c8ad5e9992328fe7bb1df3b23b123898fd0f1602", + "docs/measurements/compat-ffprobe/b4-round10-calibration.report.json": "ea086fd5c38e078e50e741a270746f24ae6b798b9057b5ab10ec14917456e643", + "docs/measurements/compat-ffprobe/b4-round3.json": "d4888957e49e86a62ba32de2bb8cf18ae5bf5a364d122a967c986e3763576a40", + "docs/measurements/compat-ffprobe/calibration-simulation-sensitivity.json": "94776a11442c27f5f1685cb0b0b9cbfed257203e5af23a0b4a331a02d5cbe3a3", + "docs/measurements/compat-ffprobe/calibration-simulation.json": "25689800522bb849e88af5c1d1914cad692501de6ad24c1bd38199edf98a2aa9", + "docs/measurements/compat-ffprobe/round10-calibration.md": "a44c4eaea6035ebedb6f19429095b276b72627f8a35d6bc83c708786460dee30", + "docs/measurements/compat-ffprobe/round10-plan.md": "027ed41e1d586ff8d62965b1fa8174fa024599c8acab21057544c55b326b5322", + "docs/measurements/compat-ffprobe/round9-plan.md": "7d5211fdf17e9824c947f58d85851aba3b517eacff8c93e7e90059ddae08e0a8", + "docs/measurements/flac-cost-cache.json": "372000c03218e89cc24c7120ae2261d3fb0297778baa3a4afed3b2ceb3c59180", + "docs/measurements/flac-cost-cache.md": "3b78986ba444c5547d9a0bd82e033401a64e8821c80bcaed9a1c87f560ea62c1", + "docs/measurements/flac-cpu-diagnostic.json": "c045304622e085eea62fbcf09249cdfce4ccb39d4a1d13f06702d98ac3677b92", + "docs/measurements/flac-output-correctness.json": "a1fd5f07e8ea5f37bf29d4ed6884e2efd26c8cc6133f587563e1ebc36d849315", + "docs/measurements/flac-output-round2-correctness.json": "a1fd5f07e8ea5f37bf29d4ed6884e2efd26c8cc6133f587563e1ebc36d849315", + "docs/measurements/flac-output-round2.json": "3318600f231cdd4e64d84c9a745b8cd0cad2d79775ed611eaf42ac4d37c57c81", + "docs/measurements/flac-output-round2.md": "166d5342042ab792f69c4abfcd8f7ca8cf0bc15de5505196310064e8c9db2c39", + "docs/measurements/flac-output.json": "c06f814e9ec24b0e832503b12c2327dd130ddc0fdf84eaf4da4686d59b20937a", + "docs/measurements/flac-output.md": "0e6d6575d481d493ed2bb210988fd4d34723fa573c0c2ab60714f585262bdf59", + "docs/measurements/fuzz-campaign-1.json": "cb3f61efa3285eedc34122834e501e8b2022d9977931d2c8567efed3665264de", + "docs/measurements/fuzz-campaign-1.md": "34d082c1847002ff5245e221598ecd04119e251f45eb44ae379c2bfcf82b1fc7", + "docs/measurements/fuzz-campaign-2.json": "bb2ac1ffc4f05327df7e5f19ffa82d39c7c61e9c349c7e0104f6632c4ddc30d6", + "docs/measurements/fuzz-campaign-2.md": "22d0df4c4f483573279b6786e0d593c1652df84ae04f419eab4fe1bc44ef3199", + "docs/measurements/github-shapes-200.md": "b8b7917e67155d800ae4422a31a57f171c88ca6c69e8ebf414286c90f299b3d8", + "docs/measurements/github-shapes-200/build.json": "44806f63ef7b8d16e91476b1a52a8f74709368f8cfc580f649cf7ef08f68bca3", + "docs/measurements/github-shapes-200/host.json": "ff5a2a32c74fea12a301b01c82445027f98d12a7537d88a064f8fb9268477a31", + "docs/measurements/github-shapes-200/manifest.json": "3f18cbb1159167533c5135d0b74d7e3de947f86620baefc2b7e4ef3afdf2ffee", + "docs/measurements/github-shapes-200/records.json": "1dba821abf7b188300eec640157734bb80142bc0c8f6c2401de81c716d6dd759", + "docs/measurements/github-shapes-200/summary.json": "fe69dcb0070aca781d3ec07538f3c6bf869d37495f834e5f5eb715a5d5e4d99b", + "docs/measurements/github-shapes-200/validation.json": "637dc6746da645465aa324d19d4d2371e26515a0f2acb1673c729cb40a174077", + "docs/measurements/h264-decoder-speed.md": "8761736590168534757aea71041265b28b8dc0739901ca2d220f8caf732912c5", + "docs/measurements/h264-decoder.md": "e1f4c8c6062c8506081ddd5f5fdaa56b058bd956de49da547475e2690d5d5e85", + "docs/measurements/h264-decoder/agreement-tuning.json": "6be5a446cd35843ea224ebd8d0294af0106490806451e9769903bc980d7c1651", + "docs/measurements/h264-decoder/conformance-x86_64.json": "be1c43666ad0c18773373af606be32eb87a00f6fc9fabb9737ee7e09ab409fcf", + "docs/measurements/h264-gap-2/README.md": "a7616afb92980f8a666d84b1a64c46e116c674d7271aeca79f016c3ec4268ad0", + "docs/measurements/h264-gap-2/evidence/bounds.txt": "a4164a2a0e06e2578fd1f3bdf8fa41fc834c07754103b1ed6c249a7f4d8093b1", + "docs/measurements/h264-gap-2/evidence/ffmpeg-configure.txt": "f35be731e8c6f11f55231e7790dac5bd8ce6128bbbe7eb3c8e905636616816d3", + "docs/measurements/h264-gap-2/evidence/functions.json": "14021323b3745e8eac887a4d78ea47ea700be92170c3df049d95f7a3c05a578f", + "docs/measurements/h264-gap-2/evidence/mix.txt": "012a199d32d662c48f3c98ab491547e6a76e8cd803b3c2f8ad7e3a6c1feee10b", + "docs/measurements/h264-gap-2/evidence/perf/1d4b1775d78a.ffc.txt": "8df3fa7cd2b097dac6ddcae433c195042589104f13e9ec02a5d543a183de2e61", + "docs/measurements/h264-gap-2/evidence/perf/1d4b1775d78a.ffsimd.txt": "5706f00bb3df85588faf88477dd2b2cda984e261d85e7c462dc894e524ed5b9e", + "docs/measurements/h264-gap-2/evidence/perf/1d4b1775d78a.ours.txt": "8bb124d3acdfbaacc075442284bfe2f6d649341fb697bb21741107dd3441297b", + "docs/measurements/h264-gap-2/evidence/perf/3b1b441e23ae.ffc.txt": "93804cdb26e22fdf9a15268c5cef866582be53f392f56ba0c0578f927a833ddb", + "docs/measurements/h264-gap-2/evidence/perf/3b1b441e23ae.ffsimd.txt": "6800549356ebc7f31f218217a9d43529de72c462f7da4e05676eaf5255bae8ab", + "docs/measurements/h264-gap-2/evidence/perf/3b1b441e23ae.ours.txt": "8db297044377eda9fe7f43a93a024c3dc240c30b76eafce6185e78f4b709fd3e", + "docs/measurements/h264-gap-2/evidence/perf/41e324ebb708.ffc.txt": "f5ca869e341b6783b3dfd7cb770e1dbf2b77baf29e47e1aba280dc581b081a89", + "docs/measurements/h264-gap-2/evidence/perf/41e324ebb708.ffsimd.txt": "c04c26827b06c63313bffa3784919bc8e985cf79115849fc1047b639b5e27531", + "docs/measurements/h264-gap-2/evidence/perf/41e324ebb708.ours.txt": "876d8c89c7dcf7f160f6c57a460a463b72fd259d6190d72de67df82b17c7879c", + "docs/measurements/h264-gap-2/evidence/perf/5185721dda11.ffc.txt": "81e8cf7addf5c9173a474d6da7b4386c62d9d09a4fdc90fb9a3db750d9ec3248", + "docs/measurements/h264-gap-2/evidence/perf/5185721dda11.ffsimd.txt": "73fc917187f55a6e24fc00cc2ab9e5445ebf87d3940f2622bbbf067b26447670", + "docs/measurements/h264-gap-2/evidence/perf/5185721dda11.ours.txt": "40313c2626a343c832260d8879a1638c7dcaa123696882c5ee0849b48818def9", + "docs/measurements/h264-gap-2/evidence/perf/6da34958296c.ffc.txt": "73415495f7d0eb1621901d13a8d1fed2b12bb2a6a91101ca6ef960b5f2e63712", + "docs/measurements/h264-gap-2/evidence/perf/6da34958296c.ffsimd.txt": "e559d9a4029e86c4c946f6a509fd8b8068af525e3468ca9def740494666b56cc", + "docs/measurements/h264-gap-2/evidence/perf/6da34958296c.ours.txt": "50b573caeafc556a448d62be52fde31605291ca0cc654a72deffcb6ba73d5afd", + "docs/measurements/h264-gap-2/evidence/perf/9db41aa16b5a.ffc.txt": "e5d1a3b11492dff0d3822db9e80cedec9b13f86dc8e242af8c63fbca5a9535ca", + "docs/measurements/h264-gap-2/evidence/perf/9db41aa16b5a.ffsimd.txt": "1fdbd4172bec45745dceafa82d5878d562aa7bf59b38f8e387f625fac9a10c7e", + "docs/measurements/h264-gap-2/evidence/perf/9db41aa16b5a.ours.txt": "1c223894f2091c545011c75db451835901f68c1636116b2c2cafb4c745059407", + "docs/measurements/h264-gap-2/evidence/perf/b71b6b31e54f.ffc.txt": "2eb933e6bc66a92262555cb1ebb929c05dc4e886f5494394ed1bc28a65132444", + "docs/measurements/h264-gap-2/evidence/perf/b71b6b31e54f.ffsimd.txt": "d74e2778fe74e8729e58a38599570a7e70f0b6d318ecb68a78e0417707353866", + "docs/measurements/h264-gap-2/evidence/perf/b71b6b31e54f.ours.txt": "195664307d6718e0d26371c9c301367ea64d4360d5b8adafda265cda294350ae", + "docs/measurements/h264-gap-2/evidence/perf/e624cbe0d2be.ffc.txt": "be2eba7accbd2e3f81fe0f89c9ca7dd965a1da2982de517d03cf239114fdc7c6", + "docs/measurements/h264-gap-2/evidence/perf/e624cbe0d2be.ffsimd.txt": "cb804c2b7a4872a09ec4b1fdd5ccc9e9d2676a9ba993b27512ed33f2cc775e3e", + "docs/measurements/h264-gap-2/evidence/perf/e624cbe0d2be.ours.txt": "d119ff67db479f61307d86501ef1b6ff43a32563971c9511181030fcd81cab36", + "docs/measurements/h264-gap-2/evidence/provenance.txt": "cb417d8f7ebf7b51f75691efdfa2c54e530d09f57b02ca3d5328417789b47f45", + "docs/measurements/h264-gap-2/evidence/stages.json": "9f1e59b216944006b4362ea607575c287885fbc0c7e7ea4b49fede31d25e7d68", + "docs/measurements/h264-gap-2/evidence/streams-info.txt": "8d39b76bb847e31240afb3ae4f18862cfb60342f7133621f4de20cbb8cf1482a", + "docs/measurements/h264-gap-2/evidence/streams.txt": "74ae5ba0edfeaeb63b2de87cf2b8489ac39df10280925eb50cdd3daeec945ab1", + "docs/measurements/h264-gap-2/evidence/wall.txt": "85c932f807c24f8db7bdba3924502346469f9b0cc5884c67409155594dc91484", + "docs/measurements/h264-gap-2/tools/bounds.py": "8d0b3db23793db5782fa6e5a480cef2d0d1e33b53cc3bd995e3d815a294f0ae4", + "docs/measurements/h264-gap-2/tools/cg.py": "a019dc1b35f5640be7c622a27ee46bee931d0e485eca959aeecc0053b5df4143", + "docs/measurements/h264-gap-2/tools/mix.py": "f716aa5245feab79feec2380ea38725046b97c046025bbe6d4ae5979704b905b", + "docs/measurements/h264-gap-2/tools/report.py": "083d08b0cc77deddf0fecdbc7be6085fd69c703879d42a9db0e0d3bed055e593", + "docs/measurements/h264-gap-2/tools/run.sh": "c98388cbca461826d41212426d20b8eb59ffa4cdd60559b389b868e08d3bf510", + "docs/measurements/h264-gap-2/tools/stages.py": "2c14629da3a86ad42354d542c49b4cf5a7b043137a5182c8ed68dc478c3accea", + "docs/measurements/h264-gap-attribution.md": "d416455ac4a7013e25abd55248f66a260504dced13a8d283e50c15ab5ec10704", + "docs/measurements/h264-gap-b/ffmpeg-simd-vs-c.jsonl": "17a3362dedaac1ac28b3dffeec111105b4f6f90b66f341e33a6450d0a68ed3cf", + "docs/measurements/h264-gap-b/isa-mix-production.txt": "ffb3923c8497185cea9dc6284bdfeb5483e78085016f0f8c0efa94a4c1114412", + "docs/measurements/h264-gap-b/process-counts.jsonl": "8016b973148d315c53e5bf56a3b2572f0276ae3eb1ffc666cdc1acc01bfecf1e", + "docs/measurements/h264-gap-b/provenance.json": "2d81ebf1722b606df735da00785514a07841757ce4a03fa0f439a0086d2f0515", + "docs/measurements/h264-gap-b/stages-production.json": "e4d69cd7ac42f32576ed5fd0a3af6b0ec7bf67b4cab23371ba61cc6a1995a1c6", + "docs/measurements/h264-gap-b/stages-spike.json": "7a19c6523efff23515f919970b61175a7d6a0183184c791e6234bc8d61a4a959", + "docs/measurements/h264-kernels-training.md": "0cf258c80eedc23f11e86f6d2eabd0f2e0420609e55b0c976c6c289323afa916", + "docs/measurements/h264-kernels-training/ab.py": "f9845745bdea7ae9c2cb1caec62f29cc2878cc1ff862203c9ea2db15d8ed875d", + "docs/measurements/h264-kernels-training/reports/c1.1080p.json": "15bd43789d9de125ec6dad284df0d6a241fcca85f0803a9de4cbb3b0e23e3278", + "docs/measurements/h264-kernels-training/reports/c1.4k.json": "54f2497a111eb7959396b907f7374131118e67ea1e0f481e448b1230c93e5b3e", + "docs/measurements/h264-kernels-training/reports/c1.720p.json": "3801341f06ac3c61358419c22ed2264da81a304a16a99471312d797d1977a263", + "docs/measurements/h264-kernels-training/reports/c1.sd.json": "cef6ef761ee88b17f132c6a20f12bfda702ce4854cf5e047091d29d06f5bd345", + "docs/measurements/h264-kernels-training/reports/c23.1080p.json": "a1e0732bf89c749eac7a68c8937f34a8479f0391b027427d8299e1e776226447", + "docs/measurements/h264-kernels-training/reports/c23.4k.json": "192f2c3b2ad3dbba097802e309ba3ed1c73e81b5a42e8564724dac274901af89", + "docs/measurements/h264-kernels-training/reports/c23.720p.json": "a02a5cc247a2dc40f34916af4c0ae16839aa4db929e5d57cc5109ca4221ddfd6", + "docs/measurements/h264-kernels-training/reports/c23.sd.json": "8cef7b7054be7b90f9fea7596c5d308d9f1e6398ae88a8c3a66ed5ff95cc1dbd", + "docs/measurements/h264-kernels-training/reports/c4.720p.json": "d6aa67b42dea5d9d5abf93322e0b7799373a789cc2e3c02af004783cf742a21c", + "docs/measurements/h264-kernels-training/reports/c4.sd.json": "e153dc58c3d58307025c3f4863dc0fd6478644553bd261f08616fef79bf96813", + "docs/measurements/h264-kernels.md": "d877070781a0eea96cdf920e6985df4c5a46f09812a4d14a81bd4cb69ce92609", + "docs/measurements/h264-n2-heldout/README.md": "2e942c38fbe484b39b96cf7cf7e4934cd6109fa394fc7d621f8659fc612bafa9", + "docs/measurements/h264-n2-heldout/es.json": "e1cc26ef217b45093a3c713df9cf2f41f24d36165d2f605d7a117cd51fd12bf6", + "docs/measurements/h264-n2-heldout/excluded.json": "1e7d5f9b13a52d6af95bf6daf5b4e93e1a72385fa2193f50815ac3cb4914523b", + "docs/measurements/h264-n2-heldout/identity.json": "1ed3df6090013da12e7f0c7078976cac585a4ea6c4a3b26203949c4dc2693c0e", + "docs/measurements/h264-n2-heldout/list.json": "4113b5a262d04bd2e401e5feecf3138f9f403db4eec8efb5d858bb5a9087e2e8", + "docs/measurements/h264-n2-heldout/pool.json": "4fd05b6ca69f7d8238b16cf43bda985d4bf407154f1ebf5c2e6b408750f0c87f", + "docs/measurements/h264-n2-heldout/reports/1080p.ff7.json": "5fdd0680244bcf3c02402742ba804da8d70c6e78bbc3feb7b71a339e25298c95", + "docs/measurements/h264-n2-heldout/reports/1080p.ff9.json": "157a853343e13f9244d36c5daea3054cb5c5844331d824cf7cb6161ab944a975", + "docs/measurements/h264-n2-heldout/reports/4k.ff7.json": "9d20414e2e51e3a21f6693a5a43948abecabb3aad5706627e0955d0acd8f7567", + "docs/measurements/h264-n2-heldout/reports/4k.ff9.json": "a36fb1acfb0287b1a71ea352fd58c4a23f1ab84ecf259f3b22fbcd60d359123d", + "docs/measurements/h264-n2-heldout/reports/720p.ff7.json": "75111acaa2c6b1f92c360cbb275aca4e851d31f7e4250b459b3ae49e640f96ca", + "docs/measurements/h264-n2-heldout/reports/720p.ff9.json": "cf3c9d77422fbc756a5143ac46024ae917d6985fa59a0145070ce704f615a307", + "docs/measurements/h264-n2-heldout/reports/sd.ff7.json": "208752745fabc1240f77b7dc8467ca12601ef9502e118f954f476b3d37ff2bc2", + "docs/measurements/h264-n2-heldout/reports/sd.ff9.json": "6036820e61afb59f69818649ef5ebeaaf0df024738f70ba1ff9245b50c87df9e", + "docs/measurements/h264-n2-heldout/reports/summary.json": "0153c6e817471e3c1f40656cbbc3ea7526fa23107027630ee2d60d09aca855fd", + "docs/measurements/h264-n2-heldout/tools/analyze_heldout.py": "50e4ccd5dfa033bb202ba5dd5b56747f9f931184a855ce105a0016be62fa924f", + "docs/measurements/h264-n2-heldout/tools/extract.py": "fca30ef84b2f4d363c450f07c643bf4d820b2ef61601bc8315eee060b10125ca", + "docs/measurements/h264-n2-heldout/tools/identity.py": "7f45767f153c4ccae6782406b99af887ce32c0fe738451a9b0ded5a77a321490", + "docs/measurements/h264-pgo-heldout.md": "13743a5035df2f926f1d429f7e123df0fa34e7923a481b47cddf8240e8a964a9", + "docs/measurements/h264-pgo-preparation.md": "5700e22056f5dc0d522659a18cb8dbb611c3f71c48b1ca47bbc42f4d1b51e070", + "docs/measurements/h264-pgo/heldout/acquisition-report.json": "d9f674883d658b3cde5e60b8c0b1e39116f259a7844aeef0d4761f7ac0999c3e", + "docs/measurements/h264-pgo/heldout/diagnostics.jsonl.gz": "6d2f2d1286e0bff8b2a6fda46cdcf6c67a16eade1d006b3962effb6e79864832", + "docs/measurements/h264-pgo/heldout/events.jsonl.gz": "47aa82b625f8dca1502f9cea4f392896a003747006794bb655df72f6b50c0065", + "docs/measurements/h264-pgo/heldout/preflight.json": "0f973108072a1428ed4fc32bf1988900a3125d9a13edc01fcf48161a9bf46ada", + "docs/measurements/h264-pgo/heldout/record.json": "80ea3d4bd5b72a356563858173b9cd66f974cdb7db685246d5db3569e5d0bb3e", + "docs/measurements/h264-pgo/heldout/summary.json": "2d590167d5e67b39b07fe9c5c2b9dbaf40a333da5df3b859e6df997065aebe59", + "docs/measurements/h264-pgo/preparation.json": "b942db1106a7e72f7a0e2d4adc9ac8c722a7c95c83b905cf72ebf39d6ba58abf", + "docs/measurements/h264-rejected.md": "5559e6d69d276452d389395e522681745ec76ecc9398fa90d3c938e07be7b259", + "docs/measurements/h264-rounds/apron-copies/README.md": "4633b14ad535b9098c10234a32f125f2856453887f1d5c1aee1e2b0e8ca560fb", + "docs/measurements/h264-rounds/apron-copies/ap.py": "32dd7143d93c451cfc6449db3823fe9877c85a8b320a1174f1ee62194b37e39f", + "docs/measurements/h264-rounds/apron-copies/build.sh": "dc74dc83dc06d5b345ea50c6164b63ba6c3ca8da9a57b46b84fcd234176c0ae8", + "docs/measurements/h264-rounds/apron-copies/identity-probe.txt": "f20f786882a5db24f954fb259d1154163c1c4f4cd09de99e3d2c93d6febf583a", + "docs/measurements/h264-rounds/apron-copies/identity.sh": "60a2a7d1a64886e5b546730e9fb5a6f704835654833665dcfd40027259423bfb", + "docs/measurements/h264-rounds/apron-copies/plan-probe.md": "7b85c5ae42f904f12421582794eddab4811530b885411a124afe6218639a33fe", + "docs/measurements/h264-rounds/apron-copies/run-gcp.sh": "9b4076d052729ba0332fc37526cc17846c211439217a564772b59addc0d457bc", + "docs/measurements/h264-rounds/apron-copies/run1.void1/job.sh": "26797ed9acef8a737ae0d60915fe60e197e7d7b9b1639eeee1daa86096a9a55e", + "docs/measurements/h264-rounds/apron-copies/run1.void1/provenance.txt": "81606b85c1e38d402d8579b484a8d59817f320d6814d99daa98feb2fb1d21650", + "docs/measurements/h264-rounds/apron-copies/run1.void1/run.log": "f5b288818c80a63be2d304df9971a10fe1a4407e76e162d957a9789eefec6c6c", + "docs/measurements/h264-rounds/apron-copies/run1.void2/job.sh": "26797ed9acef8a737ae0d60915fe60e197e7d7b9b1639eeee1daa86096a9a55e", + "docs/measurements/h264-rounds/apron-copies/run1.void2/provenance.txt": "81606b85c1e38d402d8579b484a8d59817f320d6814d99daa98feb2fb1d21650", + "docs/measurements/h264-rounds/apron-copies/run1.void2/run.log": "a284e1f149e3495cd0fea74e1ca08c2c4aca8c2a2072d1cb8b345c0385d88eed", + "docs/measurements/h264-rounds/apron-copies/run1/ap-summary.txt": "593c4094281d6799a78b9398b0b8ccc93db1077ba2028b5d75ffef7333fe0c94", + "docs/measurements/h264-rounds/apron-copies/run1/host.txt": "fe2f455356d3621a7d1aae1a6f56687ac60264ac839da6d7d1c90bc02ae4209f", + "docs/measurements/h264-rounds/apron-copies/run1/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/apron-copies/run1/job.sh": "26797ed9acef8a737ae0d60915fe60e197e7d7b9b1639eeee1daa86096a9a55e", + "docs/measurements/h264-rounds/apron-copies/run1/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/apron-copies/run1/progress.txt": "d461f72770474f9c2ee9fc594e00ff66a48994cd00437f5f13a2525bd4f98f6f", + "docs/measurements/h264-rounds/apron-copies/run1/provenance.txt": "81606b85c1e38d402d8579b484a8d59817f320d6814d99daa98feb2fb1d21650", + "docs/measurements/h264-rounds/apron-copies/run1/ref.json": "927f3b3a32ecf0a59bab297bda2c8dc36a8d2e67b249301f57b1d24e582fe8c1", + "docs/measurements/h264-rounds/apron-copies/run1/run.log": "f5baaf95444e9b0304596897608afc6808db9117a2a761202fb9140a15e78440", + "docs/measurements/h264-rounds/apron-copies/run1/t8.1080p.json": "e6e75284ce142ba1846a84682e241d72634e17ed57e0d5ff8fcefcb779a55f35", + "docs/measurements/h264-rounds/apron-copies/run1/t8.1080p.log": "0176899558ae98218eccaaa766d2aee5d913f8b61bc42fd04eb1caae4b26e44c", + "docs/measurements/h264-rounds/apron-copies/run1/t8.4k.json": "ffb0bb9da043b626366787cae8d2b0c4f8178652ece2d395619ce2796b9cad3a", + "docs/measurements/h264-rounds/apron-copies/run1/t8.4k.log": "a6cd6c1b7ff9ad12bbeba46d1609c5c7c892c8d66e7331c5ef559b6b49384868", + "docs/measurements/h264-rounds/apron-copies/run1/t8.720p.json": "2c9834720518daab286a69dbca5cddc9bff18ae7e761fb335c43149d25ef193e", + "docs/measurements/h264-rounds/apron-copies/run1/t8.720p.log": "3fc11ab9efddb5bc7f0c321eb52392a83a848bd5e25bb93a193840f10a251717", + "docs/measurements/h264-rounds/apron-copies/run1/t8.sd.json": "dd38a034529246fa1483a024e3205b7b759f88897ef45399e3238a6e2781bbd5", + "docs/measurements/h264-rounds/apron-copies/run1/t8.sd.log": "cc23af9307abeaa640a14cc05c604f047bfa91feaca2eb0542ce813627d6c906", + "docs/measurements/h264-rounds/apron-copies/run1/verdict.json": "f0a481595e926d4d318240a038e13e80c27be039ed45f5ba4ac752c133f8ab50", + "docs/measurements/h264-rounds/apron-cut/README.md": "3b04568c998e6ea61a95a24a0ec8fb9da0832a90de94970fa6de264dd2f76066", + "docs/measurements/h264-rounds/apron-cut/ab8.py": "2e7c9235fdc7aa4f69ade246042b3e4ef1621d37a6d3ecbba798bbdc92fa9beb", + "docs/measurements/h264-rounds/apron-cut/ac.py": "0bddf9c58e82e7ebfcebe968cdbd4f3fbbfe92042265f56797c199b22be06895", + "docs/measurements/h264-rounds/apron-cut/conformance/detect.json": "49a1c6bcdfe78c5f12a1fe536623c01dd44365dc1fa4bfa823424128a1950d11", + "docs/measurements/h264-rounds/apron-cut/conformance/scalar.json": "458a1da2b69b15adb8a605d4389d4925aea2aadc73fcf83058d20c5a032aa82f", + "docs/measurements/h264-rounds/apron-cut/gate1.void1/job.sh": "c354bb3a9e0600fadaa9507281a49b330f0583fba341a337a1050438c818be36", + "docs/measurements/h264-rounds/apron-cut/gate1.void1/provenance.txt": "5e98409113b3e52fd7738b0affcbcbc060b5ff14fae6377d1f4fd9292bdbc0f4", + "docs/measurements/h264-rounds/apron-cut/gate1.void1/run.log": "1e45303d73fb622b2fac324fbf321f5df7d74396df14697de49f0a91d51d241c", + "docs/measurements/h264-rounds/apron-cut/gate2.void1/job.sh": "c354bb3a9e0600fadaa9507281a49b330f0583fba341a337a1050438c818be36", + "docs/measurements/h264-rounds/apron-cut/gate2.void1/provenance.txt": "5e98409113b3e52fd7738b0affcbcbc060b5ff14fae6377d1f4fd9292bdbc0f4", + "docs/measurements/h264-rounds/apron-cut/gate2.void1/run.log": "0b990cfae50ec66c76823e9471ca361072b0a27c50168e222535973bcad271a0", + "docs/measurements/h264-rounds/apron-cut/gate3/ac-summary.txt": "de59eb87650ec40dd52e6a5c798317799d67994516c73e1796cc678affb63677", + "docs/measurements/h264-rounds/apron-cut/gate3/host.txt": "9b70091421051df922a2c14f75e17a4c5c869fba9229d219ad50515612f67689", + "docs/measurements/h264-rounds/apron-cut/gate3/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/apron-cut/gate3/job.sh": "c354bb3a9e0600fadaa9507281a49b330f0583fba341a337a1050438c818be36", + "docs/measurements/h264-rounds/apron-cut/gate3/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/apron-cut/gate3/progress.txt": "b36f6311dc93a44f976210e27f216f6a5035190f03a7197bc844f87c44a3b9d4", + "docs/measurements/h264-rounds/apron-cut/gate3/provenance.txt": "5e98409113b3e52fd7738b0affcbcbc060b5ff14fae6377d1f4fd9292bdbc0f4", + "docs/measurements/h264-rounds/apron-cut/gate3/ref.json": "3285515abf8f825190987b0e99ee50e9ce934df2b82d7edf9437ea60a67445d0", + "docs/measurements/h264-rounds/apron-cut/gate3/run.log": "ebe218f60279c8c6555eb1d8e2985324c1b6f54078ae5b801fa9d0af144c3ef9", + "docs/measurements/h264-rounds/apron-cut/gate3/t8.1080p.json": "c8d495b03ea199f9c80609f825f1e564352c2dd9b22d4aed3cdd9205392e5311", + "docs/measurements/h264-rounds/apron-cut/gate3/t8.1080p.log": "fc8239690d2fa7fa65b3af7e176e6a3a040b5dbf93d55f06c9c8249e68fe479c", + "docs/measurements/h264-rounds/apron-cut/gate3/t8.4k.json": "37fb1ad37f890152dbb2131142aa9b4f23825aa250b526f38a7833fcd7d564d2", + "docs/measurements/h264-rounds/apron-cut/gate3/t8.4k.log": "f43ccabfdf7fafa858c5cb91877a1ba9fbff3c85261f91f2e7e2c204e61c44f9", + "docs/measurements/h264-rounds/apron-cut/gate3/t8.720p.json": "1710c925572b88573169c33f476d8fe9574db2b281d22c7842a0cc1cf05c9976", + "docs/measurements/h264-rounds/apron-cut/gate3/t8.720p.log": "96929216d595f96c229382d979cc7c7dfc9d89c74c3ad3999119fcf555548f2b", + "docs/measurements/h264-rounds/apron-cut/gate3/t8.sd.json": "7529cf0ffb9160ad553cf70402260f0d5975dcf1251ede112be8d493f0b49a32", + "docs/measurements/h264-rounds/apron-cut/gate3/t8.sd.log": "d8a54024fbdc3bd9669c36557724aa1d55ea00b87e0bf480e5f307ce78ced847", + "docs/measurements/h264-rounds/apron-cut/gate3/verdict.json": "1ade1f09ef21724c6492433be0233cc0b2ec4f7c70af05cc6895d3bdd52fccf5", + "docs/measurements/h264-rounds/apron-cut/identity.txt": "03d4d057d70b4e3bade36b4a96faccfaf9d84f17f2e1215561b6e9c4e8146707", + "docs/measurements/h264-rounds/apron-cut/local-8t-arms.json": "811d2ad8590d789356f49d1c5cee7a94486e6bd7d04350e0b1433a040906f5ee", + "docs/measurements/h264-rounds/apron-cut/local-8t-arms.txt": "40c7404e0bd9055abdecb5e2322c688259c545d13a658a4353effc2c515574a2", + "docs/measurements/h264-rounds/apron-cut/local-8t.json": "e343fa81dfa132f94a1163520413ddd08a528c0016e48483be5c2a277bd67cb8", + "docs/measurements/h264-rounds/apron-cut/local-8t.txt": "32e813d0602ab77b19cd2c2dcb1f13a4dd4f8eff795f77bf0cd480b0a8372fde", + "docs/measurements/h264-rounds/apron-cut/run-1t.sh": "926380bec5def9cf2ab586a28c21adbce52a34564a832bb026e40844f9dea588", + "docs/measurements/h264-rounds/apron-cut/run-gcp.sh": "e2ea323d3c0c50c283dfeeee9f52eed142beaa0f2782b71704e078abe06a5d58", + "docs/measurements/h264-rounds/apron-cut/sumx.py": "26ed1c5bb6517e1e5155b71dba521ee382c9c863aa620aeebb93d4a6ac7fbc77", + "docs/measurements/h264-rounds/apron-cut/t1/g.1080p.json": "2d9a38c6076e8efe3e04823bf93dd1572c88f977114aca4da4155645282673bb", + "docs/measurements/h264-rounds/apron-cut/t1/g.4k.json": "ef28deb415da705e1d4539d73cbc8f4582b9934d4d03070c174b55d0f476c38f", + "docs/measurements/h264-rounds/apron-cut/t1/g.720p.json": "a69bfb0298aef5138bf556cf215e5feafbdb8f3f1f61bc7ca9f49b2d8303a606", + "docs/measurements/h264-rounds/apron-cut/t1/g.sd.json": "b7cfc0e51d08ba481dbfecadf8dcc8c57d4da3f95d1f34e5250918e57900a555", + "docs/measurements/h264-rounds/apron-cut/t1/progress.txt": "bb783eafae714e4a436f03c8dbf2b4c57e90135a44ff9c2fc12c4cd41810412d", + "docs/measurements/h264-rounds/apron-cut/t1/summary.txt": "eff1c208bfb706ed62789556cf3207096aafd0edbedc9babaf51b994b566dbbd", + "docs/measurements/h264-rounds/apron-keep/README.md": "45cd9e50cea1796b74997e1bb918c70f9f8e03553fecdeeb05c30338670cb5e3", + "docs/measurements/h264-rounds/apron-keep/conformance/detect.json": "f1f50dd303df6117cc529e865e9cc07e1c15975bb3831e0b80660125556fa641", + "docs/measurements/h264-rounds/apron-keep/conformance/scalar.json": "67fecf0d8b339c18f1035d79818a455b113bd9c20dcf0a388696cc277006e707", + "docs/measurements/h264-rounds/apron-keep/identity.txt": "af1626e8371da3d3874ca568b3257b6656b712a02780680577eb842271f6f7e9", + "docs/measurements/h264-rounds/apron-keep/keep1/ac-summary.txt": "aeb6fafb0eb076e959fec31f3cd5253b8cc11dc20c1ad95cf9772b00bea887f8", + "docs/measurements/h264-rounds/apron-keep/keep1/host.txt": "b74509be59901ac41badd99117a70412266770afc046b8329526f58cdac8114b", + "docs/measurements/h264-rounds/apron-keep/keep1/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/apron-keep/keep1/job.sh": "a3c2b3d8b8002e1c36fb429b941f830cfdeb1b1e1a1f3ffffdfeec9010d9fa4d", + "docs/measurements/h264-rounds/apron-keep/keep1/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/apron-keep/keep1/progress.txt": "cf75e3eb2a7b527cdd5bc46de2c9a18d95870c9f64595e1f2242c7f9611f22ba", + "docs/measurements/h264-rounds/apron-keep/keep1/provenance.txt": "0881053253a187b4eed41ee1938e5720d1e31efdf1fe65f4f66d919f0184c987", + "docs/measurements/h264-rounds/apron-keep/keep1/ref.json": "126677cedb4d01c5b0d0a34404e0f205ae8e7e2253ce1fea28a40e6c4d30e018", + "docs/measurements/h264-rounds/apron-keep/keep1/run.log": "1149abfd154fa35ccdbdfdd9e2d74153880bf0a76c1b1d1c99a081a6abe31120", + "docs/measurements/h264-rounds/apron-keep/keep1/t8.1080p.json": "7cc3b223f06ec35a3d3cae776963615b5f951be75a4b3bf65352fe4baaa3bec5", + "docs/measurements/h264-rounds/apron-keep/keep1/t8.1080p.log": "ea64a2f4dc73c0f1a021e60fd89219e456ad32c9040a51e16b9bef3b385341ff", + "docs/measurements/h264-rounds/apron-keep/keep1/t8.4k.json": "c409b29f62c542df49486e5ca204bd48068bb1e58d7fd13910bd35580913bc33", + "docs/measurements/h264-rounds/apron-keep/keep1/t8.4k.log": "51643b4e5f3f6ed93a5fc49c31ea74d22abcbc3c6ab302a97b9b174a43bb4151", + "docs/measurements/h264-rounds/apron-keep/keep1/t8.720p.json": "dac5850ed8f4c3e45ac1b05caedb9c1c74de9a2d932004876144d1ddebc41087", + "docs/measurements/h264-rounds/apron-keep/keep1/t8.720p.log": "10db170bec26654ff14c30f5b87244fb07ec54d53778a7ddc57325f76f767d09", + "docs/measurements/h264-rounds/apron-keep/keep1/t8.sd.json": "f1ab0dc6300ca3e0dd46948f6b193d755179133d7a1b19692a20baf5137cd0eb", + "docs/measurements/h264-rounds/apron-keep/keep1/t8.sd.log": "1d54d61cbdda892fb6dd0676e34af6370714db1abf8e4ab78653fbd286ead3d4", + "docs/measurements/h264-rounds/apron-keep/keep1/verdict.json": "cae89990938661524c12e8691fc0bbcc1e9b8cbe1f06bc052018b6c86324648d", + "docs/measurements/h264-rounds/apron-keep/run-1t.sh": "9fabeff735c5f28870dbec2b52592ac5dcc86864dced12030955f0092ade456f", + "docs/measurements/h264-rounds/apron-keep/run-gcp.sh": "ca8f0e3e4ee280fcd384837c7e50f14c898a83dae87c8d4d10234fba159c1860", + "docs/measurements/h264-rounds/apron-keep/t1/g.1080p.json": "d0b26e07b23045afeed50f1e64250ebf8fc171bff44be36bee874b0dfc6963bc", + "docs/measurements/h264-rounds/apron-keep/t1/g.4k.json": "10675a5a62128d8b14218d59a930c67e58aa6818d3ef44040fad51775e86a5a7", + "docs/measurements/h264-rounds/apron-keep/t1/g.720p.json": "42b21f5be13c4c14c2b9952f461735abe3937fa1130aa7ff82f385e5a63e911d", + "docs/measurements/h264-rounds/apron-keep/t1/g.sd.json": "b3c18ec26a119cc844c506a303f859f9f252b4a793678938cd3de8fdd35f8645", + "docs/measurements/h264-rounds/apron-keep/t1/progress.txt": "9047b3384d1eeb2e7bbccf2483a3eec7c382f76b813bd954755598dcc53193bd", + "docs/measurements/h264-rounds/apron-keep/t1/summary.txt": "c210008cb1fec7fc36a19e87dc3993ecfc6ebe1224c01d324a9f5c6196d58a32", + "docs/measurements/h264-rounds/apron-own/README.md": "6ff3c26fdb5899abf3396916ff300fefa10a2d7c81ca852023ae39f66119a367", + "docs/measurements/h264-rounds/apron-own/identity.txt": "8ff3378b28195e24789417f98fea3509fdf23449a2442b3541b0d602d14281df", + "docs/measurements/h264-rounds/apron-own/instructions.txt": "12a6e42206cce48e5d55b50351ff903698e64e4beaa8a687af30019ec2a3552b", + "docs/measurements/h264-rounds/apron-own/own1/ac-summary.txt": "df34d2ca7123211f836c5a40c6f3e4f4121983ea88e33ea0d3a12062db9ca2a7", + "docs/measurements/h264-rounds/apron-own/own1/host.txt": "3710ce834754569d9f0112cd3b33bc0097338e3362b19e3d0c22b1c699e27631", + "docs/measurements/h264-rounds/apron-own/own1/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/apron-own/own1/job.sh": "cdbc9b5b6e9eb1d4aa72c438b3ee03a83883d526d665996f88eabb1403ee3234", + "docs/measurements/h264-rounds/apron-own/own1/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/apron-own/own1/progress.txt": "0c06a2902dfe2bca1ab3966fa91e3748adedaf21ddd5fdaec20caf9c0cef9326", + "docs/measurements/h264-rounds/apron-own/own1/provenance.txt": "1e4bae6a34521c8fa4b6a522546b5d1843b3ad2556151cdfedea973a31bbfab1", + "docs/measurements/h264-rounds/apron-own/own1/ref.json": "1d8f00645803e341da305b49968ea619ee32f5f036620a2ac0085ffa55d31c3c", + "docs/measurements/h264-rounds/apron-own/own1/run.log": "08c8f7569693cbadfc825d6ed459ab2dba17da315a1d479b927ddb47dd9a1066", + "docs/measurements/h264-rounds/apron-own/own1/t8.1080p.json": "b1a7e55c158e8232f5581e428889eeaeb5e66defe9a50ce4a4e7818e524070c8", + "docs/measurements/h264-rounds/apron-own/own1/t8.1080p.log": "67d739195d930934a891b7089fb88cbfc2d6ed09f8d1ffbf4de331ae02baf24d", + "docs/measurements/h264-rounds/apron-own/own1/t8.4k.json": "a77829017b927a9c1913d98ecfe7e3899f6acafe1e77e31edbe9f73a3c4242c6", + "docs/measurements/h264-rounds/apron-own/own1/t8.4k.log": "62c422209cd2833a5710421206270f2c6557ae8a76b201cf2fb2e5e0399137de", + "docs/measurements/h264-rounds/apron-own/own1/t8.720p.json": "fa7ddaaa187ef8d92222fd41dd5d29a3697e57445caf259fa04a3683cd532709", + "docs/measurements/h264-rounds/apron-own/own1/t8.720p.log": "90e333f4795b10b0babedcf8c7a9ee4592208c73d9093707b8eac00e3509c5ed", + "docs/measurements/h264-rounds/apron-own/own1/t8.sd.json": "a74ca6a468729bd28616ea88365db67af1da7cb958f180850a7c4e621c7bb809", + "docs/measurements/h264-rounds/apron-own/own1/t8.sd.log": "49a35e4e3a3ecce293e14a5e5139a161024fa814df880e6f1a788c02d716efd1", + "docs/measurements/h264-rounds/apron-own/own1/verdict.json": "9d5885cc2c9246d898091e687a4f138b10fbdba32f9545297992111c36d5546b", + "docs/measurements/h264-rounds/apron-own/run-1t.sh": "d725b58686583b72a99f097ed762627f3a1c2b5da696a580f6a515e7b2ce2993", + "docs/measurements/h264-rounds/apron-own/run-gcp.sh": "00a8f219263499f2624e919bc920d39194ebb35395eb2a6026b259c1809490bd", + "docs/measurements/h264-rounds/apron-own/t1-info/g.1080p.json": "240e6f0e809200422646013f0a80ea843f7d5aaaca3afb18dc5fe19e92acd336", + "docs/measurements/h264-rounds/apron-own/t1-info/g.4k.json": "86aa0dd9bb3951f6d4db1cd6a1ce174154de88c3b1ef638028cf4238787349a1", + "docs/measurements/h264-rounds/apron-own/t1-info/g.720p.json": "47e38f8afbb0e917cecd6501520e3a1763316b68ad4b430d7919755249146b8e", + "docs/measurements/h264-rounds/apron-own/t1-info/g.sd.json": "67506ee88f37a2acb77dc33340bf2d1722e8692c9ad05bccb55c3639967f6fab", + "docs/measurements/h264-rounds/apron-own/t1-info/summary.txt": "641feb3781770e486fbcebaeeb6f1b45ba80e0b67964453d5dbe56605cf6d8cc", + "docs/measurements/h264-rounds/apron-own/t1-info/t1x.sh": "ce6d68a8b6a6bc5798c1d93bd97dc38aba86fb19dafd37a9927200c7d074910f", + "docs/measurements/h264-rounds/apron-own/t1/g.1080p.json": "2060fe09bc23ab1d2ba5b741156a9808f56959e4a1c6222fc1792d7e270a9d46", + "docs/measurements/h264-rounds/apron-own/t1/g.4k.json": "cda4f14c6911a39101e2d1974551a058cd8a53a7bdca9f916118a5eb714701c4", + "docs/measurements/h264-rounds/apron-own/t1/g.720p.json": "c3af3df789915e7a5cfbd9a341adad60081d69fb0c83e3eb8df6f232c7b6789d", + "docs/measurements/h264-rounds/apron-own/t1/g.sd.json": "13784b5d0b485234ed905ad1416e0647f93d530420d94b7162a9dd90d09b20db", + "docs/measurements/h264-rounds/apron-own/t1/progress.txt": "de69ca350aa63f02e5bb4e8ce06ad015a67b010c7e6fc75a7261781b13889958", + "docs/measurements/h264-rounds/apron-own/t1/summary.txt": "1d347d2b4a0e12bad2ebe14dbf1ec592ce0f5f328e3bb32e578ea833dd9af817", + "docs/measurements/h264-rounds/avx512-deblock/analyze.py": "56baf6f52114ef828bf2d534d39415b3e95585cbd4ce668dd06bc07d94c45997", + "docs/measurements/h264-rounds/avx512-deblock/bench.txt": "2360986b086b65cf586a5bbbef427eb9f26c09f76d1e68cba9718290f0e49b81", + "docs/measurements/h264-rounds/avx512-deblock/conformance.txt": "2190d976c56e051089eb00a2168156f74906bc18b15b4664d56ab3de5a14e4bd", + "docs/measurements/h264-rounds/avx512-deblock/gating/analysis.txt": "88008065932c4d964bcfc90510777782fc5818f4977bd16299202b9197682ef4", + "docs/measurements/h264-rounds/avx512-deblock/gating/analyze.py": "56baf6f52114ef828bf2d534d39415b3e95585cbd4ce668dd06bc07d94c45997", + "docs/measurements/h264-rounds/avx512-deblock/gating/g.1080p.json": "3ed2350818f6063181ce0efa5a3d6c5e46a7993f468a4ecedba2c85a8f778c98", + "docs/measurements/h264-rounds/avx512-deblock/gating/g.1080p.log": "9beeecfb65f2ab8769281fd941ae0b92c66ecc8edd2b37ed9060922dc8ba925f", + "docs/measurements/h264-rounds/avx512-deblock/gating/g.4k.json": "5288e64036ea2dfb51043bf34d62d80223e594b44bec959a83d5ccbb6cc8b8ca", + "docs/measurements/h264-rounds/avx512-deblock/gating/g.4k.log": "e3b391d73a81bde0834dcdd8b5cd5b3151b42d5f211dac943ecfbaaf299a2103", + "docs/measurements/h264-rounds/avx512-deblock/gating/g.720p.json": "fea2cee2e489a0e229977e435e1214e5d69aa1daaca5ed2b30dc485e0a0d090f", + "docs/measurements/h264-rounds/avx512-deblock/gating/g.720p.log": "c566cdca16a2091fb2fd6da33708a5b7b50a3061c0af21a38b9d66042be6ef0d", + "docs/measurements/h264-rounds/avx512-deblock/gating/g.sd.json": "22f0ec27b7e0e96fc97456f870132d88c61b1bdeadb1bc856930c9a5624349b2", + "docs/measurements/h264-rounds/avx512-deblock/gating/g.sd.log": "3d7893942a4ddd6cae7e59f62a86984fe270cd41ee55e3e723b823248832a606", + "docs/measurements/h264-rounds/avx512-deblock/gating/g.summary.json": "6ae734cef4b33a14a4e8b01a589dce08ed6de6aa0bc59dac504f61d9be77e5b6", + "docs/measurements/h264-rounds/avx512-deblock/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/avx512-deblock/gating/progress.txt": "16e561251164940c500bbfbc69290dcb32a93173b294642e6a6c6b6c64c85f6f", + "docs/measurements/h264-rounds/avx512-deblock/gating/provenance.txt": "f3c615ca3609b5981ddcca6e01ece991e59e0682d7a36f34f2cbe602122d791c", + "docs/measurements/h264-rounds/avx512-deblock/local-tiers.json": "f8f4a43cc2024d0eda0318a2fe89a2d96ca0f9aa686104318f7a6d2736c182ab", + "docs/measurements/h264-rounds/avx512-deblock/profile.b7cad07.t1.json": "85b3ec1de63b535ec95aeda2ebf364cf271f96327cd9af4254a787dfd5d58cd7", + "docs/measurements/h264-rounds/avx512-deblock/profile.txt": "31461bebc7bb375ddb4694fee53d564c678d5985740ffb8966530db6dd067679", + "docs/measurements/h264-rounds/avx512-deblock/run-ab-helper.sh": "c05411785c850c0ac42ab9182d8ec75cd69b23a1be0c7b5a08272113edf95da3", + "docs/measurements/h264-rounds/avx512-deblock/tools/miri/Cargo.toml": "a82e78a1c5a9ad4e6acc3c215f3dbac4e9db7d2ef22c027d61bb86d32d133c42", + "docs/measurements/h264-rounds/avx512-deblock/tools/miri/main.rs": "2b1c2eeb6183091e7431963120c297e378e3a54109563bf899c2739ebfbabd5a", + "docs/measurements/h264-rounds/avx512-deblock/tools/tiers.py": "91c9fd2ac1b66c0e394f3006f1fd1fe649dfb202029049898dafe002f090cb44", + "docs/measurements/h264-rounds/avx512-luma-mc/README.md": "79f511f47af404f7d89b519bf7ae691b6050bae217fa2be33363d7f65aeeeb17", + "docs/measurements/h264-rounds/avx512-luma-mc/ab-centre-only.json": "fcb0e751e3f1e0b36f5269809104f45d4d4edf9d1e512e5cb024f6bb9141f367", + "docs/measurements/h264-rounds/avx512-luma-mc/ab-refactor-only.json": "99ee13646b0ff8e7e9dfa8004f269f4fde3def0785c759ede02448279453d901", + "docs/measurements/h264-rounds/avx512-luma-mc/ab-tier.json": "be7f87140f417295292aeb13d51dfb7cd1cfb1438a4c164093c9643a4757217a", + "docs/measurements/h264-rounds/avx512-luma-mc/local-tiers.json": "c5490782fb5094a3d85cfd07b81095c16da56905de49631ba8692c1ee5f17455", + "docs/measurements/h264-rounds/avx512-luma-mc/mctier.txt": "5c14ef2eafa4962157c7b2def544ec5135d7d5bfe749d8f81f05d8a55b36cb44", + "docs/measurements/h264-rounds/avx512-luma-mc/tools/ab2.py": "ff13fb9e1632df1666cdcd66517e4f32eb1bf75ad3406bb83ef7c3ab8246e080", + "docs/measurements/h264-rounds/avx512-luma-mc/tools/mctier.rs": "ee7d5c8bd6d0497527560f9bf25481a2702cfb9590c2a8b1faecb3503297110b", + "docs/measurements/h264-rounds/avx512-luma-mc/tools/tiers.py": "91c9fd2ac1b66c0e394f3006f1fd1fe649dfb202029049898dafe002f090cb44", + "docs/measurements/h264-rounds/band-height/ab8.py": "1eff58080643ec05d653589aca0de1f9eae252f522d68a4ed2e17176b007d042", + "docs/measurements/h264-rounds/band-height/identity-x2.txt": "c21d94621c22adfd06eba945049de9f00e8a267d0f9f3a75ae7678d0f37cfbf4", + "docs/measurements/h264-rounds/band-height/identity-x4.txt": "c21d94621c22adfd06eba945049de9f00e8a267d0f9f3a75ae7678d0f37cfbf4", + "docs/measurements/h264-rounds/band-height/plan-sweep.md": "f58b65f2565e9617b266fd82ac2120e2ccb24550cbe59f6b0ed9b40593694a5b", + "docs/measurements/h264-rounds/band-height/sizes.txt": "d10d50576bc7b5a2aab8673d9bf76ff08489aa9d98ebfdffc0bc8da2922311a9", + "docs/measurements/h264-rounds/band-height/sweep.json": "3c1caaad23d0023cd949e73dcf102c6ee0011b96197e367ae2a82810ed68ada7", + "docs/measurements/h264-rounds/band-height/sweep.txt": "f725c6146e4a59cae2f5819040972764f5b0fa95125ae09337a733bcede89d42", + "docs/measurements/h264-rounds/band-lag/README.md": "b17dc6f67357d79204aad22331fd9eec4333a56a3bf2a1b9a72c3795ac73e398", + "docs/measurements/h264-rounds/band-lag/analyze.py": "ea4fe3eae8891ec61f819277e2d3f03cd4bc58c3736cf78c0b0de153a0f2ba72", + "docs/measurements/h264-rounds/band-lag/cpu8.py": "a728aa9cc1cb0744f05bdd3021dddcbc7a8e26928802f533c5da4dda7cdb947d", + "docs/measurements/h264-rounds/band-lag/followup/busy-1080p.txt": "b71f4b6600defd21bef3a4c6da4bfd5c238412d7edff552a382ee35b532329a5", + "docs/measurements/h264-rounds/band-lag/followup/diag-branch-1080p.txt": "f0b28a1219776b7da9c7c8e0755e39ee78cf9f584b8804da084a6be35c457f2f", + "docs/measurements/h264-rounds/band-lag/followup/diag-main-1080p.txt": "d2d6f30508330e6f9eec630e9f3980a79fb8bf265515f083b33180ea78317c9f", + "docs/measurements/h264-rounds/band-lag/gating/README.md": "1cac95ac8e0a2db9caef734c986989818b50d30a34379f1a6ec7b52bd3495eee", + "docs/measurements/h264-rounds/band-lag/gating/analysis.txt": "597c5da6647e5613450b45f7ead42f1afecc6c8043e0b811d6af3d473c9d8114", + "docs/measurements/h264-rounds/band-lag/gating/analyze.py": "ea4fe3eae8891ec61f819277e2d3f03cd4bc58c3736cf78c0b0de153a0f2ba72", + "docs/measurements/h264-rounds/band-lag/gating/binaries.sha256": "aedf5ec01fba5cb7a3d0bd70e40b5eddcf3265f1eb3210fc8b8809424428bcdc", + "docs/measurements/h264-rounds/band-lag/gating/cpu.txt": "cc53237758e3677dc5ec6336660721f1fc18d46f5a1f7082ffd87799c8a14992", + "docs/measurements/h264-rounds/band-lag/gating/cpu8.1080p.json": "5500037f3faea98928ad95a62ebee8468b870e1b791994d25c70a31a158ee0a0", + "docs/measurements/h264-rounds/band-lag/gating/cpu8.1080p.txt": "9c76bac3fb8f3137db7fba360978edbf48a46d2eaa5ed9d466f820c3a31ee249", + "docs/measurements/h264-rounds/band-lag/gating/cpu8.4k.json": "decb66630707372de3279575b7c1f5831c3f95a13c7ec104a733f27a1b5c999f", + "docs/measurements/h264-rounds/band-lag/gating/cpu8.4k.txt": "44acd339da49b95790686452c14e671eed3b512dfd345b1a10f04ea4bd7d057f", + "docs/measurements/h264-rounds/band-lag/gating/cpu8.720p.json": "984745857ddbf65c9f13f31eae1dff2c4caefaf97e777543aec3680afba5174c", + "docs/measurements/h264-rounds/band-lag/gating/cpu8.720p.txt": "a3ec19a6d01987ab168219638e5807102d890d225f370efdb8e32432eac01cd7", + "docs/measurements/h264-rounds/band-lag/gating/cpu8.py": "a728aa9cc1cb0744f05bdd3021dddcbc7a8e26928802f533c5da4dda7cdb947d", + "docs/measurements/h264-rounds/band-lag/gating/cpu8.sd.json": "335042646ce2a3ef5d6d0bb7b785eeb1f045deb910320a6c17c2cc99ae391781", + "docs/measurements/h264-rounds/band-lag/gating/cpu8.sd.txt": "4032fb849a8d95147ecc711e9c5d149e6f7077500d0e331b96f604546395e1fa", + "docs/measurements/h264-rounds/band-lag/gating/identity.txt": "e9d8c9e4e0cd42cc6747816d0ebfc0f03b07ccae807154c24d47c1b186bcaae4", + "docs/measurements/h264-rounds/band-lag/gating/log.txt": "0c3c69696a23dfa6fc970558a9dc83b77980f83cebd2452125e44019577ef445", + "docs/measurements/h264-rounds/band-lag/gating/p.1080p.json": "c326eea382bcd578b5692a6618dc52e9ef1b1f206628826c884ac91c3733fc15", + "docs/measurements/h264-rounds/band-lag/gating/p.1080p.log": "841ae82816511ec4dbad332f43fc9c48969698d9d7980635a5f972f0dd2814ff", + "docs/measurements/h264-rounds/band-lag/gating/p.4k.json": "d2892652e6835f8ef9035a6622ef09e3ffe9345385195d8ba22c8148cafcd0a0", + "docs/measurements/h264-rounds/band-lag/gating/p.4k.log": "bd41b530ef6d3bac1e856ec69ffb72e70b03f3b5235833f9ab4f8861a11a5aba", + "docs/measurements/h264-rounds/band-lag/gating/p.720p.json": "0c5759bcf5e9e52d57a68d2a6abf98b3bf37e7ded1f095c13c4fb2d8fcf1d92f", + "docs/measurements/h264-rounds/band-lag/gating/p.720p.log": "7b13229beb2814e9aeda2c3cac5f47387741f03ae489f3eaf8631f6e7f8fac57", + "docs/measurements/h264-rounds/band-lag/gating/p.sd.json": "5cc1a8c0dea9123fee9bd4f35d084db1d58fa8bf6299a15e44387a260581ea40", + "docs/measurements/h264-rounds/band-lag/gating/p.sd.log": "dc18327041d510214a1c38016e82dfba9299cacb6f7aeb8d2bc420df055b556a", + "docs/measurements/h264-rounds/band-lag/gating/reference.json": "e785675e4b5c0f6886daf0c775e43df1bb3caaa79fa1ce64f2a95aa1f7efe5e5", + "docs/measurements/h264-rounds/band-lag/gating/run-ab-helper.sh": "1a292a04c4e0f3ef324fca8c93bc90cab493b9bdebb30f285f9c3e4e9a3274b5", + "docs/measurements/h264-rounds/band-lag/gating/run-gated.sh": "760baf9e7dd29d5291743e14baaca8a8d5dc07d03c40c6519a24dba620afbc4f", + "docs/measurements/h264-rounds/band-lag/gating/summary.json": "7dd3f2f2ad65fa3acad6e81ffd52a04354a2b246b2bcedce6373bec135764759", + "docs/measurements/h264-rounds/band-lag/gating/t.1080p.json": "14d6e5f98d3bbf9510fb82d75ae6e4dde0f9424e43d24e2343dee69212b449b6", + "docs/measurements/h264-rounds/band-lag/gating/t.1080p.log": "2dc8ae3ba90f46e1a1da65fbcfa3136a46e2a7fb72106723ca3ac522a5577b2d", + "docs/measurements/h264-rounds/band-lag/gating/t.4k.json": "1d3b5edb67b5d79fe5d960638684a502fc522d4dcc3e51dbda196bf49417c5aa", + "docs/measurements/h264-rounds/band-lag/gating/t.4k.log": "87387a645b716d541526b025c42074db6f23cab38224a28627257236e60d3c39", + "docs/measurements/h264-rounds/band-lag/gating/t.720p.json": "a808c44668df8fcfafa9018552355e113f0ccc4bbdf649ad6349af6781c66686", + "docs/measurements/h264-rounds/band-lag/gating/t.720p.log": "22d0fc84e89f8bbcb60708f709ec7fb703df6854612fc6a33b6e3ca6a5bde5d0", + "docs/measurements/h264-rounds/band-lag/gating/t.sd.json": "4b28591291b9952353a376bc76abcfe931b02c8daa18faed47cb77f13da158c9", + "docs/measurements/h264-rounds/band-lag/gating/t.sd.log": "120ecccb5fb5ed89783a540f46d7775ba93ba5a00b61be146b2c4df82ad1dbf7", + "docs/measurements/h264-rounds/band-lag/local/identity-conformance-rebased.txt": "1b751453aac5b60764bce84b0563e1032c4c7a0518477af770478ed723f177ee", + "docs/measurements/h264-rounds/band-lag/local/identity-conformance.txt": "4e8441ea2e59d2d6af3ade550889ba8c42e724051e66eeed9224d87c1b441951", + "docs/measurements/h264-rounds/band-lag/local/larger-band-height.txt": "bc8879dd3e9ad402301e26499f9d5141b6dcee7c1aa77d3067928ef65aafebf1", + "docs/measurements/h264-rounds/band-lag/local/local-timing.txt": "8addc4853cd0dd1f50141e128823f9052902b0a35ff012b433e4cb96b279495c", + "docs/measurements/h264-rounds/band-lag/local/sd-band-height.txt": "fcfd98319caec8a4b772ae1a1909eb7ec0476128f848c723276baced1c7ce7d9", + "docs/measurements/h264-rounds/band-lag/profile/diag-branch.txt": "281ed9cda632f52a616f7b51bbcb1dcb5cb139e79dd4112798573af22f50602b", + "docs/measurements/h264-rounds/band-lag/profile/diag-main.txt": "b6938a1dd8615fe2dc7a84cdb0b99d197d7bfe9f81f3fcd6470ddea621e55c9a", + "docs/measurements/h264-rounds/band-lag/profile/diag.patch": "0f9b8b17de4342be811d7817d39a9180c1ffb4737a7373542a5732619993add6", + "docs/measurements/h264-rounds/band-slack/README.md": "b9a3f4b3290ace46e30408d49539601af1bb6ab1bd8231af00e7ff855b5455cc", + "docs/measurements/h264-rounds/band-slack/ab1sum.py": "7254eb53992d91e148db99429d31b0a851f8cf711a3c7b2a0e2a486c56120981", + "docs/measurements/h264-rounds/band-slack/ab3.py": "4825e622c660bbb3c3f78ef04cc828935cb816ca973a3e952a26c6aa549ccc60", + "docs/measurements/h264-rounds/band-slack/ab8.py": "1eff58080643ec05d653589aca0de1f9eae252f522d68a4ed2e17176b007d042", + "docs/measurements/h264-rounds/band-slack/conformance.txt": "651265cd01f471bbe269ccdf386a14d998b9cc099b2f4e3330e0213818d913ba", + "docs/measurements/h264-rounds/band-slack/counts-summary.txt": "34a442949d2962f8e43161734c6493c150b7bc3c6f89e9c7fe7e57c9fd045620", + "docs/measurements/h264-rounds/band-slack/counts.py": "db53f889767a546f019c8f002ff2d062648f868a12466e6387a16fd9d0c5a90f", + "docs/measurements/h264-rounds/band-slack/counts.sh": "39b5ea8e4d7d0cd483993d28135fc2d713c0a40a30d52d33a28d6c37f703c8d9", + "docs/measurements/h264-rounds/band-slack/counts.txt": "3d6552a31c3da4d55c1e79ee1a729a3773d36c459869853bfdc83ef344033fcf", + "docs/measurements/h264-rounds/band-slack/fdiff.py": "1d3f595a66cbe69d0e7f4790d4bd8f20e1da4779b015cc14ffd335428d2bcaa5", + "docs/measurements/h264-rounds/band-slack/ident.sh": "7ef44e1a9f089538fa5c33a187e6f0d208a6be4166fd4d29e366808f9160bad0", + "docs/measurements/h264-rounds/band-slack/identity-round.txt": "95b488dd20c8e6b6bbfb49bdb65ffc146a2ffa53511ff7e15ceef907bb35659c", + "docs/measurements/h264-rounds/band-slack/identity.txt": "6cc4d8c694793ac32f6605d76d234c56efee3d3b846162583b241039cbad168e", + "docs/measurements/h264-rounds/band-slack/instructions.txt": "d518148279a97b83894194001e41122e93d84f45f8d9b42812e8ccfe272b3ceb", + "docs/measurements/h264-rounds/band-slack/k-origin-fix.diff": "968b8d67cc2b85db1cdbca5267a435b336b6c9d46e296cc98adadee3f8f83d73", + "docs/measurements/h264-rounds/band-slack/k.diff": "1876a2af5e3ab1bcfff9243a913a6acdd862658f4c8fa56448ecbb7ec3262f20", + "docs/measurements/h264-rounds/band-slack/local-ab/ab1.txt": "e769493a9486e8c2fae9741320f7f92d0e3cbb630a7b77eda01c2ea0dfa814f8", + "docs/measurements/h264-rounds/band-slack/local-ab/ab8.json": "d5e3f473bce8b29ac568498d8b7b04f307550ba314aef4428039d93134bebd1c", + "docs/measurements/h264-rounds/band-slack/local-ab/ab8.txt": "38c05989105eb1f665a351959e9497f48e1a60272e0b086381067ce7419bac36", + "docs/measurements/h264-rounds/band-slack/plan-probe.md": "3a5a424c91f6b921aeb1940b10aaf9bf0a3accade39eeafe752a62be86d35c7a", + "docs/measurements/h264-rounds/band-slack/probe-runs.txt": "0518fa69980c6fe4905cc8408e57b4605a64379e7e2935d6b47130b2ffbd9ad5", + "docs/measurements/h264-rounds/band-slack/ps-void1.json": "82c061cc3d061e6cd8ac5ed28886a7476a6b3ca130c7ecf4d2b268aa43144cc5", + "docs/measurements/h264-rounds/band-slack/ps-void2.json": "392c4a790ceedff98e6989b7aeea4339a51f602093311d6c02066c859d3d9392", + "docs/measurements/h264-rounds/band-view/binaries.sha256": "2c39bed54da4d20e3fd9c4dfc059381c4e178f2d2888b111983050bf9927efd6", + "docs/measurements/h264-rounds/band-view/check/README.md": "a37da2ff845b1faee6e4db9131a43ddd96bd6f56b15a42f37643bba5a99676d5", + "docs/measurements/h264-rounds/band-view/check/build.sh": "455f31a0e2947d63042976ea4d434fb22eb15fb66de174449881fa27f406b329", + "docs/measurements/h264-rounds/band-view/check/job.sh": "c19c41c6563217d612882876d0b85a8cb05e1208d5391a8cf4763af56a354116", + "docs/measurements/h264-rounds/band-view/check/run-gcp.sh": "9d88962aeaf1b56d6e12174b89b9fa1ea2db54538e03bb7b807368a089575663", + "docs/measurements/h264-rounds/band-view/check/run/b4.json": "e37e965c8ba5f68f4ea997692da21cf6c563cdf78c17e1fe3325e3440897a55e", + "docs/measurements/h264-rounds/band-view/check/run/events.json": "e0e492590760dea1b2822ce86557cfee880d33f6802558e9fdc4c71a1048f817", + "docs/measurements/h264-rounds/band-view/check/run/host.txt": "51f99f8f5c5e1dc439c9618e0847f4224280adfe6f1025b4ca5879cc0058cd03", + "docs/measurements/h264-rounds/band-view/check/run/tables.txt": "41e97c20eb80aadeae333356df3c319e05f7123c7586978a2baf7e1c7e0e9323", + "docs/measurements/h264-rounds/band-view/checks.txt": "6ec4ffba4daeab04fa0c3e427fc52d3f239fd61ce010604dc73f414ea8d33a6e", + "docs/measurements/h264-rounds/band-view/gating/README.md": "1dfce7206a5e0bdcee7cd5f9cf7efa74de1cf018e7d8ab285bf63e69fdd87b83", + "docs/measurements/h264-rounds/band-view/gating/analysis/analysis.txt": "a806ad4ced5298349859b36ac4191c88f09bf4acf0cb6d151072a2ee6105c664", + "docs/measurements/h264-rounds/band-view/gating/analysis/analyze.py": "3fffda6126296560306ca8944ffdd9ff2fa958355a0aa88b0ab4d29e27dcb30b", + "docs/measurements/h264-rounds/band-view/gating/analysis/g.1080p.json": "6c89682ef34e3894765e53ff226ad76ee4a16da17c10f542240d6f053f9162d1", + "docs/measurements/h264-rounds/band-view/gating/analysis/g.4k.json": "ff7aa5b6c155a2a1c7356b1b143be56a50f85c1f6c1beea934227ec10a333bde", + "docs/measurements/h264-rounds/band-view/gating/analysis/g.720p.json": "50ef715e2bf43980f0a5d0934a44c35d663bd99ff28166d16dbc41783a163fe0", + "docs/measurements/h264-rounds/band-view/gating/analysis/g.sd.json": "04ef9b30310ebabab1d24d9b81eaaa5caee713b687aa7d89f20024692b141bf6", + "docs/measurements/h264-rounds/band-view/gating/analysis/h8.1080p.json": "e2966dcf4f311bab7997b722490c04db1e65ae844c16fe5ce4df633431d447dc", + "docs/measurements/h264-rounds/band-view/gating/analysis/h8.4k.json": "ee02a0384f2a0082fcfef6e1814783eded66b16209fa39c8893dc5b5a23e8b8e", + "docs/measurements/h264-rounds/band-view/gating/analysis/h8.720p.json": "53747cdb9801a80f8d0eea4a3b3d291ed00b35ffb118a07c2f33d0674338bb17", + "docs/measurements/h264-rounds/band-view/gating/analysis/h8.sd.json": "523ce0e42b215b096d1216324da3913b44ef25b888cc43688bf700c4b01c3e28", + "docs/measurements/h264-rounds/band-view/gating/analysis/summary.json": "b334bfd462b6c1cfc3694e23cb70a86d880c9c3c5ef7f60245dccbe8403bc795", + "docs/measurements/h264-rounds/band-view/gating/analysis/t8.1080p.json": "91559dcd5ee21d9566f9eeb1f6754c85b80433a8af43ec60076bd170aa1dbd23", + "docs/measurements/h264-rounds/band-view/gating/analysis/t8.4k.json": "e692d7760147ff50858996a4542ce611199a74ec5e34b822685d4736f5f86a0d", + "docs/measurements/h264-rounds/band-view/gating/analysis/t8.720p.json": "23cbe8b2212166d953e7da6faf8ad4ec5c24b299695be0c5e9e9b53c95580549", + "docs/measurements/h264-rounds/band-view/gating/analysis/t8.sd.json": "ce9174f2d26ae46a93e20e5354461e03c1fc3f19575abb95bec14d488cf6f594", + "docs/measurements/h264-rounds/band-view/gating/binaries.sha256": "e95148090e3854df0f7fc2fba302c1aaf42fc4e366a2f503393d9e24ff9cc17b", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.1080p.json.void1": "3b9f32518ad49b86ab512e065d5f3fbf0a48e9c8dec3c37927eeb8627a9728df", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.1080p.json.void2": "6c65c0dcd428d49d3000008d956293aeefd4640fde48a9a1176368a13f5eb998", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.1080p.json.void3": "77b1055108524bcfd17a643595796833c0cb2bf22ad55a266455ecac2ecfc6b9", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.1080p.log.void1": "d9e48f0d11d56fbaef9e28361393b2c523011cb28f986865bc11cf82db0c8dea", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.1080p.log.void2": "f6fb1947ef73ab8f98da03c1eae9768492d2f65cfb4fce7c67c185a0ff7a3f2b", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.1080p.log.void3": "181ef81f1e3fb1b3e6b86031f3031155dc1354d5316336523b2087c714b51435", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.4k.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.4k.json": "4121c5f61d35f706503b618326bb707f9eb711f9b7773dccbc8ed309960e3a3b", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.4k.log": "bd63fec52e1e9cc0fe09996d5aa11e2d9aa7e5971f83aa7757fd92fa0dd8beec", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.720p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.720p.json": "d3e0a55626d8f13cee6dbc8e32e65f66ec91b553915079a4da43728b64ca1127", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.720p.log": "09c31a136b1a4c6720a6844d4d25c569acf7578a414c38decb4bc11df6b7fd8d", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.sd.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.sd.json": "5d578ffeb3b6b0288c35fd3e1759d79e2ece8ca582fe0299ae6acdae4c417001", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.sd.json.void1": "7c562e55ff812dcadc96b3ef7e4f0e9218202fab3aeee7dd9fdc8296564b5c1e", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.sd.log": "b0225d79221a5d440abf6c7da5af8f0baa6fd1d9adeae91a5fba7f138a7ec2df", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/g.sd.log.void1": "af1b5390e773f914650647d100e3cf98197c0feaecbe22c9ac1c89799f5e75c5", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/gate-checks.log": "e158af70218bda25e50f8100c9907e1329e0a7095064fc5a862b1faae828fc4a", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/gate-refs.json": "52abbf5f691aad656500faac19db0df937875785b6ee9fba86890f403cde06cc", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/host.txt": "70cf4428e49c4e478ee7bb25c154475fae395445ab0856ebdc54f5b86e16856b", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/job.sh": "a6f27d319f15d9965731948d761cb048412f1f1f2388b99663c1088e4cc4d9de", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/progress.txt": "967c16661c16032242a59656b5d7b158e8984da7493822e3ed5f0bf79d2ef236", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t-void1/verdict.json": "7c5ccafad939a95b5a67e63b0dbe84e19aa5486db301e5287c8aae0e62d648a0", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.1080p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.1080p.json": "6c89682ef34e3894765e53ff226ad76ee4a16da17c10f542240d6f053f9162d1", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.1080p.log": "e2ed15eca477234acd438fa788b133226dfa24d184bef19ef2de63ee51688f13", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.4k.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.4k.json": "ff7aa5b6c155a2a1c7356b1b143be56a50f85c1f6c1beea934227ec10a333bde", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.4k.log": "0f9f139173ce11aa9974b359e55024f002c6ac2f710190440962644f20e7c19f", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.720p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.720p.json": "50ef715e2bf43980f0a5d0934a44c35d663bd99ff28166d16dbc41783a163fe0", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.720p.log": "7bedfe0135397e81e9992710c0eff2f8cd8d9989323705d92c5c411729c2f38f", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.sd.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.sd.json": "04ef9b30310ebabab1d24d9b81eaaa5caee713b687aa7d89f20024692b141bf6", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.sd.json.void1": "7302c8bebd7c861b58a978036e472baebae75571e546517ca8077437572f5a61", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.sd.log": "8284065f879cda4f25eb4541a6a0e7fef9315105b5f67d52ceb2a13b609358d6", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/g.sd.log.void1": "04c1db4cccefdc5b02605301c7ef6017df98777688b7fc26f33ad3f1fc74c0bb", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/gate-checks.log": "bfd344cc8b9cd135e4f0782669d73ccdbd1c9ba7b0524d8670541c1e27b5d5af", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/gate-refs.json": "05c694b5ac3fdf5ca87fd465263edb713dba8241b17389d5acb841612541bf7a", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/host.txt": "7c8757fccdf2ca72788d67004a73ece8c70a3bbcd61f27c9056f1bead3cc59aa", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/job.sh": "a6f27d319f15d9965731948d761cb048412f1f1f2388b99663c1088e4cc4d9de", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/progress.txt": "30cc6778322e8a4de1f98a056c69f2d8d5447dedebd60466d4ee84869da46fd8", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-1t/verdict.json": "a406515971321016b78a24b6127d42acd2a247af92f1db10883b88b0368472df", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/host.txt": "234adcd3abf739eb7af04db93416811f4971b487966bec6a4e630f6db4025c76", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/job.sh": "aed34b4fca58d247dcd2681de53d6b5545ac6653bb4bc9182c664e56420c37d4", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/progress.txt": "55bc04f8e32e4b6ccf71188c6f7251622b76e5bf1a2b1fa5b7ec60653e747078", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/ref.json": "de010262764df945cea46a89c99da7f9e4ed5d0bc181eb1d840dee6e846ed9e9", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/t8.1080p.json": "e2966dcf4f311bab7997b722490c04db1e65ae844c16fe5ce4df633431d447dc", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/t8.1080p.log": "11c4dbc4a662153c73bb75f49cd80a06bdc530fa5979f00785c25f629535b324", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/t8.4k.json": "ee02a0384f2a0082fcfef6e1814783eded66b16209fa39c8893dc5b5a23e8b8e", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/t8.4k.log": "5eb97d10c6a6bc540999c66614c095ccc7a538e5da7b0faf9b29276d0f952f01", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/t8.720p.json": "53747cdb9801a80f8d0eea4a3b3d291ed00b35ffb118a07c2f33d0674338bb17", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/t8.720p.log": "60cc98f425d05567baa8201f038c256fb2ce51e27c0be7bed09efa6882b09960", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/t8.sd.json": "523ce0e42b215b096d1216324da3913b44ef25b888cc43688bf700c4b01c3e28", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/t8.sd.log": "75547b97cb495e6598ccdb41f6bdd5cdf8941a3a5101834aeff9b4bc9424b942", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-heldout/verdict.json": "219f71d228a2ea2679fbe66769d5d8ede043f269c38f28002c61148e0a60e0d2", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/host.txt": "f3f8d547f5b74e2b53ea6862b733f71497b7b14f25a4d8cbac792f6b9982a5c4", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/job.sh": "83edce289d8a12f20c4994403576a58eccede5381bf02515b37174c415d202bc", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/progress.txt": "5879d67320efa480ca65329667077ea4cc5a9f0690e04089f087d1cfe96513b9", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/ref.json": "7425cbbf8ea7d17b70a2f6eb958f0ccb1430b27fefb5b480d41370f28db761be", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/t8.1080p.json": "91559dcd5ee21d9566f9eeb1f6754c85b80433a8af43ec60076bd170aa1dbd23", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/t8.1080p.log": "384bbf838bf12577cdb09ea450100370d57f96d5147e135e28259b46cb203304", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/t8.4k.json": "e692d7760147ff50858996a4542ce611199a74ec5e34b822685d4736f5f86a0d", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/t8.4k.log": "378ed12eafaa8f0ecfb93141785a091767b8bfabda6e35b6ae1a9e89e700a6dd", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/t8.720p.json": "23cbe8b2212166d953e7da6faf8ad4ec5c24b299695be0c5e9e9b53c95580549", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/t8.720p.log": "b31c125b0dddb3f77488108cd57d234b7f707a34d421d561a9b324243a21b523", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/t8.sd.json": "ce9174f2d26ae46a93e20e5354461e03c1fc3f19575abb95bec14d488cf6f594", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/t8.sd.log": "e9c3836656544a11de26401a479ddc5e02dc66ee814128ef1e10bf9ef69cef96", + "docs/measurements/h264-rounds/band-view/gating/gating-gcp-8t-train/verdict.json": "fe0865f512f5e4634c6f68bfa0d9cad647805db09e5fd5c6349fca11c2b3f667", + "docs/measurements/h264-rounds/band-view/gating/identity.txt": "ada9e6e5676237cdf2c10534fabecb7584afcc3564da95ca136d4a80f0a459cd", + "docs/measurements/h264-rounds/band-view/ident.sh": "3df3a215d8b83cbc7b3a6dac8dfe3012ae1fcd6ffacdd3f0b3608f50953dfc50", + "docs/measurements/h264-rounds/band-view/identity.txt": "508940a3a38d15439e8625876d65043ac6434fd3d71b8a4587b288fa0587170c", + "docs/measurements/h264-rounds/band-view/instructions.txt": "8b1cf8bec90ef4633750f25208299fbbdf030973f29056514fe0f2c7369a73a7", + "docs/measurements/h264-rounds/band-view/ir.sh": "b14c931f31c4f4e1e920685a2a9ce75d0994699562c2266929a850966276bcde", + "docs/measurements/h264-rounds/band-view/local/README.md": "22e7befce2c219ffa79e66f946d9a6e2e29e093eea35fafdd9ecd7d2df732a6e", + "docs/measurements/h264-rounds/band-view/local/ab1t.py": "224c29cb7b3e33914feebb3c9d6d54294e048694ec04fab9069f3b6c3fed7c04", + "docs/measurements/h264-rounds/band-view/local/ab8.py": "d70d42b2db77ffd8fd697586fd763211d3c38bdd958aef215ce16cc3ee82aff6", + "docs/measurements/h264-rounds/band-view/local/first-version/local-8t.json": "0c4a1301c8acb67a65c526d408c0f8c2bbe0571f31a70ff6d624d6212c794a8f", + "docs/measurements/h264-rounds/band-view/local/first-version/local-8t.txt": "0637cbc255c6ac8fe3f677686eb48ec9c07ad05157e477e98fc1bd57caca0240", + "docs/measurements/h264-rounds/band-view/local/run.sh": "c3c0ad3aae338887385fdb58933d647b2d0dd1ba364702b6bc4f70968e2da836", + "docs/measurements/h264-rounds/band-view/local/t1.json": "d60cc963e68cb1966e6356c5b811d440332932afce246cc52722d30bd5e175de", + "docs/measurements/h264-rounds/band-view/local/t1.txt": "aa181a3cc60fa568b34a1192c8236fccab901e856216baba7af7bc129a0e9683", + "docs/measurements/h264-rounds/band-view/local/t8.json": "fcf2d96ea7ebb634294e862d9fb5841d07891ffdd35c7bb800d1d83387e27434", + "docs/measurements/h264-rounds/band-view/local/t8.txt": "3d7965642cb7491c21f4532f21aa0ee86000669cef548fd5f86608e8d97b79b9", + "docs/measurements/h264-rounds/band-views/ab8.py": "1eff58080643ec05d653589aca0de1f9eae252f522d68a4ed2e17176b007d042", + "docs/measurements/h264-rounds/band-views/an.py": "a3d89a078e38e251630aa555a4b2831121e4ae48443f458a080fe695fa4676a1", + "docs/measurements/h264-rounds/band-views/analyze.py": "028c785d64603aa567425a510bd2ffd3945aa627fc6bb88e50181afc47aeede5", + "docs/measurements/h264-rounds/band-views/cg.sh": "c7decef4e91f90d5453a448a25141b9bdc5ce232b047e40613ae5cb60cf0c310", + "docs/measurements/h264-rounds/band-views/conformance.txt": "f7d5e6995448b32ea948dcb753440faf76a40f93a6c6f8b50b232cbcef79054f", + "docs/measurements/h264-rounds/band-views/fd.py": "06d2fae39bcdd9ca02c520efe47a096f74b95a67b773739a48598443d784d121", + "docs/measurements/h264-rounds/band-views/gating/README.md": "76c0cb1f2a076ebd6556fad5ba65daae386570ea05bcc343d39b58bd92a52053", + "docs/measurements/h264-rounds/band-views/gating/analysis.txt": "bf8f3b93e7ac99a48db17766deff3d743d668ae722e58f46396ac96b2c33be66", + "docs/measurements/h264-rounds/band-views/gating/analyze.py": "028c785d64603aa567425a510bd2ffd3945aa627fc6bb88e50181afc47aeede5", + "docs/measurements/h264-rounds/band-views/gating/binaries.sha256": "22222323a9c59be3f82250fae87ea567fc72fec1ac5a0f00483fd97cf6900127", + "docs/measurements/h264-rounds/band-views/gating/g.1080p.json": "d0ef34c748d101d420415059684963cd81b5d0236feb98c57bea596107e4f195", + "docs/measurements/h264-rounds/band-views/gating/g.1080p.json.void1": "54c99458ef8c1b0d9a81d10d77d149627e8849e3707cd3b55f75a8b4a33568f4", + "docs/measurements/h264-rounds/band-views/gating/g.1080p.log": "b8f10dc16cc184d761f6b842a08dc89158a853f86af19138ec4202d764b9a708", + "docs/measurements/h264-rounds/band-views/gating/g.1080p.log.void1": "d933c6e87f6a204c55c50808f74f07f397ddb8dfebf4a4bfeb03cdb13743c1e1", + "docs/measurements/h264-rounds/band-views/gating/g.4k.json": "aa349ada7b4b29b01e560047dcd46a97eab23964fac34ad9f2e6aba381cb24dc", + "docs/measurements/h264-rounds/band-views/gating/g.4k.json.void1": "7086658340540f8900359e9e716c0c12bbafa6262011a6c1fa12b6121a92fbe4", + "docs/measurements/h264-rounds/band-views/gating/g.4k.log": "106d32a2d9755e1f429ca25ccd99e204e79285da755d3b0c4efddacc61c04200", + "docs/measurements/h264-rounds/band-views/gating/g.4k.log.void1": "0cd3152b3c3aaa4c21c57acb9018c0c98517b55a437b58790426f80671ceca59", + "docs/measurements/h264-rounds/band-views/gating/g.720p.json": "a028f32202b5ef8d9a0215630e2aa757f8fcf881fea19f7f3f08d38f43e385f8", + "docs/measurements/h264-rounds/band-views/gating/g.720p.log": "c2d0707a36775c24d12af73039066a8907878cacccb05528c58b1354f6e90e2d", + "docs/measurements/h264-rounds/band-views/gating/g.sd.json": "643d1ee1c1218e6221ca4d37a383bce6f9364f986d23763a3073e9bd3e6e710c", + "docs/measurements/h264-rounds/band-views/gating/g.sd.log": "9fb8b22b50309f76058ef18d9a7b4154b23ca4745b9cbd4aff13d7eddd371f57", + "docs/measurements/h264-rounds/band-views/gating/hostgate.log": "a62602b1c9a47900712f94a23ba3a6611af6b7b9b60d33cb922016953650f7b1", + "docs/measurements/h264-rounds/band-views/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/band-views/gating/progress.txt": "b086f70d4f792c4a05e3361e971a4a661aa7b6ff014579d5c767929585cfdba2", + "docs/measurements/h264-rounds/band-views/gating/provenance.txt": "8f18caf68e58631e27e44db38442cb1bdf926d8e8b38035f038eb5adc0bfeead", + "docs/measurements/h264-rounds/band-views/gating/run-ab-helper.sh": "0f12fcea10cc59cf5ba39d583f3e07488207321631ef1f6d68f69a7311b9bc0f", + "docs/measurements/h264-rounds/band-views/gating/summary.json": "2b81bcc31e8d21920decf078e1c3f0b0d5fefc760b4d584cf25b7a8b7cb9c80f", + "docs/measurements/h264-rounds/band-views/gating/t8.1080p.json": "0b9f1020fc8313772441e2cd44c8798f79b7d117f661bffbf9a915ef39c9f536", + "docs/measurements/h264-rounds/band-views/gating/t8.1080p.log": "ecf21c63d288f935ca294b393714150681358223d8a3ea0e91813f4cf41d29f4", + "docs/measurements/h264-rounds/band-views/gating/t8.4k.json": "81916cceb1874e982d4aab8a4587fae734b19f848943da3384048766d44d8ef6", + "docs/measurements/h264-rounds/band-views/gating/t8.4k.log": "6767cdaf9a25d75d36708c149c14b745b12b2d1d240dbfe688a0be27e1e9f564", + "docs/measurements/h264-rounds/band-views/gating/t8.720p.json": "ca9224e0c49ae29ad47e7e024b00b1f1b431a70aa4d4dfc3cf522f2dfc418c50", + "docs/measurements/h264-rounds/band-views/gating/t8.720p.log": "f216e2cd71f95d8cccd2500a56100172c9d49aeac1b317b5b5531d89f5ec0ca1", + "docs/measurements/h264-rounds/band-views/gating/t8.sd.json": "8fd257b5b5eb15a13bdd09ac27f8cc5aa2e688f4cc4a134520868805f3bdf721", + "docs/measurements/h264-rounds/band-views/gating/t8.sd.log": "0eddf9dab56dc84ac09f4ec58d0e673ce78d8e25d6a57182e5dc266699ecad91", + "docs/measurements/h264-rounds/band-views/ident.sh": "3a834c1515a6092c5949f3c102108c9a91eaee08136f6c0ecfc1a8e78beb476f", + "docs/measurements/h264-rounds/band-views/identity.txt": "a6841da4eadf34ee1109f70a1796155bce79635ef456911c01b33be622db7456", + "docs/measurements/h264-rounds/band-views/instructions-k.txt": "fdfd2b8a44e4a73beaee95d04b0bc73cc50196ba63c98f9257124483934d7c51", + "docs/measurements/h264-rounds/band-views/instructions.txt": "77f1c7cc3f1b89269e0a76b12ef1f26b779c530653624ea37caca003c58a8cd7", + "docs/measurements/h264-rounds/band-views/kcg.py": "800bf0ef6afc831cd43314a8482f369c179fa3854dc048ac608ec9775362168f", + "docs/measurements/h264-rounds/band-views/local-ab/bv1.log": "11e3542b54442fa7e01f8da10795ee1bacb679856f134a51230a6c91a14347fe", + "docs/measurements/h264-rounds/band-views/local-ab/bv8.json": "df08280c8e9c060bc3a889220409684b4f5956c8a3b748d32e6299bc4ce1e2d7", + "docs/measurements/h264-rounds/band-views/local-ab/bv8.log": "b758e982254ce4fc7c3943c13641e38d20c389162b0eb8cc075802f50447b3c8", + "docs/measurements/h264-rounds/band-views/plan-ir.md": "e6b4043213e89b9e116bed7dbe7072da98f1a04ba48ae78011e4c0999437fe58", + "docs/measurements/h264-rounds/band-views/plan-probe.md": "fcebe842326aac8f5cef7c7adeb64eac5149ac1fd98490b764c29ff0a8eb7aae", + "docs/measurements/h264-rounds/band-views/plan-scaling.md": "e92976352372265b6c3c8f4a0e3e7d9b4f73d3f7b206a361175cefaa34dacd79", + "docs/measurements/h264-rounds/band-views/probe.json": "3a95a2213869fb725f952af88a1a38cc01008cbb9852fc27d19b0b02aadc593f", + "docs/measurements/h264-rounds/band-views/probe.txt": "5558d1b611b5c10962b49c44e0e1410b86b8d4c42f3c99ad6e5be3dc497d968f", + "docs/measurements/h264-rounds/band-views/run-ab-helper.sh": "3e8bb6181610db978b3da592be29f463b2fd84fd95f12be23c750cc246d09f1e", + "docs/measurements/h264-rounds/band-views/scale.py": "2fae88e32c6350d85923f521608bd6c2c243ed55591634e9ce8a7daecce7932a", + "docs/measurements/h264-rounds/band-views/scaling.json": "a2a8f992229f504ce0bc436dfbc7fcef9d27f97efee0bae92b31e7ae360f7c5f", + "docs/measurements/h264-rounds/band-views/scaling.txt": "4f7667da19b0194c544b4e6cd348fdbb090fb349485f84b96457c86da256ac4d", + "docs/measurements/h264-rounds/bs-kernel/README.md": "e27a635db565e344ea22950433346360ace3c0c18a95a2245d5f0c779de81b76", + "docs/measurements/h264-rounds/bs-kernel/analyze.py": "f4238598947679abd6a8289399908fc066d088d2551fec35d95418c1dacb3336", + "docs/measurements/h264-rounds/bs-kernel/conformance.txt": "e16ada7110daa43707114a798588f019ab79995f95674ec83aef061cb94c0a8e", + "docs/measurements/h264-rounds/bs-kernel/fuzz.txt": "302b48d21d9cab507a8d472d06d525a7d78e0ed994f1bfd20cdc400a35ebcf04", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/README.md": "ba41bb8d416a8451d286941cd6f9a46c00ec3577894e759875de570c7f4f9dc4", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/host.txt": "6d9b7a79ae5c691484aca4e8abcfdd469c6e7d1bc24795ee03d9c24003e6f37a", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/job.sh": "07a72ee7f57f09763da2607ff95e0560c5ba56820c92289805206e471522a879", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/progress.txt": "3bb762be29cf14dfb66ca6a2f597e2189ab66f18447094db2fc2adfc678fa662", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/provenance.txt": "6ab3afdf079a24477edad2b32b1a9bdc333ee484c0ca5a1f2192511290c55cb4", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/ref.json": "d95b051dce6d02a99f98fe8359ed0303ee7f7d843bbca7909e61466c305eea14", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/run-gcp.helper3.sh": "733301c462ae52eca86d76bf448fe9fa2807f6e53fae8a9be4456983c39daeae", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/run.log": "4473d387ea1660ed4b8b65cb2404c57bf41d4603c761ce326129e7f74a295218", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/t8.1080p.json": "146aba8e708ec7b8349b6ed66f49d1c55eae634c94da0d37913fc8eba34cc575", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/t8.1080p.log": "b794e47024ea2d2d9cffe61fcf21659956487a308d7ad4b543fc43f5743b2b47", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/t8.4k.json": "da77f00cb814098ca41c4f5e18295588152b459e888975a7537eec1cf22ffd2a", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/t8.4k.log": "e3858feac2bcbe7cd147ae599c2ba63404759454596965d42377deb354343d90", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/t8.720p.json": "ddcf31ac6c25c917b6bd2f77391c871c5f33f8096a686aef89993bcc44ae1f50", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/t8.720p.log": "ee6caba54e665aa21eff02e3363b780fa40ba9e0c1bca353f3109384e20ea92b", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/t8.sd.json": "d4f52a2633b5f27243d9ee653f83ad0c94412529522d564aafdb1aa7f7cb7580", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/t8.sd.log": "ed7aad57cdcf85668e8ca6dd768cf9aac599a640553e5532e1820425a5fb43b0", + "docs/measurements/h264-rounds/bs-kernel/gating-gcp/verdict.json": "4ed4b3ea8060df1554d1923d2cdfa2f3acf19e1637337b71b303679dab6f6631", + "docs/measurements/h264-rounds/bs-kernel/gating/README.md": "ccd864ea768a04770b13f383be1b1f5674d20b1e409c482e8fce743cd16a67a0", + "docs/measurements/h264-rounds/bs-kernel/gating/analysis.txt": "5d20d3dbc1e8140589dff10327cc60acc328b103dc33f535a8266c0e93ecfab7", + "docs/measurements/h264-rounds/bs-kernel/gating/analyze.py": "f4238598947679abd6a8289399908fc066d088d2551fec35d95418c1dacb3336", + "docs/measurements/h264-rounds/bs-kernel/gating/g.1080p.json": "e591d5c546980e1b4cc03f956a39660df02cc37cc511d912a5dfe0e848f92bf5", + "docs/measurements/h264-rounds/bs-kernel/gating/g.1080p.log": "4294037299657d61a22f84eb8950b8a8237e0d35a46dbeaac04fbea59e9f2ff4", + "docs/measurements/h264-rounds/bs-kernel/gating/g.4k.json": "423a4d51b6803d548e47320409d47c2d905a03731c2347e360d13293abdb7e9e", + "docs/measurements/h264-rounds/bs-kernel/gating/g.4k.json.void1": "ab91d57731e96ee7c589f5932b69dccd751c050556b4a56bcfaee167b60978cc", + "docs/measurements/h264-rounds/bs-kernel/gating/g.4k.log": "759f10e2c028cb60ecb056daa5d063413bd22b110844f0d9387df45a02561326", + "docs/measurements/h264-rounds/bs-kernel/gating/g.4k.log.void1": "7d9a5bb147e4ad1261fe1be9195c695462e2b60843e980c412e0cfe1b9051d4a", + "docs/measurements/h264-rounds/bs-kernel/gating/g.720p.json": "76243dc3bb9a767bf1c0a0a1555c9375db06897956de25f590ad85d6fc069561", + "docs/measurements/h264-rounds/bs-kernel/gating/g.720p.log": "53a7278f9ecf71e6533daf3a212ff7b213b84b3bf245db2f9c1ad54a6eb6baef", + "docs/measurements/h264-rounds/bs-kernel/gating/g.sd.json": "da894015f52c2200c00c563d19ac258c2aca159b6c0e278adedcb21d5038762f", + "docs/measurements/h264-rounds/bs-kernel/gating/g.sd.log": "bed47df6ba1ca8e89587dcf05c3a6191f3e49c994d6e6ae6e03a285dd2aed39e", + "docs/measurements/h264-rounds/bs-kernel/gating/hostgate.log": "1cdb495f9e765e88d5fae6958afa9d3736ee3a18290446492adeeefbea889423", + "docs/measurements/h264-rounds/bs-kernel/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/bs-kernel/gating/progress.txt": "bf8a6b670b84531de8a071558226a445423b7e13b52fc0c3127c9139401e73ff", + "docs/measurements/h264-rounds/bs-kernel/gating/provenance.txt": "b22ac4f1b17833af44b35a930cebbd805a72ab3b880c3611d806c14281c28a5b", + "docs/measurements/h264-rounds/bs-kernel/gating/rerun-4k.sh": "b1c94db601e2a843cec52e1425418eb160dfe324bda5790518c9610a64ef5c72", + "docs/measurements/h264-rounds/bs-kernel/gating/summary.json": "8cc49dfa15fc2b0d9278d5a787ba02b4aa87153918019516d7063dfe1f353331", + "docs/measurements/h264-rounds/bs-kernel/rebase/conformance.detect.json": "37fc7babd2f6793a3cc6b64d9b3ae58e4a16b07049366b427161e72f3544081c", + "docs/measurements/h264-rounds/bs-kernel/rebase/conformance.scalar.json": "529415c0aaff2797bf88dd37794e146fc8e773107a39bc8a25d51911ce816d0e", + "docs/measurements/h264-rounds/bs-kernel/rebase/id.1.avx2.txt": "1e01cbfc7c3bad0b701e9bff4d8337a59604b007f1e6d82c115831339be2ea86", + "docs/measurements/h264-rounds/bs-kernel/rebase/id.1.detect.txt": "1e01cbfc7c3bad0b701e9bff4d8337a59604b007f1e6d82c115831339be2ea86", + "docs/measurements/h264-rounds/bs-kernel/rebase/id.8.detect.txt": "1e01cbfc7c3bad0b701e9bff4d8337a59604b007f1e6d82c115831339be2ea86", + "docs/measurements/h264-rounds/bs-kernel/run-ab-helper.sh": "f903f380d97894317f2ef17558e76f671f317ef8e6b16cbad58357fad76b3a6b", + "docs/measurements/h264-rounds/bs-kernel/run-gcp.sh": "9908ff1d4163169a70b84f27958bf08be42ca8ab40cdafc030c4caa6ccac9602", + "docs/measurements/h264-rounds/bs-probe/README.md": "315d8d52b188bb36ba259ad6aa44a14bd6e0440a37d83ba37fa40ceea7999591", + "docs/measurements/h264-rounds/bs-probe/bound.jsonl": "43a649ddc4e9a2641d1b39b52e2a1b39b71e1c68e5c948aa6cd90bf8e626574e", + "docs/measurements/h264-rounds/bs-probe/bound.py": "5eb4a5119448f61e5fe374d7a1c4025d3f49a5522f0a8cd588fb354f48c6b008", + "docs/measurements/h264-rounds/bs-probe/bound.txt": "51e83499620da34c2398b0a474d09e69ce2bd586712af688d99c1046025d217c", + "docs/measurements/h264-rounds/bs-probe/cg.sh": "68ba8684e1c61fdbd56006a4eec4bab8f045ad7b3bf1e8628111e294d5d3df7d", + "docs/measurements/h264-rounds/bs-probe/nmb.sh": "d1da582153b46a91aec051af0938b260f67b18c7010b60a8b484669d7c51fb4d", + "docs/measurements/h264-rounds/bs-probe/nmb.txt": "c667c9d1a2f5a984017c86c1dc05a2e694bc8e2e7ad587c4b33b3cbfc6ec6a56", + "docs/measurements/h264-rounds/bs-probe/perf.sh": "b3c77dca5512fec0a81e4801624460fb9ab9526fc6158a0aa95245d545333159", + "docs/measurements/h264-rounds/bs-probe/plan.txt": "58ebff93f66f15144c2656cb4ec0be2fe2deb6894db56c77d148d5d4701dcfce", + "docs/measurements/h264-rounds/bs-probe/table.py": "9a0b1e0418680e0542f88dad6617f5346963b256344937f03700ec9b3f7cb48a", + "docs/measurements/h264-rounds/build-alignment/analyze.py": "5babcd45a12fe5f6b8361f96adfcc26fb4502d5a500aeb2f41bf41e2164a2f6d", + "docs/measurements/h264-rounds/build-alignment/gating/README.md": "413a5d21f66a02917e36772efa21c4f438d5f0c3faebd8cdd89a07fd52c68954", + "docs/measurements/h264-rounds/build-alignment/gating/analysis.txt": "bfe716b5f6872d64d2317e8eb021c58214a85f969bb1a4e973b49ff45fbcdab9", + "docs/measurements/h264-rounds/build-alignment/gating/g.1080p.json": "165d649a5c1ba309a16883bbc2db1f574a8351da61a3cfeeefc10252c4ea4a8c", + "docs/measurements/h264-rounds/build-alignment/gating/g.1080p.log": "585eea7192c30e6fffad480c93f0f307db41d608c95c055a3a473296e899fcd0", + "docs/measurements/h264-rounds/build-alignment/gating/g.4k.json": "899d060bccc5abc17a19af0f0b8eef4000a32241e3e39ba8812dd6ac41f5ec92", + "docs/measurements/h264-rounds/build-alignment/gating/g.4k.log": "62f095f2b40726022435eefb9d9b6e29f0371c5d187dd2943cc190dfd1a909e5", + "docs/measurements/h264-rounds/build-alignment/gating/g.720p.json": "112700f2b93c4d6f0cfb0c4a0aba358d1ba0aafbee14aede7f76799f05b17126", + "docs/measurements/h264-rounds/build-alignment/gating/g.720p.log": "00f63bdf14c73a41ac5b39e949c48d4ac5f680bcaff00148920662693a1acba5", + "docs/measurements/h264-rounds/build-alignment/gating/g.sd.json": "c2fe54a616da4e352171d91a4cf07388fe476d35fcd0fc259ec962a6208745eb", + "docs/measurements/h264-rounds/build-alignment/gating/g.sd.log": "f84b7d7be8e656693f938a1da8285cd73112536aeea83bf0ed59b3bb8608e53f", + "docs/measurements/h264-rounds/build-alignment/gating/hostgate.log": "60bfd193662890d20b25ed91e6d9da86ae6688acf3eaf36750b827e9eb242300", + "docs/measurements/h264-rounds/build-alignment/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/build-alignment/gating/provenance.txt": "46b535f971a367fa3e74e62fdcbd165e3ba7e4ad51cc27208fcbc4e364a7d989", + "docs/measurements/h264-rounds/build-alignment/gating/sizes.txt": "564349397ed522eb8127f399fbfad1060228c09f1e3963342ef4e230d767f060", + "docs/measurements/h264-rounds/build-alignment/gating/summary.json": "3baaee8602d4f24cd280eefe1695d0b5528ce4712950a1eb7aac468e3caf13fc", + "docs/measurements/h264-rounds/build-alignment/gating/t8.1080p.json": "071ab9fb2bcd24576d0bc0ce36b5aec2fb25f07f8e6c8dd087a0e0adec761ed2", + "docs/measurements/h264-rounds/build-alignment/gating/t8.1080p.log": "6c54aec6063c629720d14cc47f2551a6c2a315f40a675811e838903616e83ca5", + "docs/measurements/h264-rounds/build-alignment/gating/t8.4k.json": "97d540557a1ff50a2dfcedd2f7ff7421d69c6d7fb183bec9e8fb6389951f6f16", + "docs/measurements/h264-rounds/build-alignment/gating/t8.4k.log": "31d89bcaf0415334e2d9c5a4c45a05221be857a3e8e93d28870d88e744f58c2b", + "docs/measurements/h264-rounds/build-alignment/gating/t8.720p.json": "cb065c95a63eca3540213b248854713819e84d705a64f25fbf529fccb4dba7d5", + "docs/measurements/h264-rounds/build-alignment/gating/t8.720p.log": "d84dac3779626d90b8e309a47ab1a1950b8e590527a4f3fec8a33893dabfe1d9", + "docs/measurements/h264-rounds/build-alignment/gating/t8.sd.json": "f2597f64c3e40157408a1ed464629d918bb59d29b5117275d0d49338db9ed8a8", + "docs/measurements/h264-rounds/build-alignment/gating/t8.sd.log": "202ff79956f22ae2e901c1b0eeeec45e41f43ca9134fc78daaa54628bd3e8c33", + "docs/measurements/h264-rounds/build-alignment/k.patch": "2347eb007e3533bd00b3ced1d6418e3bfb90d14f4d0af8a34ec2d3a612c11a3c", + "docs/measurements/h264-rounds/build-alignment/run-ab-helper.sh": "f05d256588c3027ea0ec60a2208edfb73e6d675a32a01ac822f0c6ac7b0c641a", + "docs/measurements/h264-rounds/build-alignment/run2/run-ab-helper.sh": "942c75b5b2756b7ba06710840f8a9cd93f443a14e14a856ab6c75680c6c01335", + "docs/measurements/h264-rounds/build-alignment/second-run/README.md": "6ac6d8047c8d1423605f2ed59c7e36864cb599b087764b2f84682a4f09fc4f74", + "docs/measurements/h264-rounds/build-alignment/second-run/analysis.txt": "5731ccc7858b288aa54b3097cd4e3f1cb92fdd742a0adf0c11a5193be29e17c4", + "docs/measurements/h264-rounds/build-alignment/second-run/g.1080p.json": "1b9eff832d73db904e82d0283e1f943c51ac0da20a3188dc08510dbfd6269594", + "docs/measurements/h264-rounds/build-alignment/second-run/g.1080p.log": "cf6253391193ab34066a16184145fb681cff28977318410b8719f689a415b909", + "docs/measurements/h264-rounds/build-alignment/second-run/g.4k.json": "892087ed97822674ad89071ba988843a9217d99e89c65b2498b1fe157b822cac", + "docs/measurements/h264-rounds/build-alignment/second-run/g.4k.log": "afecbb601b37ca31a1371174dca35fb13e6fdd1ec04b1e268561a105dca52306", + "docs/measurements/h264-rounds/build-alignment/second-run/g.720p.json": "7526211166a5f317b3970044388781e2ff1d3ade4ebc92e4298e5bcc40115ae6", + "docs/measurements/h264-rounds/build-alignment/second-run/g.720p.log": "e1b097c58a728218a412e8062db1c5318e4171879bd73cec14208b17a0167903", + "docs/measurements/h264-rounds/build-alignment/second-run/g.sd.json": "8a21073ae5284dbfade2babb7df5045b3db4049a5fb8e1b85eb7728d03c3dd43", + "docs/measurements/h264-rounds/build-alignment/second-run/g.sd.log": "cb0177b51e2df43442b0fa6e290e90b5f7c294a6857e01794be90d78dc20dfdd", + "docs/measurements/h264-rounds/build-alignment/second-run/hostgate.log": "f5331cad0b039f6ed8a810ca8dc6b446591cf51963b7b7a935006fe3f3394383", + "docs/measurements/h264-rounds/build-alignment/second-run/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/build-alignment/second-run/provenance.txt": "f57498da6ebc8840a4081bc1ed5247d8d919e2ac88ac2e91d06e01edf93a3f7f", + "docs/measurements/h264-rounds/build-alignment/second-run/summary.json": "82e2d2b015e4480687f44bb557d093c8e7c399c11df02e2abc9041fe4b416489", + "docs/measurements/h264-rounds/build-alignment/second-run/t8.1080p.json": "ecc20c476b0a9f70a0cd262149a1b510d25567e5272e9a11c35d302066e429c8", + "docs/measurements/h264-rounds/build-alignment/second-run/t8.1080p.log": "96644e76f9f0aec810bd44eea22e52055b999d9b1a5d95c4cbf1cdd419c0af5a", + "docs/measurements/h264-rounds/build-alignment/second-run/t8.4k.json": "91c80c9a9fbf9153c9ff7b3802e5e7abaa1e139ea9699c2018b702542585df8f", + "docs/measurements/h264-rounds/build-alignment/second-run/t8.4k.log": "012ec4a973b00854e44de6e598e077cd2119115538025d74d9d161ce416f6290", + "docs/measurements/h264-rounds/build-alignment/second-run/t8.720p.json": "6f040953cd396ef318080fe42c14e97686d99c59ad01cfdf01fc9a931abe33ed", + "docs/measurements/h264-rounds/build-alignment/second-run/t8.720p.log": "9def6c5ead73e8ed8fff1e7f3353754da389ff3464855a2a356164b1ca9c3434", + "docs/measurements/h264-rounds/build-alignment/second-run/t8.sd.json": "2da7dc4970e762e684bcf3e69c615be41218ba2a1b5bc96399ada7ba6fe9801f", + "docs/measurements/h264-rounds/build-alignment/second-run/t8.sd.log": "177554cfc65172cf9d27b6f63688614bbad6105f1c8a8874422af40088724e3d", + "docs/measurements/h264-rounds/bundle/README.md": "f2f470d6f4d08a51ebd8d1eb2ec5e66823981148f6227d2d6904a57491049d44", + "docs/measurements/h264-rounds/bundle/analyze.py": "4437be4e9e2ea672ecf6e80c58e200edb4f44ea10c6d9bb72bb299cd022309cf", + "docs/measurements/h264-rounds/bundle/conformance.txt": "11242e5163556a3e4ab5253325b366d08c17b03078e5520111330a9ae65d682f", + "docs/measurements/h264-rounds/bundle/gating/README.md": "5f122b00275ee21c78fe0f33d3c735871b91c2fc2130f0c1ea68625046542f9a", + "docs/measurements/h264-rounds/bundle/gating/analysis.txt": "2b46cc3053dfcdd3a50582cc4801f0a5a3fb15966c820dee6990939e7c0512c8", + "docs/measurements/h264-rounds/bundle/gating/analyze.py": "4437be4e9e2ea672ecf6e80c58e200edb4f44ea10c6d9bb72bb299cd022309cf", + "docs/measurements/h264-rounds/bundle/gating/binaries.sha256": "3ba3d7d76032e1a28379ce9b2808786ded0ff22348ed67462592ee91a508145e", + "docs/measurements/h264-rounds/bundle/gating/g.1080p.json": "c27ed08168138296a0546fb6ab9216efe84bdfdab15f40f458fa1fa821a20c83", + "docs/measurements/h264-rounds/bundle/gating/g.1080p.log": "2133262396f6482e18f2e576e911d6fd47350edfc63d82e977027ec8a5d68373", + "docs/measurements/h264-rounds/bundle/gating/g.4k.json": "3b3a8e15f97b128446b171ba24eb5d58d1c3f21c269bb992193dff0919164772", + "docs/measurements/h264-rounds/bundle/gating/g.4k.json.void1": "d53f38cd3844d783b1599ac595eebab77b12dab0301397aaea74f481c7c373fa", + "docs/measurements/h264-rounds/bundle/gating/g.4k.log": "a6748bd369ac5adf8bc517a150b4547ba74e4619e38e3c815d32891c930d69f2", + "docs/measurements/h264-rounds/bundle/gating/g.4k.log.void1": "96adeb43a8f2cc39a9423fad10364d98f982b0e1c441aa3461fae092bd4222a3", + "docs/measurements/h264-rounds/bundle/gating/g.720p.json": "87c1ce13623b72bb5ffe7cf1e585261372659a69b50a0d0912a73a48ab1e2e74", + "docs/measurements/h264-rounds/bundle/gating/g.720p.json.void1": "225da2d4affeab833aa2d5fb5fb53d935efb52e541ae3a7418fba0571011cf05", + "docs/measurements/h264-rounds/bundle/gating/g.720p.log": "3200546d14f0ff41cc3b9d6f9549dfb0a3ee526ba7b434fbc51802adc7871f4f", + "docs/measurements/h264-rounds/bundle/gating/g.720p.log.void1": "d6a09226efd87287957fbd43c82ff0fe9652347cbbf7e465f382d0e2898df3f1", + "docs/measurements/h264-rounds/bundle/gating/g.sd.json": "ba870b2f1209c290e82ecfefbbfdfe202e4db9f049ecee8042bb9049fa3efa99", + "docs/measurements/h264-rounds/bundle/gating/g.sd.log": "49fbaf4f8eac4b462a6917924c31f7627f2846bd2c60197649cbfafc242227f0", + "docs/measurements/h264-rounds/bundle/gating/g.summary.json": "c3b6d2de476232946e774d36eb4848eb2a4314b11b25805d8bf641f32c396171", + "docs/measurements/h264-rounds/bundle/gating/hostgate.log": "f3277f3e1285726f637939d677bcf43064b93f3d13ec48bf40fd7f7421d1166f", + "docs/measurements/h264-rounds/bundle/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/bundle/gating/progress.txt": "4dd15e8fbe9ece504c1516921bd20d02be34f1b7bdd263d68ed6cf093ca60ca1", + "docs/measurements/h264-rounds/bundle/gating/provenance.txt": "e14c261b8135320c1ff0e72f5106c9507797f7323f2cff744fcfeb96e55fc19f", + "docs/measurements/h264-rounds/bundle/gating/run-ab-helper.sh": "0f5b701ba1e96e553742df22bccdaafa57db6a46d2ad1a1dab116a34e00c8319", + "docs/measurements/h264-rounds/bundle/gating/t8.1080p.json": "fe76afd8a37425b38961270dcb5111431665d6b9fb39cf0a877865875be9b0c4", + "docs/measurements/h264-rounds/bundle/gating/t8.1080p.log": "ae1b266d5b4883325bfa64085b86a623fcb9ed1423ed767b174ac2f2e19661da", + "docs/measurements/h264-rounds/bundle/gating/t8.4k.json": "2ff5ea2db017607202af6398efe6c0756eb6cdf4c6e95f8669b3caaeb39cc782", + "docs/measurements/h264-rounds/bundle/gating/t8.4k.log": "d88214e3aad855fa32e74b48c079c6e16584c60c7ff36419796fc8d298e7f7df", + "docs/measurements/h264-rounds/bundle/gating/t8.720p.json": "32ec521d64911be7b9309062ae9c3b0b53224c2d2792b927c83a965a6f6ff02d", + "docs/measurements/h264-rounds/bundle/gating/t8.720p.log": "a2da6d8c867a6eb868b5e89096ab6a7439b7b16cf8fea29e6b117cb648090412", + "docs/measurements/h264-rounds/bundle/gating/t8.sd.json": "4c63e1d02b8330afef5c13a3d56e96638e676f1ff78ac5d374cadd55de3eae31", + "docs/measurements/h264-rounds/bundle/gating/t8.sd.log": "96155197b5430dce1150ad327bf7be64236fe0bf32f5a8e536d8c2c8f443bc7b", + "docs/measurements/h264-rounds/bundle/local/identity.txt": "7e84ee4dca0812e64c7043015741d968f4716bd16ebf9073f34e5a3c4059b6d8", + "docs/measurements/h264-rounds/bundle/local/local-ab.jsonl": "72d977b3eb9317fcf3c31280faee9daf8f74742f2cfc0ab77afb9b9bc184e740", + "docs/measurements/h264-rounds/bundle/local/local-ab.txt": "e76c7a651d4bceca8cfbfe0603375c433bbde0abe975db72a5cc1639776a2fd1", + "docs/measurements/h264-rounds/bundle2/ab1t.py": "22049f3b0c9acb3cfabdd8871b51d278a8999334c875ce06c24a18e27f2aa176", + "docs/measurements/h264-rounds/bundle2/ab8.py": "1eff58080643ec05d653589aca0de1f9eae252f522d68a4ed2e17176b007d042", + "docs/measurements/h264-rounds/bundle2/after-main/README.md": "50897ddf63f91c98f77b1bcd08cd24a73ad34c1887472c0f9a7bd02e3de8cc41", + "docs/measurements/h264-rounds/bundle2/after-main/binaries.sha256": "5194dee084f200a5fa1583df4f906f5cb14c755e940d9edd8892a3acbb5c8f1b", + "docs/measurements/h264-rounds/bundle2/after-main/conformance.txt": "f8b29bd19208e9cd655f577e80c58e4e869fc66a279dd46824f232c312148d49", + "docs/measurements/h264-rounds/bundle2/after-main/ident.sh": "6887e96e1f93cbef1a2706440cb95ca5e1622b0999bfe42acb700db0c5b94a9f", + "docs/measurements/h264-rounds/bundle2/after-main/identity-fast.txt": "c21d94621c22adfd06eba945049de9f00e8a267d0f9f3a75ae7678d0f37cfbf4", + "docs/measurements/h264-rounds/bundle2/after-main/identity-safe.txt": "c21d94621c22adfd06eba945049de9f00e8a267d0f9f3a75ae7678d0f37cfbf4", + "docs/measurements/h264-rounds/bundle2/binaries.sha256": "25da535145af4014c10e08919288b64301d5f915f9f260424380cd1c96e1bbae", + "docs/measurements/h264-rounds/bundle2/checks.md": "27afd984573d834fe3d77942505edf239890e5ce9e88d6a50db73a82b0cb5746", + "docs/measurements/h264-rounds/bundle2/conformance.txt": "a55e835739b035b35bdbbfd9882bc7d209ade00096e1872538cdff7f744bb256", + "docs/measurements/h264-rounds/bundle2/gating/README.md": "2ee76f7bae5f0ba99487df52229f09a2a62f39a5b40f6e43323dca2da36fb85b", + "docs/measurements/h264-rounds/bundle2/gating/analysis-final.txt": "e145c539b230b03176650613697656674422e72c0a84c2b15dac00d530c8ce7e", + "docs/measurements/h264-rounds/bundle2/gating/analysis.txt": "884947a3145cd6d57f28b529bd4bc1033cff23c031a6627e13ed0210cdf9ba13", + "docs/measurements/h264-rounds/bundle2/gating/analyze-b2.py": "06c24244dc4cb351e39a6193d20f5a1af6c468f1bf430c40a34e067929f149de", + "docs/measurements/h264-rounds/bundle2/gating/analyze.py": "06c24244dc4cb351e39a6193d20f5a1af6c468f1bf430c40a34e067929f149de", + "docs/measurements/h264-rounds/bundle2/gating/g.1080p.json": "9aa48b3600de7dccc0d9e447ea41d5a554a62647b966ebae8519e35ad324215b", + "docs/measurements/h264-rounds/bundle2/gating/g.1080p.log": "29dbe3806862b1639463870e9224b35822a5cbca730bd251e58f79f8f5733e23", + "docs/measurements/h264-rounds/bundle2/gating/g.4k.json": "ab15ea4b86bc75408d59e0460ffed714d1915665524e73ef44959a710148e1be", + "docs/measurements/h264-rounds/bundle2/gating/g.4k.log": "defcd2979a11184823e7cba5baa575b764251349b0585f94b16908c3ca7f4976", + "docs/measurements/h264-rounds/bundle2/gating/g.720p.json": "cf57bdbe8a8923b1c803c606ee2b6a0b11b6b19c1322150ab940882be7bcde9c", + "docs/measurements/h264-rounds/bundle2/gating/g.720p.log": "48f30be23f092972c1a97738218d6a56c48f7ee2f1fc735c7907c4faabc1991c", + "docs/measurements/h264-rounds/bundle2/gating/g.sd.json": "0ca20d12301f0f2d3c4ee5830dd5cbaf8e5c6f9ef594ded3a2c7f14d01141d58", + "docs/measurements/h264-rounds/bundle2/gating/g.sd.log": "2d418613723b88ac8ac0a49bad78047b4a7c93a038a53a101e31bae006678aeb", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/create-attempts.txt": "d12b1bd12f49580c138e674613063ec0b0850ee79e0cdb1ea0c8e8a9328f77ba", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/host.txt": "dae57835277c087b936638bbd8d50500013289e6d1214508f7316432d2e4f3c6", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/job.sh": "dd1d24ed811107d10d2cdb2ccd85fedc03672850f8243fc8e724493c1caa7fb3", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/progress.txt": "90a98b5fdc07c2e828b515fee1a216c36ca4f81b967edc58c54d48b8758184fd", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/ref.json": "9a889386eec46b1ef35c4bca6af81dddf815819f284ebffaf00eaf226be70ede", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/t8.1080p.json": "ce70fe1fcb73f9c85e8f52a584d0ed2a04b0945842b1154b6cbdc3b75a25f43e", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/t8.1080p.log": "76f4f215784d6bd1f6f08732774ea5961b2264022078b4242b54658e548579c5", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/t8.4k.json": "e5d3539b2d622fa1d2d2f1897bdd1b0444eac788ae6f12d472b4f0b0563fbe19", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/t8.4k.log": "d62faec07ac827e3ea6abb3dbb145b161a828fcfc847102274a9bfa496470333", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/t8.720p.json": "0b4c7986151b9d7f1b1aeca927987d42c7f29c07f2b65f98d656c8a2628617f7", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/t8.720p.log": "203645a74785e4f18ee4935d5bb0d2b0e3e70ea53a5760002738a8f9b12fb176", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/t8.sd.json": "58cc2079804bbd94bd46ca6875d6bc52f3638b4de6b83ee83a4045f298b400d5", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/t8.sd.log": "9dc3c244504becbd6e6166718dc9dd90a6c905cb0d6a8f4d6c207072b3fb36cb", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/tools.txt": "b9cf171e7aee5bdde20f4bbdfa653ddc23f1cd39ad625fa7ba80d0d2862fc100", + "docs/measurements/h264-rounds/bundle2/gating/gcp-heldout/verdict.json": "20b7b79827b7a581b088dc5e43d01fb9f2e4e9b701596b8a143d869c2b73d8d7", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/create-attempts.txt": "a629d8043a34894a2491c8cf2d2ff9966d9206e738736e9531b4a6b55ad165af", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/host.txt": "9807a3f3d37156c555dc9ef2d5877c3d7b39f13fd140d7ef3c7be7e2d540fa96", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/job.sh": "06ad38fac2cdcb7c99e734a6403d7603d13fc8621da14db2157cfd318ed21b3e", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/progress.txt": "11b25b76cd11b688d737146f785642ad28c80df91bea6c7d0184a2f5f0972e9b", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/ref.json": "9417469a4f8f93f391e544304b3ce6ca3ab0b08c8448bdff477803ded167bf1d", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/t8.1080p.json": "89b772dc3d64464b0ccda8034d9dc6d84453aeb83b2976933d789d409fcdf40d", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/t8.1080p.log": "e6dbfe2baa38b4034294a7cd21eae4853b2b636222022f5ab15f89b86efc9694", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/t8.4k.json": "9d580e4880b61378d80dde697ffa83edfbe3c060ea004cf721ec7b8deb762ee9", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/t8.4k.log": "07acd1f2bbe3a232da839318c857b678a57712f0881a0ae47a8a70ad59400c89", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/t8.720p.json": "dfceb0f40221cfccb06129617fd24b237ae184198c7d8a425f0a07295b9b9d2a", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/t8.720p.log": "d8b55a80fd7e4a38bc7faf44f16a9dee7cafed1e05f00b42ae7bc42f6dfd323f", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/t8.sd.json": "0f8913efa82ec974cf0862673eb7cec4cba0f7ab25de147035b57991e29372c7", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/t8.sd.log": "5e1dea709bfee72aa62f78582fd32bf092f6dc38ca579b1c0ee9a3a1c23342ce", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/tools.txt": "ddfb825dd6e9209bba4551b4c674eade943fd06258481464edf3eddf5fdc7da5", + "docs/measurements/h264-rounds/bundle2/gating/gcp-train/verdict.json": "a3042e2f0bb21ccea1306208cec3405c64d1aacbb93f7a4bbd4ccf3c54c0b0ed", + "docs/measurements/h264-rounds/bundle2/gating/gcp8-retry.sh": "3967b05f5746ad2ad577e486dc5d53988984358103af597722983bdf1f212cd4", + "docs/measurements/h264-rounds/bundle2/gating/gcp8.sh": "78e916d5a89059c29ebe8ba862200e6e59bbdc705bac44c980caca02943837e8", + "docs/measurements/h264-rounds/bundle2/gating/hostgate.log": "465700b447e5b58d2b44f4b0900192ba3ad8e8eebd1a3eee04418cdf4c9eb091", + "docs/measurements/h264-rounds/bundle2/gating/identity.txt": "895eaac4d3308327d074a4daf0d600989a88496500bd716fbc77dcaab2f3063f", + "docs/measurements/h264-rounds/bundle2/gating/progress.txt": "93f28b9ceea8ebf78fc3bf6bccff2768a836fea8351d02f144cc38db223ba67d", + "docs/measurements/h264-rounds/bundle2/gating/provenance.txt": "dda60c16aadf5475d9f498f6a090c41bf0783368762a9a7f51231f54403ca18b", + "docs/measurements/h264-rounds/bundle2/gating/run-1t.sh": "b6b6f273958c34d04630b75b2182b4f77c5bd1d699ce9b21ab10d894ca6fe8ee", + "docs/measurements/h264-rounds/bundle2/ic32.sh": "bbe581cf4e28889f81c6b72cae4c041eebf31da9bdbf303ba052d47bd89f7dbb", + "docs/measurements/h264-rounds/bundle2/identity-fast.txt": "c21d94621c22adfd06eba945049de9f00e8a267d0f9f3a75ae7678d0f37cfbf4", + "docs/measurements/h264-rounds/bundle2/identity-safe.txt": "c21d94621c22adfd06eba945049de9f00e8a267d0f9f3a75ae7678d0f37cfbf4", + "docs/measurements/h264-rounds/bundle2/instructions-item-f.txt": "04ec6b05930cac5042ea0c863c291c77f55d47d28250157da99847a7fd3f0237", + "docs/measurements/h264-rounds/bundle2/local/README.md": "df9d1ba64bf865d37740a0eed96de020aef77fe7c71bd9b094d9f29dac6f31dd", + "docs/measurements/h264-rounds/bundle2/local/local-1t.json": "d9c564793363a67e15f15439ee3b59e20eb2fa3704e4b82dc1cfd95e572ca55d", + "docs/measurements/h264-rounds/bundle2/local/local-1t.txt": "63cba0b77a38f8569a142352e5727575237780ff371a9c6dcdf2864b875e5018", + "docs/measurements/h264-rounds/bundle2/local/local-8t.json": "f581ed01f48ed302d35fb4cd17e5c17c7e3147998f6604b3a8dc725ee32dc4eb", + "docs/measurements/h264-rounds/bundle2/local/local-8t.txt": "aff675e5686cb68e9c4f294d820a14a465022a3a01f01fa11f54a5f6be9e71bf", + "docs/measurements/h264-rounds/bundle2/plan.md": "b49c9e9bd5c7e17b8ff61d8baa8b7e947e96bf351c853aca904917037ecb214a", + "docs/measurements/h264-rounds/bundle3/binaries.sha256": "4bc17c7e12853a4f645a654c22e40bfb10a7af1817a389d9695b7922b481801f", + "docs/measurements/h264-rounds/bundle3/checks.md": "688bc5a01ff43a886b1bde5001180ecc4d80a87f56582962913a7005d2dbf2f9", + "docs/measurements/h264-rounds/bundle3/conformance.txt": "d7b29ba80d2d30effdaf33b3bed430e1f40142effe9ad68f1b24af3377f3257f", + "docs/measurements/h264-rounds/bundle3/fuzz-filter_chroma_mb.txt": "db718f325aa1cdb3b3138e250d2f41cf3e3284fe4dd5e93fa82c222b55922d55", + "docs/measurements/h264-rounds/bundle3/fuzz-predict.txt": "48fb0dcb309dc8c6d0c3e79b5fac9922534dc1f8dedfc97290f482329363ab3a", + "docs/measurements/h264-rounds/bundle3/gating/1t/REBASE.md": "76afd775fddf15aa52b0afb25b197bbdfec31882066e75c4ce6a869069ca528b", + "docs/measurements/h264-rounds/bundle3/gating/1t/STOPPED.first-rest-start": "2d699fc1ce62c7ce11cd61403a206e784124713f350593d533acd659e52f83b4", + "docs/measurements/h264-rounds/bundle3/gating/1t/g.1080p.json": "62c960bd71f893a00417c30a8801e06ccf1df4d52eb6e06cc89562f05f639cac", + "docs/measurements/h264-rounds/bundle3/gating/1t/g.1080p.log": "594ea0b98bd733b18c8d1947dda8a64f8a9cfad7bbdb29006c0227e2e6716bca", + "docs/measurements/h264-rounds/bundle3/gating/1t/g.4k.json": "a1a4b159de30087148466c3dad9be3a831cdbfcf32554557e9128067ad9b32a0", + "docs/measurements/h264-rounds/bundle3/gating/1t/g.4k.log": "39ce108893c9ebda8d50876beb6d94d490561079364a987111c91caa8efff042", + "docs/measurements/h264-rounds/bundle3/gating/1t/g.720p.json": "de73d9e16a20fa04f103e19fb7d0e74db6732fef880b2230ebee067a14174173", + "docs/measurements/h264-rounds/bundle3/gating/1t/g.720p.log": "a32e8e5cd6da1508506d7a1c59609e2df9fd45300eb78c2071d4da89528f0415", + "docs/measurements/h264-rounds/bundle3/gating/1t/g.sd.json": "4e4f266c7d61bed7f41439d0dda5130365ba8898a2b0be40d52a92b196298921", + "docs/measurements/h264-rounds/bundle3/gating/1t/g.sd.log": "50a7a45a2541ea7e65995ee2c5eabc36c17d60e5d3196c7d2f97bdc09a4eea1d", + "docs/measurements/h264-rounds/bundle3/gating/1t/h.1080p.json": "634408e51111657a581bb7d1c78a755f1fbd5ee4b1d7bf97364810b75a1c7a0e", + "docs/measurements/h264-rounds/bundle3/gating/1t/h.1080p.log": "6d71640ac039f46c8cbb395f5f7bb0d00e1cd02df6c7bd0ce90ca3adb59063d9", + "docs/measurements/h264-rounds/bundle3/gating/1t/h.1080p.log.killed": "df49369bc564fe04d3e68bef11dccacd9c084b01e05a703cd8389930986c27d9", + "docs/measurements/h264-rounds/bundle3/gating/1t/h.4k.json": "b97f894c4b1003cfbcc6ee4a196d351df0b0c64d7dc47100b4936a10ac5fd760", + "docs/measurements/h264-rounds/bundle3/gating/1t/h.4k.log": "a0971a293ac6c5dffc20e8e60d529e0b0ff23e260d7f1efe69570ca67373cb0e", + "docs/measurements/h264-rounds/bundle3/gating/1t/h.720p.json": "8eaee9ae4e1ea54736c4cfdf5a3ea308c4324e8006f1911ac41274561dbd6f4a", + "docs/measurements/h264-rounds/bundle3/gating/1t/h.720p.log": "cebee590351bae1be78a895bad6ad3bfb54aa9a4b9961c6d9eff4a5408c1b1b6", + "docs/measurements/h264-rounds/bundle3/gating/1t/h.sd.json": "38f70fac8299b0a5c1e00cc7e74e360dee795141d27e85fbbe8cf5b212c01f30", + "docs/measurements/h264-rounds/bundle3/gating/1t/h.sd.log": "f1d2aa3d3dacab3e834eb0ecb3bf7e1b81e5afbd00c5a01281c4ebb1ead9d24c", + "docs/measurements/h264-rounds/bundle3/gating/1t/hostgate-rebase.py": "2808ed72eb98d80ce4778b4154985ecf4a0f6832d30a93d0da6ee9e4ee23dc3e", + "docs/measurements/h264-rounds/bundle3/gating/1t/hostgate-rebase.sha256": "e557bb1e11652fa2919a8017fca20677a54f8bb59913cfb1ec264f9b41397470", + "docs/measurements/h264-rounds/bundle3/gating/1t/hostgate.log": "497b0d25cdc8afa5cdcceb8a3729ee22464a5e646bc2865a625ced470ec1ce88", + "docs/measurements/h264-rounds/bundle3/gating/1t/identity.txt": "c6263652e78ce3dc17fe8266ef11e284fb94fe21484b229c9e4fc0cd95e8112d", + "docs/measurements/h264-rounds/bundle3/gating/1t/progress.txt": "faae6b67ea048f96d065a739d3c1a8061340d8c1b7d94ff10ff29d78c751f4c9", + "docs/measurements/h264-rounds/bundle3/gating/1t/provenance.txt": "ff73ef5247d527afabd0447a234ab7b43c5c601126124f546f9e2e718721c485", + "docs/measurements/h264-rounds/bundle3/gating/README.md": "6bb0fdcfbc2391ee83d7241986171641ce8244631adc602015f6c65cdf6cd594", + "docs/measurements/h264-rounds/bundle3/gating/analysis.txt": "0a184a5d492416750b82ef06d52e37a9b69aae417352c6507978b0b1385bec6b", + "docs/measurements/h264-rounds/bundle3/gating/analyze-b3.py": "e0913fb77c2fbb41c33562c7c7771b6e98640a181e1e4ed091ec2aeb3271e0c8", + "docs/measurements/h264-rounds/bundle3/gating/binaries.sha256": "0d56ec8f01155f55e909eb03e0e28846e6cbbee419f2399e4527d49d0f4d6368", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/host.txt": "fa0e0f822ad68cb2873cdadad37251ab44004c8831841ded44ffa85b64faa3ff", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/job.sh": "1b3cfd0110090369f80e2ce93beeeed64ef82705ea13cb51e6d253c8bf0dd6ee", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/progress.txt": "3e56c03a458a3a63ab38da318bcc325f5521da200bd3607dbb98e9064367a178", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/ref.json": "876553fa44fdeacc94177bdeff58a714a68f823d54b65bc87e5f0931f4593879", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/t8.1080p.json": "5672af7cdbe4fd6d3d675b1e5da98c1c9d83195df1d65560a6c39ba1a963b3a0", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/t8.1080p.log": "cde970df99aa3f6fd5e79f3d17b6fe02f1129f6f5333e69f7d6fae5ea56fa1f9", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/t8.4k.json": "dafdd08e4ffb623067b1bd8c61f82976a25dd925fbff82e33e7454cf81832ce0", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/t8.4k.log": "6f080e3ca75e96bf18a6c9f5b371592aad51f0980b091effc681b015d9016d52", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/t8.720p.json": "33c344ed1c065baf7d006c9d3279fc0d6045e11dd7d31f598a0bd1fa41566d81", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/t8.720p.log": "0bab97fed2a2db23b5cbed354c532931d9acf4cb4ba79f2e1f83de2df819cb17", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/t8.sd.json": "b00c97b4f4c8910e83266a0a805f51fe0c6392ac240ef904402ab35a77316d48", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/t8.sd.log": "0bac3f1f486972714ba5a13f46b0fff794ef26de6be053b6c6455b9e8dba3eac", + "docs/measurements/h264-rounds/bundle3/gating/gcp-train/verdict.json": "27e637a74a39ce8d95ce4d10498afe3f41f774235535943c37fd9ab8c64c4aee", + "docs/measurements/h264-rounds/bundle3/gating/run-b3-1t-rest.sh": "711ddcae198db389c9d28ed54d2d13229bfd3934ad478cce42f02f224730d481", + "docs/measurements/h264-rounds/bundle3/gating/run-b3-1t.sh": "a1af71051364681e3f223161261b9151cfa4a10e125e5ba56411d4dc79928e16", + "docs/measurements/h264-rounds/bundle3/gating/summary.json": "0d7ca64a6d32106dfd43377c254c03a07f3333e0ff640993d13f7f9cd9b5dacd", + "docs/measurements/h264-rounds/bundle3/gating/tools.txt": "e06ac435516a01f581dac97c0253f4806df280c3e0b333ac5b04d3b7610bf877", + "docs/measurements/h264-rounds/bundle3/ic32.sh": "531a710d8cc01fd713f8f3fef23613f702823d92c2428d957700f0a5143cfb8a", + "docs/measurements/h264-rounds/bundle3/ic_ratio.py": "1d231e004d77e5c1021db67ef3848a53bf78b48d3334c79a7a1648a3203c0193", + "docs/measurements/h264-rounds/bundle3/identity-fast.txt": "c21d94621c22adfd06eba945049de9f00e8a267d0f9f3a75ae7678d0f37cfbf4", + "docs/measurements/h264-rounds/bundle3/identity-safe.txt": "c21d94621c22adfd06eba945049de9f00e8a267d0f9f3a75ae7678d0f37cfbf4", + "docs/measurements/h264-rounds/bundle3/instructions-bundle-1t.txt": "a8bc0b4745c8db403a48230ccf1cc9e95ae8059629a1a124f91b74216f884cc5", + "docs/measurements/h264-rounds/bundle3/instructions-items-1t.txt": "0bd1515f374c282ee23fbe54f1f028a72c4a86c4058eecbc64d90b74ab9ce841", + "docs/measurements/h264-rounds/bundle3/instructions-wake-8t.txt": "6ee484183911f35df7044b5718535087bde6f7ab1938d26b11a0b6f99a96ed0d", + "docs/measurements/h264-rounds/bundle3/local/README.md": "c7312535cd19382c6c86e5cea53101dce5618f5d0b80160dc72bfc03f4157a39", + "docs/measurements/h264-rounds/bundle3/local/local-1t.json": "66dd39e05e3a6f0f8327a3a90450bdb3367f90a34c3facf99cb942ed24d455c1", + "docs/measurements/h264-rounds/bundle3/local/local-1t.txt": "6efb952833ae61e200736a2b52d61588b3ef1b374d403ddd2210ba04a589f029", + "docs/measurements/h264-rounds/bundle3/local/local-8t.json": "d2a8429fd78708eb12838292d5dbc7a565ffa9c35e6b35a052fe094fbde4bfcc", + "docs/measurements/h264-rounds/bundle3/local/local-8t.txt": "1468b7898dd393e5c8088a32fac1197771c95d31cd2312ed004fafc12d0b662f", + "docs/measurements/h264-rounds/bundle3/plan.md": "ae28b8a0c53b1d1170ea345b025fca5c4cc5672e2eec5c920d1654cde4274155", + "docs/measurements/h264-rounds/bundle3b/binaries.sha256": "d56f770e607286c4cac2d758a68fdcfb41958b152f11c0a6070e12f8b05cc64d", + "docs/measurements/h264-rounds/bundle3b/checks.md": "0931a54aba4cef42a202c4ebea248d7a7a598f8dbdcf6eca22e0a10ad786b7c6", + "docs/measurements/h264-rounds/bundle3b/conformance.txt": "09b4c2cf7893c2779c8c416fc1dd9a2f4e5ca14c7bfb514471f2c30ffb26c8f1", + "docs/measurements/h264-rounds/bundle3b/fuzz-filter_chroma_mb.txt": "2d2d29d9b97a83bcfd7d30c49e9ac3ee878ce6f82f57a47d9871b074e7650c9d", + "docs/measurements/h264-rounds/bundle3b/fuzz-luma_mc.txt": "8378d892a263f8ad672f5c8274ed952ec0372938dfd4d8e215b2c3f170ea5f12", + "docs/measurements/h264-rounds/bundle3b/fuzz-predict.txt": "3742a21ff873a2f2fd451f77c8589b5822b94200e9da9ebfb671f61cd6f7f754", + "docs/measurements/h264-rounds/bundle3b/fuzz-weighted_mc.txt": "28b6cd9f5b027c0cc7e6616262583208a6ac72eb9b024af9ed4f4ac02253106c", + "docs/measurements/h264-rounds/bundle3b/gating-request.md": "22200a930b8def683c5afe219ff9852dc750ca67c26d2600422f790e4756f3e7", + "docs/measurements/h264-rounds/bundle3b/gating/1t/g.1080p.json": "f1c701fde1bba2b800cccb31daa3d304ba4546f59946274268a3dcb9aa0ef912", + "docs/measurements/h264-rounds/bundle3b/gating/1t/g.1080p.log": "8f29e08279908baaf0e4f36cc53b7b79b874916c68d0e23753392b891e1576f7", + "docs/measurements/h264-rounds/bundle3b/gating/1t/g.4k.json": "341f06c7ae6139367ae60a459b610be286695db5c69854b70a739d73275c6762", + "docs/measurements/h264-rounds/bundle3b/gating/1t/g.4k.log": "8207bfe7b2eec0132ce31c218630969b5b3d1a020439e2946daf9f82e19642b4", + "docs/measurements/h264-rounds/bundle3b/gating/1t/g.720p.json": "508aeaa573386f2e2a53cf6fb55f1b31c0f8be4b68bc13b736e8d2e0d97d1aec", + "docs/measurements/h264-rounds/bundle3b/gating/1t/g.720p.log": "d2e48aa413a3ef709716a77b971bc69b47558ae06419ea1e9f1f00a2a938d136", + "docs/measurements/h264-rounds/bundle3b/gating/1t/g.sd.json": "25b176ba92150f4113f409e832b0e4b708b036d62da6e2e3710da965e82b1ca0", + "docs/measurements/h264-rounds/bundle3b/gating/1t/g.sd.log": "2f842bd03764e053fb7bdcaea62b6084394a8fdfe9293046742158b3da95dadb", + "docs/measurements/h264-rounds/bundle3b/gating/1t/h.1080p.json": "7b8e928e7cc3ba1c27c48be0aea9b9250756aaf3261b9111c200c20f2b820ea3", + "docs/measurements/h264-rounds/bundle3b/gating/1t/h.1080p.log": "fd8de0fd99c5b5bfd249d86a9e31a514974b185edb30cd58d669f4a3efb02dae", + "docs/measurements/h264-rounds/bundle3b/gating/1t/h.4k.json": "6f2769c67bbbc1bfeb2bd9345e7c803f1db7e811c0b0965c70789b47cc8c3d50", + "docs/measurements/h264-rounds/bundle3b/gating/1t/h.4k.log": "f4b3af53d4c6d0a91afa430b897824b3a329f4ff49467b45a873ba697ee446ac", + "docs/measurements/h264-rounds/bundle3b/gating/1t/h.720p.json": "37a083ac3306037bd4b2fbb587ac5846c813f5cd70f74df0a5e4e978d5aaf57c", + "docs/measurements/h264-rounds/bundle3b/gating/1t/h.720p.log": "742d4b358b3adb4161ec37b3237514c614d58fbf73b44bef20dfb4fd3ccaf8ee", + "docs/measurements/h264-rounds/bundle3b/gating/1t/h.sd.json": "b9a9738b7e6ac49df697e7dfb909c5ce85fd8fc0854c5913fb24ab8ca3514a75", + "docs/measurements/h264-rounds/bundle3b/gating/1t/h.sd.log": "ed42a34b9b005d2a2a9be379f731220cc0462e6db4377ef9288bcdd316de6115", + "docs/measurements/h264-rounds/bundle3b/gating/1t/hostgate.log": "5b21e6ab25790b3cf439733937a98d736b0ba7e745df9c2ac1a5dc3790415583", + "docs/measurements/h264-rounds/bundle3b/gating/1t/identity.txt": "139335b5dc84f7985243c9594d2cb5b094f8b1fb5ddac740250d5b4621c2d08a", + "docs/measurements/h264-rounds/bundle3b/gating/1t/progress.txt": "6904a7db1f7490907848e6c3a372ee7a461e5cffc9245a82205484c85ce99ffb", + "docs/measurements/h264-rounds/bundle3b/gating/1t/provenance.txt": "1339f22a4bbbd72936f43654966b9e14f50b757343a823c6b303247c284aea14", + "docs/measurements/h264-rounds/bundle3b/gating/README.md": "a3403fb69c5bdfe14e4a8d549d0b0fd51312d17c21a80dba8326346c853042e3", + "docs/measurements/h264-rounds/bundle3b/gating/analysis-1t.txt": "93d5f0cfe3b826f9d05786abb2aa76a46c8ad8ca8ed8e31a55517299bbd96a3b", + "docs/measurements/h264-rounds/bundle3b/gating/analysis-8t.txt": "d7bf02402d47ada1b4534984b9439818f7ae37fee2bb7657b417c414fafe5a4c", + "docs/measurements/h264-rounds/bundle3b/gating/analysis-gcp-1t-heldout.txt": "56b515f11867aa26a01a4ffeff76a0741823fb6cef4c6348417999ae3877fc5d", + "docs/measurements/h264-rounds/bundle3b/gating/analysis-gcp-1t-train.txt": "39392d2d54cbe52fc758116c21d7ac6f7a442c7c9a45c80310a3594af610ed41", + "docs/measurements/h264-rounds/bundle3b/gating/bars-1t.json": "c95ae18a112539f439f166a4a9e6e6c6f60a13bfe46692b7c19b14e4e3408692", + "docs/measurements/h264-rounds/bundle3b/gating/bars-8t.json": "56b8c661c18c4237c74cd91f00bcfe6df496a181af82ff88a2db5af95d08d830", + "docs/measurements/h264-rounds/bundle3b/gating/bars-gcp-1t-heldout.json": "724982065c1c6cb9cee83cb7bb9d0947f3fbae789c54b7bbcadbbfaba04b20d4", + "docs/measurements/h264-rounds/bundle3b/gating/bars-gcp-1t-train.json": "f255d82b2ad8fd0b5b370210fb37d2d8430f4784c746cc5dcabfcb7ec9a30aa5", + "docs/measurements/h264-rounds/bundle3b/gating/binaries.sha256": "5304af343bbe8b30c588622d7e6a1843542f31274b8a685f4ebe105fb0ae2b09", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/g.1080p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/g.1080p.json": "5781f1b4bd702ded3a18a1dd2fd73eec563b0b47aa99bb6ec196b5b703b00cba", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/g.1080p.log": "d50480b968ad5eb0b79beb9a56600b2a6127de9871cc7e037a6b4a61d415453c", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/g.4k.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/g.4k.json": "254fbf93922456eefb0c53df59639f39a490d79399d961c084893ca5794d79fb", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/g.4k.log": "110a4cd6d5194504b603ab4b30349d3d27b89880c3891223912224b2da115332", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/g.720p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/g.720p.json": "3712e1381d631eba17349e42a8bc1398145b1340914bf6af4e861fe5264a54cc", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/g.720p.log": "56312b53533681866b0e59dfce2f63da13eb578007d4df240bcc2607d2beaa22", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/g.sd.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/g.sd.json": "4a6dd1cdaf72de6fb9085a3740a1b42b319ecc6e3e63b2c80ed81b772d05ce79", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/g.sd.log": "3651507adf5316da79e4f818ee25f1a10363eb2ce447c4be21cc9c9f489527a4", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/gate-checks.log": "2ea6404fc86d0ac88c264ffcdc8b45c7c885d2cadff65d77b155a978d89cb556", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/gate-refs.json": "e7513e5edbd4641a31ee2ffd50c88f4ac6425a5c7abb8ba99b29019b411c35f7", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/host.txt": "fea041d5641310963ea23848d471d72a2b7b09e324cbf5cf8d8b46557df8c411", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/job.sh": "3ae5dad5a36e177bc1c5da8ada0ed3367f3003748e9acfc15450854270f21118", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/progress.txt": "f4dd84fb2277d67725b00b6488ab62045a27028e0a29b16a68c72cf506eec236", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-heldout/verdict.json": "93fba3dccecc85b26df27f05da6196f284d9becd6bdea0f7f9c6c92e77de1413", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/g.1080p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/g.1080p.json": "e4690be2b2eb197b3ba47504c7d9ed67b0f7fa5901c51ce7f2b918f51b4e0228", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/g.1080p.log": "40bfdd0ff21be337cb195832f6a1f501f4de70f96e4259e06e196f0dfa4b57e7", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/g.4k.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/g.4k.json": "c1135e93170daaabe3e8e47217c0a20268c5b9f67e537dcddd6583ed3f57fed9", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/g.4k.log": "7847ecd54c967457e266b20808a1aeae7134c19e63743e9bb380bd76af6df04a", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/g.720p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/g.720p.json": "43db0b648e2f8f086bd52e72fd686bc131514c2e8015ee0d493aaef6f256253b", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/g.720p.log": "82107223fc45823f1287df1924c9745740b5e651aab355fd0f57b2856d29a8a6", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/g.sd.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/g.sd.json": "1ae1e690496aca1cb60bd9a20d2b077fb3435129a231bd7310238dd841902770", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/g.sd.log": "ffe7d4422af16fd831690468439a8a9958f0cf8cb4253702b36366e96fe486f6", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/gate-checks.log": "bfd4801cda96ceae19a4708dd9e9c9d75b4daf0dbb792c8880bb713daeb351f5", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/gate-refs.json": "e8ae184bdf1000466ef2ea9737b1123554d4b477d1b4719b51e1962ee1541085", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/host.txt": "ccc1d552dc211c9c70e8f38d3ef252c1fa9b7c1ff0ab146f79562979282fed47", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/job.sh": "3ad79b3ea970a3c5fd33b93305793cc174b99eeaded885648897b6617dca1796", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/progress.txt": "9c52dc4585aa18096888b39b87efafe8ebdfe3293340a6460eb836525e1661c3", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-1t-train/verdict.json": "93fba3dccecc85b26df27f05da6196f284d9becd6bdea0f7f9c6c92e77de1413", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/analysis.txt": "3d312635faba4d675c17b7a331dab94b000e2236a9374d16e45ac16dc681785e", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/binaries-as-run.sha256": "30123b5183adfd0e2d5dcfa5b1acd24bb79f6ef2c5a37bf9d207633a1025ac8e", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/host.txt": "e90f71e13042faadce845e0db27c9a101fed8b954f2382cfb4b72d759e3cd0c6", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/identity.txt": "9ef8163066a68a27eb67b9c1929838b3552ae5d5acd5b2d5fe420795fbcc109d", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/job.sh": "20a16ca3543dc783735777ce019ef21ff7d6fda2d26d8e1f85f29a048a424520", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/progress.txt": "2769e03269cbde431fd4a01c5c26285e48c95d5f3a2d612d2737f82a6e7d1c47", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/ref.json": "ed03dc2be389208873f89690bcc1f8494beb234b5b641ec64fb34aef27b83114", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/t8.1080p.json": "4b76b8cf4746eb9a9e856e62d252b4e2d990f222d461799479d18b3651ca2441", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/t8.1080p.log": "ed9afa86ee41226554865f6e68bcd2368e72f6da52f3addc590e23085d6d164c", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/t8.4k.json": "519af4f9cce411aad31f82e5ccc94366e0bc5599f250f3a78748bfb489cc7fe9", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/t8.4k.log": "55517bdd22abac4854cb4afe439804b51411509a1f9045d55e01b91255306178", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/t8.720p.json": "497fdaa220e6e6eef4b0b764f9cfeee08b0deddbc2ce7ece13b4d78cfebdbba9", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/t8.720p.log": "ac1540a1fb88b822ed84cae7dac264078a0574df3c9b99b438d49757657d2328", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/t8.sd.json": "c80b8ccf8965d8335bae9eba5c6beb90c9e6c29e488ff66733789d4f70ea8f50", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/t8.sd.log": "002b6d8985aaf961471cdb513d77c6c2f22ecf0eba5bc2846cccb52e7eee09c6", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/tools.txt": "5291042038e1a7f8ba6a0beeb509613b715ac6ed2af57f2bbeceec893ab72b34", + "docs/measurements/h264-rounds/bundle3b/gating/gcp-8t/verdict.json": "a878d6a84b1d02c6042945d776d64090ad52861f46d30d2279a11b2823cdee79", + "docs/measurements/h264-rounds/bundle3b/gating/identity-job.sh": "03cd9a84fdec200dd16608d0a9424946c4a2f691df73d854c5c7af1c0bc41574", + "docs/measurements/h264-rounds/bundle3b/gating/identity-summary.txt": "869e322dc0ec9737c2c388f82cbf2f2db3a05721b267cd53fe261cb8ff985cfa", + "docs/measurements/h264-rounds/bundle3b/gating/identity.txt": "9a666d815eabdc8f35a89de07fa6adbb624d14526bbbcaf81b0c3c1b10bb0020", + "docs/measurements/h264-rounds/bundle3b/identity-fast.txt": "7552e299511ed18fcadb06350b487bb4270d3bde31df02521c1718139a1142b8", + "docs/measurements/h264-rounds/bundle3b/identity-safe.txt": "b8463df6c75dd1d221557194b3ed8e0a0a1a11b828c6cf3d799f16c8475d907e", + "docs/measurements/h264-rounds/bundle3b/instructions-bundle-1t.txt": "981f12f0b772e25dd4f481af8a1cff779ec3188d4306e4ad92a57e473b3566e9", + "docs/measurements/h264-rounds/bundle3b/instructions-n.txt": "53a383eb46b9932a883de30dcf9cbdc7cd0b66c200b1fc7193a7021423b7f866", + "docs/measurements/h264-rounds/bundle3b/local/README.md": "83bc3352422095326c8dbdebc58c42d3bbf2760a5c06d8a42df1fe46995a7acb", + "docs/measurements/h264-rounds/bundle3b/local/local-1t.json": "b298a84f25a279ca9b8ad0c7bb2140e51d4c6b192d5720a61757bc311c4ce89c", + "docs/measurements/h264-rounds/bundle3b/local/local-1t.txt": "b859ae5848570921a4a110245eccd6f9ecfc187bed61aecdf851cfb5c106d025", + "docs/measurements/h264-rounds/bundle3b/local/local-8t.json": "5f410052c6f0c67ce2b706c193f7909722e1b2153ffd4df704743ef2c097b6da", + "docs/measurements/h264-rounds/bundle3b/local/local-8t.txt": "fdf1143596bbdaa12d557290d9b58705658ed271a977771b74ba5893648c7aa9", + "docs/measurements/h264-rounds/bundle3b/plan.md": "2241b1031facb6e46b3285be12ff0a75316d821cf21e6d808cf5f4cdf6f510ea", + "docs/measurements/h264-rounds/bundle3b/scalar-luma-share.txt": "bcd82267cb0d7e0242b3e9b1502a4b13fb1aa25d4c56c1ca84b27714b41bd870", + "docs/measurements/h264-rounds/bundle4/README.md": "13ae5d4e5ebf9fc50fd5db5a0dfa1c7a5738592e5842d09e78b18caf991510ae", + "docs/measurements/h264-rounds/bundle4/b4.py": "500fd404a711e803645773332fca5f7d4c017be430c252e5971ed19afab41464", + "docs/measurements/h264-rounds/bundle4/binaries.sha256": "704a0741412eca88bf35b353565b15e45e451af6e560f7edcc51872d60c545d5", + "docs/measurements/h264-rounds/bundle4/build.sh": "98722a403f49a913ecf523df4d6e74d09c273e70186656923ba40761e0738999", + "docs/measurements/h264-rounds/bundle4/checks.sh": "55b0ea731c79ee3e29da1971abbb58c377afb84d76f34e44294844ca8b4dc088", + "docs/measurements/h264-rounds/bundle4/checks.txt": "73af0a86c45224ec8af33451ebb73fe5ba5e3482280f96246a346ae7106883e5", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/README.md": "5dbef224ada1f68f303495607d223089db1f15ea6dccd43aa23ddf47115d18f6", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/binaries.sha256": "f79e0d16f21b4deb6ddd7f4a21a51153d4d199df9ba8607463da4d92dc5e1668", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/g.1080p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/g.1080p.json": "83ae8df9ee08bdb6ef0788f8fd618376770b516948d8f31c82341e254252a839", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/g.1080p.log": "c629c8c42242681e0e491ab3cda70da39f575f4f82f08ce615c23f856d9b175f", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/g.4k.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/g.4k.json": "02a8a71c3c337d764c79b088ef0616947ec3522fc65af5b0d4f121d25515172b", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/g.4k.log": "84780b8d32b4918c5a30c004664c5345f017e469488bc4c133af4e5108524b80", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/g.720p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/g.720p.json": "1d4c1eaa48abbebc4d142e56e74ce2f1f7f54c5256d97808731e5cae60cb4147", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/g.720p.log": "e6328eaa1ccea421726a2ac2bde01ead4b13bd847649ad1b84044e7769763b01", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/g.sd.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/g.sd.json": "fb842bc783851c0ef6b14ffe9c332f74793b3a2f6136ad4277ad53f5448721f6", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/g.sd.log": "0ba3fe521052d29037fc952165eded8c72bc9c592cafedb0bfdbf6280f049ca2", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/gate-checks.log": "1becf9282e070416a9995a38528d0d713b0160f9db946e7d262a0735f75f5dc5", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/gate-refs.json": "de8b93ed1b24ccb7a38612c05a14a136e2c03bd57c2cabfa50f84bf4321d8d1e", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/host.txt": "c4dcde795aef623625e606772ed431a1a3ef18aacba3fd60026e4714c1c50082", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/identity.txt": "ada9e6e5676237cdf2c10534fabecb7584afcc3564da95ca136d4a80f0a459cd", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/job.sh": "8e98c1bc51c85dcbe466dd19159c37045da902ba14681c35ac472c56f2fde4b2", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/progress.txt": "4c527e5e4cede8fc39cfd5da4c3df382536ffa80a39f24a872d539237db04891", + "docs/measurements/h264-rounds/bundle4/gating-1t-gcp/verdict.json": "a406515971321016b78a24b6127d42acd2a247af92f1db10883b88b0368472df", + "docs/measurements/h264-rounds/bundle4/gating-1t-hostfault/README.md": "445a54d5b8adc4b9d064abd2e43597e236415c7312de8cab6e1c2c0e0c5a7440", + "docs/measurements/h264-rounds/bundle4/gating-1t-hostfault/STOPPED": "44af1e1c14880cb827093faf06f3b82d1003e0ce49ace41d54c46f98c27d7b60", + "docs/measurements/h264-rounds/bundle4/gating-1t-hostfault/STOPPED.1": "44af1e1c14880cb827093faf06f3b82d1003e0ce49ace41d54c46f98c27d7b60", + "docs/measurements/h264-rounds/bundle4/gating-1t-hostfault/g.sd.json.void1": "0547adc1b61754168cb9420f02fdb5fc794509a7cce6cc61d2fd3de81a2e6257", + "docs/measurements/h264-rounds/bundle4/gating-1t-hostfault/g.sd.log.void1": "1d6587d62cd116705bfa2e471411bab5e0ba549aa2ea3d6d2380c503abfbddb0", + "docs/measurements/h264-rounds/bundle4/gating-1t-hostfault/hostgate.log": "faf821d3db3f40e3a9ba78f6636549052ed91780c8f41a2c334c74a3c06c3e4e", + "docs/measurements/h264-rounds/bundle4/gating-1t-hostfault/identity.txt": "895eaac4d3308327d074a4daf0d600989a88496500bd716fbc77dcaab2f3063f", + "docs/measurements/h264-rounds/bundle4/gating-1t-hostfault/poll.log": "83ced6c83cb516ebf98e97b363b10d885a0427df7046b4b0f17760e80172b3e7", + "docs/measurements/h264-rounds/bundle4/gating-1t-hostfault/progress.txt": "912ee8e43aedb21504cb054032d63f8137f3550afe688626c110cccad165ae13", + "docs/measurements/h264-rounds/bundle4/gating-1t-hostfault/provenance.txt": "b538bf5a14ce00925b8133c5f58ffb4d9dd34ddad8c5a22938557869c0eeaa3c", + "docs/measurements/h264-rounds/bundle4/gating/README.md": "884c750d9fa5a419adf48ae2d7e2616d74260075ada3e178add6c921d53e583a", + "docs/measurements/h264-rounds/bundle4/gating/analysis.txt": "367eeb901e0366add6567deb25f44385d590f4e930dd2aa87c6c3fa7c348f1fd", + "docs/measurements/h264-rounds/bundle4/gating/analyze-b4.py": "2a5e8ff19a1123d32b782abfc52474e559f1255e5da3e1a5321cffa5a77f342e", + "docs/measurements/h264-rounds/bundle4/gating/binaries.sha256": "e8062985db94ae616ddf5818b7cf0f041368658c5a305fd8766e21e9edc7b6d6", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/host.txt": "aec176c62a7e6971daf08ad64bbb313a11ab3f0d469d667f22565e4f91d1d106", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/job.sh": "c4958d021b58c12a294632b8978e28270e3ebe0d2009d571c43e9d2b56bfb18b", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/progress.txt": "77211b4ddc41106cad661ea698848b0b165898f004782628ed3b6897a47eda40", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/ref.json": "4c542bca218bc5cca4e26783ce7783a1b1fa706fc4f20938cf499624b9ead376", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/t8.1080p.json": "e12c0ac1c3fec3c5784fc17fd3c6f265c8e78a8e8a01badb71c5f60c2d92f388", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/t8.1080p.log": "e118327431a37408ff54c808767a20a3925b4382e5bc0820cb805104051e567a", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/t8.4k.json": "eb3776963aa8ecf20b38564810b97fead61daa51d0b052de44a805fa36d5ca1f", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/t8.4k.log": "56ea39b8ccaa0350086c1c0f322ed1c26417005c73a483a13f44c489040a5c77", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/t8.720p.json": "ce7bc40b5fd880af1f49adcbf3550ac0bf69821c42e5d2b11b7ae87e89825d59", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/t8.720p.log": "9e1120016cf0be2728a426e6277328f7414b573eedb17a74ab4efc862c1847bc", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/t8.sd.json": "55a8fb001a5bff9d42cfaa44dfa6537dded1e5789d73dd3db0309a1a1e659431", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/t8.sd.log": "98f65a11c36bce98f9f499a9fb9d97ef22f25d5cc63262f19cb0886c84cec5ec", + "docs/measurements/h264-rounds/bundle4/gating/gcp-heldout/verdict.json": "8e098e770cc7681a100bf93511dc57c55618cf3a6cedde41fe463ef0c5f6a109", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/host.txt": "0ce330a353d10c2c7e76a32fa3974aace82ffa4ace743bc0c4d410f05d47efb2", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/job.sh": "19955cd6db41b37fb707882bcc3d30b13ad5887f250dba1ab48ef7ccd0d61dc4", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/progress.txt": "cde010fbb9c106a1ef33ae8aba11ea6dbce6a4e4cf53f2a16673421cf2524953", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/ref.json": "ece42437d8871329f8cd92aafb48ba6011f916f6fe9fc9512513d8751717e5c1", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/t8.1080p.json": "fb866d7db57d3913d5c198b5269ddae789ee307ab00b2e22bca5438bb5ece28c", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/t8.1080p.log": "663759d0b7a797ea00a9ca365b585efa5cc0958cae10f82193e5623c7a994ac4", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/t8.4k.json": "ca364b7f9ea11e2be90dea20f3432f37400910851f07905049b575cce4c350b5", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/t8.4k.log": "01841b51d599b16fcfc4282f4b69274d223572e8555d6d76ba3cd177e1ef65ad", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/t8.720p.json": "a88d9b39a1b49c21d15cf8b940b8c5a96851d0387d6dbe0b4f474b6f1990125d", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/t8.720p.log": "b5f5c1eaef293ad90bc7cd1a3a7b25007d98e495037655954a0ff556b53b3102", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/t8.sd.json": "f6a28e281c7794dacef9bb404bffdcafee4ea48f94baa00245f66f582beb99de", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/t8.sd.log": "309077cddaea504decd1bc8edd5e34e3f2d0066f9f4d2704259ea4284f224509", + "docs/measurements/h264-rounds/bundle4/gating/gcp-train/verdict.json": "29eeaeaffc3bae1400c404c02b1394bec9ead5b495be690352513384262ddfce", + "docs/measurements/h264-rounds/bundle4/gating/identity-and-host/STOPPED": "e3df7d5a8016cdd3f046c5a3c1265b22103c2c799f39651b4c53d2c2bb2281f8", + "docs/measurements/h264-rounds/bundle4/gating/identity-and-host/hostgate.log.first-start": "1f0fc5aa3de16bb2f1843abf0995523f7a2e4b7916d382950878371219364942", + "docs/measurements/h264-rounds/bundle4/gating/identity-and-host/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/bundle4/gating/identity-and-host/provenance.txt": "e4f33feffae4aea5a53ee95a17be5ed9b8263c651fbfbab6e42291537f0ad33e", + "docs/measurements/h264-rounds/bundle4/gating/identity-and-host/wait-gate.log": "5ee79b10c5fd082f38dda563248fa1ddd3904792c5dd715da24db4527043fe2f", + "docs/measurements/h264-rounds/bundle4/gating/run-b4-1t.sh": "59aca07e36f686ba7ba7deded43c37251734d8a4b1992f4cad4d74773b5ee668", + "docs/measurements/h264-rounds/bundle4/gating/summary.json": "40eb546d9b8001c5f00ddc3c50bd253ffb0618493d62daa2cf428c41b1ba2173", + "docs/measurements/h264-rounds/bundle4/gating/tools.txt": "814b034d7feec764aa277713d70d3e401ba10e0fd15f1ec61fa02e6e7fbc9354", + "docs/measurements/h264-rounds/bundle4/gating/wait-gate.sh": "8337cf7518641f7afd498552dabae6ed75f4c3053c9eb62fbe5cd4a16ce73572", + "docs/measurements/h264-rounds/bundle4/ident.sh": "3df3a215d8b83cbc7b3a6dac8dfe3012ae1fcd6ffacdd3f0b3608f50953dfc50", + "docs/measurements/h264-rounds/bundle4/identity.txt": "508940a3a38d15439e8625876d65043ac6434fd3d71b8a4587b288fa0587170c", + "docs/measurements/h264-rounds/bundle4/instructions-1t.txt": "63ffda3efdc9c5842b25a65cf075cf72570009f85f0adbbfaff3c90a0dd16b59", + "docs/measurements/h264-rounds/bundle4/ir.sh": "0eb88d5aec2d8c06931a7f5c2754b17465da3a07778b8cd6afe0d2899e3386a8", + "docs/measurements/h264-rounds/bundle4/job.sh": "7bedf57485a3b940516d5d196aa063d5bb5ba9793442027306db0a51b5e7c3f3", + "docs/measurements/h264-rounds/bundle4/local/README.md": "aa3cf350dc91de7aa04d2567db484c36903a50a2a597f7b2aac850d07a87ca8b", + "docs/measurements/h264-rounds/bundle4/local/ab1t.py": "4af77799d55e53b8fdbed67f5877e291aa474a2778afaf79f42827c8213e1788", + "docs/measurements/h264-rounds/bundle4/local/ab8.py": "b27e27a0c9063807fcbde77eb813fbeefeb842eab948a8abf9a4c6c860e7134d", + "docs/measurements/h264-rounds/bundle4/local/binaries.sha256": "818dcf25edb7b4ccdae40dadecc433cd33f63ae57e9051e3d197446a28feb4de", + "docs/measurements/h264-rounds/bundle4/local/first/t1.json": "5f25ddefe92dc63da57ca4a6041c7c5e39468a27ebadb15e787fceac8225561c", + "docs/measurements/h264-rounds/bundle4/local/first/t1.txt": "02334a9767eed69e093df1c2eab9e4c3384254150b4e5d43a3b0a509c96ba4d3", + "docs/measurements/h264-rounds/bundle4/local/first/t8.json": "d5d501d5544a64415ec19e6e37f3d7709e770234ca30eb43aa108c513ac9964f", + "docs/measurements/h264-rounds/bundle4/local/first/t8.txt": "c2e6cff7503bc1caf396b1ef720d1b09e08783f64a2cbad21469bd4054fb69ba", + "docs/measurements/h264-rounds/bundle4/local/run.sh": "c23bcdb23491bbde361b94ec0791284236c5ff18f95d4fd610207201a51111b3", + "docs/measurements/h264-rounds/bundle4/local/run2.sh": "d3c3a814af7ec8427b4e5098fd630e661a1b6233d73255ece1a49e36756a5578", + "docs/measurements/h264-rounds/bundle4/local/t1.json": "73dc6b9edb965d59b373990029643c6c155385f208576b340b867a8cf4fdd0eb", + "docs/measurements/h264-rounds/bundle4/local/t1.txt": "4246bb19e536b34b4593d27f782f723815c6512074df4e53acd0362be90c3604", + "docs/measurements/h264-rounds/bundle4/local/t8.json": "b573f1790864b1dfa394c95d85f9afc75d8c2f03ee4d975f427bb538ccd480b0", + "docs/measurements/h264-rounds/bundle4/local/t8.txt": "de9ee531acb91967c947b8fad0c8bdcb9943614487bb1243e3a7967d4d9d177b", + "docs/measurements/h264-rounds/bundle4/run-gcp.sh": "f5d7835395dd35586d954da6a20ff96a15e556952fd71d0c30993fbe2f0b90ba", + "docs/measurements/h264-rounds/bundle4/run/b4.json": "4b0d5664097df18e2482a4eb0213b63400c535f375aa8d119f3e7472d1bf65d5", + "docs/measurements/h264-rounds/bundle4/run/events.json": "f97d5dc3a7cb4f7573dac7270520eafea1c01122e997351ddc6c098aaecffe38", + "docs/measurements/h264-rounds/bundle4/run/host.txt": "0862315ef36f4abed565b0e3ce7851264bff9d2e58be9208be37579ab813e505", + "docs/measurements/h264-rounds/bundle4/run/tables.txt": "0853e2b08ad25792277bb7ab5a7b9fdb682ba93d12467d2dc9c6440dd7c229a3", + "docs/measurements/h264-rounds/bundle6/README.md": "1ccf4790aaf07a0bf5efd79cfaa649566bb174c8c7a61f2611c5df3b8854f1a2", + "docs/measurements/h264-rounds/bundle6/bars-1t.json": "3a5b4680bccc1bba9ac5751745d64df2b85e34c4224304aad15e8f82297d2f0c", + "docs/measurements/h264-rounds/bundle6/bars-8t-heldout.json": "350b046326f8b1c16f7a5a1daabb29a9b0daec549641a47c8943f3241fe71a4e", + "docs/measurements/h264-rounds/bundle6/bars-8t.json": "80061c14ba4e54130b2449f17ed60423f9ef94e1537881fa107dac86a6b87841", + "docs/measurements/h264-rounds/bundle6/binaries.sha256": "3c3974720ac2f568c33c73459548fce0c1b6e074e05b08653788a249ba49f31e", + "docs/measurements/h264-rounds/bundle6/diagnosis/ceiling.py": "1987f742df4472352afe2d7a4f706df78c44c9617e69cd9e4af9e9a1e1dfffff", + "docs/measurements/h264-rounds/bundle6/diagnosis/counters.py": "42d7c0216dffbb52cbd13c9b6019ba4a793d3d016a047ed7dca4a8fac8565622", + "docs/measurements/h264-rounds/bundle6/diagnosis/run1/counters.txt": "8674fc1708229f0877c7063248b9a319b7ad42f49391918de1d199c832ecf636", + "docs/measurements/h264-rounds/bundle6/diagnosis/run1/host.txt": "a889cf5a59a7106fe9146fa9d16221782accdf2f8c5642886a58b9e2cda36f4b", + "docs/measurements/h264-rounds/bundle6/diagnosis/run1/instance.json": "5a79a204c5f47a175cb488ce15334260b9f7b60b19bee08df6a876d5737aaf13", + "docs/measurements/h264-rounds/bundle6/diagnosis/run1/job.sh": "d5d5544913497a596b62f310a433e1b1ccee52a1f5e5d331a3023726bcae5848", + "docs/measurements/h264-rounds/bundle6/diagnosis/run1/progress.txt": "07db095b1692ae1b625128d1e01b769c41184f6d217e2a4bad6992cdf936fe6b", + "docs/measurements/h264-rounds/bundle6/diagnosis/run1/run.py": "4145754d1d925e05b8a196070993c209d702f3ea10d054452a96088dffebda56", + "docs/measurements/h264-rounds/bundle6/diagnosis/run1/stat.jsonl.gz": "ade0cf68834976e496650d606a0ceedebf424d7f7c02066b276c3647e79c750f", + "docs/measurements/h264-rounds/bundle6/diagnosis/run1/topdown.jsonl.gz": "b8a03baf6006a0704bb3389cd12213208ee217937a2bf649bfa2829d536bf987", + "docs/measurements/h264-rounds/bundle6/diagnosis/run2/cg.sh": "b913b3b3a6a18c393557908a624f0ef7245f10a0502bbd9812930e3fe0d4e112", + "docs/measurements/h264-rounds/bundle6/diagnosis/run2/counters.txt": "4577c90c1c0aaa38a90427d529b5a1e8a3d5f6ab22ece01a96b40dcab94cd999", + "docs/measurements/h264-rounds/bundle6/diagnosis/run2/host.txt": "fa4d5f84c82213027c686bde8a87ad95f9b4023d636f538587fa2991c8439d8f", + "docs/measurements/h264-rounds/bundle6/diagnosis/run2/instance.json": "5a79a204c5f47a175cb488ce15334260b9f7b60b19bee08df6a876d5737aaf13", + "docs/measurements/h264-rounds/bundle6/diagnosis/run2/job.sh": "3323d56dd591161b33eba633db3abb751a7705838ae59b9f2ba9485acbc731c9", + "docs/measurements/h264-rounds/bundle6/diagnosis/run2/progress.txt": "3ae300721294aec324b4c03398d809e3a078dccf63bec964996aa04439da2187", + "docs/measurements/h264-rounds/bundle6/diagnosis/run2/run.py": "08f92a97d85558e4cca6893f20ece8dca29e49fd4087944b06ce486bdeb3e246", + "docs/measurements/h264-rounds/bundle6/diagnosis/run2/stat.jsonl.gz": "69f406e7f0dbbcf06bfb6339dd81362db89b76427260d66d426cf9075e1648f7", + "docs/measurements/h264-rounds/bundle6/gating/README.md": "39298378732cac4e98c4800f4ac7767cdbcf1b94c90c8b5399ab03217b6386b7", + "docs/measurements/h264-rounds/bundle6/gating/analysis-1t.txt": "b4404e5975b805a7ade56d830574f9d6104e7b58115edb107ae416d601b3e2b2", + "docs/measurements/h264-rounds/bundle6/gating/analysis-8t-heldout.txt": "7e8235a44457c41dde3dc96d89e932e29239f0de54bd74c912c3a8050bc4530c", + "docs/measurements/h264-rounds/bundle6/gating/analysis-8t.txt": "3f8a87d212957230efd4ce20de3cb5ba4dad6d94e119ced3785b475591b5b418", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/freq.json": "8bd0456251a38a3ac5e53df83b4c37c8a962b6cb5d59b00f356e192bd153e30d", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/g.1080p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/g.1080p.json": "fd62ec95372555cbfba6e2f2aae2e44e8986dd082706b355ab605accea950970", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/g.1080p.log": "5f20af47df96aa218ce7405b62c53c01486d982ea7826085173aa4fb9cf3311d", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/g.4k.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/g.4k.json": "686f52d213fd5762b75ed34853f23246ed1159252fb1870155540d43f239ba02", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/g.4k.log": "db09ffbf24749561706c524fcdfb7b7caa3c0a56fa3133a8f2441795e1e5b6b8", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/g.720p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/g.720p.json": "0e29c385eaed847bb65eb2af62cd0b723f2831e588c0041b827818a4ded5cd35", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/g.720p.log": "44094380f5bb32283970c20cba4195f7620a24b27ae3dda3df96a34019e69a82", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/g.sd.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/g.sd.json": "d81fa163025b00aef5f736ac40dbbd3f82e7f84b3c159cbd4cd06648bd25e016", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/g.sd.log": "f0cccc0aa54ff8a86d24ade5d777c82484ea0f2dd6a51760aa7488613e4236cc", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/gate-checks.log": "75c2a6c7de9d863a79ff3c44a331f7b7fa0ce5316f57328facde56371229eb39", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/gate-refs.json": "706a2a1c37d1d9d7abb2149f3a34726ae8eb3fe685c14fbe3bc6e907180db584", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/host.txt": "91ba5564e5a7abc3e5b003d1e153536aa58b6d2acc47bdc989ad9ee8113a4273", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/instance.json": "55dc358b510d5b9fdf86a0c2eb5b29534c986e8bc63a0a578a661e1df47bb9ce", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/job.sh": "23dedf8ccbfcc8e2a467b516f2a9b4defbc49ba3a9481f5360b7b9dd4fec0166", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/perf-install.log": "f177cff32b4350f64dcb6772444dbebc41f1429d2afbc07a3e53edbc1e85aa33", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/progress.txt": "70bda8be1384f345de741f7b4fc47e6f3ade88a82d6ec52bbbffc1495da02cc9", + "docs/measurements/h264-rounds/bundle6/gating/gcp-1t/verdict.json": "a406515971321016b78a24b6127d42acd2a247af92f1db10883b88b0368472df", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/host.txt": "46324d057a9eb3543990ccf5a8ad17f5427d50e4763ddfdaa33fd1eb4c3c1809", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/instance.json": "f97896bf30c18f8ad89081a9b0a21d31802a69d7bcf157eba40e99e96707a298", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/job.sh": "aed34b4fca58d247dcd2681de53d6b5545ac6653bb4bc9182c664e56420c37d4", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/progress.txt": "ea439b969937fac5f18b1885f5e5f8430e1aedb1f5cf706a657958776ec63ff0", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/ref.json": "6c1687cf63326074f7cf076427d4f933f9df0eabc6c9f1864b178c3590f5a05e", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/t8.1080p.json": "c32e00f323f6d685c45d088d831628274df5187a2fcc47dde52d37320f8ff94e", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/t8.1080p.log": "e0b841edccb5d7cc3291a5ec8e626ab106eddccdf9ecd8d47566659b3cfecaaa", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/t8.4k.json": "7006fe6ba447b53de06eea15f3297cb76fc45f713b8d9fd2dcd5b17cd76b0740", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/t8.4k.log": "064a73121c825d4119472d49e738e0aae5470021923d6d0cb60fc9c4bc8d2591", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/t8.720p.json": "6ca37833e443460d2ace790c68ee7a9e8f13897b4f3e68db4fc7537ec967181f", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/t8.720p.log": "b1e0923a0e0b9e0ce7d524b064074a25ed505266101bc99fbbeea48195c51b54", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/t8.sd.json": "931afe5e6525b14406029fa1bcf52f0d9bb9dbce671640d006da2df1be0bc85e", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/t8.sd.log": "25734f5a4c75f9679f8f91bcd57281d820b51b2eecc293164d270889839e13de", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t-heldout/verdict.json": "8dca7700bb2f1602b79355733dc8368d1b31b808cf00b1be932d451faf14434a", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/host.txt": "c7eea61836ee618c768a945225f93a2ca0f84b6b5e007263b22e6559c4720879", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/instance.json": "f97896bf30c18f8ad89081a9b0a21d31802a69d7bcf157eba40e99e96707a298", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/job.sh": "83edce289d8a12f20c4994403576a58eccede5381bf02515b37174c415d202bc", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/progress.txt": "86713d43a8bfc5573875a2829ab8496c4e55bc392270dbc41eda83627d499b4c", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/ref.json": "bfed6585dd01993e2422de9c63f665e6975f9e0417aebc4bf5776bb93ff0aa2c", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/t8.1080p.json": "a3f69542660cef3c372892b09953e55e1c3f21ceffcefd1d8c2808c767d96275", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/t8.1080p.log": "64f92e11a24685a952839f1b3f3f01b00e84d801a7552a814aae6fcd03b87db5", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/t8.4k.json": "b1e01952d29087b2a2e43794c0aa90bc444c5eb9521bbbff7dc9b494938259c3", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/t8.4k.log": "5cc99e8ff55918b238d51531e18762f37c54ce814cb5910d5d82ab1bb3959f0f", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/t8.720p.json": "677661b1b09fd9d6c7155e4f89fecceb1f89f309ae5c7b77d15db66044619628", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/t8.720p.log": "c680b1ed01cb96bf4d730534a73cf8be603af5022dffbaec3f5c2c3b247484ad", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/t8.sd.json": "24ace6c863a9c1ae15383a74d78800ad3b7b4a0a809ad7e7c87bb4d2f77465be", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/t8.sd.log": "76793b715a1a4375da5450867f37df876ee1c4f1b0ff232205f4c83e112317a4", + "docs/measurements/h264-rounds/bundle6/gating/gcp-8t/verdict.json": "19eebb35a58415e4ad6b7bbabcd6ab757d841ced8cf64c27081705c8dae51e7f", + "docs/measurements/h264-rounds/bundle6/identity-host.txt": "10e885de847a8b4388245eac208e2448ceae10b5a074db221b72d8888a14a3c7", + "docs/measurements/h264-rounds/bundle6/identity-job/ident.sh": "1697eefcba5f38021e27ab2e7df218fc938e74d90414f2a70d03b4edd39776ad", + "docs/measurements/h264-rounds/bundle6/identity-job/job.sh": "a5f405c0b9de0eefb6c2e73fb39b7d9b63bad64e5cf6ad54fcdd2fc78b7c9115", + "docs/measurements/h264-rounds/bundle6/identity-summary.txt": "269936df45bbf8617210d3d25de68bd3797f6fbf9075ea1726b217760c59f789", + "docs/measurements/h264-rounds/bundle6/identity.txt": "3f1f3e295e6d9a73d37ab7976a339c4aa60457669111d2a6adccbe269af9fe08", + "docs/measurements/h264-rounds/bundle6/instructions.txt": "3c7ed5c71e12f24c06ab016c03f76aedc48df7d4a32b5c1e901811fe9a94982c", + "docs/measurements/h264-rounds/cabac-compact/README.md": "b7be43c0e6b6e024a38976994b4550cc2970dd28e35eca52a5189f5464130c93", + "docs/measurements/h264-rounds/cabac-compact/ab.jsonl": "14b611b0ec79b897a77da1c063233411f8e9ae5e60f63b4cb698f22f92e07b27", + "docs/measurements/h264-rounds/cabac-compact/ab.txt": "20eb23d244efaa5920454d0d04254766b8b0c0882f1af137d7bb1b4cc70ab1ef", + "docs/measurements/h264-rounds/cabac-compact/an2.py": "f549295ba9396956d2b2e6169d16363e330e2de23bc83c3d5894aa4b61c139e7", + "docs/measurements/h264-rounds/cabac-compact/cachegrind.txt": "78282fb125e30ab8e1eb3d089d8562bb1317537380b8ead186aec408912974b9", + "docs/measurements/h264-rounds/cabac-compact/groups.py": "347d5e0561ecda8206a09be1c180b2d562cba238a949f0139e4464c012eeb601", + "docs/measurements/h264-rounds/cabac-compact/identity.txt": "8fe8572d389bf5a1c233655099d01c9c19ae245291576ba26ef05a0293a7639a", + "docs/measurements/h264-rounds/cabac-compact/lines.py": "ad54782b751da2226e2d04fd31c234f09c42e2d67c2a5dde04603db908aff155", + "docs/measurements/h264-rounds/cabac-compact/lines.txt": "b617a1a2fc66159fce96d10bf161f6c1d2a0f4e7e68283c5cfd3204c06feb184", + "docs/measurements/h264-rounds/cabac-decision-asm/README.md": "c2f3627f46c2b4e1c4aeab45f8de9b468f755e4222deb06234e681519a5e8b3a", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/host.txt": "78cc22c82726fdb3b8de638a3fd7a3e090dc3fe09c3f0a690d770567335676cb", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/job.sh": "06ad38fac2cdcb7c99e734a6403d7603d13fc8621da14db2157cfd318ed21b3e", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/job.status": "ca2ebdf97d7469496b1f4b78958f9dc8447efdcb623953fee7b6996b762f6fff", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/progress.txt": "fb2f89bbbaa7747774086999416fd4a505b2542bca379d1502cdfe149b544583", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/ref.json": "c0830db2b3f45d829ad8052c158898a05c3942551e7fd6627998ef5d06df4c78", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/t8.1080p.json": "8e1f187a19f567391c08745971ee3e461873f0541c430f551af1eda45cee2d22", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/t8.1080p.log": "d36d178036dfafedd75ce8b26dd9801945dd1035e15ba3d743c80dff9eea3283", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/t8.4k.log": "5063cb7791cbdd781bb5bdc741fb1393429b6ea46b5b7b020ff92ecf15b5fd8f", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/t8.720p.json": "8ec40484bf947173d9e07b4f0f7da128c355271a3b7d44858907c14208edcb35", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/t8.720p.log": "ae6aa24b674d8be08291f3aec96da97cc7f7da1d9881049b60df92ef0eb06bcd", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/t8.sd.json": "dcfc3011a6dd574b07d24562bf7dcf38b8365add19c82b69143c1f03a8ff51ee", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/t8.sd.log": "22fc518f48672c4458a561ecfd05fe37310db6f60e8ffccf94e26228342f05b0", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp-void1/verdict.json": "2b3c4734a359df497224e84f3082559d29f043668a2d14d01d126459ce3c0ffb", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/host.txt": "53865ed980f948223093dd087c0deb9dcf7754d875afea590a7fbca2c5f28657", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/job.sh": "06ad38fac2cdcb7c99e734a6403d7603d13fc8621da14db2157cfd318ed21b3e", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/progress.txt": "70c2ab0ead435a60d82fcc634593bcf124494c74b003e3d3c50f65452395a76d", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/ref.json": "02e4b4d32d345753b38aa78e767d62a62e1007e12fac81d4538567257714d732", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/t8.1080p.json": "65b170cac835fc1d9109a6b27913dbcf8f07f4d60c50ba415e929abbc921b0d4", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/t8.1080p.log": "3efb003a8288715782a6f2bbf645ae6e79801d57c6bb754b5a2af471afd0637e", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/t8.4k.json": "ff7c472e90a3baff3a2ea90985125a1df1675ab177f5bd29a1578836ea4f4cfd", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/t8.4k.log": "042c85e7b42010d6326b3f7e6d31c01c4cb1a8391b1547fa57026aa21b069bb5", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/t8.720p.json": "12f61d8b389a6c2a1f05233c719c2cf82a7aee729aac70af606cee3b5747d04e", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/t8.720p.log": "0b11048f0b486c469c4376bf72b71de9c018a246e09e081e4c55f116a83d9e86", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/t8.sd.json": "adf4e19f6877cc4a1a1ff78abade7b685bcc7f2dc3292c72aa8efa384b2b17e1", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/t8.sd.log": "78c028839835ea32edf9ecb2b6bcd11dbb5f6ae400da7b6a56bb7a2fb97865f0", + "docs/measurements/h264-rounds/cabac-decision-asm/gating-gcp/verdict.json": "a717b1bd6e8bf1faa95397c2997aa448f6d689172821042aa8b864ece7b12035", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/analysis.txt": "cb13fbe3a4b50c3b2e4284222aa48cc8977840ccbac16586664be8fd890538e4", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/analyze.py": "b81f01e5a7c45017ccc2454a21d8b279883bfc11ea74bf6434107d905c84dbf1", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/binaries.sha256": "3e82dc0a663dbf230101d26cc8af20407a980c26824d1c97eb86ffd98a581a4b", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/g.1080p.json": "51135466c1fdc770ca8b3f5044f6e522f7b466e9f8c6c30158556877f614388b", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/g.1080p.log": "4f931ba168d5f26a290201b83004d96ce60d341ddb61f5ccd51d36ad0abe7e55", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/g.1080p.log.killed-by-restart": "c28c9ba9f7ab369224df6767e59cd01a57a4d471ffffc5ef3c257a7821a0160a", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/g.4k.json": "e97e02eb3d275f8ce92a7406da9ecc52b2488bdef61760d5fff91894c7ba7c0e", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/g.4k.log": "808373293a8cad0c135edea1db10fcc332cf04bb7d01cb7e08681d3ff6d71121", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/g.720p.json": "ee2cd0d078cc4aceab64aab9f20b4b95e844ab1db6121ac86e31c7333b78b4f0", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/g.720p.log": "4fcd71edee5912a7081460c6ae7fefe955a124093610168b3977d23e3e26583f", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/g.sd.json": "7c09acb652d5a525dd060d4bb7b2a14c02e3539ca7b05182adbe2185d43746e1", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/g.sd.log": "bd2fa006e7630c8727ecf3b365f2954fe9a5dbbd17fcd8591d6a58d39704a94d", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/h.1080p.json": "53efba260fadbdd1fc77d1ee5e021667491b8bb3df44ca516e7289ce7fd82708", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/h.1080p.log": "166974b93585fa09ad3ef283bf165f866d2c07db090b973bd925c0855091f476", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/h.4k.json": "ef839dee08dcd14f101c03997049bc200c868d21e88a783ca7e0e6f53d12a8df", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/h.4k.log": "1d8b942460e5d74685c6b41f9f703081159d8f3217929a1dfd44665a27729dca", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/h.720p.json": "123922c35e68a90d64cf3dd689c22bcd6f71c2cf6acbc19407b00d7970313c1f", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/h.720p.log": "67eeffbcf2f5c3f785e4c5a2df553a51e8318413c61783a0d2d3df3a5d3ba9e4", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/h.sd.json": "e03d727e206ad8a964a4a742b1a634f1dfbcc80578c77546bf492c6cfebacc1d", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/h.sd.log": "1d8cac0b495b5c9dc7717302dcbfa4af7f54a5c7cb0878e8b033dafb81d6eac3", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/hostgate.log": "32f568eb93f5be83fbd691aef45f673e6271dd4aa7f4c5c6e822a18d426494a1", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/identity.txt": "859e17e5923e2e0719c658ccf405c14f23201e19d3ef6d21d2226c9b93edf8b3", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/progress.txt": "dfa430a08970b87bc320be8f8692f520f5e6b8d83404aeff50d4b1199b36f16e", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/provenance.txt": "d1a42573ff40a4dae55652cf7a0b7c6cda8038bf1359fe1e578877c47e328521", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/run-1t.sh": "c676119fdc654a0bf178c5a7e4b7fbecbabacf9b7a466bca273320049a2e943d", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/summary.json": "19c9a1e5cd490e8a645a03436a663309ab0a05b375e4326948109ed1a8659ef7", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/t8.1080p.json": "65b170cac835fc1d9109a6b27913dbcf8f07f4d60c50ba415e929abbc921b0d4", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/t8.4k.json": "ff7c472e90a3baff3a2ea90985125a1df1675ab177f5bd29a1578836ea4f4cfd", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/t8.720p.json": "12f61d8b389a6c2a1f05233c719c2cf82a7aee729aac70af606cee3b5747d04e", + "docs/measurements/h264-rounds/cabac-decision-asm/gating/t8.sd.json": "adf4e19f6877cc4a1a1ff78abade7b685bcc7f2dc3292c72aa8efa384b2b17e1", + "docs/measurements/h264-rounds/cabac-decision-asm/merge-identity.txt": "cb0a06dc46b649c9a3ae1696c52b7ebf3a639d9c27ca1a183cf6c658d9c69c2b", + "docs/measurements/h264-rounds/cabac-decision-probe/README.md": "c5fa41db0cf71e806710bdc22d62ab4b94977b2e9d0ff7cdc06611dfa2bbc3eb", + "docs/measurements/h264-rounds/cabac-decision-probe/ab-c-summary.txt": "77a74b1eff9135a78f329b067395c49934d003bf4d228e26a16da92e04982397", + "docs/measurements/h264-rounds/cabac-decision-probe/ab-c.txt": "f198a52a548a1a0a11430a8879e47cf7402214c5995608d1ee2b97c3d4181564", + "docs/measurements/h264-rounds/cabac-decision-probe/ab-probe-summary.txt": "02c0ecb47026c6a487d349feea1dda26e22eddfb49020361b2b0debfc4705f76", + "docs/measurements/h264-rounds/cabac-decision-probe/ab-probe.txt": "c2a896193852cf880eb0969ab4fc6475abb718af33400b1a44c2b4a6a48fb810", + "docs/measurements/h264-rounds/cabac-decision-probe/ab3.py": "ddb3d0c20a74b603ed261654a08b6f92ac5ac04c7fdb1e8bc360cf8acca21247", + "docs/measurements/h264-rounds/cabac-decision-probe/abcls.py": "c37aa727c3bef34b695340c15fa69634ba956674323108ce942dcbc22e9b1b79", + "docs/measurements/h264-rounds/cabac-decision-probe/abq.py": "978032f511d6e115d8e586e26153990c107f109529a264af5f9b9c253393fedf", + "docs/measurements/h264-rounds/cabac-decision-probe/binaries.sha256": "5087051bc306c29033a30a3c179c476b48736ce6390c6a938c92c3812c857907", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins.py": "be850953f4fd46f01c55bb9b85ba0d8430e05ec5ab30c0724d4f30cb5d6bcc8f", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins.txt": "f960484646c77d8ccae09a49184ac041e3a92359a2e684490a56a0584f5fd494", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/175433794e02.txt": "fc4210d8098c573436e5cebbdbdd420d2a5b203132c03436dd11386673d62a4c", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/1d4b1775d78a.txt": "b9a69858008b09ff6336aa881cb319023352981dd3409067788a9b3aa16b106d", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/278dbf5a63bb.txt": "08f92703e9af8f5d9785a679f075e7105f4305a065e813155ad13278d6a3848d", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/36501d448eaa.txt": "8339c7225f37c57aa3239d056831cdac3f4f8ef4330469e07865158c6d19a140", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/3b1b441e23ae.txt": "2dbf6c59c56fbdd21cfe326a06542252197cced0714dcb13c8cc60fe36b46a4d", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/3c593b8f0809.txt": "6eef09616c1b47dacf2c0e5c938045a250cc152631e44539c2695af3ff7bb5d8", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/41e324ebb708.txt": "79cfa8ba98efe4fc59ce648a2d0faa0021c24834aa493dfa03e4fad7a168bef8", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/4b54de28c2b3.txt": "9b6a19a8fef9ccf98a43595a43e08beb1fff7bad948ca81d81ebd456eabe4340", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/5185721dda11.txt": "6cc78c40b75dcaf89db4e2c7a6c381a10fa2ab79a07ae696b51681989ec42159", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/65ec61f95a00.txt": "8dd79119bd52f41d7fdafa80b067850a297de62907de7e8fe6f11922dd3f7b3a", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/6b18d9f0f88d.txt": "ec054a75f43024c900b553f5c8f11225c6d3fe53425d2df4204157f62f055a95", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/6da34958296c.txt": "708e1ba327abf1402ea79a8798539a9089bed9dc4596e53c24435ba17be7d149", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/6e90422a670a.txt": "aceb0817b8574dcc1e6a01af7f14ed95af0d2d25efc292e3d95473bd6739a464", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/6f7799768413.txt": "6cc78c40b75dcaf89db4e2c7a6c381a10fa2ab79a07ae696b51681989ec42159", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/7650ae466748.txt": "ab5440215111a0eed1a60341f7428397f020556ed0bdcabf43b8403bd7e26272", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/76e0b1692494.txt": "ef12624f7b86d2937e8d5d8e8f858de88f68a3e17ce2a027769a925a91941de0", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/81ed4778ece2.txt": "1c5331faa5e56d7d5a44344df808ec1b86b0d59b21e1e4417abcfc12c96316f6", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/8ae90cadb5bc.txt": "13b707cbb12b20168165c97593fcd5b3cabbd14f91ec3f4f6f61d315e3f342fb", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/9db41aa16b5a.txt": "6cc78c40b75dcaf89db4e2c7a6c381a10fa2ab79a07ae696b51681989ec42159", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/a6af290d9053.txt": "f14753200ecebb7e79ab96aca7207cce5703dbb85e6b82570fd8a49d2ffd74c5", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/a81de82106be.txt": "d2470d3240fae17c26238c2cd723dad5c012efeabedf11113e2b66b865b982b6", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/ae16bb7c7192.txt": "a8c0164bfa51442f260bdb6ec81b948d55fd762b7cd8df8e2d89c7753428dc64", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/af38b0cfd840.txt": "0d6880069cb4efd8d078cf35c46073e53d02f5d184501719291f152deba1e275", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/b41f70a7fa60.txt": "b07782c0a4d696acd2756b1e2f396205e243d7f744ee87f6b124936094a51ea5", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/b71b6b31e54f.txt": "6cc78c40b75dcaf89db4e2c7a6c381a10fa2ab79a07ae696b51681989ec42159", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/c7ecda16e4a7.txt": "6e6d791bcf53ab8b1bf7c5d5b77c82f1a6aaaa97ed5436abe30d3114c8706897", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/dcb262cf0138.txt": "179e117dd3d2bd729359b6d2985ad931629b265c9e109a1868affb184c3a1d51", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/e624cbe0d2be.txt": "b18be6761a78542fa07582130b4b4ef9293f6b434c1820bc48db66d049d8667e", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/ec473c99c538.txt": "6cc78c40b75dcaf89db4e2c7a6c381a10fa2ab79a07ae696b51681989ec42159", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/ed75c044e944.txt": "8b457780a3dbf7c8867dfbf76e542b81f4652be8410d1029a5de30b6bd15ccce", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/f8d92a911e72.txt": "097d7152d8e9c05b057ebef2f017d1f249a7936f302a9e6c3455ba9d80e0f725", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/bins/f9e973f44570.txt": "6cc78c40b75dcaf89db4e2c7a6c381a10fa2ab79a07ae696b51681989ec42159", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/byfn_pmu.py": "aba562aa99a0f0786ef0c352cdaacd9a9db8057812f07bfa53175011663fbb61", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/cg_core.py": "7f3a1786e58322cc026496ab9eb9d9cec0286f02782e4b8f6039931090ae4e34", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/cg_ff.py": "fcf6fbba02e4849c98c3bd7492b02cb7cc0111c36d78d0b5e6b2fa3d83315d7a", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/cgparse.py": "850a0061608f0cfe8a4ddbcc3f2bb71b17b0657100d604fcbf41669b3de049ab", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/count-bins.diff": "44a964ca52913d65c6c1c4a7a14c1847b859fa0f03ec2e4232ac42da612d9287", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/final.py": "1f740a2c1dcb0fa7a9a3283749183c7ff26e2d8496792f82955a1c8bbdc71726", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/final.txt": "ebe1531dc421ce9581231eb00905aad52c5daa8574d59380cacdd116441b6e97", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/fnlist.py": "68c359f0cfacd1c8f58ff7b6e11096f61945ac16da1586aefe534d18f518e68e", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/fnlist.txt": "ec7f118131bd7bd96b4b1da3748a6972ab6f01648a97bb05020c9214dbfa74a2", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/mbcount.py": "0c308cdf9678020980584a376f3b1b7c2a9bece1ec9d12016b7269f3b3be8c01", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/mbs.json": "dbdc844277c30211166356ded50166287eaff2b54eaa356c4dca9281829840f6", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/pmu-byfn.txt": "a2dea9d9e62418b42cf2ea02ecdebc8b54417bc78dc453de20b411bd00f7448a", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/report.py": "c560ff283db2f56bb8d5f3c45f405775c27b44cd7baf8c966089fb744208ad7f", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/run_cg.sh": "12004aefcb27f4d124ec23e19961a0f5963ae92bb8dcf1290ae6c8b8302eb9cf", + "docs/measurements/h264-rounds/cabac-decision-probe/breakdown/sig.py": "63c372dd6d38f918b4571bafefcd0fc0532f34da233ae9cb782f09e17fc2aa55", + "docs/measurements/h264-rounds/cabac-decision-probe/decision-asm.txt": "5169c6d8286365fbde46c377302beaddbdbc685c7d5fa0145c917bf38357d10b", + "docs/measurements/h264-rounds/cabac-decision-probe/plan.txt": "e0fbf34154fab58c9770711fcd0450e7a1fee5fe1518b30a9fc0bc4e3a59c6ac", + "docs/measurements/h264-rounds/cabac-decision-probe/probe-pad.diff": "91e8a9893dc110e88b912ec8c1c25362697e20d8b078a57a36744e67275f2ccd", + "docs/measurements/h264-rounds/cabac-decision-probe/v2.diff": "5282750eeefd805a3c862a97324c5d5d51974ef95d9847ed705a1fedb20f3011", + "docs/measurements/h264-rounds/cabac-decision-probe/v6.diff": "331b2293710ac46d346e8e22b0dfbba47b48508037d811284c89917df3db0250", + "docs/measurements/h264-rounds/cabac-fast-local.md": "2c49ef676df5e8b9cdc41bcaf301ef0cfba084d60e4d05c8213a2398cad85191", + "docs/measurements/h264-rounds/cabac-mb-start/ab-summary.txt": "406528537dc273e07905a36def4aea4651ee7dea9b2b188eaa1918d85a138091", + "docs/measurements/h264-rounds/cabac-mb-start/ab.txt": "dabdef0cb30c31c0b72e7054b64b123c099d4abb0b3a25850357645c9e6236f5", + "docs/measurements/h264-rounds/cabac-mb-start/ab3.py": "8f0abb2a95718ed2ff5f6ada28f9cd811315bfdf9dda3d81cde00e9ed8678ab9", + "docs/measurements/h264-rounds/cabac-mb-start/abq.py": "e5b5b21561e34a3b474db71086d56ec30776dcb4d34268e989a8ae7305b14ebd", + "docs/measurements/h264-rounds/cabac-mb-start/binaries.sha256": "3be54db85178038db0850c028351c06668bf78c094029f0f8280ea069841df6f", + "docs/measurements/h264-rounds/cabac-mb-start/conformance.txt": "6c344cc7de3d334db150209b44f228d30043b19d37893d0728596046371acfd1", + "docs/measurements/h264-rounds/cabac-mb-start/gating/README.md": "e1861411371e0dc91e96ea56e37d41b0d3f74a92e40fe8af38f61574be2fa552", + "docs/measurements/h264-rounds/cabac-mb-start/identity.txt": "54d7ba671ce917956ba92d52c9d9fdfa0af6618300b40c97d5238608e1eec4d9", + "docs/measurements/h264-rounds/cabac-mb-start/plan.txt": "6a0f0412e49d7d46766b7ed1529a59cebaaad2b3578ef9e3e26a0d08227bb693", + "docs/measurements/h264-rounds/cabac-mb-start/probe-counts.txt": "7827743a821175283f7724b66990723f481d7b76f7b0c64d258d6e4b58ae6573", + "docs/measurements/h264-rounds/cabac-mb-start/r-count.txt": "8aa9adbd7cf72788fd6739b4ee27cbf85c722a57c6710d9d61f6e2e46e98960f", + "docs/measurements/h264-rounds/cabac-precheck/README.md": "4c1e3a74520e537b45d8aea8a23654118c5014afe65954498d4af296d84716cb", + "docs/measurements/h264-rounds/cabac-precheck/analysis.txt": "88524173b84b57545ba448842e97722fd00bb0e7737a1a6cc39daae1108a55cb", + "docs/measurements/h264-rounds/cabac-precheck/analyze.py": "a045c7af95bc0e42d47643d8c5855a2100873c1a43a61929affb8e3d42b5638f", + "docs/measurements/h264-rounds/cabac-precheck/binaries.sha256": "3ba7f576959429fd03ffbc49452d51cc1d396aeee016ab83c4e9d82bafcc603e", + "docs/measurements/h264-rounds/cabac-precheck/config.json": "36a8441419ed5e52eb0ad21b239ec5976299422a867fcea945e98132e17a8b48", + "docs/measurements/h264-rounds/cabac-precheck/events.json": "d5acefc781cfa9b1b0d111966d13c5e369a95bf6d046745ad45b55d2a707b356", + "docs/measurements/h264-rounds/cabac-precheck/g.1080p.json": "671372e8967948bbb4961de4f7f936a21e3e203a9b6434254179c110142d9c65", + "docs/measurements/h264-rounds/cabac-precheck/g.1080p.log": "12b8eb305bf8f794a008e6a913e0919eff6b25450993082f9681961d4cf7fa68", + "docs/measurements/h264-rounds/cabac-precheck/g.4k.json": "efa28f6b3cc8a5a0a2bced0126e453891a99a04bef5d9070ddc3ca94b459d240", + "docs/measurements/h264-rounds/cabac-precheck/g.4k.json.void1": "cf257ca5d1bc823d41cb9189c145ddb20a702a7cdf5bd337ba878bc12fce7394", + "docs/measurements/h264-rounds/cabac-precheck/g.4k.log": "6326eacdbfa127d0007b6ae20ae01aa011524f02bda19ef68d957cae92acfbeb", + "docs/measurements/h264-rounds/cabac-precheck/g.4k.log.void1": "7e6cfcd342b7434666d6b298a541bd3c382f17bac3bb9d48840706561d166135", + "docs/measurements/h264-rounds/cabac-precheck/g.720p.json": "31388b35a69b55acebb6b2842aa2d543995fbf217aae7ac89e289d0cb583b6c6", + "docs/measurements/h264-rounds/cabac-precheck/g.720p.log": "867eaa0958c9a2dde63cbb2eb416f5e786af2319f8a2a2dc7589deb00ea5d8d3", + "docs/measurements/h264-rounds/cabac-precheck/g.sd.json": "48df5f3dbdb8afe3570142ab3aafc7b52a03003678ffd19a4f58dd08d3f96067", + "docs/measurements/h264-rounds/cabac-precheck/g.sd.log": "8b58c272ca51bf5d810b0e2a0f1d9d29fa1a436562d674abbc9eee1a26e718e1", + "docs/measurements/h264-rounds/cabac-precheck/identity.txt": "0414f5189b59dc80307b8dd24359525c75db9625dc37f01fc1f37b6a392b1cec", + "docs/measurements/h264-rounds/cabac-precheck/local/b1-shifts.txt": "7c81ff20f402eea27657ec48bc7681532c7b9a90718797b5b504d5d0282885ee", + "docs/measurements/h264-rounds/cabac-precheck/local/functions.txt": "cb814277401c35b855ed42e6369d8aff3a8ef0f1d9d546f9b1d5e98b4150ca92", + "docs/measurements/h264-rounds/cabac-precheck/local/sym-175433794e02.e1-b1.raw": "3aed058e34a6265370965dc6d59863c856c8a5844b0a1273f01abea3f2b5ca96", + "docs/measurements/h264-rounds/cabac-precheck/local/sym-175433794e02.prof-c17ae06.prof-c17ae06-bmi2.raw": "ab7270a0c0b9053e906cc5389e583f1e14b90563a49f8b0580672214ad0b5014", + "docs/measurements/h264-rounds/cabac-precheck/local/sym-1d4b1775d78a.prof-c17ae06.prof-c17ae06-bmi2.raw": "c3fd6366af10e5615716c287e734a18b5574b612b1af24cfa182da773a17d061", + "docs/measurements/h264-rounds/cabac-precheck/local/symdiff.sh": "c6febfe07201a149e91013df2c2bbb0ff3671a29d1087b1d97371134c673d4bc", + "docs/measurements/h264-rounds/cabac-precheck/local/symsum.py": "6035022cc384833cb2350bcf1e798ca4ff3d2fa1cb118f5f84e0e85da6db6dc1", + "docs/measurements/h264-rounds/cabac-precheck/log.txt": "6a9605feac2bc7b70ec3c1ad7673ae390d18e6acd6f95743eae3494701eaef0e", + "docs/measurements/h264-rounds/cabac-precheck/precheck-ratios.json": "674ea164b6d72b7d6b65f3122bc0504ea5b3d8e329405b52255ff09a69a5336a", + "docs/measurements/h264-rounds/cabac-registers/analyze.py": "e6e8fd997e58a0895841cec1cab330b3f9392f17edd60f6a6dfa680b67510e55", + "docs/measurements/h264-rounds/cabac-registers/exploration.txt": "4621531c8ff9a24ac2ae35bd7a1b07e9ac0761c485720ad6a8042a7e0109ec2b", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/analysis.txt": "900a4803361fd411e30ccc3b6f3a01f2fce7407f794d758f37a8aee38520f781", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/cpu.txt": "61fe37b48cba45208c91b5973e3b6c2e9b59861ab2b8bd51effff835ff0add55", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/g.1080p.json": "74fb5cc429836302f7867e17f45c69a418e8f98ce4de4bb618f7afa51d463c1c", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/g.1080p.log": "ef6d5d9762d008ce7e3f13a289d51526a6f6b77f51bebaed33bbb8a45135594b", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/g.4k.json": "5554859278325add4a39c11f6bcc4f595fc15f2feee892a231740df3723731cd", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/g.4k.log": "43d171e6ac8b08fdfe61b6abed12767b7d6162f739a02c866e9715b98c98a77c", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/g.720p.json": "dbe9de1bde74105af7c3b2bf372bf6f2284f764617185462765c4ea803a43975", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/g.720p.log": "d37940e5b7ad9c840c71684696cbc4e4dd5dc12a1adf312d483bee2ba08e2605", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/g.sd.json": "6c9a657634d602d4f0a0166b653d3ca365a4edd670ddaf57b620677b0cdfbaf2", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/g.sd.log": "9617aabd7408ee6780cb8792e147cde7f6616d825e02eb0ef9ca726ba34dccd7", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/g.summary.json": "5deea99a569aa93b91dd6681394c58ad9acc8f932dff8670fd15be3ead67ed5d", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/identity.txt": "7460eee1891da14df5312a33fef7413001d19fd6327e80ee1b46a62ec0d96da4", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/log.txt": "e66f1d9862f24ce654f60a6b5c6adea7a79060a4e81b80ee1caafcc7bd93b425", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/provenance.txt": "e3c1d7e613b37c86c25ea53aa354907b8c346c3970c7435acbc2f0e7abd18fe5", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/reference.json": "07ef733bb711d19c74a4167b0efa6cb53e17e57ce299642f5f9ec0fe235aaa04", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/sources.txt": "352a4efc9cc81af0d555b9c1414075c8eefa2818c056fd5b01d8c01ec5b44a18", + "docs/measurements/h264-rounds/cabac-registers/gating-zen4/stdout.txt": "f6454afc0f0bfb15cd120d44a2f03a3397bf6250a369ccde628b2c21acb19bbc", + "docs/measurements/h264-rounds/cabac-registers/gating/analysis.txt": "8493ae4327b9b5f08806c85afdd9984cefc3b3af7542e29f5537f196aaf47a44", + "docs/measurements/h264-rounds/cabac-registers/gating/attempts.txt": "29229d47baff1bb2cda29887880579d950c4e04651676dd15db20e5358fd5733", + "docs/measurements/h264-rounds/cabac-registers/gating/cpu.txt": "1f4d3f82deb3eabae423d5d56236e8129866d6a09606f725f846c843ff491180", + "docs/measurements/h264-rounds/cabac-registers/gating/g.1080p.json": "5dccfcc9af3912b0cac8cf3218913a8c7ce3e8f70497a41cf45d2cb77988105b", + "docs/measurements/h264-rounds/cabac-registers/gating/g.1080p.log": "3099f4c37039fb73d33efacfc8fbedb1dc8e57b10911c2d031238a3c9435b313", + "docs/measurements/h264-rounds/cabac-registers/gating/g.4k.json": "5b2b2decff6da3498e7b48c1eaae029362b991add5e4e0c0e2d6983f199979c1", + "docs/measurements/h264-rounds/cabac-registers/gating/g.4k.log": "ab905ab288485c198e431f6ba635bd5264d46ef8af5c21c2e3108f397eadfc46", + "docs/measurements/h264-rounds/cabac-registers/gating/g.720p.json": "84dbf7a20a3ec86688536efd6b242550c6bfb6bdcd1cb2d85a35483b8ee67c7a", + "docs/measurements/h264-rounds/cabac-registers/gating/g.720p.json.void1": "4985da979947eb4ba03057aedcb5dc7965edaa774ba4e1c030d01d7fcecef91a", + "docs/measurements/h264-rounds/cabac-registers/gating/g.720p.log": "9f74eef208c43d4dc5032a6e900c4d380745750ce126ef8fec16075668f100a8", + "docs/measurements/h264-rounds/cabac-registers/gating/g.720p.log.void1": "07faebf40ec99a60dc4f12ae51716944a2e9eab4d3542dc18df75dc03436772b", + "docs/measurements/h264-rounds/cabac-registers/gating/g.sd.json": "f7ae86ad658b3283d4f79eeda9eec06dd852c8e5b111d8718a817a78e0b1fcbf", + "docs/measurements/h264-rounds/cabac-registers/gating/g.sd.log": "6df81be802bd68db6dfe1324ff44a3dade7e2389d5b17d43bc1f96598882b4f8", + "docs/measurements/h264-rounds/cabac-registers/gating/g.summary.json": "5e6e002706257645d834e202bb0fa445ec18700f6a998182be275a955ee2dee1", + "docs/measurements/h264-rounds/cabac-registers/gating/identity.txt": "7460eee1891da14df5312a33fef7413001d19fd6327e80ee1b46a62ec0d96da4", + "docs/measurements/h264-rounds/cabac-registers/gating/log.txt": "4f6066e62da2fb57748e12c04a08105eb66beabfe8173ac37d0feba4f1db3bdb", + "docs/measurements/h264-rounds/cabac-registers/gating/provenance.txt": "e3c1d7e613b37c86c25ea53aa354907b8c346c3970c7435acbc2f0e7abd18fe5", + "docs/measurements/h264-rounds/cabac-registers/gating/reference.json": "b2ee8f1505059558af1fe00466981c478a7619d949f4235b227f411d5b14139a", + "docs/measurements/h264-rounds/cabac-registers/gating/sources.txt": "3a4343159b60695539dfaf1b30ce579a099682e182d4c7dc6b0054af57a601e2", + "docs/measurements/h264-rounds/cabac-registers/gating/stdout.txt": "b90341e4186958bd29031ed4595b23e0278b094685ada51baa315543cb585294", + "docs/measurements/h264-rounds/cabac-registers/instructions.txt": "87c1605b1491688b8a6c8f1de0781fb77b3cc7115876593849486d34f2ae0784", + "docs/measurements/h264-rounds/cabac-registers/intel-4k/README.md": "28ccbc5e1a889d30471cc502a2ae05aeee092ea6006e2629f2cc79a8328857d3", + "docs/measurements/h264-rounds/cabac-registers/intel-4k/g.4k.json": "d91bb7df9867bc041809bb50bb881d9940bee862345067cda53054a9a0d7eb55", + "docs/measurements/h264-rounds/cabac-registers/intel-4k/g.4k.log": "a61d1bdcb94978b7538462f46fc58ea1962d55a42b34d51a11203070589c2aca", + "docs/measurements/h264-rounds/cabac-registers/intel-4k/provenance.txt": "97527dc37e9943cf101a26f233a709241aafb5d6e7f923c9018f4d86373c8ab2", + "docs/measurements/h264-rounds/cabac-registers/run-ab-helper.sh": "95762d4c519e338c2cae17c2a0f3e1a250f594ac275036adc02a54ef02757717", + "docs/measurements/h264-rounds/cavlc-block-probe/README.md": "9d9bd96d862c841e38c3f65d35d72a254110c399739f22e897e8a053f76e295f", + "docs/measurements/h264-rounds/cavlc-block-probe/ab-summary.txt": "c8c549a353f3eeaba919966c5cdfe2b45186ddf885e20fd2db9053468febbcef", + "docs/measurements/h264-rounds/cavlc-block-probe/ab.txt": "44f1e9eaa8c5f9a044e40babab718624afdad151be4c6c005e0aae44904b0c30", + "docs/measurements/h264-rounds/cavlc-block-probe/ab3.py": "8f0abb2a95718ed2ff5f6ada28f9cd811315bfdf9dda3d81cde00e9ed8678ab9", + "docs/measurements/h264-rounds/cavlc-block-probe/abq.py": "978032f511d6e115d8e586e26153990c107f109529a264af5f9b9c253393fedf", + "docs/measurements/h264-rounds/cavlc-block-probe/binaries.sha256": "c2abd22cdc52138f1962c8648b295bc2ec0817a8a4b3a50ba1778a854eee816a", + "docs/measurements/h264-rounds/cavlc-block-probe/c-ab-summary.txt": "480666d121f48f574a083c514430e560af8f3821fe6bc49c8abac044db79d66f", + "docs/measurements/h264-rounds/cavlc-block-probe/c-ab.txt": "aca2462e7d065e2b7d96eb85010719b6228c265eb5042f41a2be01ab80240695", + "docs/measurements/h264-rounds/cavlc-block-probe/c-conformance.txt": "d8c6cf0dde8f1c6338372dae0c8409d17388536c8e120677c267d0af05ec70e9", + "docs/measurements/h264-rounds/cavlc-block-probe/c-count.txt": "436bb63c0ffc449744aa90519d7c87f4cfd88b4ea35006eab902b7531350cda3", + "docs/measurements/h264-rounds/cavlc-block-probe/c-identity.txt": "8509ece284e30f03dcb6923c82571015111a090a74b76c83c6f77f78d4411f6c", + "docs/measurements/h264-rounds/cavlc-block-probe/counts.txt": "21d7ac868fdc293af9f73c99b77861ba745ad31f80da4c5bc19335bff47556fd", + "docs/measurements/h264-rounds/cavlc-block-probe/plan.txt": "01e739223fa62752a46b68c211f0b4cced4066c971d1887315bed74455574114", + "docs/measurements/h264-rounds/cavlc-block-probe/probe-pad.diff": "42cbb632b4878371f7739a8089be3a07457e9125e8419e118fe20d0e234127de", + "docs/measurements/h264-rounds/cavlc-block-probe/verify.txt": "cd0116d10ee1cc72db69970a27b312294749698d8e1d148a891fa6da4efe9e53", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/README.md": "2a915252c7d39608e2cff0e08a00367d67b32f4189e95f01e21175c5983194dc", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/ab-summary.txt": "1b1b4df9b1c6ec2e4251d4e0e5a8cc8c452d8ade3bece72a876d62ef1b2c0501", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/ab.txt": "eb52522a77d58b8dc70d137b0bd8f674371a1980ebfa636da2b2099bf130ff99", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/ab3.py": "8f0abb2a95718ed2ff5f6ada28f9cd811315bfdf9dda3d81cde00e9ed8678ab9", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/abq.py": "978032f511d6e115d8e586e26153990c107f109529a264af5f9b9c253393fedf", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/binaries.sha256": "2a7b19f44258afa2380576b2556fcc6ad4bfc3c4d99c09c786c03384e195396e", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/c-ab-summary.txt": "e9ffd49ecb2d7a58b1d024ea38a5caac1b50546e975012377e25c14d64dbef5e", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/c-ab.txt": "fc9c74dfbf47a31679c955c1e47c2d16fbaa63454744f3938a628281b80dca93", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/c-conformance.txt": "5f7f8e1f7332c454c6c66c6e5e157af1d5f8a43b680580b0c41e938d0e5830ab", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/c-count.txt": "71663718e3da31dfbc92544d2eb453aece2ada03b37cb3bfc09dd7708b630a6b", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/c-identity.txt": "9051b1ea2c0e8ded03dbdd2b23d5061a9f3a35c7e01d8a76017a3ab8fd9d272e", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/c.diff": "fad9436259030af78c4c0752dd3e6902a3821bdd9fb63076421feb8902d04a30", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/calls.py": "30286a953158963d35a98f47f0ee62fa452fe919e22c808f5189476d84d662c0", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/counts.txt": "cf427b81e80637d27485e262607cb108c30a981987e8355b847e26bd61ff484b", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/ident1.sh": "5df342f762211e0ead2a3c4dd92181ef00230daeaa17fe850156944d4ac4d180", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/plan.txt": "e015cc6b2e424663ed3d4eaf83db56acb0b9ee703d8607bb989ea907a7ea2a74", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/probe-pad.diff": "c9ee5c1c109e44eade9bc2ab9033d637eb8130fa23e02d299d4410fcfcd864f4", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/sites.py": "5282d1223f8d76422521bd44d7c5fbaaaeb4f3a8d0735a7a356d388c121aa4ad", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/sites.txt": "717878f4f29a2a11542fca4cabd5d486e20f25aee11ee5883b0b39bfb258e209", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/verify.txt": "d8322e9d1402b41b7cf012163cc391a0a3fbe0d53bb938c51d32b4ecbcc71b39", + "docs/measurements/h264-rounds/cavlc-mb-window-probe/verify1.sh": "75c034e2bc190c890a3ea8ef31bba7b0e642f6bda207c7fc19a47b8656b92186", + "docs/measurements/h264-rounds/cavlc-p-fused/ab-summary.txt": "c93861f2a32055577a2c4a434d9b8f86aae95aea218e8c01f6b867f7cd5a67b6", + "docs/measurements/h264-rounds/cavlc-p-fused/ab.txt": "9258758cb3af0d7e85381709d824c8c34b71190309f9831ada42a221de70a0d2", + "docs/measurements/h264-rounds/cavlc-p-fused/ab3.py": "8f0abb2a95718ed2ff5f6ada28f9cd811315bfdf9dda3d81cde00e9ed8678ab9", + "docs/measurements/h264-rounds/cavlc-p-fused/abq.py": "e5b5b21561e34a3b474db71086d56ec30776dcb4d34268e989a8ae7305b14ebd", + "docs/measurements/h264-rounds/cavlc-p-fused/binaries.sha256": "68787ab4d1879a3dcb9794a151504c98b7148372de069c524f42dd4d7bbe228d", + "docs/measurements/h264-rounds/cavlc-p-fused/cgcount.sh": "0a311ea450c198734eca86b68e3fd247ad6be1bdf82684ed0a93cb90e3169302", + "docs/measurements/h264-rounds/cavlc-p-fused/conformance.txt": "11f786c824b8f0de3ad5456ed51ec117c55421593924ef1244e9d90ee4846fda", + "docs/measurements/h264-rounds/cavlc-p-fused/grp.py": "b363a206df721bfec10a7d1152288609eae9ffc92d0c1c8b40b533c77d31289c", + "docs/measurements/h264-rounds/cavlc-p-fused/identity.txt": "f336563b3c38180d9e7e8fcbd8679438829954c9194cab9827b6f75979930c8b", + "docs/measurements/h264-rounds/cavlc-p-fused/placement.py": "f2d5f178f49bbbec626eb0d7ef7e154b396c7dd9740c13206ccc0532780a5336", + "docs/measurements/h264-rounds/cavlc-p-fused/placement.txt": "69060cd331edb4a7eaf147fa570409576ef368ce59fceeeccac844dae3d80ff9", + "docs/measurements/h264-rounds/cavlc-p-fused/plan.txt": "becfe24770a0f7004518471596d383f4fdb7de7ac312900cbcebf6a4d5a6ead4", + "docs/measurements/h264-rounds/cavlc-p-fused/profile.txt": "702a585d07571662cc177e428198bfb0db8e7ce0b8232b967fd5f64f979abfdb", + "docs/measurements/h264-rounds/cavlc-p-fused/r-count.txt": "a5b412317ee6bd6a5bbdb2bfec1ed27359f4330332cb37e5af151a84dce8be34", + "docs/measurements/h264-rounds/cavlc-slice-fn/ab-summary.txt": "f4f5396b489e9c07cc0f5eb35c58ace959d3b8c7782d63d16094b76f14180584", + "docs/measurements/h264-rounds/cavlc-slice-fn/ab.txt": "eaa7e74035db7ef7294a7fba76b6ca0f8e1c028b71053c68611734cc5a15ac34", + "docs/measurements/h264-rounds/cavlc-slice-fn/ab3.py": "8f0abb2a95718ed2ff5f6ada28f9cd811315bfdf9dda3d81cde00e9ed8678ab9", + "docs/measurements/h264-rounds/cavlc-slice-fn/abq.py": "978032f511d6e115d8e586e26153990c107f109529a264af5f9b9c253393fedf", + "docs/measurements/h264-rounds/cavlc-slice-fn/binaries.sha256": "b965e5d5b53d3b1b1f83c412f27a1a7c7ef3ab5c0ad03877e8363e481d384a34", + "docs/measurements/h264-rounds/cavlc-slice-fn/conformance.txt": "e09676b5f9752dfccd032b4234604b10c749c8d81d985a7419e749ebf69d3e58", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/README.md": "fcbb0e2cc53ec51c41cc65ce94787a5bfcc31532ae7e291aa5bb5f057a7ea6e9", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/analysis-final.txt": "16bfe349fddc8ac3fb4e8cbd7b357ad7c9649a2b96cb661a3e1dcc0d16762c93", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/analysis.txt": "5a266eddce5d39e7fd42271211d52295d93dbba439aaac6f43c09fedad25fc86", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/analyze-sf.py": "e5f647f9c34712e72da20a93997f209917b02200b78c900b6428427ba6dea643", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/analyze.py": "e5f647f9c34712e72da20a93997f209917b02200b78c900b6428427ba6dea643", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.1080p.json": "aeca1dee7f5cc36958f094b35ee1783d3f31ae53a2abe29d71293a22139109f6", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.1080p.json.void0-first-run": "df9b3a74c15d19213f15f3cac4a4ac4efbda2e01e6c4df6626ed160f3459f7ea", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.1080p.json.void1": "0feac0e9f8a4192b200fe4176c69dd05bae65cca846154379096e67ac47c64f2", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.1080p.json.void1.keep-0529": "0feac0e9f8a4192b200fe4176c69dd05bae65cca846154379096e67ac47c64f2", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.1080p.log": "c933024cd9706834dd83e3f419d7a661885758113c85f78feb6fae94658d08b7", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.1080p.log.void0-first-run": "431c5f76be975fcb5347f5ce34ce841ed83d3c172dbc007e8259072ceb9afbfc", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.1080p.log.void1": "c2269c063278430bcc69f79cabb736359b4e040ee59e8569b5b28b633316ca6e", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.1080p.log.void1.keep-0529": "c2269c063278430bcc69f79cabb736359b4e040ee59e8569b5b28b633316ca6e", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.4k.json": "f30d54bb68e31a60ae6c9097dab6e43daf944ee0d8b76c1e9853baa4f17e0e81", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.4k.json.void1": "e99c6201e40ff0da01a7a1ac131bc94690af82459ae968e54c6b021dcb57f4cb", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.4k.json.void1.keep-0852": "e99c6201e40ff0da01a7a1ac131bc94690af82459ae968e54c6b021dcb57f4cb", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.4k.log": "fe1c22ca2f77d640e0cef82c0866ce40597531d2db5cb6da9a879e28f9315dbf", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.4k.log.void1": "cda3253b92c3e2388bd6f340b062ceea8d4325cf36d830f623c3619bd1d071b2", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.4k.log.void1.keep-0852": "cda3253b92c3e2388bd6f340b062ceea8d4325cf36d830f623c3619bd1d071b2", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.720p.json": "604e478f924176e3f793fbf0ee18e584efd2eb62dde1efae5ebb6b488d288e66", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.720p.log": "279f0d333ea256d801ca137615655ee92302d6f3b398cbf3b68fca4a8688daae", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.sd.json": "b6f8836c69f220e5433e6a1b301cb8bdcf127ed6fa844f761c611dc04a8c17d9", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/g.sd.log": "8969bed10d9ef7a795ce437cb77639895ddca8d0b70a129f65f08efc76a77204", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/host.txt": "99e261062b9f9dbfb7bdd6cdc7995e87f43eef9f027b9272ae494879bc8c19ae", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/job.sh": "06ad38fac2cdcb7c99e734a6403d7603d13fc8621da14db2157cfd318ed21b3e", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/progress.txt": "f773c454c6bccb65a05b8561332b5d89007a663f70b159dbaa0904a0835bc03f", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/ref.json": "e44a9a0e13592d023ac7b3c00087c3ab8e2ff15484272d3045836ae39198f04c", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/t8.1080p.json": "a139a8a866d3ca12b177f11f461f7d01fe88de718f622fcaf2ff0b37ad6a2b1c", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/t8.1080p.log": "fa907bf19141b93424d4c0ded241c21f79e37cec95498e5d3ad45708a2c7ed91", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/t8.4k.json": "cd3cf0bb4e4237a74c894e4562e2ac7e44b3314f2cd7242304c38ec46ab2026d", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/t8.4k.log": "8c07ae4e9e68e2dd44becc9c872e5f8c19054c06a118f502d37a0825ef3d2bb2", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/t8.720p.json": "1e6fa63dd5b54acaefdb873c806509d651b4689d9e06eff0fb5c1a0fbf158937", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/t8.720p.log": "222b285574bb882852b402716a47ebcbb4cd4633a56526340b1d9d75d9100270", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/t8.sd.json": "c3ba94c25f64fe6b19a443cb158b537d28b3c4a4b38cea3009f219906d20b403", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/t8.sd.log": "871686c99950dabf95ab04cec526b1af44c9c678b23ddc0e7dcd2edf0188ad68", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/tools.txt": "f9b77914d8eff83d82ed9b6ba02a00fbf6c1a99b4144e19819c1ea68d2540c7b", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp/verdict.json": "bf857aed7a1d1b08f6511de831a66f0bea24a8fb6782d8fe3a7530a795a56cb7", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp8-retry.sh": "3967b05f5746ad2ad577e486dc5d53988984358103af597722983bdf1f212cd4", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/gcp8.sh": "78e916d5a89059c29ebe8ba862200e6e59bbdc705bac44c980caca02943837e8", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/h.1080p.json": "d082dd850a933a1e0431bf0cae2fe6f0dd198ef2074e18e924e886a51e9473db", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/h.1080p.json.void1": "82244a4f67bd76ba35ef05a8ad76ffa7888d75ffd7a2a483ea62ddb1c334028d", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/h.1080p.log": "3bad14029c0461d4a77d2eec1ec4435a667274a6e92d65c3828f168e55b24fe3", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/h.1080p.log.void1": "313ecd1643841fb06c597164577f799176ff94ab9c124174b60087f787cfee38", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/h.4k.json": "12644e58e2ba9f9bbe763302320f96237a831f207891429507ba325126af612d", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/h.4k.log": "c91e675c287c7b8f8b27deef020edfae08391cebb96a6f91a8e2cd0ce2d9cc8e", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/h.720p.json": "5abef51d0591407b19ec376866372d8a1968bcb5af3d0c1783e50a61aa6c4a69", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/h.720p.log": "db238ba30b5b4f0fbf411c22be44ee2b9088b3ad23e34c33051ec70163944955", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/h.sd.json": "a36137d58dc7c8a82ddae87badbdec7c31ff27b02d4e9b2c8567106de8bfadf6", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/h.sd.log": "53f2e6104c2aebbde78f94362e315007bdb3cd21fd25e5a82be12a58e28ebde9", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/hostgate.log": "28d5bbef8c26ef8c8528867da0fec93a6cd3210e99c2e47bc8fad20031b7d4cd", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/identity.txt": "859e17e5923e2e0719c658ccf405c14f23201e19d3ef6d21d2226c9b93edf8b3", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/pps_entropy.py": "e82817b61c42a0193a214b075d71d58c2e7584127b5b666ba480dfc240485ca7", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/progress.txt": "d0a7ecb0d182acf7a85343b16bc5e3daaa0aabb558603ef888d223eb1147781a", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/provenance.txt": "8bc38059b79c2479950e057bf0da3ab6e318126312b1b2f59775933c9f3fab47", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/resume-class.sh": "ef4f2d3b3bc204a161753a7bef4a1c8157b88ef3ecdfce7124508f5877176bad", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/resume-rest.sh": "a7760767a0b06a0b53a584dac3b8e034d11942b9c915ff83e16c88a47d725db4", + "docs/measurements/h264-rounds/cavlc-slice-fn/gating/run-1t.sh": "a0d3849d08a514a8026dc0df2de690df6ad4de7299b77deb174c62d592891701", + "docs/measurements/h264-rounds/cavlc-slice-fn/identity.txt": "ecddb6acc3d346c2cc1c4fcff7b9d9cafbd98fd9a04878b5bc1e0c0a503a5203", + "docs/measurements/h264-rounds/cavlc-slice-fn/merged-checks.txt": "fb877a0756fa536d36ab22a9d9bfcae348dc6e393aff4d5b1261a28df504f752", + "docs/measurements/h264-rounds/cavlc-slice-fn/plan.txt": "71dfc607efb41fb20077e258b91a775a157caf6a5269796544a671f408b57bbf", + "docs/measurements/h264-rounds/cavlc-slice-fn/r1-code.txt": "b2280d5a12dd87a4cb846d06ebb4ccd2b3a909dfe43fe48e7cfd9f0a820ad2ee", + "docs/measurements/h264-rounds/cavlc-slice-fn/r2-placement.txt": "98824d34e4e47376bd8535d64cffa62871e7146e7f93f525440f26cbf75636a3", + "docs/measurements/h264-rounds/cavlc-slice-fn/r3-count.txt": "a036c860d5dfb0daed63bfb9964b563d6da8e0f262c551f2ecab4c2899a603bb", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/ab-summary.txt": "f832c8896b067a88d46f2ec56b7331040762f27efdcccb9b56939e03ea6065b2", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/ab.txt": "ff5307a6c4bb757e05afbd3cda699639125789756ba672dd81cc567c8c94916b", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/ab3.py": "8f0abb2a95718ed2ff5f6ada28f9cd811315bfdf9dda3d81cde00e9ed8678ab9", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/abq.py": "978032f511d6e115d8e586e26153990c107f109529a264af5f9b9c253393fedf", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/c-ab-summary.txt": "eded38358ad31aaaba663cc02b130f554867ffe52bd94d003a238eb124160319", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/c-ab.txt": "f80190d51c3848a392ee9242c896e502155a69f9c0e6df0e8aad447d6115ec21", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/c-conformance.txt": "ba6e5b8395c1139e6aefdf209c4dc5b63c86ed37a3aeeb41ae156e71bde47dd1", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/c-identity.txt": "dd97ad24cb8de326ae3072952794b1f9a022ca424cd7873045b1c68cdefe538b", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/c-nofast-identity.txt": "f3fd95edc5c9e2fba8e3d0bbdc6998dd3df3d1f4535639599b13d6fa17531268", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/c.diff": "6ec155a03f4cedbfde9afd1fc8b9849d767a5f51776ca2873a07601e3a315e5d", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/ident1.sh": "c2103c6edc21d5ad8adaf45115c8ff2f6947e08237912b18ecf92f3c68beab01", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/plan.txt": "941a3e53d21c2ccdcdfa0a6784ab51ac66f72cc97cf9c1b9298b180660b75592", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/probe-pad.diff": "20190dee86b4db7a753e93ba75219fafab660289e14d6e7bd0765e18279de9bb", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/verify.txt": "38936db6814e41012b5fecdced6b2d82c247ecf237d039047a38d753e777df12", + "docs/measurements/h264-rounds/cavlc-slice-loop-probe/verify1.sh": "a182b61b60fe61ba8950f79c49d5f31809f923411226796bb747bb5e8d524e1a", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/README.md": "7c5754823cf88dd18e249855826913a693e91f6487f8536b9be0bc07d8136240", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/analysis.txt": "f7c34cc9fa4e8a4d1d601220baf2bcb5316ff8a806199fcd75b82e9c945f3f09", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/analyze-sl.py": "d75ba90dce69517994bac870591add9b6fd5b7175d3e64856a4f9a16522a1d6b", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/g.1080p.json": "5b606f61f9c60b4fdaa45065c7055596b30ea875762e93ce55b455347368aa01", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/g.1080p.log": "b92fdeac0397202c63eb51e50f177973bb6fa5389b3539a9920665dda09220c8", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/g.4k.json": "29e694deb0e043392cf8f415683949a98fd590724343648f209499645f22e133", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/g.4k.log": "485120e16180395f886504e0966b9bd4c2fce8cccb33e1962a3ab970371baea0", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/g.720p.json": "9d6920d612d87c8d435716b55e3d368919be455d54e94783adc29eec2cbaf6b0", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/g.720p.log": "e43af16b0a1d4ea231546bf99fbc4d505823dd0f7e94b2da67600def6e0942df", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/g.sd.json": "f0c307f3fd28eaad14a7590baf7362af1f2613a963c0d5c272970899601af3b2", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/g.sd.log": "c89934a8919a9bacbc7323ec8f68e66152dda1f7b71783b8515ca754eaf29c4d", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.1080p.json": "cb677fd9f865251d42785bd3a19c7db81c2c36b3c17efe67f504bba3b2e4c2b2", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.1080p.log": "d4e8bd4a1e4fa8f6c647c619d77c1ec13610b98edd1b50606fe6a3d35fdb6a2c", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.4k.json": "0a34fef1eab9f90098b31caa61cfb9023267025afe48f3c999ec319dfc5b51c2", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.4k.json.void1": "f0a0a12900774987e8a962925966ad44e6ce4e1ed936e8c6891e7c39f23339d3", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.4k.json.void2": "eaf15c0092604a98be7ed5f09dd831548e0312f8ce40416d9f0a325b5e7ad6bf", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.4k.log": "ce84c9fb5579cf78cfe9c0fe3a527aeaa07e5e4c8ed670dd4cb60eb1a5f29996", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.4k.log.killed-by-timeout": "73e8668587b56b8bc522c068c0185936a010538416773ea466f7215fbd090586", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.4k.log.void1": "9e561d52590a7eb5a2a3308c1ba5ab41c17414586df970c32c55c06c602781c0", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.4k.log.void2": "6dfd23a1811d972c28f816858ee6dd9a79c31d8a8cd1bf4d6a794f1f5d72839f", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.720p.json": "e00afc2b32c19e28814fa8b4b75fe1e3ee0a6168443bfcbfaae9710c48c91258", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.720p.json.void1": "e69623494feae8be251350727728bf84538271838e9857cb8063962760e0d157", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.720p.json.void2": "14eb07fbf8d621d3feb53c421d5d87df27bd012d170ba99f27f8666345aba0e8", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.720p.log": "57e99158051607f301671649af34797c84555e897e9dc14e4cc425019f09695d", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.720p.log.void1": "a5e073fffdc3f2198aaff82728fadefd3686d192a4698f4fd793833581cd41ba", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.720p.log.void2": "54068a9acb7c763726f491e07220848664efafa01a8946f3c90c3701c12bb7c2", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.sd.json": "255839a8f8867d5140ffcd2c9995c29e18fe196225f4ca6e68f9dff58c75358a", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/h.sd.log": "1c288b708f40e4ec981b3fd70b6f8b65f09899bb913c2dfaf753b0c2277a3d2e", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/hostgate.log": "9e581964b46b27b6653438ab4221535256e9e93a94981c132977d98ea9031234", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/identity.txt": "859e17e5923e2e0719c658ccf405c14f23201e19d3ef6d21d2226c9b93edf8b3", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/pps_entropy.py": "e82817b61c42a0193a214b075d71d58c2e7584127b5b666ba480dfc240485ca7", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/progress.txt": "d7bb43d582dbb9551279eca82d37b646c493c47906724a00ae1eedc81af88f46", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/provenance.txt": "320426e30629714c7bd97f401ba5954045db2c55b127226072fbfc47eeec3ec9", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/resume-class.sh": "ef4f2d3b3bc204a161753a7bef4a1c8157b88ef3ecdfce7124508f5877176bad", + "docs/measurements/h264-rounds/cavlc-slice-loop/gating/run-1t.sh": "a0d3849d08a514a8026dc0df2de690df6ad4de7299b77deb174c62d592891701", + "docs/measurements/h264-rounds/cavlc-window-probe/README.md": "cf529015fbc57509e6469f5a24a60cf99c357a5271c87bc5d585927bccbd7c5a", + "docs/measurements/h264-rounds/cavlc-window-probe/ab-summary.txt": "87d2b12ed1b3ff6c35c46f6847d2d64794b28150b8e637f6ae475b0fe34613ca", + "docs/measurements/h264-rounds/cavlc-window-probe/ab.txt": "56915f5e3ee804884f004fa4b42e6f68f8f4983f8d22a318bacf6cb1bee8095b", + "docs/measurements/h264-rounds/cavlc-window-probe/ab3.py": "8f0abb2a95718ed2ff5f6ada28f9cd811315bfdf9dda3d81cde00e9ed8678ab9", + "docs/measurements/h264-rounds/cavlc-window-probe/abq.py": "978032f511d6e115d8e586e26153990c107f109529a264af5f9b9c253393fedf", + "docs/measurements/h264-rounds/cavlc-window-probe/after-main.txt": "1fd845dc2fe79437a52b2adb3ece47595fbf0549889701bf8ff8a9860eca675f", + "docs/measurements/h264-rounds/cavlc-window-probe/binaries.sha256": "2c46fe3524d2617409763e8aa252b4f986de69547e799e75b275cc03ee58bca5", + "docs/measurements/h264-rounds/cavlc-window-probe/c-ab-summary.txt": "618c74b0fc545dcab763a366cbc33ab8212a05d025245305d95dee9d4a3395b1", + "docs/measurements/h264-rounds/cavlc-window-probe/c-ab.txt": "04efc638d2e4438dee0f3ae2cef86a8d730a7db0be0760be7c001832d18c3d3f", + "docs/measurements/h264-rounds/cavlc-window-probe/c-conformance.txt": "ca97f8134bc642e8ef3385b8a1b7b739138c3a0a8a3fb6fda1e1f82cd6afd36b", + "docs/measurements/h264-rounds/cavlc-window-probe/c-count.txt": "b4192fc85b8c050da708c219470bb4a0eb1a01b72b67e191231fbd074ee81190", + "docs/measurements/h264-rounds/cavlc-window-probe/c-identity.txt": "8ec8707b18b8863a3ec0df040e9f108e511dcd991edf50f24c5ec9937079a0c0", + "docs/measurements/h264-rounds/cavlc-window-probe/calls.py": "30286a953158963d35a98f47f0ee62fa452fe919e22c808f5189476d84d662c0", + "docs/measurements/h264-rounds/cavlc-window-probe/cnt1.sh": "9fd1d8ad58b0b0de22e09ed0cadaf29f0c227e3d79f53d919f6d173c7eb95457", + "docs/measurements/h264-rounds/cavlc-window-probe/counts.txt": "f2abcbd7c5566b793ca7a402213e0ca0ee084a57cff854c8d04990f5a3065856", + "docs/measurements/h264-rounds/cavlc-window-probe/ident1.sh": "907ea131e84f40028dd4bf54ca56ba2794675472fd4e6392e8bb7ed630bbd07f", + "docs/measurements/h264-rounds/cavlc-window-probe/plan.txt": "d001751175728fdd7be6d05b8b44f96ccfea1c2ef340528cae6636e33a686b0c", + "docs/measurements/h264-rounds/cavlc-window-probe/probe-pad.diff": "935ba51a2e54b607493944fd9e0f8ba32ac69bb8ad5e1c479631a9aac1e1852d", + "docs/measurements/h264-rounds/cavlc-window-probe/verify.txt": "d73da0120fc0ce49b07a29f003187cfa3cbc7cb89ce670527038233f9453a9ef", + "docs/measurements/h264-rounds/cavlc-window-probe/verify1.sh": "1f530d1ac6984c1a97c5c0f405a498ae61228bb77f5d3ce47ab45edfd367005e", + "docs/measurements/h264-rounds/cavlc-window/gating/README.md": "2d5ecf982491375af2614aebb1b40f1ac8f6cdd848f10403c082bf839add701f", + "docs/measurements/h264-rounds/cavlc-window/gating/analysis-final.txt": "9ad7fc1910813d0b16cdf9974cbf0401cccdb9ed30a071d3bc873ad1a4bc00b0", + "docs/measurements/h264-rounds/cavlc-window/gating/analysis.txt": "ac61407e038b4a09e32039a51b5faeb5555e1fbfbbf6fec843ee672dad9f5d2a", + "docs/measurements/h264-rounds/cavlc-window/gating/analyze-cw.py": "38e37903d022fed0f4efd921e2ac4093651cc8fcc9e1a3e83878c290985fbbe9", + "docs/measurements/h264-rounds/cavlc-window/gating/analyze.py": "38e37903d022fed0f4efd921e2ac4093651cc8fcc9e1a3e83878c290985fbbe9", + "docs/measurements/h264-rounds/cavlc-window/gating/g.1080p.json": "a6e0e88e6c111adf974e568bdcb2ac38a61a2673524bf7ad4a42c8a5615fc3cd", + "docs/measurements/h264-rounds/cavlc-window/gating/g.1080p.log": "45c4992bfe6f73ff241533766c9f442e522bf9f64ee60717e43335d40619fa0f", + "docs/measurements/h264-rounds/cavlc-window/gating/g.4k.json": "598123f65a5e6140f3839071275f20951f68910280e47ded619b59d6da89404c", + "docs/measurements/h264-rounds/cavlc-window/gating/g.4k.log": "36ddc4dac5dfcfc5ad62327ff5a7dddd2b98946d9329b426c2566200f9654faf", + "docs/measurements/h264-rounds/cavlc-window/gating/g.720p.json": "6a84b1dbb7771c3c003399459b4f9608e1a769655cea3186a6057102b3fce7ee", + "docs/measurements/h264-rounds/cavlc-window/gating/g.720p.json.void1": "cf30bc9f3c9460f7e3e4db83313de0a5ced6e9602a0faf6395f517a1df9488a1", + "docs/measurements/h264-rounds/cavlc-window/gating/g.720p.log": "8b565dc3fb8863b6b2d18cd83df8c76a9b7877d51a9eebdfea59a917389b9ae5", + "docs/measurements/h264-rounds/cavlc-window/gating/g.720p.log.void1": "fd180243a29c9b9538bd4abbf0b8ce19a6b07ff8dad78e020ae73e271a62189a", + "docs/measurements/h264-rounds/cavlc-window/gating/g.sd.json": "2f00194bc3bf778bb6202fdc464990b68cb3482094b0f727a5710bf79ed984c0", + "docs/measurements/h264-rounds/cavlc-window/gating/g.sd.log": "be09edce4b6b881b5f8f99a338157a1a1cbd0d80862754c9d93bdf95066037fb", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/create-attempts.txt": "c804814d9afeb3af6eb8b3898a436056966f413da11de62fb8e6d335ab9bdb92", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/host.txt": "fb07b809fa12b2ebb16a36b640970beeebeb39060f17b04d360e113dd0b20376", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/job.sh": "06ad38fac2cdcb7c99e734a6403d7603d13fc8621da14db2157cfd318ed21b3e", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/progress.txt": "96752784312cfde75a013409a59d908a69bd50b082d6c3bcca5c1b386e565004", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/ref.json": "c74831b8f37653c252d80b53a937915795ecda679ea300ee7e792d81f710a47e", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/t8.1080p.json": "6030d22e8e454a0fb7a4b8d737c54ab799a9a28967983d5b6ddd4052c578387c", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/t8.1080p.log": "ea3ace6a958ce3def0fea33a96b8c285f55ea940dfbeec66e3ff6878b4058f49", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/t8.4k.json": "9e7297bb11e4db78fc631bb79ca0f125b4b85ffe604c52300c84d63d17e34b47", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/t8.4k.log": "2efa04dd97d2cc3135b054ad4edbbe0dc686ecf73b7c7477c37ed0d5c4ab76f8", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/t8.720p.json": "2c6c32e1e2ddfb952e4a5d642bc0cf7b18e9e054fd10e06261d5ee0875197584", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/t8.720p.log": "1de1387977f24f86a7c3872a19991400a7e67f4840844070f875dfbf4d018624", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/t8.sd.json": "fb3646dfb6a8e0f8083e5610545cae6bc85509839f7790bf16eec47deb73464b", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/t8.sd.log": "5ba0f150963ee8413c43b64bf9e795b42ce9124a13257d3aa17aeb2dca28f9d1", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/tools.txt": "a92507c6ebf447ad49233f7e617d88e247a6d52aab4773bba7809563d3b69917", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp/verdict.json": "7766be243682499f13eec7b6a7ea4d9f74a4b00969b4e120882477c3e2338549", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp8-retry.sh": "3967b05f5746ad2ad577e486dc5d53988984358103af597722983bdf1f212cd4", + "docs/measurements/h264-rounds/cavlc-window/gating/gcp8.sh": "78e916d5a89059c29ebe8ba862200e6e59bbdc705bac44c980caca02943837e8", + "docs/measurements/h264-rounds/cavlc-window/gating/h.1080p.json": "6139c3720d1b79687fd0ec07f537b46f1ff37ef1019643787ab78f0d172e10d3", + "docs/measurements/h264-rounds/cavlc-window/gating/h.1080p.log": "ecd50595babecd193ebb0f7e3dd468e02ed3ad140bf546375667ad0819c658a8", + "docs/measurements/h264-rounds/cavlc-window/gating/h.4k.json": "bf4def381a2b8b0d808b6cc8d2417aa0640d0e6757f997ba0a9cf8ec4dc6734d", + "docs/measurements/h264-rounds/cavlc-window/gating/h.4k.log": "9e3691e62c12075be976f92d805ed94d6cb2879cca3472dfe6dd5649b0819d33", + "docs/measurements/h264-rounds/cavlc-window/gating/h.720p.json": "eb1d7c9887522ce1ba10c21aef8e4c2ab1ce70a1d4cf973da780c3f9fe6d3ab3", + "docs/measurements/h264-rounds/cavlc-window/gating/h.720p.log": "c2fc32995da2abcc447733d5cbfb811ab33ff259c8c84b7c904ff2073fb9d034", + "docs/measurements/h264-rounds/cavlc-window/gating/h.sd.json": "c15338ab2d98babe6a3cf153b4e3d42b8922eaec2bd7f034a1c5cbc5df5a1f05", + "docs/measurements/h264-rounds/cavlc-window/gating/h.sd.log": "3aa24a29581ee7946b6297897290b0cda8f8f9cdaa6d8096d8d09561cd0bd1ea", + "docs/measurements/h264-rounds/cavlc-window/gating/hostgate.log": "855559609073f65f38cc8b3d2f67c0bc77efa9daa0e366e51e9c40f699c22484", + "docs/measurements/h264-rounds/cavlc-window/gating/identity.txt": "859e17e5923e2e0719c658ccf405c14f23201e19d3ef6d21d2226c9b93edf8b3", + "docs/measurements/h264-rounds/cavlc-window/gating/merge-identity.txt": "2fc63fb6d93d580513f64369308c8cbf4d25bec191d7c77a5cd69e724e8f37a6", + "docs/measurements/h264-rounds/cavlc-window/gating/pps_entropy.py": "e82817b61c42a0193a214b075d71d58c2e7584127b5b666ba480dfc240485ca7", + "docs/measurements/h264-rounds/cavlc-window/gating/progress.txt": "d7066c75ba4a3bb09f8cebae244f6760c34cad53f28cb0738340fc73bab463d2", + "docs/measurements/h264-rounds/cavlc-window/gating/provenance.txt": "5db3ae6c6d3983b7b0cfa545d975ea9d1060add80dcc92512373113d8861c5df", + "docs/measurements/h264-rounds/cavlc-window/gating/run-1t.sh": "a0d3849d08a514a8026dc0df2de690df6ad4de7299b77deb174c62d592891701", + "docs/measurements/h264-rounds/chroma-apron/counts-3c59.txt": "c3ebd9ef5d7835ac0178924159064cfa02885975f598796b4e7ec49a253e6289", + "docs/measurements/h264-rounds/chroma-apron/identity-item-i.txt": "c21d94621c22adfd06eba945049de9f00e8a267d0f9f3a75ae7678d0f37cfbf4", + "docs/measurements/h264-rounds/chroma-apron/instructions-8t-item-i.txt": "6cccb1aefdfb9d365db86798bcce56bfc34488f6650fdf791e8ba3070eb96312", + "docs/measurements/h264-rounds/chroma-apron/plan-probe.md": "92b1e542be6b0605036845c532a924b47573b3b1d520c6fdecfa23471e771973", + "docs/measurements/h264-rounds/chroma-apron/progress.txt": "4fa449aefd138c6809826f5f862b981e615d3c2c2301cf180cfd4e011ec3ac4c", + "docs/measurements/h264-rounds/chroma-apron/run.sh": "8999159fb9e28194f216475dc63e50de117c154807fb00e0c5c5a1e289859db4", + "docs/measurements/h264-rounds/chroma-bytes/README.md": "5a9e959cd92ae5dff0c9b5a17f9c227bf95f4c6dfc0d61aad8a9f791892842ca", + "docs/measurements/h264-rounds/chroma-bytes/cmb.rs": "76c7d576c428ae3a218d5b375c5850a529995f6a5974a1a800ed646abcc7392d", + "docs/measurements/h264-rounds/chroma-bytes/conformance.txt": "88f3a655b67ef3f78bf096467e21e4f73f669acc5d598f2a8423600e97c6b8e3", + "docs/measurements/h264-rounds/chroma-bytes/cpi-parts.txt": "581ea07f2013b94c093745cd68097a12473e711174f3c09641d37df252b06ec8", + "docs/measurements/h264-rounds/chroma-bytes/cpi_parts.py": "99e7e2f6647c04d28ea4e2482a420023f23f0a7a82f7af06a2e2d0669718a81c", + "docs/measurements/h264-rounds/chroma-bytes/fuzz.txt": "ce3f2493c5475f99ecbb0b4560fb3ddabca8fa66de257aaa93232173a7460eee", + "docs/measurements/h264-rounds/chroma-bytes/identity.txt": "eb918ae73c26d9322842d3e2ae106e9a9f64528914ab6fd665e1ab559a0479f5", + "docs/measurements/h264-rounds/chroma-bytes/ports.c": "8c3843db9236e51cc83640d2067a85b6289889b2d5aaea4577a079360f86e883", + "docs/measurements/h264-rounds/chroma-kernel/analyze.py": "6d681f6d05541f4ffecab5fcc54707e95f7923d404a5082d9cc89a1e3b52d766", + "docs/measurements/h264-rounds/chroma-kernel/core_split.py": "7cbc3121f46cf959421c36c69296114eb4ebb70740ca9707a4fe46e700da59f5", + "docs/measurements/h264-rounds/chroma-kernel/gating/README.md": "e82e30a10021a50599e37bb3c3011abcd0de3874d47a4a73668c5c0d56f977b7", + "docs/measurements/h264-rounds/chroma-kernel/gating/analysis.txt": "9f857b1b202f76ff80d7697c5239025037421984cdf5f411603bfe25da70a503", + "docs/measurements/h264-rounds/chroma-kernel/gating/conformance.txt": "7faa415e609af408c643291be5bca0ae0e042e5d3a074d5aa82bde929513d005", + "docs/measurements/h264-rounds/chroma-kernel/gating/g.1080p.json": "a11eaa47b9fe5538e48b8ac50a1f463c69033f3f12cc86deb42884d4487df593", + "docs/measurements/h264-rounds/chroma-kernel/gating/g.1080p.log": "e0278209fcb281612617877ea3b1b4dd5827667ba11fa17854246cbff8c7a589", + "docs/measurements/h264-rounds/chroma-kernel/gating/g.4k.json": "bee780f46d9898886a95794d6f5282d4d7b45cb0588ba631d4b21ba0c308059f", + "docs/measurements/h264-rounds/chroma-kernel/gating/g.4k.log": "800b5aa8794b7b2ce1b414d8646b625a15e685d48a4439bc2e148c3a7ceb6771", + "docs/measurements/h264-rounds/chroma-kernel/gating/g.720p.json": "123fd97761cf153e4475040c8462ec151f60328d949a12799ab8294b66c7372f", + "docs/measurements/h264-rounds/chroma-kernel/gating/g.720p.log": "005bff981ed2718c718ff5bf9f7d698f94958ed0cbcaa87f556562c0c6d52652", + "docs/measurements/h264-rounds/chroma-kernel/gating/g.sd.json": "0ffcac3460dc12b93cd7fa228153ec88ce191f24a17aa30b9dd20769bc97e6ed", + "docs/measurements/h264-rounds/chroma-kernel/gating/g.sd.log": "bac8cecc7ef6e944031fb08fb5b5baa5de4d9565b2adb5b2ae64e22d2e9ce48b", + "docs/measurements/h264-rounds/chroma-kernel/gating/g.summary.json": "c11e5f03410e91466ea65ddc3f77ac216fb62094d18206e8ca4c98a87228f4ef", + "docs/measurements/h264-rounds/chroma-kernel/gating/hostgate.log": "f5340e9155f1dee6115ff6ca0e6a3b35e723af4c2fe420bdaa90eba5d2458566", + "docs/measurements/h264-rounds/chroma-kernel/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/chroma-kernel/gating/progress.txt": "b8a74e921c10d0ac8029bcf24e0d07f6617c007188e7e6eec41568e7cf43b129", + "docs/measurements/h264-rounds/chroma-kernel/gating/provenance.txt": "88ac4788e790ff565d38b05a8043c8937b05a10e32950e5ff7842fed437ed424", + "docs/measurements/h264-rounds/chroma-kernel/gating/run.log": "788df4ee6c6a975640a21c7484e492256ccee040147233f19ed85d9aa0797da0", + "docs/measurements/h264-rounds/chroma-kernel/instructions.txt": "e3310afbfa37d8f1f5003e306790a307389dd46f133eef1fc8c6362f6c8f455c", + "docs/measurements/h264-rounds/chroma-kernel/local/README.md": "f032a25424fa84d141a43510dfffac283d8d3a38f90600d98a99bdc09d3d1913", + "docs/measurements/h264-rounds/chroma-kernel/local/hints-at-entry.json": "d0a24d760eed081cd5ce772dac251fea5db1f8d92dec739e1ceba0da96f4e182", + "docs/measurements/h264-rounds/chroma-kernel/local/loads-stores-4k.json": "64f3855030c37822e3f84a84135cafa6a8984507e3f9918cf9a499a49f917f96", + "docs/measurements/h264-rounds/chroma-kernel/local/reference-ahead.json": "a47549c51c93af9768d722023635d5a273d8abb9b29cdd88cf67a4955e5b356a", + "docs/measurements/h264-rounds/chroma-kernel/local/upper-bounds.json": "262fdf27706228f4958dbf11969d1a8338b5f14dba5c26e293300a856a0f23f3", + "docs/measurements/h264-rounds/chroma-kernel/profile.txt": "e6f9ce7dca1d1e7431214fcf71adb073869e8e95787d0a134810531d4d9a15ec", + "docs/measurements/h264-rounds/chroma-kernel/run-ab-helper.sh": "e292630b22f6b9adcc890eeb477f7755f3c6e5d6251ff838b9182eaa4bd1dc7a", + "docs/measurements/h264-rounds/chroma-kernel/verification.txt": "5ee03ceac78588678ed59da7a1ac201c6ffe25ec07968ce5f44e8d606d106222", + "docs/measurements/h264-rounds/chroma-mb/README.md": "801b620269f0122255b8ff1442c716881a519048276ac6d37a1c28ebda0e7d0e", + "docs/measurements/h264-rounds/chroma-mb/analyze.py": "8375d231bee58e2b8577c2d4f11cc40a4c33e5afd79e092986668a11f03601a8", + "docs/measurements/h264-rounds/chroma-mb/calls.txt": "eb5b750a74f9a7a51984b0db76b874fb4978228a1a5105ffce8b715bea721dd2", + "docs/measurements/h264-rounds/chroma-mb/conformance.txt": "895d4477bd98b7058c3ad463cad9b41a1ec1908e6e513d02d43a67fa88b5d652", + "docs/measurements/h264-rounds/chroma-mb/fuzz.txt": "93addcad1a27a413d40f5140e59367523b73301c5b255a0640ab5e827b621ed1", + "docs/measurements/h264-rounds/chroma-mb/gating/README.md": "7a720fa6d53d9c870fb852d28082d33abadead0ba534e82cd2965b4ae3234f7c", + "docs/measurements/h264-rounds/chroma-mb/gating/analysis.txt": "0db7a1422b9391f651b2d3add5eaf0a38b5c41f9860a482812cd5fbb19a06235", + "docs/measurements/h264-rounds/chroma-mb/gating/analyze.py": "8375d231bee58e2b8577c2d4f11cc40a4c33e5afd79e092986668a11f03601a8", + "docs/measurements/h264-rounds/chroma-mb/gating/binaries.sha256": "828f2426b86b78d42e07a44178c0c70e85f3ca74de523766a5ef2a2c564622b8", + "docs/measurements/h264-rounds/chroma-mb/gating/config.json": "27a710b3c373b6211db1cd0875b402208ced81271472b52d1af87174a785b901", + "docs/measurements/h264-rounds/chroma-mb/gating/events.json": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "docs/measurements/h264-rounds/chroma-mb/gating/g.1080p.json": "d5d640cc7d886dd87b7f4df087451040e31e20793411583fb8b7c71601056f1b", + "docs/measurements/h264-rounds/chroma-mb/gating/g.1080p.log": "7f3cd1579b6491cfced05ba10420eb529f68f0835c358d1689d4e52fdb30df77", + "docs/measurements/h264-rounds/chroma-mb/gating/g.4k.json": "f29cb9cbfc4834d577d7835e7f0bdbbb7c9b5e0a46e3c8b4510d0fcb3be61fad", + "docs/measurements/h264-rounds/chroma-mb/gating/g.4k.log": "5e15af31d7c841d31d077e3842a908239a0507b550ca7482ab06bd30e9a5d1f4", + "docs/measurements/h264-rounds/chroma-mb/gating/g.720p.json": "67dc6d743889d6b2e76e0e6469371e1ffea525210c251fab82ef96d652167f4c", + "docs/measurements/h264-rounds/chroma-mb/gating/g.720p.log": "9d38bfed2acf9bdd336efe15600287e370f02bc835845bdf13aa040e53880cc2", + "docs/measurements/h264-rounds/chroma-mb/gating/g.sd.json": "5cfe0ac38cdfaef15e6e7bd5a69573a45bc9034bf0b15730dd374e44d84c27d8", + "docs/measurements/h264-rounds/chroma-mb/gating/g.sd.log": "58ed5a8261a029c597d04225e79a2bfd14a8b5318517029fcefb7a9eb6d6ea53", + "docs/measurements/h264-rounds/chroma-mb/gating/g.summary.json": "9e416ef54dc430e0c6ddfa2735a0f674bc5f005477886bea29b6e3a44a5b36f3", + "docs/measurements/h264-rounds/chroma-mb/gating/identity.txt": "3980bdde6c8a232105cf508e121242d10b5582b01ed3f60e53dc880551d9a14b", + "docs/measurements/h264-rounds/chroma-mb/gating/log.txt": "d36fe25f021e617b5c64d2f9949afbcaa00c9b700dd383e7f0f9472a72593310", + "docs/measurements/h264-rounds/chroma-mb/gating/state.json": "22ed2fa64bd88bc164924a7bbcf5816fd0a3e9351cbf20460de9b09ed5600d72", + "docs/measurements/h264-rounds/chroma-mb/gating/t8.1080p.json": "48d646fad3da6f29b9f30bbabcb11d34bd55825f1e2c4c3ae5612be6e9153871", + "docs/measurements/h264-rounds/chroma-mb/gating/t8.1080p.log": "d1e303acd753885ac9b8dc87294c45933dc499ae0287df324d59fa232fd74da8", + "docs/measurements/h264-rounds/chroma-mb/gating/t8.4k.json": "aa55062c3f3340ceee7b616eeb2f5bf146bb1c6fbb01f840de75fb0c5b49fb5c", + "docs/measurements/h264-rounds/chroma-mb/gating/t8.4k.log": "0a750584935ef94e59c068e78cd54f2f22dfa04d69470662ce03660eeef21dc6", + "docs/measurements/h264-rounds/chroma-mb/gating/t8.720p.json": "698ba6eb0d092c2ac03c693b946bc31b46a70b192e9585f6a29aa188eeca5f46", + "docs/measurements/h264-rounds/chroma-mb/gating/t8.720p.log": "e8ab7e331c8645ebefc6777a6a50e607de3c249b96f5944fcb1e54ce721f5738", + "docs/measurements/h264-rounds/chroma-mb/gating/t8.sd.json": "808430a33de002447d2a9cfb4d51ceacf9d888d3e766a7fad1797b9ca911777a", + "docs/measurements/h264-rounds/chroma-mb/gating/t8.sd.log": "2bea111b0ff36faba309d33177ab2f5ac76458fafa7e23325822d323cea98a86", + "docs/measurements/h264-rounds/chroma-mb/harness.txt": "62930d6cb0c608f344e9168e56aca6e2d38933d4c2e8193c65a9fcd949dde6aa", + "docs/measurements/h264-rounds/chroma-mb/identity.txt": "00ee4900bbd323fe40cd1cf47adbe8995f590a84532351b29a185c9385762308", + "docs/measurements/h264-rounds/chroma-mb/instructions.txt": "f9595ff47b0deeff4244b0c09c19c7c8c8fa69d52f57d0033bff0f953e972a04", + "docs/measurements/h264-rounds/chroma-mb/local-timing.txt": "e0afe6d2e0e0debc2a52e6c3dc4b04a2b8cac3d65d1a119cb088de47e9b8ebeb", + "docs/measurements/h264-rounds/chroma-mb/tools/miri/Cargo.toml": "3dd330f8384d8f2112b4c2da32add9e5930b966758933acc4a66d44c63bcf49b", + "docs/measurements/h264-rounds/chroma-mb/tools/miri/main.rs": "91b8acee5cc169149013fb899743529740d2feb874c68cf1736cfca13b36390a", + "docs/measurements/h264-rounds/chroma-mb/tools/pairbench/Cargo.toml": "2d2c53b50e4043c50ae769df0967346b24310f7f346f5600e9150fe7729b71e2", + "docs/measurements/h264-rounds/chroma-mb/tools/pairbench/src/main.rs": "864b5ec73d48baedb9fb7f6bb90067bdb3b0a5fb845542e7cbbcabc353f3eadd", + "docs/measurements/h264-rounds/chroma-mc/analyze.py": "e3bdb3956ede06f1161b20426e7123a46425001ee7a833b2573520f4e2f47e99", + "docs/measurements/h264-rounds/chroma-mc/g.1080p.json": "808179a1a0cd10a638fef074e90617efe79fe929704578dc7a7bfec0dbd91536", + "docs/measurements/h264-rounds/chroma-mc/g.4k.json": "9cfb24073e577037b1d6568b89ef3f1bdcf23621f9abfcf02b229a98881c68c1", + "docs/measurements/h264-rounds/chroma-mc/g.720p.json": "856f79ae622cc1483efa9dea9c9e30c8de9dd8ff534a4785398a9927b786d638", + "docs/measurements/h264-rounds/chroma-mc/g.sd.json": "4c3e8fec85ff8f2bbfe7e669cb677db6023b7b96cbc3e8348308f6760d1d8ae1", + "docs/measurements/h264-rounds/chroma-mc/g.summary.json": "c587110f8c97ce63668d61ba32807defe25e696ccf6f53e6ba3f1847fa9475c6", + "docs/measurements/h264-rounds/chroma-mc/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/chroma-mc/instructions.txt": "aa3a1e0e2dbe33fdad8c80193ec7cdcb10c75f0d828e6bbad6e0aaa2a29e5fea", + "docs/measurements/h264-rounds/chroma-mc/provenance.txt": "621142a15496083c95df9fc81889ed626d30087c9293635280dc384ad1822001", + "docs/measurements/h264-rounds/chroma-mc/run.sh": "0dc90040f0e0c7ef710df9f3f7782ffb15bd5becf73028f1f8538e08d1a342b0", + "docs/measurements/h264-rounds/chroma-recon/README.md": "f8514e8d480dae5a4e956ad8b1a0540625d24feaa6d1c826646e45eb0a031ff0", + "docs/measurements/h264-rounds/chroma-recon/analyze.py": "3892ed7dc3b95c33284ec569117693589df5ad4607aac3b8b154e5fcd01323d5", + "docs/measurements/h264-rounds/chroma-recon/gating/analysis.txt": "6e8fb2e9b9b34c29220938d21fcedabbd997e49af7ba550cab4930e1afc46e94", + "docs/measurements/h264-rounds/chroma-recon/gating/conformance.txt": "6d5eaadb82acbc671071761eecb3294a850fe0e404340d6776c3830e154e57dc", + "docs/measurements/h264-rounds/chroma-recon/gating/fuzz.txt": "e94c82d47e09437f58c040eae0228331cb03db0ae5065e97bc86d888db18e1b0", + "docs/measurements/h264-rounds/chroma-recon/gating/g.1080p.json": "7b7941ca5e734e9e77cafffcb811f4719f990ed637534f741bbe899701e630df", + "docs/measurements/h264-rounds/chroma-recon/gating/g.1080p.log": "b07f5c63c62bb044666e48f9afddb195b5b854cffee2f4749a3cda018558b831", + "docs/measurements/h264-rounds/chroma-recon/gating/g.4k.json": "4be6d07705d40abb036080f65354e362b4ed2b5bb8cad79a189999bc1f74e0cc", + "docs/measurements/h264-rounds/chroma-recon/gating/g.4k.log": "cdac3293cb34f32d75c05f366ed281fa5a991905155ff4a49d39c16eba6d91b9", + "docs/measurements/h264-rounds/chroma-recon/gating/g.720p.json": "f8d2013e08efa6f0222569a87597ad84632e1342dfa43deefd5e362782e17453", + "docs/measurements/h264-rounds/chroma-recon/gating/g.720p.log": "76a1348a2145d619926a58d0520fdfe6971c6af51e2682694dfcebab440ddd9a", + "docs/measurements/h264-rounds/chroma-recon/gating/g.sd.json": "1f484c4190458641542264d3538159fb2ab169b73bd5d218169cb7fb5016ae18", + "docs/measurements/h264-rounds/chroma-recon/gating/g.sd.log": "63ba28bd5a99335c81382f73bccfa543799bf3a1093330d6f9671857a4042c41", + "docs/measurements/h264-rounds/chroma-recon/gating/hostgate.log": "94331ab79fd5d40c8118b77f3e817c156e93217a588da412d3690b568229c469", + "docs/measurements/h264-rounds/chroma-recon/gating/identity-rebased.txt": "2352791242fd3c6c2a839acd02208a8b3f782b8fc7de6091d800e7a64250b082", + "docs/measurements/h264-rounds/chroma-recon/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/chroma-recon/gating/miri.txt": "9d8da17f0218ea324b8dcfba825f863eccffc00c4c90ec23471b2b8913fb3e22", + "docs/measurements/h264-rounds/chroma-recon/gating/progress.txt": "92f7a1afe74ced7861c4db1d877c436c052d8af1bdf87beafd78ea5274c24a33", + "docs/measurements/h264-rounds/chroma-recon/gating/provenance.txt": "f2b17dd82acdc33c56272fd27afd5361eae42bf05dc71a9e5083a7d3962e15cf", + "docs/measurements/h264-rounds/chroma-recon/gating/summary.json": "2bf715f12ebbbf95e55d8b75ad191fbc58fef79010396f052084bfc42d1a2c2c", + "docs/measurements/h264-rounds/chroma-recon/gating/t8.1080p.json": "bd2dc9e48308b2adf2e16e5a3e45fc6c82fb6bca6e279cfa9ab76e46e626e112", + "docs/measurements/h264-rounds/chroma-recon/gating/t8.1080p.log": "3b7f1be5282add5d1a5cf0ef93731a238fee0e80ec0fe3589f2773e161969ee7", + "docs/measurements/h264-rounds/chroma-recon/gating/t8.4k.json": "4486da3535c91bd19f48bb8d5cacc2878d1a4b7c33aa52501b5192284cc708bc", + "docs/measurements/h264-rounds/chroma-recon/gating/t8.4k.log": "fd939f400bc52509e0b830f23aa641593b0e7c5110ffc5169f05a9ccdf9ba29f", + "docs/measurements/h264-rounds/chroma-recon/gating/t8.720p.json": "68e589c6b76998ab7548a1788364008f58e8141344c71409030127a2e195abba", + "docs/measurements/h264-rounds/chroma-recon/gating/t8.720p.log": "fd4a5d5b0f1cc0d21cff36dc534df8045f9fbdb3817b7013a53611cda46a33f8", + "docs/measurements/h264-rounds/chroma-recon/gating/t8.sd.json": "46e7a9eb1d2b6ae13fc0d14b93eda6b17deced3ac54a8e9b8e3bce3d6fb296d6", + "docs/measurements/h264-rounds/chroma-recon/gating/t8.sd.log": "782f11cb71054289f1de9a57cecd25254c81fc72801bd94bb6e9f6ad7bf87f10", + "docs/measurements/h264-rounds/chroma-recon/instructions.txt": "e959fc6f9c475c3eb8dfcb8f6effbe62bf3baca2048b8cae8ddf77d92a1de852", + "docs/measurements/h264-rounds/chroma-recon/level-checks.log": "144414d39e24f8f8dde46949036b8959b6011a667de1a5f5683d893362051f7e", + "docs/measurements/h264-rounds/chroma-recon/run-ab-helper.sh": "9e8fd360074c79060f1c93036984cbee0ab9c45a0c34e050ceb6a3be3f4ca727", + "docs/measurements/h264-rounds/chroma-recon/tools/miri/Cargo.toml": "b69e5d9effc5d947633ac9c866be33960378334b63131aeff874a27a86f71b54", + "docs/measurements/h264-rounds/chroma-recon/tools/miri/main.rs": "ad7d132b03e5aafb2c6f04e4894b485b2f61bc506bc26c8f5ac8b4ba9f3f3686", + "docs/measurements/h264-rounds/coarse-dispatch/README.md": "557c5259f40d161e12932c960f73cab7209b92dd1aabdf6e2fdbb57c17673eb4", + "docs/measurements/h264-rounds/coarse-dispatch/analyze.py": "d5ee153d94e17b857a1c1068a23555ff1be3c2f8a1285931ce270c190930ffa0", + "docs/measurements/h264-rounds/coarse-dispatch/gating/README.md": "7638367cc05e42d95f5899d03649099dfa21b8b9e83aaa084bc3242bf893d758", + "docs/measurements/h264-rounds/coarse-dispatch/gating/analysis.txt": "d27c8562ce7f1cf12e392a171ce4ab0e8273b4f237bb76642d111efc6b362283", + "docs/measurements/h264-rounds/coarse-dispatch/gating/analyze.py": "d5ee153d94e17b857a1c1068a23555ff1be3c2f8a1285931ce270c190930ffa0", + "docs/measurements/h264-rounds/coarse-dispatch/gating/binaries.sha256": "8908b7632374e794316fffd895e984486895dad6aef52937901a1d72314b1a00", + "docs/measurements/h264-rounds/coarse-dispatch/gating/config.json": "09c14749c168fbaaf53e29927f1fa716dd1b20b45975a71847b47c3ecc8fb8bf", + "docs/measurements/h264-rounds/coarse-dispatch/gating/events.json": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "docs/measurements/h264-rounds/coarse-dispatch/gating/g.1080p.json": "fbfbe733928713ee2f22faa259a72931686bfdefba4494cc38fe1de75479e765", + "docs/measurements/h264-rounds/coarse-dispatch/gating/g.1080p.log": "67a3128393a4ff0454c4c273955804f8b79e79f81c2b8c8660243c69c175ed1d", + "docs/measurements/h264-rounds/coarse-dispatch/gating/g.4k.json": "e586b85fb7cc6681a80f7f9af14602eeaf9679dbe14dae65f09d1a5f0e82eb9d", + "docs/measurements/h264-rounds/coarse-dispatch/gating/g.4k.log": "6e3e61582ca3076e66eb2b722987cb4e63d9a350cdc668ae548428be4bc3aa2a", + "docs/measurements/h264-rounds/coarse-dispatch/gating/g.720p.json": "4054b83ff3de8c3347805facfde25e0c69ef0bb4811250dac05df9568a2485a0", + "docs/measurements/h264-rounds/coarse-dispatch/gating/g.720p.log": "03061f965b9593b793ccfbe63110519475dc08254c0931bc3154589325b344f4", + "docs/measurements/h264-rounds/coarse-dispatch/gating/g.sd.json": "2f1d64013759f3f0da4ebbeda79c69310afcab6d94898fd267da1b9c3fb5a981", + "docs/measurements/h264-rounds/coarse-dispatch/gating/g.sd.log": "4e8c85aa43b0b176242f9085e8e2e2ee6dd5e896336490170003506eaf84533d", + "docs/measurements/h264-rounds/coarse-dispatch/gating/g.summary.json": "23297dd78f8ce6a782141c4f8777cc67b9c10b1de83f65c846d0a0ec7f3fb06f", + "docs/measurements/h264-rounds/coarse-dispatch/gating/gm.1080p.json": "ff1137998a22439993f92604199b905f6dd257fdc01592f27b58435195573c07", + "docs/measurements/h264-rounds/coarse-dispatch/gating/gm.1080p.log": "9440b307139231f0a0e6d6ca0fe5be4320a4507ea892a24cace21c08f5cf0670", + "docs/measurements/h264-rounds/coarse-dispatch/gating/gm.4k.json": "7f1413c210f18947ab75fc849844c48be579868dfb2290792f490847fccd4f0f", + "docs/measurements/h264-rounds/coarse-dispatch/gating/gm.4k.log": "b5b160b61946139a1365d8ad6dd8a82be4659ae925e48cc92da0b3f11387f656", + "docs/measurements/h264-rounds/coarse-dispatch/gating/gm.720p.json": "e009f7a02a79db6a31ca4dc59a85dcaa722ee182d0065a9c7decbdc71604f364", + "docs/measurements/h264-rounds/coarse-dispatch/gating/gm.720p.log": "388a3613880dc25a249b9d4be7387635a34fb3e8a3ec21031d0eeb1d74f02bc6", + "docs/measurements/h264-rounds/coarse-dispatch/gating/gm.sd.json": "430142421966ee7dce2dc0b44ee52a1d4219ac4353068ec6fbc0b9245dcb8669", + "docs/measurements/h264-rounds/coarse-dispatch/gating/gm.sd.log": "690bad747f981df66c1ddf1355787d1eee74e5cda1339b48c925c1652a02e121", + "docs/measurements/h264-rounds/coarse-dispatch/gating/identity.txt": "84c3b39d0d1ae6660d13f09fc7ca6f4ffbffc106ca20acbb0a8e34cf824b881c", + "docs/measurements/h264-rounds/coarse-dispatch/gating/log.txt": "c9912588d59f4a5e58cf9968920d20bf084fc1e039a9bc18e3285b3f98cc3c6f", + "docs/measurements/h264-rounds/coarse-dispatch/gating/state.json": "7562cc4e5e7650166b29cef8fdb2e99f66cff93ff62ad2805c92eca3a1dc2c39", + "docs/measurements/h264-rounds/coarse-dispatch/gating/t8.1080p.json": "d62b7d68d9a14a6baa59599ccc455cd2ebe2cde081fa86ae72bdce09b86dbbe7", + "docs/measurements/h264-rounds/coarse-dispatch/gating/t8.1080p.log": "13c13f49ff27d478c26548ae5ca176d9f072c848300a6edf6aa6efddb356d1e7", + "docs/measurements/h264-rounds/coarse-dispatch/gating/t8.4k.json": "ab40fc8f0f8382e18abaf0fedbbba9ce3627145036ad6794a8426054d360a410", + "docs/measurements/h264-rounds/coarse-dispatch/gating/t8.4k.log": "7258a36803145454984a08e6e9b391abf4fe04944d49e7d5ff1999d9239d5e25", + "docs/measurements/h264-rounds/coarse-dispatch/gating/t8.720p.json": "82c58f50c9e1c1ccf77f88af437b9ac0298cc43bb4d53a202f17603ee1ca7113", + "docs/measurements/h264-rounds/coarse-dispatch/gating/t8.720p.log": "9e88bd91cb788a05c2a3f5b20af8c6958f135d758089964d32b6012e5ce4d94a", + "docs/measurements/h264-rounds/coarse-dispatch/gating/t8.sd.json": "c26289681be0dc78aa519ff1f1dc070ebfaf5821c5dff3839a6361fa0bd8792d", + "docs/measurements/h264-rounds/coarse-dispatch/gating/t8.sd.log": "04bfcf23a209d6ecc0f9bc05567093c962a86d1b8002ff49fdf0d9f0f2d0e3f6", + "docs/measurements/h264-rounds/coarse-dispatch/local/functions-v3.txt": "762ee40a19755a6c7dc35f22bed375388e8c4e80fb6497912dc90d9a612ef421", + "docs/measurements/h264-rounds/coarse-dispatch/local/identity-after.txt": "8eea1c2af5db357c67e2236397f54b1bc1c2dcc6023111770ccd60b525ea61c9", + "docs/measurements/h264-rounds/coarse-dispatch/local/identity-safe.txt": "23229fb5a92f3781483a09b12b4c610298d74b310d09db32e84e93d9fcf76ea0", + "docs/measurements/h264-rounds/coarse-dispatch/local/instructions.txt": "a684fe8b9dc449cba963e1ad83d5d4b70c43bb2f44a4149d36312405eeb741f8", + "docs/measurements/h264-rounds/coarse-dispatch/local/local-timing.txt": "0cfcb6b7685074fa807e4ccda5d338a9095f1b2ce8c422a09ed185d58cad8a7b", + "docs/measurements/h264-rounds/coarse-dispatch/local/modes-synthetic.txt": "0e1fabaa212a28eb13aa7037b81b0a385cf1f364bc9106d7602430c7030aea15", + "docs/measurements/h264-rounds/coarse-dispatch/local/modes-training.txt": "4be107c207d80f527b048e719c9d2d50e91c5c714c21f901295e7ef63f8b9593", + "docs/measurements/h264-rounds/coarse-dispatch/local/symbols.txt": "654ccd07cb38909e8e491b1b04f245c8e212b139137c4ec8a5f2c603762fe548", + "docs/measurements/h264-rounds/combine/README.md": "3cdabf7fef0c99698c571c065ba273649bcdc9a9381417ba3be1acb4f579b5c1", + "docs/measurements/h264-rounds/combine/analysis.txt": "724fdbaf6cd41d4aa798cbd9727f6715267d7393f602b9686047b40b1dcb9066", + "docs/measurements/h264-rounds/combine/analyze.py": "d5a4913abf54f71aa18296a3c4343f44f09396ec765306a2e092cc7d4dfb33bc", + "docs/measurements/h264-rounds/combine/g.1080p.json": "f5b66c53a9e6562b3c626cd6b2352706f805efaf25495546413f821bade13d1f", + "docs/measurements/h264-rounds/combine/g.4k.json": "0032bef45d9e6d3fc5ffd6a88a52012f090378f7a72e00233b3d6bd7d5c7571d", + "docs/measurements/h264-rounds/combine/g.720p.json": "900e60aa69a66df4590a38ff2118aa3ad4d76eb29ae9fb7ea3016dec2a5a5ae6", + "docs/measurements/h264-rounds/combine/g.sd.json": "28e07c04aedebb8daf719b28915409dd3a113d04c6ea86b53ad438c8a9e5610e", + "docs/measurements/h264-rounds/combine/g.summary.json": "151259ed488c85e18379633dd30506be56cfbb2cc53839e30167d069b216be69", + "docs/measurements/h264-rounds/combine/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/combine/instructions.txt": "f4d28c5adf92f5e2123baee5734e987b1cdf2d3087372ebc68204f51314a8f60", + "docs/measurements/h264-rounds/combine/provenance.txt": "a4a422ca31372bd96d5957750c9ba3cb6c018f045693cf19da71feccfbc441f4", + "docs/measurements/h264-rounds/combine/run-ab-helper.sh": "9412e86e4dff0990b52d7c4df3c2f1dbdf943e26138fa2f38fc734708825ba08", + "docs/measurements/h264-rounds/combine/run.sh": "d2e05c8d587330151a2efe38a396e74eb02d39579e38e2d40af75eceaa9914f0", + "docs/measurements/h264-rounds/deblock-chroma-ab.json": "38f72940e3debc6e6acfaa071bb7e050b2357e3d133df43461b6417b5c44058f", + "docs/measurements/h264-rounds/deblock-driver/README.md": "c500d5f24f2be97dae157e7ba82676948e2e46fdaab100ed6da575deda5fca76", + "docs/measurements/h264-rounds/deblock-driver/analyze.py": "97f27c8e04810ff181fa1c9009d61d48eb3080fa11997eeb3d1fc4b903e71dca", + "docs/measurements/h264-rounds/deblock-driver/conformance.txt": "c0b6f45e83091bea8e6596413dbbf6a5ae687dda20e83b1426f1f1e640a9f9ea", + "docs/measurements/h264-rounds/deblock-driver/gating/README.md": "f79fe73866458391c1ed25b477c9d4ab75f953bfc3869541f4b4318b5e2cc034", + "docs/measurements/h264-rounds/deblock-driver/gating/analysis.txt": "774f5006360ee6577aefc9a9c05cdcaa6f8e93cdc60db8baf3c9cd706c20093e", + "docs/measurements/h264-rounds/deblock-driver/gating/analyze.py": "97f27c8e04810ff181fa1c9009d61d48eb3080fa11997eeb3d1fc4b903e71dca", + "docs/measurements/h264-rounds/deblock-driver/gating/binaries.sha256": "65fafa1a46dc12c27ed12f8fa1492f3194bc124453da3419479d966dbca2a80d", + "docs/measurements/h264-rounds/deblock-driver/gating/g.1080p.json": "3bd3863831187e8d26adea77015c2fd4db6877f85726cfe263481c49d99ba443", + "docs/measurements/h264-rounds/deblock-driver/gating/g.1080p.json.void1": "1704621ee0807fa4a9d47a6ea8250c0859fdbd7a4008823e0eb3db6bc3fb4f81", + "docs/measurements/h264-rounds/deblock-driver/gating/g.1080p.json.void2": "aa583799b7823a3cab3508522a80707b1b317bf5c183ab623a2d625d916853be", + "docs/measurements/h264-rounds/deblock-driver/gating/g.1080p.log": "596a5f128d9e6a1cd5f8475b9d11bee217d5c111e0cb82093243d42ca289c579", + "docs/measurements/h264-rounds/deblock-driver/gating/g.1080p.log.void1": "6cb5770510728ae23e12a19fb89250ebcc62c21e3910b0ec8a51f71dd36b14a6", + "docs/measurements/h264-rounds/deblock-driver/gating/g.1080p.log.void2": "5e6da5448425eb76c46d057558dd621692a4a56f1788b8675a1ab8b6b39de1d3", + "docs/measurements/h264-rounds/deblock-driver/gating/g.4k.json": "2b9b0a36def809bf2f9776e211603a802d8c64f9b4487f12c79b8cdd140e8957", + "docs/measurements/h264-rounds/deblock-driver/gating/g.4k.json.void1": "5a853e40e984059d5009cdb297d7b6be9ad9602760519095312aa23ba81f5f03", + "docs/measurements/h264-rounds/deblock-driver/gating/g.4k.log": "96492c063b56bc3861aff640f7f3d5aa076ab170683990ac596fe6018d77db01", + "docs/measurements/h264-rounds/deblock-driver/gating/g.4k.log.void1": "a57d091dc6c3b931bab808f84a715998a48b0ae6d41a4582e4e3a48e8252b6a7", + "docs/measurements/h264-rounds/deblock-driver/gating/g.720p.json": "96b8115036641ef37b9bb33fae417b1607445e15393100cab14dbec68e51fac0", + "docs/measurements/h264-rounds/deblock-driver/gating/g.720p.log": "b106abe3e2adc5e9f7060b489acc3cd9ca6d7186169b746bdeb40cae81e9763d", + "docs/measurements/h264-rounds/deblock-driver/gating/g.sd.json": "1dacf84845a46ccfa80b57c8d44a198e1474eab005ff58c615541e26a6e95160", + "docs/measurements/h264-rounds/deblock-driver/gating/g.sd.log": "928f55ed542b2244d43c5f302261f1286489e8199b28c23de1a5ace38cda2163", + "docs/measurements/h264-rounds/deblock-driver/gating/hostgate.log": "ebb7ee574d948653f09f62281507d5157e91d1a3c0b8f6c5eead640289693a98", + "docs/measurements/h264-rounds/deblock-driver/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/deblock-driver/gating/progress.txt": "6d37eeeed3c56c26e5bc99fc28679858031f2adb39f889896b9ab5537fbe0f91", + "docs/measurements/h264-rounds/deblock-driver/gating/provenance.txt": "e7f1dca3b8b9f1162bd649ebd3b1d2edd8e5908a1920f8eb4ab510e7b35bac0f", + "docs/measurements/h264-rounds/deblock-driver/gating/run-ab-helper.sh": "1a7fdacfb534182d3e5879a938ac209b7c54e4e819fde963992e8fa79bd6c66e", + "docs/measurements/h264-rounds/deblock-driver/gating/summary.json": "85531713d7fa98f2c967124ab90ec331b253e1c9e0531263f83bd5ae327c1604", + "docs/measurements/h264-rounds/deblock-driver/gating/t8.1080p.json": "67eac02352e44449723a1f1d73185900191a9d6d64a9edc9dfc5d44215e8802d", + "docs/measurements/h264-rounds/deblock-driver/gating/t8.1080p.log": "b4d550cd2b025c6c93e6dad4492cd866c084dca805a653190123a7f288894e2b", + "docs/measurements/h264-rounds/deblock-driver/gating/t8.4k.json": "2fd1d4837ade4eb9a984de706ed3442d8b26f85493afb3cd1cf018cc6590bcc3", + "docs/measurements/h264-rounds/deblock-driver/gating/t8.4k.log": "c83a076697a31d32d50fc9158635d673a47b09e1da5752f623b7120711d8cf32", + "docs/measurements/h264-rounds/deblock-driver/gating/t8.720p.json": "9d5b18b057e82452cc1946d10af3a80d6d5883b29f3a2c7386a86791022f0f4e", + "docs/measurements/h264-rounds/deblock-driver/gating/t8.720p.log": "7d336ccb515334bc8cc9deff28d25f042a0ccb6de273dedb0d7099588e6eb9da", + "docs/measurements/h264-rounds/deblock-driver/gating/t8.sd.json": "1798b50db9ce124409510e90105e3237b911d100f213e28791f7a8488ae1de3b", + "docs/measurements/h264-rounds/deblock-driver/gating/t8.sd.log": "e924b6fc5cb188ca6fe77f23025995aab79b7f1ab4d6f1b3a110d0694ff706c4", + "docs/measurements/h264-rounds/deblock-driver/instructions.txt": "693a62515bd8675bd99efcc5cf93b02a5e2ece2502f02923c8d4deba573acd7e", + "docs/measurements/h264-rounds/deblock-driver/k.diff": "a3fe7424e9ff7bfdd651942015617f66a973dca776218a375c164200b087dee4", + "docs/measurements/h264-rounds/deblock-driver/run-ab-helper.sh": "1a7fdacfb534182d3e5879a938ac209b7c54e4e819fde963992e8fa79bd6c66e", + "docs/measurements/h264-rounds/deblock-glue/README.md": "e8b03578901d072335de9baee7df7a18362cea58ba7e437cb87a7eba9fa0420a", + "docs/measurements/h264-rounds/deblock-glue/analyze.py": "e30a7a70ea104e6320fbdf27786e6662cdf40a9501a05cb880d6a1cc5a0ae8a9", + "docs/measurements/h264-rounds/deblock-glue/conformance.txt": "0bb54e16926a0828d6c359699063f85a2a2059e8c15cc5c79cb8f629921a2daa", + "docs/measurements/h264-rounds/deblock-glue/gating/README.md": "4b767ac97b1d3898b9b9121bd736723466d54c2d76bc89535b0006d8dcccf505", + "docs/measurements/h264-rounds/deblock-glue/gating/analysis.txt": "cafc853dbef5b1ad8d05ef9af7957b2b241aedbbd24e812c20cf5032e84a4769", + "docs/measurements/h264-rounds/deblock-glue/gating/analyze.py": "e30a7a70ea104e6320fbdf27786e6662cdf40a9501a05cb880d6a1cc5a0ae8a9", + "docs/measurements/h264-rounds/deblock-glue/gating/binaries.sha256": "3416b1c457718e5a33a563f465df2b6c16b9580b11bb4162f17f727ff4fb7790", + "docs/measurements/h264-rounds/deblock-glue/gating/config.json": "268544c415eb72f3a317a1d1536f5af9ee5b39c5383ea4ed2d1f34d9037d1492", + "docs/measurements/h264-rounds/deblock-glue/gating/events.json": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "docs/measurements/h264-rounds/deblock-glue/gating/g.1080p.json": "03ca182b8f1cbf1198fd45b69b17238dd6f05fa62e218e73ee38e39b0903dc7a", + "docs/measurements/h264-rounds/deblock-glue/gating/g.1080p.log": "03668575078928418ce66340afb1ffd55953ca10b31e1b46f373705e4dc9708d", + "docs/measurements/h264-rounds/deblock-glue/gating/g.4k.json": "2b2db7ea1a86fc010c7f114497fee9d6814daf57a2f2c2722fe180b5945da7f6", + "docs/measurements/h264-rounds/deblock-glue/gating/g.4k.log": "3c2f618dabf90dab4b7047726c2244c975baa468ec33400baf0c94e457cb0fa8", + "docs/measurements/h264-rounds/deblock-glue/gating/g.720p.json": "e83ce4f9594eca43a364e99cd8ad85658158e016b1d1b67bbeb9b493ae7b75d4", + "docs/measurements/h264-rounds/deblock-glue/gating/g.720p.log": "453e9ddc6803a0947765716d053743dc85a5e235bbebe0138428e4a1ffe858f3", + "docs/measurements/h264-rounds/deblock-glue/gating/g.sd.json": "f0ea749255901fe16e18d6757171190e2a5162cc3e54e8e808a1b31dcd14349f", + "docs/measurements/h264-rounds/deblock-glue/gating/g.sd.log": "24c5fac6cd9ac63e5b8e903b46b806894e0a2f5f7630a99ec59d27f81fba5c7d", + "docs/measurements/h264-rounds/deblock-glue/gating/g.summary.json": "9dc8d2ee2f41023067f6edf481268d0f2a1728945472ba619647d67ae477306e", + "docs/measurements/h264-rounds/deblock-glue/gating/identity.txt": "3980bdde6c8a232105cf508e121242d10b5582b01ed3f60e53dc880551d9a14b", + "docs/measurements/h264-rounds/deblock-glue/gating/local-attempts/d1-unstable-1.log": "b67cc9b44eb828b027fea51bb0223799d1700ffe34875026622a16a272c4b904", + "docs/measurements/h264-rounds/deblock-glue/gating/local-attempts/d1-unstable-3.log": "17ace136e08bd9111a87e7a29987070d463b2801282ca4525f28b8186a470538", + "docs/measurements/h264-rounds/deblock-glue/gating/local-attempts/d1-voided-2.log": "dc0ce806dc35b98e80b50f3b1f2d455da4838cd360c50533aabedb8433e66d06", + "docs/measurements/h264-rounds/deblock-glue/gating/log.txt": "1c845b77b27f31ec294dc87770c957a872b0ed5b048e92b8209ae9d8dba9d6cc", + "docs/measurements/h264-rounds/deblock-glue/gating/t8.1080p.json": "75cbcaa75eefaeac75a5be23ea27f9ae0cd836767315e14e61a3eafaf479c7f3", + "docs/measurements/h264-rounds/deblock-glue/gating/t8.1080p.log": "dbdb5bfc106ce6fe89ce2ade2a981217dabfe0bb25ce3f5074a32ddc430f7b13", + "docs/measurements/h264-rounds/deblock-glue/gating/t8.4k.json": "d78d5040950a629cedff7fa90a3ef2a0f032d015337e8384af88fdec4cdf44b3", + "docs/measurements/h264-rounds/deblock-glue/gating/t8.4k.log": "bf782a4bdedf235f2da7cc97dfa2bb7ef598c821aee2ade6423b2ec2eee8db11", + "docs/measurements/h264-rounds/deblock-glue/gating/t8.720p.json": "01cb356774356462231ad9ae68166e01ea54390ab25c671cfd1449d14afd6e09", + "docs/measurements/h264-rounds/deblock-glue/gating/t8.720p.log": "d8f8b294d8fadea9c5ff2d2eb50e6119335bc3c79cd9cb542368ff2b44921a65", + "docs/measurements/h264-rounds/deblock-glue/gating/t8.sd.json": "bec0b42e3eeb97cf8dc60aeb58701324bdfd71a3aaa7aadbbe2bb2c60aebced5", + "docs/measurements/h264-rounds/deblock-glue/gating/t8.sd.log": "29024a330ec376e1e80160d27b52d0bff2cdb314673a65fa89591991d07984d2", + "docs/measurements/h264-rounds/deblock-glue/identity.txt": "a96336f5010ffd155cb40f2a7c5fa2d3200e11f85c1add52b239d1ad9fa85b98", + "docs/measurements/h264-rounds/deblock-glue/instructions.txt": "ef0b7ee5427919fa119a1935c2c9fcc1795df7cc4ca09711d0a463e2920cbeff", + "docs/measurements/h264-rounds/deblock-glue/profile/deblock_split.py": "bb164bda7bc9445e4ea1a84018e5f874d8c44956651210d272eb289b87da2d84", + "docs/measurements/h264-rounds/deblock-glue/profile/lines.py": "89f66b35fc57330f9eb26a04ed4402895a00b9a7ebf7e491ebec6eb47c471310", + "docs/measurements/h264-rounds/deblock-glue/profile/lines.txt": "433a9982c8652e8a21270e338ef80522a55a25215a2fc965e2565836bfed3745", + "docs/measurements/h264-rounds/deblock-glue/profile/split.txt": "5aec21dd737aef5969fb56fe9d7f19c8f0c2cac45caa9d076c36bbba575d1fd4", + "docs/measurements/h264-rounds/deblock-glue/profile/table.txt": "306a54d7fc7d49050678bef00930dfbab717eca6a40f204d28655da685f64518", + "docs/measurements/h264-rounds/deblock-lanes/README.md": "226e7c50fddc41465546a8fd2f6b9f62db13bfd4676bac0cf9194ebe7af3dd58", + "docs/measurements/h264-rounds/deblock-lanes/analyze.py": "d512eaf2bb1c85b89adf874ff4f099f766a86f54cdfd377170d10e4a6f194ad7", + "docs/measurements/h264-rounds/deblock-lanes/conformance.txt": "962f2c2a44e46852ef5d8083b4516014892335a19d0bfe3d2e7e06676761412c", + "docs/measurements/h264-rounds/deblock-lanes/gating/README.md": "6270554b902b274675b1295dd7c05e3e1871cf2d4f5232262e113e243ba39dfc", + "docs/measurements/h264-rounds/deblock-lanes/gating/analysis.txt": "d5633c8aaac274f896118199c5da7bc962a0bb1cc9ed2627b584284978aa76a3", + "docs/measurements/h264-rounds/deblock-lanes/gating/analyze.py": "d512eaf2bb1c85b89adf874ff4f099f766a86f54cdfd377170d10e4a6f194ad7", + "docs/measurements/h264-rounds/deblock-lanes/gating/binaries.sha256": "c943dd4ce2f3ab44825872e979f1e4eda7fc80a1f5060aaa35bf70f711e8bb42", + "docs/measurements/h264-rounds/deblock-lanes/gating/g.1080p.json": "b02cd7953889511eae47a2f533374c074c60976cb32eec26bf9a74a458eb22d9", + "docs/measurements/h264-rounds/deblock-lanes/gating/g.1080p.log": "d231ecdf557a28fbfabd3d20939e740b89f215d2c7fdf810da44e4c695d6d7f1", + "docs/measurements/h264-rounds/deblock-lanes/gating/g.4k.json": "fb80a867d4d443d0217d695fe700761f02afaa0345e4ed67c6f9ce6a2069ad11", + "docs/measurements/h264-rounds/deblock-lanes/gating/g.4k.log": "dec2d977c3be2713566b54bb0dba8793cdc958c4ae65da8919505ed90430d7f8", + "docs/measurements/h264-rounds/deblock-lanes/gating/g.720p.json": "cafb198e51d26241eaa25783784cad0b421cc5dfcc2ee01081dea7020a0bf364", + "docs/measurements/h264-rounds/deblock-lanes/gating/g.720p.log": "814a60ef617cfb8c6af2783cac24ed4f4789847f0148716341316e52fed4d635", + "docs/measurements/h264-rounds/deblock-lanes/gating/g.sd.json": "9c4ad0ce686d2dd5b5c6b05658bce2c8fcd8368b761e98189369ec8cee9e950e", + "docs/measurements/h264-rounds/deblock-lanes/gating/g.sd.log": "822f62e3ccee110f9aad272cbe95a0dbbf707b8c8fdebda2c1745004044fcf21", + "docs/measurements/h264-rounds/deblock-lanes/gating/hostgate.log": "b212584c17b3c60d5234eca6ca9367c593e7f37fe854c6b0166cb247b176acc8", + "docs/measurements/h264-rounds/deblock-lanes/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/deblock-lanes/gating/progress.txt": "5f36411a86b0726e445c3b746aa8613f19f6b756463049b7af53b5135b49fcc6", + "docs/measurements/h264-rounds/deblock-lanes/gating/provenance.txt": "a97a9d857252b7c98d2cb48599088e33280318e634eec0d87e03c6c3ed1bb468", + "docs/measurements/h264-rounds/deblock-lanes/gating/run-ab-helper.sh": "ae6021821d4f8e712c04b544d04cf4db93a81981e84ff8fc3b768c489bfe20c1", + "docs/measurements/h264-rounds/deblock-lanes/gating/summary.json": "8446f0929639b27f85e3ecaf28374564e9aa2935f8314e867904b327d11a619f", + "docs/measurements/h264-rounds/deblock-lanes/gating/t8.1080p.json": "692cec6fd70778a06f93fded172486a78212125a5164776bc325c3d95b820d58", + "docs/measurements/h264-rounds/deblock-lanes/gating/t8.1080p.log": "5f659ae53d87d42595f06a3334cf9eeb2fdb8eddd6db9a2f0054878661fe80ca", + "docs/measurements/h264-rounds/deblock-lanes/gating/t8.4k.json": "0a05a3330df4fd33275b3c5875956a43472cb2f8262789c2662d79a8908368db", + "docs/measurements/h264-rounds/deblock-lanes/gating/t8.4k.log": "556e7d64ed94b4e75fb4184e29c6fee6ca4e9207963212c0a87b6ae955d340a5", + "docs/measurements/h264-rounds/deblock-lanes/gating/t8.720p.json": "0c33d63cf3fd575953434875f4dee00ecda684d5d943510ff59bb6e3833b1784", + "docs/measurements/h264-rounds/deblock-lanes/gating/t8.720p.log": "9c3c0a02077553399d03de3bf8e572f6612393ffb6dacdd0397f9d501b292f1c", + "docs/measurements/h264-rounds/deblock-lanes/gating/t8.sd.json": "386d6dd5c2c932e94da44195b0fef14adadd118dbd9c590db94e8605e6261f6a", + "docs/measurements/h264-rounds/deblock-lanes/gating/t8.sd.log": "544b5ca1687d3d07bc5edcb88ba07f1fc31731f078582c605d7187eff161b789", + "docs/measurements/h264-rounds/deblock-lanes/run-ab-helper.sh": "ae6021821d4f8e712c04b544d04cf4db93a81981e84ff8fc3b768c489bfe20c1", + "docs/measurements/h264-rounds/deblock-pair/README.md": "6cae0c183434f2ed481d07460d8204b8f390714d55748468487f9c4c8dca8d2a", + "docs/measurements/h264-rounds/deblock-pair/analysis.txt": "5f007fa10b8125dece54f8030e4aaecc360f7cc479b77910ceb2050762e9e501", + "docs/measurements/h264-rounds/deblock-pair/analyze.py": "562111a0472dd4f8e1af678d9842ecf864b32544bd989b8a9db4975767591fcd", + "docs/measurements/h264-rounds/deblock-pair/g.1080p.json": "37c2bb7376ec61805e5265d269bcc8610ce341bec1739e518065468834d76798", + "docs/measurements/h264-rounds/deblock-pair/g.1080p.log": "1adfb198adcd113ff60b6edabfa1c3595b30489b6b32ede78ca6792925f48009", + "docs/measurements/h264-rounds/deblock-pair/g.4k.json": "efdff94901f6556139f54dbb9ae2ced086d625226bce0f27d26b2fe970e537a2", + "docs/measurements/h264-rounds/deblock-pair/g.4k.log": "6f76eb6a4cea84faaf89786599381655b19b59bada49567080352350c0410396", + "docs/measurements/h264-rounds/deblock-pair/g.720p.json": "caffb5c41a20cce03a5441645fc63e123d7bb6c741aaa225ed9d751e80ab4187", + "docs/measurements/h264-rounds/deblock-pair/g.720p.log": "4c000f50c70d36840685f3412b393131a0ddda781fc1f07b0a6e88e8aed77a0a", + "docs/measurements/h264-rounds/deblock-pair/g.sd.json": "fe2bbeac3114bc02bcbfd229695f5b35bf2294483a886671e7e9f1c75006939e", + "docs/measurements/h264-rounds/deblock-pair/g.sd.log": "d411bf003b407596094cfa3e87a23ede8b657b62d65a08302af4a79252448f78", + "docs/measurements/h264-rounds/deblock-pair/g.summary.json": "36689f7140d955d0cd8bb90af98409d66d6fd3ce5fcab097955b85f809ae4a7d", + "docs/measurements/h264-rounds/deblock-pair/gating-README.md": "52ead75806d4a99ed71bc08b1c51bf637ab2cf1653f3e7f68454199fec0ccda3", + "docs/measurements/h264-rounds/deblock-pair/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/deblock-pair/instructions.txt": "264aa9d89c6a2d2f8d9141ceb1c07cb1726743d7ca6afeb665365674eaa3d668", + "docs/measurements/h264-rounds/deblock-pair/local-timing.txt": "8efdd5eb5b76287b529d14628031a91518631e5d5bb7428d25c346d1b2f71c44", + "docs/measurements/h264-rounds/deblock-pair/mapped/g.1080p.json": "95be106afb1e7fd3eb5a41b84c1f89ff89801e6c323b419a65d825abf2859dbc", + "docs/measurements/h264-rounds/deblock-pair/mapped/g.4k.json": "8127ea5ab0e6614c524b3c85e593dcaf1734530f46226d4e0f59a3f016db14d4", + "docs/measurements/h264-rounds/deblock-pair/mapped/g.720p.json": "ce4d7acc6fbee2f22cfc4fffb804037660303601d9a7a075cf9837d16af02143", + "docs/measurements/h264-rounds/deblock-pair/mapped/g.sd.json": "9a3b2964ea6666ea0b093387cbe6bf65c0243ed526f0f3ee7df7ba16b95d85fe", + "docs/measurements/h264-rounds/deblock-pair/mapped/g.summary.json": "36689f7140d955d0cd8bb90af98409d66d6fd3ce5fcab097955b85f809ae4a7d", + "docs/measurements/h264-rounds/deblock-pair/profile/rep.py": "953e09b0d6172371ae9b92f7e0c9bb7c7af3c330cd33e22be37b9a477f5dd068", + "docs/measurements/h264-rounds/deblock-pair/profile/report.txt": "184fbacf77906911429d1e1d6fb0b1c2bb0d594f7b6bba24788b7bf9fd0eb1bd", + "docs/measurements/h264-rounds/deblock-pair/profile/run.sh": "d7868cf7a1ef5af2803156934af8b7a3f6b56e0266a7310cf0929d5ded4bdee7", + "docs/measurements/h264-rounds/deblock-pair/profile/stages.json": "b93834a18932dd5c0da8cedf59b2224a08dfa74f84e852a87c600fa14cffc1db", + "docs/measurements/h264-rounds/deblock-pair/profile/stages.py": "9eb5af837aecdacfe5ec8e8fe4357fa50ea09dc4263ea6b1a19b178ff97bc114", + "docs/measurements/h264-rounds/deblock-pair/profile/streams.txt": "74ae5ba0edfeaeb63b2de87cf2b8489ac39df10280925eb50cdd3daeec945ab1", + "docs/measurements/h264-rounds/deblock-pair/profile/wall.txt": "3e92dda4313e9af5645dda63fdc702ef87604c252b99598d0b0717f3d59296e0", + "docs/measurements/h264-rounds/deblock-pair/progress.txt": "34c387c25595f2eb12f6a96705a041fd0972acfaae2febe162beb79cf3e0c744", + "docs/measurements/h264-rounds/deblock-pair/provenance.txt": "0f1a16bf51d512842d761e2ef319e302a535108b085d844f6d1b1c3d374e850a", + "docs/measurements/h264-rounds/deblock-pair/run-ab-helper.sh": "b50b65b6b4fd96e1ad71b1636b7c9316593a7c3437f0a83f098de033e93a3fa0", + "docs/measurements/h264-rounds/deblock-pair/tools/miri/Cargo.toml": "52654b228347e6f078a665d13fc1acedeae5527409e931d0f80f518d62016ce1", + "docs/measurements/h264-rounds/deblock-pair/tools/miri/main.rs": "532268ba36a4f5c0fa79d2e2b952bd3b58cda7506db5cebe72b77081a9b98024", + "docs/measurements/h264-rounds/deblock-quiet/README.md": "ecb67e0a68acd81b5fe0995c3e6aa1e61ba7d115d11034679615cfc4ba2ea29c", + "docs/measurements/h264-rounds/deblock-quiet/ab3.py": "e0b8c8ec0934df630df03d2744d4faaeb90552c0aa0398d6c1f2ed4923361f45", + "docs/measurements/h264-rounds/deblock-quiet/abset.py": "c3a892ac4f22b78c6affcfe75a9186c394229b342ab2093c6d7c750b33d9c694", + "docs/measurements/h264-rounds/deblock-quiet/analyze.py": "41544758e26e07b39445cb86ab4fde6c336e32694865b5406cf1927a8e08d87e", + "docs/measurements/h264-rounds/deblock-quiet/cgfull.sh": "34afaa21c985aa2b45eea6153091b67bdaffa941353fa933648a05dee7af2fe8", + "docs/measurements/h264-rounds/deblock-quiet/count.diff": "c2b73f9818a180923508ff2501b6db1d7567db8e394370417fc35c39f9b7d10e", + "docs/measurements/h264-rounds/deblock-quiet/gating/README.md": "8810eca44ad1d450d1b6f25688f3229bbcbb713fb0414ec9033a80c7cddb9080", + "docs/measurements/h264-rounds/deblock-quiet/gating/analysis-final.txt": "d660653459f4f58c327b4d6fa8fe815368bca8f4ad328fb17833c790676f7c6d", + "docs/measurements/h264-rounds/deblock-quiet/gating/analysis.txt": "3bb1a0e36574215441e8c05246189e67576260900ea35048cdee03d59f50840b", + "docs/measurements/h264-rounds/deblock-quiet/gating/analyze.py": "41544758e26e07b39445cb86ab4fde6c336e32694865b5406cf1927a8e08d87e", + "docs/measurements/h264-rounds/deblock-quiet/gating/g.1080p.json": "6d87f1793e9504eeb13c1a9a98b80f8a1f0a4583164061819f48f890c9a3824d", + "docs/measurements/h264-rounds/deblock-quiet/gating/g.1080p.log": "a9df091f75ed943330888eed3f51f078aebd269a6b494cfe3b5c68af51dabea5", + "docs/measurements/h264-rounds/deblock-quiet/gating/g.4k.json": "024f734499f3a40e9666738f45d6bc44d88ebcfdd11286fb25ec071b7295a33c", + "docs/measurements/h264-rounds/deblock-quiet/gating/g.4k.log": "2fe1ce6410eb1eb120192e0e9f4db76bfe32828c93af473ad59ea23790b7f4aa", + "docs/measurements/h264-rounds/deblock-quiet/gating/g.720p.json": "4fa7dcca12765a270d08484f1018279833c614a5ec6af5bf0b1c802db342a104", + "docs/measurements/h264-rounds/deblock-quiet/gating/g.720p.log": "1f26ea77d3a9ca9f21c0acd9a1eeee36e7e19c897161c9aea6a28fa439608aa2", + "docs/measurements/h264-rounds/deblock-quiet/gating/g.sd.json": "05d8457b252b20e79c6106aa0665c8819f47ef528b8bef9e0c0e12bb60ba1930", + "docs/measurements/h264-rounds/deblock-quiet/gating/g.sd.log": "6588804a1b76d295492b843a00882c91d3c6b3518774374e82d824be414ad867", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/create-attempts.txt": "f9d8a3fa58d6e373f562c5551c0542a57f9e61c6249c766db44431c64ed0ab2f", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/host.txt": "9f3cf798c0243b63a0188c8233c284b3881531d2351244ad96163b8024ff04e4", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/job.sh": "06ad38fac2cdcb7c99e734a6403d7603d13fc8621da14db2157cfd318ed21b3e", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/progress.txt": "577ff2a6c570996bf03ffeb3c25ef2cc19a3d878684ce82ed8f6fe3f647b20e0", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/ref.json": "c1ce82392d0d5b2e1a36826299acecd0f0664d6230fe44a765c88298e73bdd5d", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/t8.1080p.json": "516cdac7583024ae325007f3f23605b07cf041f40ef0766c60bc417451ab5958", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/t8.1080p.log": "60769e9d2159a6efd04440b3b45b93f95582c4a0a2511e35314b2b49eec48eff", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/t8.4k.json": "c39ac9c99487a2c9b716ba2f11226731cb4c88a4f61cb1e12bf0232b681eec95", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/t8.4k.log": "44d08b93bb27940ced49bab84277aec8cd8bb7e40e7d530ceaba472e1eaef223", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/t8.720p.json": "19e470f06012f5b1fa0046ca89ce5d358caf39c76228b95892d1e1db898fc2e9", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/t8.720p.log": "5f7ffef4a4ac5e0556db0d8060ab578de8a0bc7b796b47898ff124f77a6d4d68", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/t8.sd.json": "ce278c72469e7e762962381b5ca8f508e3b9d3fe0cf773d66114affc57d05e54", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/t8.sd.log": "c18a940a89a5bf4c05467dee2811bd7433e64fea80c7d12857ab336c45c110d7", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/tools.txt": "62ddfeff630da0a82257e70ce67dc1f0e66a4434f8319b6d6d4821144b770c5e", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp/verdict.json": "0444188e0904c2d1ca3c4cc91010d143bef222187bd2f871fc4fcea117dbe4da", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp8-retry.sh": "3967b05f5746ad2ad577e486dc5d53988984358103af597722983bdf1f212cd4", + "docs/measurements/h264-rounds/deblock-quiet/gating/gcp8.sh": "78e916d5a89059c29ebe8ba862200e6e59bbdc705bac44c980caca02943837e8", + "docs/measurements/h264-rounds/deblock-quiet/gating/h.1080p.json": "42a8d66613293b41c160faef204c4fec347cf711f12583578a23dcf3db8a17e3", + "docs/measurements/h264-rounds/deblock-quiet/gating/h.1080p.json.void1": "336d819c4ae04b43815122d6d132324df916120425f1f9c97958f8ff619d46f7", + "docs/measurements/h264-rounds/deblock-quiet/gating/h.1080p.log": "2559383623cdbe7bbf58f436a47ddb770f207fbf842db43ef3c36c0f97e814e0", + "docs/measurements/h264-rounds/deblock-quiet/gating/h.1080p.log.void1": "a3c9e26097c4ca183ad7b0507122486f23e05a717667ceeb0d783dda0ccfab9a", + "docs/measurements/h264-rounds/deblock-quiet/gating/h.4k.json": "2acec15cf3ab9238bffac4d5ecf74c7696fe8f711a2cf9fbf5eca06493d74a1a", + "docs/measurements/h264-rounds/deblock-quiet/gating/h.4k.log": "3c1da004c81c833f61b4902b6f619fd152ee59da44a04e16b28aa52d9ee2a322", + "docs/measurements/h264-rounds/deblock-quiet/gating/h.720p.json": "53c9f172cd946f315a4d7e484d78ed3ea5c172d24ea4e767fe04ae90a2447159", + "docs/measurements/h264-rounds/deblock-quiet/gating/h.720p.log": "adf0006af66d4337042697aa166176cf40f86a9f4682589b4339ae07651e4eb3", + "docs/measurements/h264-rounds/deblock-quiet/gating/h.sd.json": "196cf5c47c91c1184da490387053f38f66fa5288a9050388f3c43486a5d9de59", + "docs/measurements/h264-rounds/deblock-quiet/gating/h.sd.log": "6cb9de4ad17c1874e3ed6e260002eb287674c93287d040e8a66103326d15d785", + "docs/measurements/h264-rounds/deblock-quiet/gating/hostgate.log": "2fd7da693653d76312b90a88d384d16e71b7bbe608aafd6945b1dabcac1b8551", + "docs/measurements/h264-rounds/deblock-quiet/gating/identity-after-main.txt": "bbdae18d4361022202aa16c6652c264d6f4278d7cf8bfa6f2a791d77dc9ab9ac", + "docs/measurements/h264-rounds/deblock-quiet/gating/identity.txt": "895eaac4d3308327d074a4daf0d600989a88496500bd716fbc77dcaab2f3063f", + "docs/measurements/h264-rounds/deblock-quiet/gating/progress.txt": "1e94ea0779358d225880395a1294f823faee96b5d364d56e1cdcfd00be2ad98c", + "docs/measurements/h264-rounds/deblock-quiet/gating/provenance.txt": "b264189591652eb98cfb6b38d26b1c80de2b42c7fa097b56b80799506a1d9b0f", + "docs/measurements/h264-rounds/deblock-quiet/gating/run-1t.sh": "b6b6f273958c34d04630b75b2182b4f77c5bd1d699ce9b21ab10d894ca6fe8ee", + "docs/measurements/h264-rounds/deblock-quiet/gating/summary.json": "5fafd2b8cc73647c7bf185f45d2d80e58041ea012a137211e94843673597de33", + "docs/measurements/h264-rounds/deblock-quiet/ident.sh": "513dbf247ab7c1bc6bdc117c8cab7737afc11446ac1a4c0e26aeddc41bb5f3ff", + "docs/measurements/h264-rounds/deblock-quiet/run/ab-k-summary.txt": "99371ba90c4de93a81f5a036660d8eda2dba4ae007d8ae59fcb8a6bf14bb41a0", + "docs/measurements/h264-rounds/deblock-quiet/run/ab-k.txt": "c92fa5a8efbe24760b2afdbdedccfd13f7d72659f77d31d35ffeee21aade419f", + "docs/measurements/h264-rounds/deblock-quiet/run/conformance.txt": "b07ca6d6fcf83f7398f676d365f04b2f1c578294fff3ea6b1f70c8778c00cdb5", + "docs/measurements/h264-rounds/deblock-quiet/run/deblock-counts.txt": "322c3ebff7598494bae6d45c9db9a706ceda011701f6536e63c312d8173126c9", + "docs/measurements/h264-rounds/deblock-quiet/run/identity-nofast.txt": "c86042912fec023c80bd1869ce6a146dcb7114daafdafddfdfc984b96f4fef82", + "docs/measurements/h264-rounds/deblock-quiet/run/identity.txt": "0828580ce0d9a5034624cde878750c0376095d77f933321713f82ee658176805", + "docs/measurements/h264-rounds/deblock-quiet/run/instructions.txt": "d9ae751633131a0e2a68ea11f4fb008e31c281c4492f7e8b520ca2e2d6b6aa02", + "docs/measurements/h264-rounds/deblock-registers/README.md": "9e9dc90e08fc4ae199bb2e89b4f6f66fa619ee55dfe369283f0775f99d31a3e1", + "docs/measurements/h264-rounds/deblock-registers/analysis.txt": "e7af0a32568b0c046aa18902cfe36ed30791d62c1ace41defa5a9b0b9cf47d38", + "docs/measurements/h264-rounds/deblock-registers/analyze.py": "116f0ef300c2ce06c0a52af0137a325200680af87f6bad00715dd50ed39f5222", + "docs/measurements/h264-rounds/deblock-registers/g.1080p.json": "bc230da5fc4e2fced7ea83a1f3afb00ef24b5543fbfd8b527bbbd0c8d31eca47", + "docs/measurements/h264-rounds/deblock-registers/g.4k.json": "a6b8bc92455344b1438ad3749c6aaf4fc59a75516dade6c723b83e59d2ffa92b", + "docs/measurements/h264-rounds/deblock-registers/g.720p.json": "2ab4c9b8cdb053002e47163e9c90944c9b74a554ce9e1812aaac9f6165bae742", + "docs/measurements/h264-rounds/deblock-registers/g.sd.json": "1de5b49cf1c21a8389f04b248acbd2e51e3a14cc33305895c623fdc0e0275f82", + "docs/measurements/h264-rounds/deblock-registers/g.summary.json": "c5bb0d6336f845f30e31bb37d8768d07501ffdd449978ac759ee9eee2abb4ac0", + "docs/measurements/h264-rounds/deblock-registers/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/deblock-registers/instructions.txt": "5135a85f1bcb71c05f24fd87c15b445ef2d105947394c988b86d193693938a4c", + "docs/measurements/h264-rounds/deblock-registers/provenance.txt": "bd6cff703034913b48b41e7fa1b3771b806494a99b9eed0d0474c015759f6924", + "docs/measurements/h264-rounds/deblock-registers/run-ab-helper.sh": "62ebdc531eb316fb245db7048ba54ae7793ecef326f1f82f36d42e0a27894c9c", + "docs/measurements/h264-rounds/deblock-registers/shapes.txt": "04c161aabd96863554b6be344a324c847ffada5add549fb2c999c81799778eca", + "docs/measurements/h264-rounds/deblock-registers/tools/count.sh": "3d444c2182cddf66e2d301c09bf60bdb3630f8967d6c140ea48f556fe02a957a", + "docs/measurements/h264-rounds/deblock-registers/tools/dbkcount.Cargo.toml": "f90709428e206a48174e61f9bad99bd01da28a72c23aaa062d524718db5ff57d", + "docs/measurements/h264-rounds/deblock-registers/tools/dbkcount.rs": "6a82465af25de29598feaf8b5412ae975febc85f2534980284e54ca2ee65d9af", + "docs/measurements/h264-rounds/deblock-registers/tools/miri/Cargo.toml": "70cae210f7a4a9918f644f59897ae6d13cfb5d320094ca1002bf7ce111a318b8", + "docs/measurements/h264-rounds/deblock-registers/tools/miri/main.rs": "f921077391c1e225421468ea9426249d71d044a962c6439ba1fcdacb46909d16", + "docs/measurements/h264-rounds/deblock-setup-probe/README.md": "05af78360e2bff52a2b669570f721c7aa253af662585bf0e8605f3e92e76642d", + "docs/measurements/h264-rounds/deblock-setup-probe/bound.jsonl": "daf49bdc510929397fb082d08f03e65d9892bfcb3f5b4abaa5fdb959ae386f87", + "docs/measurements/h264-rounds/deblock-setup-probe/bound.py": "da63760122256b97c856fceeced7dc330dd2ff6f7c257beb50e0f44ef93e1812", + "docs/measurements/h264-rounds/deblock-setup-probe/bound.txt": "28acc7e572572bafa3bafccc957b578806043275c8ff6d3bf4dc51182e82f55c", + "docs/measurements/h264-rounds/deblock-setup-probe/cg.sh": "92db85f25e19324a9f3999f4dd8681f863731cea41c193d37898f976aded26e7", + "docs/measurements/h264-rounds/deblock-setup-probe/nmb.sh": "d1da582153b46a91aec051af0938b260f67b18c7010b60a8b484669d7c51fb4d", + "docs/measurements/h264-rounds/deblock-setup-probe/nmb.txt": "c667c9d1a2f5a984017c86c1dc05a2e694bc8e2e7ad587c4b33b3cbfc6ec6a56", + "docs/measurements/h264-rounds/deblock-setup-probe/perf.sh": "b3c77dca5512fec0a81e4801624460fb9ab9526fc6158a0aa95245d545333159", + "docs/measurements/h264-rounds/deblock-setup-probe/plan.txt": "c69b23330f3a0c7c0699fd765cf2fb2a29c5582a9e7ab8f6483d431372dbb61d", + "docs/measurements/h264-rounds/deblock-setup-probe/table.py": "73eed20c7d2af91fdb14f8842ecb5004ca3c90980997597e23a30162cd654fb3", + "docs/measurements/h264-rounds/deblock-setup/README.md": "89c789384cf4eb719b324a8dc6006be93daeed49caa5957cacfefaadc00065f9", + "docs/measurements/h264-rounds/deblock-setup/analyze.py": "3b88b84b811cf8cbfc9b5d6ffb1a8d2330e89e9e650ce9bea60d77427591ec35", + "docs/measurements/h264-rounds/deblock-setup/conformance.txt": "80e5b3a442a70f23e48a71f2da00c41c094ccd75cce8466d537e39e471f71491", + "docs/measurements/h264-rounds/deblock-setup/fuzz.txt": "509238e94ba1ec9d596df1f5bfece2d79fdd16f63880e9503d55a32ab664fb77", + "docs/measurements/h264-rounds/deblock-setup/gating/README.md": "3322dd1939c043b1ffa1cb558eb464d0da5af367c22d108f2971228a5abc99e6", + "docs/measurements/h264-rounds/deblock-setup/gating/analysis.txt": "833d40eaf29cca71414103ae4c8d635372dac3ce1609fae46d25671342c0c494", + "docs/measurements/h264-rounds/deblock-setup/gating/analyze.py": "3b88b84b811cf8cbfc9b5d6ffb1a8d2330e89e9e650ce9bea60d77427591ec35", + "docs/measurements/h264-rounds/deblock-setup/gating/binaries.sha256": "3f16cd8157bf704ba99ce480dc63566b8c75843f85b51b4741c8e7ce2a3843fa", + "docs/measurements/h264-rounds/deblock-setup/gating/g.1080p.json": "5f75f8918085bf69096b675543bc83214c55c5eb556b8d45fcd5a42b2695b96d", + "docs/measurements/h264-rounds/deblock-setup/gating/g.1080p.log": "fa34eff9caf7822e36e54ae917c54c432d70539a4dfed3ee9e2d6040f06b19c4", + "docs/measurements/h264-rounds/deblock-setup/gating/g.4k.json": "1d39f5158323db082934c9494a87e55e0c62c77a4702d3d2c3a7695a34eb2da0", + "docs/measurements/h264-rounds/deblock-setup/gating/g.4k.log": "7ae67c95cbfd1b2e2634086d546d9cb54ef6e9bf6e947580323cbe5d64bd8128", + "docs/measurements/h264-rounds/deblock-setup/gating/g.720p.json": "ab3ba24fbee19f1d0956f7f34ae1171e6d9095eba06b28c9ec67bec247f2cfdf", + "docs/measurements/h264-rounds/deblock-setup/gating/g.720p.log": "6e9c8161650697a827b4616f923e8c2f12bec88da57dac76aae4bcb77d6b6ff7", + "docs/measurements/h264-rounds/deblock-setup/gating/g.sd.json": "4536443b25076280b2be68c113205560cdf1eab4b3629b5aaa3801ab42121aa2", + "docs/measurements/h264-rounds/deblock-setup/gating/g.sd.log": "5ed22b9aa92e3a3502c68b8274cc7cd361184c09d6a1b59d6069561f7fa30f51", + "docs/measurements/h264-rounds/deblock-setup/gating/h264_parity_acf3ee2f.py": "66495d433e8e7454ae8844e2c0ea6d18f269cb296bd2b48acecc81a680c43923", + "docs/measurements/h264-rounds/deblock-setup/gating/hostgate.log": "ea5ac4d14b1d008c7445637f398056985454cacca1ed9e4a0b8b460206c38e4b", + "docs/measurements/h264-rounds/deblock-setup/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/deblock-setup/gating/progress.txt": "8ed0e6ab6422ee71fbd2ba62dd993de50fe349afacd81db94b9a3ee8ab0cd72a", + "docs/measurements/h264-rounds/deblock-setup/gating/provenance.txt": "69ec215b9e9d0c245f8564d6b0a2e04fd23b2395740b320e2ce57bb761282fe4", + "docs/measurements/h264-rounds/deblock-setup/gating/run-ab-helper.sh": "e74f92c12ac5330bb7327b7c7f67db9a82a4de0e9398e665c585bbb93bd5d347", + "docs/measurements/h264-rounds/deblock-setup/gating/run-t8.sh": "189ae4c94e7779c433e97ca88d44e8a20061522d94f10605b668a3cc642fc4b4", + "docs/measurements/h264-rounds/deblock-setup/gating/summary.json": "881d3906ba2511e1d0f814e06882ac1f347e992a9400dffed3520ddc3977f2f2", + "docs/measurements/h264-rounds/deblock-setup/gating/t8-aborted-1/t8.sd.log": "f9f61024a50f5db97e153f344a64dd50b0e715b96cb3766b1f0854baf6c64885", + "docs/measurements/h264-rounds/deblock-setup/gating/t8-aborted-2/t8.sd.log": "8e3ec9130e8301036eb12b147655b888849bc9e7a443ccf2503fb779f4516688", + "docs/measurements/h264-rounds/deblock-setup/gating/t8.1080p.json": "01bd06bc93c99c98d7ec8e9318b852f268436a6fe99aae70051c21ded19b7bb5", + "docs/measurements/h264-rounds/deblock-setup/gating/t8.1080p.log": "c5104346af29b3b31f69875378dfc6928a53ab8f79bc784a7995fd4d49f73c6e", + "docs/measurements/h264-rounds/deblock-setup/gating/t8.4k.json": "59902ce460e62f0478213e9c046101601fa0e434153a909d616371bd091fdc2b", + "docs/measurements/h264-rounds/deblock-setup/gating/t8.4k.log": "46553c5983912d5c8771aa5638c88cf68bc307ed95221ddda43d98947d2a5eb0", + "docs/measurements/h264-rounds/deblock-setup/gating/t8.720p.json": "abb3f625ad529b4be742919c8755de6c92201d373aa2970970d3f91aac909d21", + "docs/measurements/h264-rounds/deblock-setup/gating/t8.720p.log": "a5f694c4ea92ee655e21fda0327f02dfa9ab7cd39c13711d5a50c31953fbe402", + "docs/measurements/h264-rounds/deblock-setup/gating/t8.sd.json": "2c34364513981d73c5bb524565dcbcafc023fb93d77a334029287f2822675a36", + "docs/measurements/h264-rounds/deblock-setup/gating/t8.sd.log": "fc1c2aee23aa9894699df99a82999f20dfa23552ddfb40ec8507997439a7ebf3", + "docs/measurements/h264-rounds/deblock-setup/gating/voided-old-pair/g.720p.log": "fc3d23b3a24afc20f804739c6c4fdf2e31a3aec3c71065a8eb2abc0a4a614c43", + "docs/measurements/h264-rounds/deblock-setup/gating/voided-old-pair/g.sd.json": "ea00985c13770ed0aac57e74b7739c94787c0338d998aa61a0d8210b6100ac16", + "docs/measurements/h264-rounds/deblock-setup/gating/voided-old-pair/g.sd.log": "042cc73bbfb1789fbc62b3afb9f4d651d385339e77c27a8177211e1192946e34", + "docs/measurements/h264-rounds/deblock-setup/gating/voided-old-pair/hostgate.log": "cb9bc6c4bad2279eb0cd060eacf252b029d55ac2bd4b99ef1c3ad08daa9e1cb5", + "docs/measurements/h264-rounds/deblock-setup/gating/voided-old-pair/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/deblock-setup/gating/voided-old-pair/progress.txt": "3012ddb5d395b9d925c98ca9f6b7301f4ebb2c1728b396d78998514bd7653b24", + "docs/measurements/h264-rounds/deblock-setup/gating/voided-old-pair/provenance.txt": "dde217b6f691fdee29dcdf94397a483566cba1651dcd57c583f0d4ba6773f0af", + "docs/measurements/h264-rounds/deblock-setup/run-ab-helper.sh": "e74f92c12ac5330bb7327b7c7f67db9a82a4de0e9398e665c585bbb93bd5d347", + "docs/measurements/h264-rounds/deblock-strengths/README.md": "86301478f13d2ee239fd2ab0dcf2c43052e6d0f872777235c9d064ae0bdfc85a", + "docs/measurements/h264-rounds/deblock-strengths/analyze.py": "87c09f5a7ff2225891a34772b2e933d2eba931818464a5832c0693f90cb2ee43", + "docs/measurements/h264-rounds/deblock-strengths/cache.txt": "d990d3729316587504cc4d21ad71f3ddf665e3c00dbf3b50f820a4730d9b1523", + "docs/measurements/h264-rounds/deblock-strengths/conformance.txt": "f82480af98bd7adf16c7647fc37f5bff8b48685052b26672bc48e7532437ebe7", + "docs/measurements/h264-rounds/deblock-strengths/gating/README.md": "9733502539c9451528912212ef28277be252e19e901b6936778ed169e56dffae", + "docs/measurements/h264-rounds/deblock-strengths/gating/analysis.txt": "2f2c5a5a2b20fc2693008142073e63016da2948e3ecddf4b33cbd63f1e55c902", + "docs/measurements/h264-rounds/deblock-strengths/gating/analyze.py": "87c09f5a7ff2225891a34772b2e933d2eba931818464a5832c0693f90cb2ee43", + "docs/measurements/h264-rounds/deblock-strengths/gating/binaries.sha256": "a4b4429cee6008c42fbd120285b981ebfcfaeb1bf0459dd0bfab9c6e3aa2f55b", + "docs/measurements/h264-rounds/deblock-strengths/gating/config.json": "2a1fa6fb2e8021f0c0c0af042bf73d91f8d04439b61bd254b8b272fef25f97e3", + "docs/measurements/h264-rounds/deblock-strengths/gating/events.json": "eb7e69d2b276ceb5ec4659e742490fad4e8193e9a25c1e19612b817d59468a0e", + "docs/measurements/h264-rounds/deblock-strengths/gating/g.1080p.json": "e16a7314b048b55570fbbdb19a8ea327bdf3880101ce59e26174ed072564efe8", + "docs/measurements/h264-rounds/deblock-strengths/gating/g.1080p.log": "228ef6d6377a2d777f68032f0caef192f7369b580b36483f642d11103043ecb2", + "docs/measurements/h264-rounds/deblock-strengths/gating/g.4k.json": "299525387fc9d2cbafe7cdf7fd29fb448485c4557cd35c14b3381af9d4faa918", + "docs/measurements/h264-rounds/deblock-strengths/gating/g.4k.log": "91b68a924840a3a82f97531c1f40ca5ee08a5426bece57b2271bca77913e8776", + "docs/measurements/h264-rounds/deblock-strengths/gating/g.720p.json": "667a53643c820410c57ce412b2543ea76d44a1997cc2e653774a002592f4a17d", + "docs/measurements/h264-rounds/deblock-strengths/gating/g.720p.json.void1": "52d9202a3e4c6817cf2cfaf4dfaf899b309ad36d4d44c1b4b0b2c878eca23cea", + "docs/measurements/h264-rounds/deblock-strengths/gating/g.720p.log": "57849667ed7b8bb06a837c7a7e8a3763f16b404bb2b13ef54dd123ae69a95da5", + "docs/measurements/h264-rounds/deblock-strengths/gating/g.720p.log.void1": "a0e905d37dfe92ef7ac0de40aab9c4efe8d817068dce0376b3b09a6e2c82ae56", + "docs/measurements/h264-rounds/deblock-strengths/gating/g.sd.json": "4c769a0059ab8bf6eb52e69c00232bd548bd523f30556100e40dde4aa3ef700b", + "docs/measurements/h264-rounds/deblock-strengths/gating/g.sd.log": "646316fa12c5040240ab0649a5aaa7dcaa7eba40254bb4b47f13d9495365dcaf", + "docs/measurements/h264-rounds/deblock-strengths/gating/g.summary.json": "de00e1c8b96c8a49f318b624984ec37e65f184e858322b7e9724111ca5cf0a76", + "docs/measurements/h264-rounds/deblock-strengths/gating/identity.txt": "3980bdde6c8a232105cf508e121242d10b5582b01ed3f60e53dc880551d9a14b", + "docs/measurements/h264-rounds/deblock-strengths/gating/log.txt": "a305153a8f2715ed6491b656169bf753b056ed1b48bb7512cd664b7babeb0fc1", + "docs/measurements/h264-rounds/deblock-strengths/gating/t8.1080p.json": "9a874046582ee71ace93f97083910ee245dac2735db794229ca87d70ceeb2138", + "docs/measurements/h264-rounds/deblock-strengths/gating/t8.1080p.log": "d006076b18c127e2d278b21fe721338577f935c0fa0d5344cac3eb9ca70e6c3f", + "docs/measurements/h264-rounds/deblock-strengths/gating/t8.4k.json": "c0512d84e0efc08ba73fd6019d7cfbc578f8892a399a52a9442d8de5ef257323", + "docs/measurements/h264-rounds/deblock-strengths/gating/t8.4k.log": "7cf33a4d21f7cc9e3ee8ca686f3e554b760298b50dfe32acbffc1d5c09409496", + "docs/measurements/h264-rounds/deblock-strengths/gating/t8.720p.json": "0a608ae14a30cdda11e631e051616d6f9b670219023fec8d71fb9b63cc8360b0", + "docs/measurements/h264-rounds/deblock-strengths/gating/t8.720p.log": "ebee24bff583822166d95e846d0e96638249ea6d9d845b9c092e46feb9d88142", + "docs/measurements/h264-rounds/deblock-strengths/gating/t8.sd.json": "a36063376c171e46529040f59301110e5f053f63639e3f142fc12127ab8f0b28", + "docs/measurements/h264-rounds/deblock-strengths/gating/t8.sd.log": "4cdb9f1b5e610567d75ebfb6b7aa8633dc54986acb477d04bfd41b2e05e8f720", + "docs/measurements/h264-rounds/deblock-strengths/identity.txt": "3fd705028020090f40866d494b540e68f557fc84d18989e5e0f7fb1113679d77", + "docs/measurements/h264-rounds/deblock-strengths/instructions.txt": "8137ecd2c754a31f1dd0171fc4126cfac92f190f341920629c04e7580ab067d2", + "docs/measurements/h264-rounds/deblock-strengths/local-prefetch.txt": "f5015ad7f5e2f832636a2b42971c79c997c2141529128ac22f75d5f35c63923a", + "docs/measurements/h264-rounds/deblock/analyze.py": "87da2e3b592ed2f43544a010fab99c4b5b89891c4a585df24137159f3360b00f", + "docs/measurements/h264-rounds/deblock/g.1080p.json": "3d88b6dcfe48bb03b6ee83fb2b34de69848d70abb79715b238197cb9b3e55205", + "docs/measurements/h264-rounds/deblock/g.4k.json": "45f80f6d339965f7ae73e8e9e0559aac0718850756528c0c94a1a79fa4ad66e2", + "docs/measurements/h264-rounds/deblock/g.720p.json": "2d2e6637f4dd266a20f728a944e2d863587649933ae7895d8d084eb2f61d7629", + "docs/measurements/h264-rounds/deblock/g.sd.json": "a8bdffd7c9f3a582b1c2f148f5618a5d60f80ee0398399e6b420877bb4ed6f42", + "docs/measurements/h264-rounds/deblock/g.summary.json": "f18000adb6bcec2ac7d5c315fe0187eec40ce0665820ce02ec7d6ebd11081d02", + "docs/measurements/h264-rounds/deblock/identity.txt": "21b426d52b85395c3de863cbea6c193fb912d7220587a04669f30d830cc1e125", + "docs/measurements/h264-rounds/deblock/provenance.txt": "7888825863044bede880629e6edee29ec772a70b75c3ce23101773f3526e10e9", + "docs/measurements/h264-rounds/deblock/run.sh": "8b908d14309e1ca3d6b8e7fb76cd3507ee44b1e360c45377f1ae31c63e482db5", + "docs/measurements/h264-rounds/decision-asm/README.md": "7be19dc92bcc44076f4244421424108034fb4794fb767d6023f8289618ef71da", + "docs/measurements/h264-rounds/decision-asm/ab-k-summary.txt": "88d0df338541d9dd2b3757f5cd7706efe6cce342d9394d3fd9c2a8fb0208ddec", + "docs/measurements/h264-rounds/decision-asm/ab-k.txt": "a60a6ef75ee7a6a60ccada2acdae6e45a42b3d8869912ea7b6850d8a3e143b72", + "docs/measurements/h264-rounds/decision-asm/ab3.py": "8f0abb2a95718ed2ff5f6ada28f9cd811315bfdf9dda3d81cde00e9ed8678ab9", + "docs/measurements/h264-rounds/decision-asm/abq.py": "978032f511d6e115d8e586e26153990c107f109529a264af5f9b9c253393fedf", + "docs/measurements/h264-rounds/decision-asm/binaries.sha256": "06f5aef16c0a602e1e3e83b33d9c824cff2712c1b992799bde17d7f51477c889", + "docs/measurements/h264-rounds/decision-asm/cg32.sh": "98065fb6d5ac8c249a9dabc0289083651a0e14c75a675941431abdca087f878e", + "docs/measurements/h264-rounds/decision-asm/conformance.txt": "da4e23a33084eda262c051cd179311a3bc41c75b7059062298b9e52326599a10", + "docs/measurements/h264-rounds/decision-asm/count-32.txt": "9c5ef742a7b99325420b49e8c170fffa9791d3c1ce59370b3e51afc4cd6b3119", + "docs/measurements/h264-rounds/decision-asm/count-a81.txt": "27bc3c4b933f99e4ad5c38f40e52a067e70317cc5021385687cd1c1bdcc61a9e", + "docs/measurements/h264-rounds/decision-asm/fuzz.txt": "3bb664b74bbaa89213cca396ddef3f2430745a4b9b2b448dbe029fe582dbfa3e", + "docs/measurements/h264-rounds/decision-asm/ident.sh": "ffa55e2455f4c709649e0a903a71665192509d271f0b235e3536df49bac4bc4d", + "docs/measurements/h264-rounds/decision-asm/identity.txt": "4067d157acbcafb398f0aff3b1252b788b930e3c1f6d85af7563f8043daed4a3", + "docs/measurements/h264-rounds/dispatch-wide/README.md": "9b5fba7d324ff5719add40860d5c933d45ffb168f2a53f66868e86f96b1ab9a8", + "docs/measurements/h264-rounds/dispatch-wide/analyze.py": "5dfc2cb4e45660b532cfb5371515e33aa6aa6daf4f2b02e7f5a8037cf8ab2c16", + "docs/measurements/h264-rounds/dispatch-wide/conformance.txt": "76e12ff8e7df20bf0fc3f024da0399f954bbe3db2cef66fb5bfad31865eb038f", + "docs/measurements/h264-rounds/dispatch-wide/gating/README.md": "1685563ca9fa6bd23aee33edca4b4d9447fa59b1cf39d41be2992e4b7abb9e7e", + "docs/measurements/h264-rounds/dispatch-wide/gating/analysis.txt": "50324df72fecec4eb5345e5abef15b3dbf75b17891dd60d0608f35bbf2839a11", + "docs/measurements/h264-rounds/dispatch-wide/gating/analyze.py": "5dfc2cb4e45660b532cfb5371515e33aa6aa6daf4f2b02e7f5a8037cf8ab2c16", + "docs/measurements/h264-rounds/dispatch-wide/gating/binaries.sha256": "da2214ee889531524961be3e2551585e26c71291ef55189c527c1598c17a723c", + "docs/measurements/h264-rounds/dispatch-wide/gating/config.json": "09c14749c168fbaaf53e29927f1fa716dd1b20b45975a71847b47c3ecc8fb8bf", + "docs/measurements/h264-rounds/dispatch-wide/gating/events.json": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "docs/measurements/h264-rounds/dispatch-wide/gating/g.1080p.json": "ff5596a5e96659021c709f21db87e0ab9a5e5ba137bf08a53b8e07549d388947", + "docs/measurements/h264-rounds/dispatch-wide/gating/g.1080p.log": "4b0e9136eafcfe6ec6fb43d12b57dc18e58fe236ec9ad752321fbf3421913268", + "docs/measurements/h264-rounds/dispatch-wide/gating/g.4k.json": "0f00b56f067fac0c375516b025b3096b0feb80259311a5da90b43ee4b63543e0", + "docs/measurements/h264-rounds/dispatch-wide/gating/g.4k.log": "be95d5f3b7d3c8a3ac45f35bfb062b3dddb182cd4585cb45b85b791a50bfc820", + "docs/measurements/h264-rounds/dispatch-wide/gating/g.720p.json": "47e08b9e3406bd9600d719a819174c88c5e7faeca9985e1c75258e4f909bd45b", + "docs/measurements/h264-rounds/dispatch-wide/gating/g.720p.log": "06af28c07bae5d069fcfbb456a029bd34bf1bc3a525889d3a15957a1dc7d40fa", + "docs/measurements/h264-rounds/dispatch-wide/gating/g.sd.json": "7578a67e1b75674b8da9694745be327c3a8a4df769bf27ea7b18d7c206d61058", + "docs/measurements/h264-rounds/dispatch-wide/gating/g.sd.log": "868bce293d266c1a1879edfac50ee7f2a2bf307dcc8514596979743db7d5b06c", + "docs/measurements/h264-rounds/dispatch-wide/gating/g.summary.json": "8b1cf2b1581a26b3921a7c31c88208cd2b20256afced15d6b6bf056d22399d21", + "docs/measurements/h264-rounds/dispatch-wide/gating/gm.1080p.json": "b83728a7362d18e1b4f31c5e3770ecef561984bf358577b2539e00938dda458c", + "docs/measurements/h264-rounds/dispatch-wide/gating/gm.1080p.log": "3412011b53a67f1d5fdff6bef97b6ebfc239d28c713f974930a3c1f1ec472688", + "docs/measurements/h264-rounds/dispatch-wide/gating/gm.4k.json": "872506ccdda547b1f9ae6886b3d03b74dd7f8c7d9d920bb96bc589d44fccccb4", + "docs/measurements/h264-rounds/dispatch-wide/gating/gm.4k.log": "7f4ad34d9b54df6d064af51733bc11b766a031b4c5fd1886f12b7853c754a04b", + "docs/measurements/h264-rounds/dispatch-wide/gating/gm.720p.json": "eb340ffa29c678fefa6d4e1e5bca62f848ce867d0cbbc613ab28c55066ba6921", + "docs/measurements/h264-rounds/dispatch-wide/gating/gm.720p.log": "664cf423af01c784231be4f9989e2805d455404d02ee00f317413cc3aca25769", + "docs/measurements/h264-rounds/dispatch-wide/gating/gm.sd.json": "0e404de235418132035a9389c7dd4662d5f526e55c4613d0b50f2773609ace26", + "docs/measurements/h264-rounds/dispatch-wide/gating/gm.sd.log": "1b37bbed80abb4016038bc4184aa4aa21ccf45c872235b583af64a84db9c26e9", + "docs/measurements/h264-rounds/dispatch-wide/gating/identity.txt": "84c3b39d0d1ae6660d13f09fc7ca6f4ffbffc106ca20acbb0a8e34cf824b881c", + "docs/measurements/h264-rounds/dispatch-wide/gating/log.txt": "fde87aef322a55f2c2603d4039e3fadc7c2e3da8ee0acdf717916ab8d014fc0a", + "docs/measurements/h264-rounds/dispatch-wide/gating/t8.1080p.json": "c455ff7a6c0bb868249a111c2c55cb5a4436c7fb28ba0bcc5d1484f5074b36aa", + "docs/measurements/h264-rounds/dispatch-wide/gating/t8.1080p.log": "46c1954826013652b41f74b9cfdf2c73f6f587ea9d77eece397259ba4def01f8", + "docs/measurements/h264-rounds/dispatch-wide/gating/t8.4k.json": "35a2e3bf99a473fb50f68dee2297e5e9144ce099012228375698d573b6fb82ca", + "docs/measurements/h264-rounds/dispatch-wide/gating/t8.4k.log": "41ae03e965740777c660d4450243581b3ec8d18fa5c2962852d565eac5683038", + "docs/measurements/h264-rounds/dispatch-wide/gating/t8.720p.json": "1763d89fac707df477c00081945b0799f5f73f26e53b6ba8a036e290b4e811f6", + "docs/measurements/h264-rounds/dispatch-wide/gating/t8.720p.log": "3efd311504ea88006e4c55116556c2d48b9f39da9f9f05add72d87765a484f70", + "docs/measurements/h264-rounds/dispatch-wide/gating/t8.sd.json": "a3749730df03fee06cd2f7cc1ae86727492b2793e35bdc94037f35b59696512f", + "docs/measurements/h264-rounds/dispatch-wide/gating/t8.sd.log": "da3860cceb9502c1c7ef9e36ae10343acecd1fe4bcc4fdb7fa641b56e7c3543d", + "docs/measurements/h264-rounds/dispatch-wide/local/files-rejected.txt": "f9ae873fcbbe8359a4d79ee7e320f73a757898c1233727b3fec999f456d69d7d", + "docs/measurements/h264-rounds/dispatch-wide/local/functions-rejected.txt": "5274b3d5c2f0eb1b925bfc8ce876ce8ff616468837ee37247dc98b01413712c4", + "docs/measurements/h264-rounds/dispatch-wide/local/functions-w1.txt": "43603f35f04fcf23719c535a63b7f4f8e0e0dec36b59f506ab871531ce0f8ded", + "docs/measurements/h264-rounds/dispatch-wide/local/functions.txt": "6c7c84966e384caab917347142cd505eeaf167b2a2ce64395311b0ef9d0d484e", + "docs/measurements/h264-rounds/dispatch-wide/local/identity-after.txt": "297cd270f786b84b0a078c2ca5b6b63e5f18a858b56add1d0eff621a89412c84", + "docs/measurements/h264-rounds/dispatch-wide/local/identity-safe.txt": "9cbb371216a433cf4166589311e1044f811625757944eef9cf5713f97e24a813", + "docs/measurements/h264-rounds/dispatch-wide/local/instructions.txt": "a48e4fc1187a89a50089fc68c631c50a2e4ce3a412d555d32b1d8bb9d1e81f4e", + "docs/measurements/h264-rounds/dispatch-wide/local/local-timing.txt": "86e361b11c22d3d55c0721f6ab63c5c22efed620d803d949ae4074fa1a5a56bc", + "docs/measurements/h264-rounds/edge-window/binaries.sha256": "188f7a76c103c783f46f05df8bfadb76353c1a6a0caf6a09ef14d1bd30774ee1", + "docs/measurements/h264-rounds/edge-window/check/README.md": "536374550c5614933769adde5d7e1cf5c7aab33f585963acad159ae08c16441b", + "docs/measurements/h264-rounds/edge-window/check/build.sh": "534db96bd7acc4e9df5e0fa136c5063bb3e036ce71e452871cd012f76f15890d", + "docs/measurements/h264-rounds/edge-window/check/job.sh": "950f621c0bc19d179f953c9595071da39b6c82e009f7f04351c3ac824fed2a6a", + "docs/measurements/h264-rounds/edge-window/check/run-gcp.sh": "669e7e529bae829561dae84200c6cd732841afdfcea5e981239c9f94618c271f", + "docs/measurements/h264-rounds/edge-window/check/run/b4.json": "c42cd3776f33f5f279f8ef0f3a7aa5fe4e7f66eac9bd583bcd1c3ec5ead81d82", + "docs/measurements/h264-rounds/edge-window/check/run/events.json": "17143437e742ccba410196902327f58f067657565c3c01be86553b832891e6b6", + "docs/measurements/h264-rounds/edge-window/check/run/host.txt": "1ff7287019031a22725698784a0923368e11246363772396f0c97c7ac2585bcc", + "docs/measurements/h264-rounds/edge-window/check/run/tables.txt": "3e78f841c6375ae177ad787563ea36c7ba7559cf003c0449f864da80a0f4e9eb", + "docs/measurements/h264-rounds/edge-window/checks.sh": "b41011531810b504eed636c1506f6129a1ef1f24093d346a6830c6637b414ac4", + "docs/measurements/h264-rounds/edge-window/checks.txt": "d00ba8f1064ab8e01ba4388cc61f65f4e797ac799bea377bb4e2eb6e87300725", + "docs/measurements/h264-rounds/edge-window/ident.sh": "3df3a215d8b83cbc7b3a6dac8dfe3012ae1fcd6ffacdd3f0b3608f50953dfc50", + "docs/measurements/h264-rounds/edge-window/identity.txt": "508940a3a38d15439e8625876d65043ac6434fd3d71b8a4587b288fa0587170c", + "docs/measurements/h264-rounds/edge-window/instructions.txt": "207e4f03ba4e8242a23c1fd94cd492d297145d49bb29b82704fbb2b1e06487f9", + "docs/measurements/h264-rounds/entropy-after-decision-asm/README.md": "ffa5e3fe25b084eef5f0a194a57015cb9be5ad5e7f0a432dbde3c788ecb3ff09", + "docs/measurements/h264-rounds/entropy-after-decision-asm/binaries.sha256": "ad8bd2e87c45d5db78668a495ccdced2691622496ac6b5be9d1793152872f14e", + "docs/measurements/h264-rounds/entropy-after-decision-asm/cavlc-shares.txt": "d7923808a000f6124a2b929cdf2102148d73fcb84bbc34d5703d76486bc79bc4", + "docs/measurements/h264-rounds/entropy-after-decision-asm/cavlc_shares.py": "62389a5185f227dd12cf6706346db09e4c245e2c0b2c783cd45dd035aa88cf45", + "docs/measurements/h264-rounds/entropy-after-decision-asm/cg_core.py.diff": "dbb605d47bd4e113aab4acce632ab7c02a71e54a03c432ea3c1def7fda553b1b", + "docs/measurements/h264-rounds/entropy-after-decision-asm/classify.diff": "d6b0246a57c71b2da5f26ee0308bdbe5fae1e67afa1c84844a6aab70cf56cc40", + "docs/measurements/h264-rounds/entropy-after-decision-asm/detail-cavlc.txt": "7bad6d65cfbe893051733fa5d9df02e416c1df125f04a4c19011ab148f0efb4f", + "docs/measurements/h264-rounds/entropy-after-decision-asm/detail-mvd.txt": "fd6c68b2dd1ab29c89130331cb98d2f1f2f675cbe93ba21d5e6c1826eae0c200", + "docs/measurements/h264-rounds/entropy-after-decision-asm/detail.py": "ea50a6ed165eccc5a39e03df7b3b48d6adcde682982e297ae119668b2b37df16", + "docs/measurements/h264-rounds/entropy-after-decision-asm/final.py.diff": "2b35caeb2c8159f3ae5c69ab25692a2e12e74b718990fb5ab6b0716b279f7ee0", + "docs/measurements/h264-rounds/entropy-after-decision-asm/final.txt": "7a88881cde2e73bceb65f01729c08b4800dce34045aa00b6e496ed53d2b7d4a0", + "docs/measurements/h264-rounds/entropy-after-decision-asm/report.py.diff": "4dccfe88e74665176f903c8b2453b661b9916e4707ec4faecb6986b8b2b9e539", + "docs/measurements/h264-rounds/entropy-after-decision-asm/run_core.sh": "f367d20979b8c3481137ad21dc9a678599870deb9da576af40081a22ecfae002", + "docs/measurements/h264-rounds/entropy-after-decision-asm/shares.py": "6e31ce4803ad36f2fea646ae1a52c4ffc5b3da46100d532019ff293c4846b917", + "docs/measurements/h264-rounds/entropy-after-decision-asm/shares.txt": "e905da8f7401f44be732c7c3ae76549e32b3f34241bdb67b6b34df3108b745b9", + "docs/measurements/h264-rounds/entropy-after-decision-asm/sig.py.diff": "06ed450412cbee1ce28ce8432494da8191ae178e77423d75cfff4c82a6301a0c", + "docs/measurements/h264-rounds/example-stdout/instructions.txt": "dbfbc50a79cca8417760953990ffa7cf1da0dacc112376afc277bd86fe3ef02e", + "docs/measurements/h264-rounds/ffmpeg-write-audit/README.md": "77c2cd5efd6845673bcdae33001c5c1e25de5919392b1964a4c6c61fba57a2f6", + "docs/measurements/h264-rounds/ffmpeg-write-audit/correct_reports.py": "61550008dafdd7405c1e7b9fef0d0f349829ad4de5f69fc17b888b0bb7956edb", + "docs/measurements/h264-rounds/ffmpeg-write-audit/corrected-reports.txt": "75097b723ecea9f690358279029648633ef14ea42f6dbc9659163cdca82c097e", + "docs/measurements/h264-rounds/ffmpeg-write-audit/factors.json": "4aaa66df2f5e3b3b8289bb242cc4a6d3efe4ac9e57919afc4f327dbd3830c4cc", + "docs/measurements/h264-rounds/ffmpeg-write-audit/factors.py": "404d5958b708cef9cac831dc18681a289350a4c87127e807b4741747d517b6da", + "docs/measurements/h264-rounds/ffmpeg-write-audit/heldout-medians.txt": "9bfd08030d2521aa9cbde9114dc6a96f16d7bc395a938e83c3794550ec3087d9", + "docs/measurements/h264-rounds/ffmpeg-write-audit/null-check.txt": "dcc87fbc85409bafa9191cd3126165036e9891987caedb05af04401a8e806105", + "docs/measurements/h264-rounds/ffmpeg-write-audit/vsync-heldout.txt": "27819db935b54ef93fe65d8d148b4b99280504498d4d088bbcbd49bb22179aa8", + "docs/measurements/h264-rounds/first-touch/README.md": "5e6edb877e1dd64eaa5c85c93181f336b3eb14f35fc67e14e4de8c7977378235", + "docs/measurements/h264-rounds/first-touch/binaries.sha256": "592ebfa9fa219bc43ed66e51a22d38a8b3d9dc771b61120b5a587f407a759833", + "docs/measurements/h264-rounds/first-touch/identity-probe.txt": "aed0ae22c8d6551abd496d4b63e2e1b8d1860dbb80f25c84ea62cc8be9bb80ae", + "docs/measurements/h264-rounds/first-touch/null.py": "51eee349166a31155a3f5f65e378d1e9e1ed55dcc5d6d9fae9de3c43e5b130bc", + "docs/measurements/h264-rounds/first-touch/pf-run1/host.txt": "969ec070290b81be7bda55bb03628d5e6139393f1ed4177d1a22072c8067c2cf", + "docs/measurements/h264-rounds/first-touch/pf-run1/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/first-touch/pf-run1/job.sh": "33dc1f7696dc11ee0fd9b33aea51a2c82fbc9716d9f2a41534bf58ec2b236851", + "docs/measurements/h264-rounds/first-touch/pf-run1/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/first-touch/pf-run1/null.txt": "6309546d5f1e5d4ffd3e4aa2a129d5385427bff44231200e0cea1dcaee3cc1d6", + "docs/measurements/h264-rounds/first-touch/pf-run1/pf-summary.txt": "58219e9dfb96686bfb3a55fcc057f39fdcb7de55b0f42eb3d4103723d863c232", + "docs/measurements/h264-rounds/first-touch/pf-run1/progress.txt": "3fdab15d063f2cea5bf8c8c8ae4400a0809b64f82bc9cf463008ce1c01dc6b0d", + "docs/measurements/h264-rounds/first-touch/pf-run1/ref.json": "b62d722d883326f3c381d012d07308ea49c415c4d394c8ef6c4cdc78a4ddabf4", + "docs/measurements/h264-rounds/first-touch/pf-run1/t8.1080p.json": "5c1192a4b6bee1d9821beaa0b2d9a15e148c8d8f638c560808823033454184de", + "docs/measurements/h264-rounds/first-touch/pf-run1/t8.1080p.log": "12230d22de6f9371f6bfdb7a0c5d026c5f3823b1a7d1559bb22b71a3a27599f7", + "docs/measurements/h264-rounds/first-touch/pf-run1/t8.4k.json": "2e88dc2e69b0bf7e0b31a376e518c8a32c6985f43b1af6da6fdd429c3362ef7c", + "docs/measurements/h264-rounds/first-touch/pf-run1/t8.4k.log": "fa0d1327d6d9f29061c4c948813faf04c4381b19ac6afed746e8be838888681d", + "docs/measurements/h264-rounds/first-touch/pf-run1/t8.720p.json": "80a81a56cfcbaa141c4c60bba819a4272545d3e6fac098b8baebdc2446a9ae57", + "docs/measurements/h264-rounds/first-touch/pf-run1/t8.720p.log": "b4da069551af214b47404bd7c123b997dcbb74c55969d4b8c45f2f5ef846d897", + "docs/measurements/h264-rounds/first-touch/pf-run1/t8.sd.json": "e151a36279ad5bc23567b240a216584344421a571169ccc56a6fcd059dc9306f", + "docs/measurements/h264-rounds/first-touch/pf-run1/t8.sd.log": "bcd20edabdc300aabbca386f2dbead9ffec68329cc3a30083c6a1ae455dafec9", + "docs/measurements/h264-rounds/first-touch/pf-run1/verdict.json": "24ad2204a2c288b373fdf46e0caa03e83f34b0c12f86e07e85e528074109ae93", + "docs/measurements/h264-rounds/first-touch/pf.py": "0038119f77a558b63b14c5d87ac48d659d68bf6b3dda5c1e314f952554a6b3f5", + "docs/measurements/h264-rounds/first-touch/plan-probe.md": "22702d3e0cb9aafe66648632b2c623c3302dddbdd555c033d4d1b618e4aa6c97", + "docs/measurements/h264-rounds/first-touch/round/README.md": "0456c891d468ac29ca9cfa93a56168cf6819d43f6694835693c8e5b7eb144c89", + "docs/measurements/h264-rounds/first-touch/round/after-main/README.md": "11b734b261516dd4b106d07719b68e2784836de349fa79adb45ddae45193e63b", + "docs/measurements/h264-rounds/first-touch/round/after-main/binaries.sha256": "2c46b026ea0ee39c1597c67b9e8d715908a5955d4a18154d01155e58ba62af66", + "docs/measurements/h264-rounds/first-touch/round/after-main/conformance.txt": "e19f3a36b8ecfe7d5225c77be057a22898d2c27f9520679d962612000564cfca", + "docs/measurements/h264-rounds/first-touch/round/after-main/ident.sh": "6887e96e1f93cbef1a2706440cb95ca5e1622b0999bfe42acb700db0c5b94a9f", + "docs/measurements/h264-rounds/first-touch/round/after-main/identity-fast.txt": "c21d94621c22adfd06eba945049de9f00e8a267d0f9f3a75ae7678d0f37cfbf4", + "docs/measurements/h264-rounds/first-touch/round/after-main/identity-safe.txt": "c21d94621c22adfd06eba945049de9f00e8a267d0f9f3a75ae7678d0f37cfbf4", + "docs/measurements/h264-rounds/first-touch/round/binaries.sha256": "619935f009b15f4d7c194c6fa6d342d6f2d808682249df4271e3df4bbeac832e", + "docs/measurements/h264-rounds/first-touch/round/conformance.txt": "cb769b36bf0f3db1936a9cbb7acdcf0bb999ccd07e3116101bbbecd3f6f54d28", + "docs/measurements/h264-rounds/first-touch/round/gating/1t/g.1080p.json": "95c9c8e7cf67acf13b085cb4f049ee4027e0c9d3224cab8e10a4fd7b80dda340", + "docs/measurements/h264-rounds/first-touch/round/gating/1t/g.1080p.log": "8b49fad22e146fcfbcab75a66c8d70fa1e9a071037ad493c74fe185e445b04a3", + "docs/measurements/h264-rounds/first-touch/round/gating/1t/g.4k.json": "9ac2d0844e1fae2f7a9e1ad1350094f3688105c13168600779c79032821f5da0", + "docs/measurements/h264-rounds/first-touch/round/gating/1t/g.4k.log": "f41e79ef44e6471b6bbf0a2c17e8738bf9aacda6f9a5d8ef2f3e282f851a0882", + "docs/measurements/h264-rounds/first-touch/round/gating/1t/g.720p.json": "8909d65f8dd988294afb8d538438d74aaa8b44a2959e211b842c025516a2e408", + "docs/measurements/h264-rounds/first-touch/round/gating/1t/g.720p.log": "9ccb3eec675420026113397191959bd265a3363e0fcc73d4c61f7a2bb2738656", + "docs/measurements/h264-rounds/first-touch/round/gating/1t/g.sd.json": "a35eb760312f2b6b1d9e70fc124150d010e029325378ef85d2faa7f97b3fb307", + "docs/measurements/h264-rounds/first-touch/round/gating/1t/g.sd.log": "f700ab06440c544e9b03c6431bfb6b5576d31b9eac2c4ce16eec048282829663", + "docs/measurements/h264-rounds/first-touch/round/gating/1t/hostgate.log": "4a3ddae0e282aa10f49d7c0908cab38e58e7060d3ed145ecaa37d78aa6757b5a", + "docs/measurements/h264-rounds/first-touch/round/gating/1t/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/first-touch/round/gating/1t/progress.txt": "08ab7ca310b2454f9c2280ed9d5a40f2a6b6294f0121c81c283e52d6e9bfe770", + "docs/measurements/h264-rounds/first-touch/round/gating/1t/provenance.txt": "b507b10ce735dcd0c3036df9bad7685bc8fe568cb0e298f661aef625e34a010f", + "docs/measurements/h264-rounds/first-touch/round/gating/README.md": "a6fe1b65666d95f6f402e599f5c90e644dc46a9a3ddc2555de0ff1e5d2b5fd2c", + "docs/measurements/h264-rounds/first-touch/round/gating/analysis.txt": "0abc6b0370bf8013c8afab2b193e618d21e55644cbe5421d1f8b35a99b1fef51", + "docs/measurements/h264-rounds/first-touch/round/gating/analyze-ft.py": "fd5c389b84b4c5b625eaa8c01a0e25046a6d57811402f997bbdc6788ee4ab855", + "docs/measurements/h264-rounds/first-touch/round/gating/binaries.sha256": "003fbafd6c85f6198637474d545d3c31f3c26d641fee2bab21b05bde31afcf94", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/host.txt": "ba5e57903fde6204888f34d1fd1c8c007447786d8196f286f8e26fd25554399f", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/job.sh": "cf449cfc8b1672fee980f639a667f3649d943c173e7212d660aac762285dd9ec", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/progress.txt": "4137282ab7c90ac1f333a78ba48fd9fefe6c3f6748e26bad79c97a4bbf63e3f6", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/ref.json": "e8eb4c4dfbfa1380a4307f000fcffef505e41e6df60c7d026d468742d4ee4a36", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/t8.1080p.json": "1fe40042eb6aec5f1b99ac3a76fb950c9b4e843e215859d7779914be7ff3236f", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/t8.1080p.log": "88760f0d15303aa9985d0f7ba63ab3e085fac1570ab4513b881e746f9a0b9bf8", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/t8.4k.json": "83087975d80adac9c0002a10602d245f3a02cc054de3963a6dd712fc48ec7e57", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/t8.4k.log": "94cd1053f448674e6e2065e012e50ce58926336e5862601248ee60d6728bfc54", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/t8.720p.json": "e32d3400fa8d179d64e3744831dc4620b8a5fe639887d9f45db50035b5c95a37", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/t8.720p.log": "13059c036b1fa91fa9f898c37d3d3b6e139a4d65113b09ed8cca045c84179240", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/t8.sd.json": "10a520b18ed3353278bff6b7089a255b721970bbaf300b31b99f42e9eb1b9e1d", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/t8.sd.log": "cf5c29e33fb3d9f3bd3671d7e715b7b3daa213c62f7e05557e8708bc57d0630e", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-heldout/verdict.json": "3739640d64a6c6648b628552487abc668643a65900fd9cb6d57e8b6634349c4b", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/host.txt": "401c6930c16d54cc6d209998529b175ebd74c5f84895e998ef98d72748a0a34e", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/job.sh": "1b3cfd0110090369f80e2ce93beeeed64ef82705ea13cb51e6d253c8bf0dd6ee", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/progress.txt": "5ca2b0227d34c35604fbb893004bb3aae85f8d2b1639cf654dbe04b098fba967", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/ref.json": "7505a48aa90b8760a44a73dd03b1fef044d29f27591cfb35d6dfc9b03864b435", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/t8.1080p.json": "255e0224961162c82dcb5ef4c7599372fc40427501038cc12e84f4608b5fadd5", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/t8.1080p.log": "24b5582a2e957309bc75008df70dcaf381495c848a51f29a811e443bf473b47a", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/t8.4k.json": "790514c1d370636059d76ec33ec8363bcd8a7a945ace1311876be0f59f452a34", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/t8.4k.log": "603c2861209e17bff61df65dd01e7e23017659ff53cecb19cba5a1e5c5613a9c", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/t8.720p.json": "059adb3f5a9c9107571730b1316b6af5f18065bb6cb13e6e709a0e008c81834f", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/t8.720p.log": "96b59594898a3ccd778d77b176c9a7c49e5e17beb2f09e4fb1caa70b77e792b2", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/t8.sd.json": "d3dd74fd6336012570007a6ee53a6c2c56e3e127836dbe174134bb06f5cff059", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/t8.sd.log": "a953230681be6f55e167db8d4d4cbe674950dc3e3bc953aac76ac1feae33a3b1", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/tools.txt": "688e69ad78d8f70b08fbd4175748134f9304f6d9b3a19ad912f0a1ca4c791146", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp-train/verdict.json": "beee3c667a3fca4961ae3c63c2e0b357b3d148a8fef5adc93cad0eac582e21ac", + "docs/measurements/h264-rounds/first-touch/round/gating/gcp_round.sh": "fd0091929a3b47dfa1edd4a731fcad134329ee9161272c0e394e50e5b67c5588", + "docs/measurements/h264-rounds/first-touch/round/gating/run-ft-1t.sh": "9bab595d7586b7684b51821227ead51ed838d421e61206d28435b84765b549be", + "docs/measurements/h264-rounds/first-touch/round/gating/summary.json": "723ff1d1662e5d5ae04ed312ecae49ca7833e3a86c095f30cab7d96bb3fc27b9", + "docs/measurements/h264-rounds/first-touch/round/ident.sh": "b2693be2132f9b88d03967d294cf9730401b50c40d50eb880a3feee7ec502e75", + "docs/measurements/h264-rounds/first-touch/round/identity.txt": "aed0ae22c8d6551abd496d4b63e2e1b8d1860dbb80f25c84ea62cc8be9bb80ae", + "docs/measurements/h264-rounds/first-touch/round/local/ab1t.py": "22049f3b0c9acb3cfabdd8871b51d278a8999334c875ce06c24a18e27f2aa176", + "docs/measurements/h264-rounds/first-touch/round/local/ab8.py": "1eff58080643ec05d653589aca0de1f9eae252f522d68a4ed2e17176b007d042", + "docs/measurements/h264-rounds/first-touch/round/local/local-1t.json": "0dcd0566185eb32955ee928d00255a4402cc17aca0e7ced894c26c9c14fb1efd", + "docs/measurements/h264-rounds/first-touch/round/local/local-1t.txt": "37fb6aec10f3640ec4bbf4165abb7d73576bdba871cc72afe31255ebeac7515b", + "docs/measurements/h264-rounds/first-touch/round/local/local-8t.json": "3965dfb1770524f3e5e60b4c0718766c5ffbff783d13af7b68b212deb65e7522", + "docs/measurements/h264-rounds/first-touch/round/local/local-8t.txt": "123f897ed416d2e33c7bf3dee081c134c23154880025db8363177c47e20109e9", + "docs/measurements/h264-rounds/first-touch/rss.py": "1a1cd682f370b426555b7cd3a40c0501484c2fa2f35611b1c0d4c66b648f2c08", + "docs/measurements/h264-rounds/first-touch/rss.txt": "3961e86847492fb681819850c34df126d8966f801f3d0de5498daa1a5b231603", + "docs/measurements/h264-rounds/gcp-1t-fixed/README.md": "959fa0ee6ca2ebb5b4b66733a8ca090c1c2fb01d4718ea4e042c840fb7da410d", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/freq.json": "2ce73e95b5e5ef88137a3d54adb5ef0767dab7d5699eb60dc4f154d6bc789a91", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/g.1080p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/g.1080p.json": "65b1d1e7e2dea9290ae689a73e2e232dbf34f13d74afe7c1cbf8419991d3b82a", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/g.1080p.log": "7af8591d81e4eb5a350e4c6b68f255c32e98de90e5ac6ef05291c82bf14e4540", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/g.4k.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/g.4k.json": "f3332a5aca8e2b3a9698abafa7877744f6e7dc69f777ca10df5713bd040ccba9", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/g.4k.log": "b534ff74bfe30bce232a91546b5e99699e2061ac7d325b574b6027b971719e66", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/g.720p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/g.720p.json": "48f9fb7d394088286907d586b3bd8069a10648f9f08ac7c55abb48d7ac9a3d43", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/g.720p.log": "08634ecb75a0a3e3f6ffc1cccf2433fe4522e0fe05699dee41387e8df1db15ce", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/g.sd.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/g.sd.json": "ed4497f0746f1c2f3562b3948a9d775626ec7c9a59a4a8210fb0c8f24ecd44c3", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/g.sd.log": "5871a94d4c26d3d7c005cce6043a31471fbb95d78411abbe04c2101b71b52897", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/gate-checks.log": "2428678f7b522d78da59084645447dcf97148f320239fa7c5a928fbcb4491bc6", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/gate-refs.json": "ea09f035f7b85d1d5410dc5a87e96ce045a4aa2b52e7a8b2a4fec68d1a197844", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/host.txt": "41c94eccda93c3c7207528083b4613aae69b51599d6c34be4b92a2c20b20ab6f", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/instance.json": "55dc358b510d5b9fdf86a0c2eb5b29534c986e8bc63a0a578a661e1df47bb9ce", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/job.sh": "31415f23182a544c64e3745e7389bb512bbd190585f971be944dba0bb3f095c7", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/progress.txt": "1cdc68bd0dc728dd4416be79828b2a8c2e298ef958181d626f73b7602ad849a6", + "docs/measurements/h264-rounds/gcp-1t-fixed/aa/verdict.json": "a406515971321016b78a24b6127d42acd2a247af92f1db10883b88b0368472df", + "docs/measurements/h264-rounds/gcp-1t-fixed/binaries.sha256": "772032fd3d1ad93436a006922161d9301cda792a321e2e0494e73154aa4d212f", + "docs/measurements/h264-rounds/gcp-1t-fixed/calibration.json": "f93e275b89cf6a00d33f64dcf7ad24cb9bdbd9446c206ef3875066550dc2edfe", + "docs/measurements/h264-rounds/gcp-1t-fixed/calibration.py": "b0b8053598b6ca8011d60c0dd987b7976a7b48b60a1f865311b78042b3d4ee23", + "docs/measurements/h264-rounds/gcp-1t-fixed/calibration.txt": "aa79451230b3f3c034107c23245263bc3c46173e69886d5e5e41f497c7fe1e9e", + "docs/measurements/h264-rounds/gcp-1t-fixed/identity.txt": "9e4b240f4d15e325549920dd46e276d0d4cf031b8e867b78aa1ce34f101ebf6a", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/freq.json": "f77b02792ac4c88a0f5ec4ee62010499e95e3f888592c5a309afac32fdf1fb16", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/g.1080p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/g.1080p.json": "6e4ef13a49384036afa2564e48f494142fd257bf18c07a0f43ce4c9c7d7aa3c4", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/g.1080p.log": "fad34f0c63b833a811c40f9cfa9893732fa0be0b8270a5c0e2c2c5040f32fc48", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/g.4k.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/g.4k.json": "da6e9ea6233f5117680ca6c7ade82388899281c71d24a0cef579e141db77d402", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/g.4k.log": "393cc0da25232a50fb5e0ce258dc4d33da6cede6a7fc7d8b98ffdd6a4c9974f8", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/g.720p.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/g.720p.json": "80b20a753c461d97679c9cbffc34f9c5d425c0c2fa1d1a2c9900cbe96a277baf", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/g.720p.log": "9f4d1395b151916202b0ed98fc35b1296d57e393b7082e2d4415c5db85fb52fc", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/g.sd.gate_ok": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/g.sd.json": "dfd3bb0c8f3dcbc8c26b49a4f60ef23647e5bc961832511883cc60db96e34510", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/g.sd.log": "70aeb4819480321fdbe940e0f33279e643b7f760134ec589b6adc62d8827385b", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/gate-checks.log": "2ade92ba9f6d60861d269a0a0d2f7948d90ac4e515f80f3e35719cb43e7f5404", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/gate-refs.json": "f2d9afd3c3474d9e294ca77f37e6de1628b7e1bc589418f7e6bc85d2dde385a9", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/host.txt": "32f3c7236e224da1d2931159f6f22305823a0d1c629b3275a3262fb3ed8780d9", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/instance.json": "55dc358b510d5b9fdf86a0c2eb5b29534c986e8bc63a0a578a661e1df47bb9ce", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/job.sh": "355c8286ef6e6a9f09b3e187c9346c055a4a464b36b589a0160ec7ed52bf19ca", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/progress.txt": "195b5d26b2ca81ab0af5ff88aeeb8932062d387d323572b191a8691d347b0148", + "docs/measurements/h264-rounds/gcp-1t-fixed/na/verdict.json": "a406515971321016b78a24b6127d42acd2a247af92f1db10883b88b0368472df", + "docs/measurements/h264-rounds/gcp-1t-fixed/smoke-acm/freq.json": "b030825153de0a8a823f4b941994370baef9541e5bd677bb462ed37fbb22e994", + "docs/measurements/h264-rounds/gcp-1t-fixed/smoke-acm/gate-checks.log": "8bad3c9de476502d17d8e50bbfcc8356dd19506842928eda82ad694643d0ddb1", + "docs/measurements/h264-rounds/gcp-1t-fixed/smoke-acm/gate-refs.json": "fcb679f98b97d1509088705f0797f11302a3d69961155a2ea2004eb94fb7d652", + "docs/measurements/h264-rounds/gcp-1t-fixed/smoke-acm/instance.json": "55dc358b510d5b9fdf86a0c2eb5b29534c986e8bc63a0a578a661e1df47bb9ce", + "docs/measurements/h264-rounds/gcp-1t-fixed/smoke-acm/verdict.json": "a406515971321016b78a24b6127d42acd2a247af92f1db10883b88b0368472df", + "docs/measurements/h264-rounds/gcp-1t-fixed/smoke-unr/freq.json": "c226666ade2c45fe3e1ac6c3ac94606f085ce7045a9e1d562524db74a70608f1", + "docs/measurements/h264-rounds/gcp-1t-fixed/smoke-unr/gate-checks.log": "91a5fc10814c1156c03bb28460206944bb8c1c7d5b41317b90d7b1db3cb65363", + "docs/measurements/h264-rounds/gcp-1t-fixed/smoke-unr/gate-refs.json": "2b0ece16cee97a6f44c20aba1e5b1e8da9ce655b42e8d0cd66f28a1e8613ef57", + "docs/measurements/h264-rounds/gcp-1t-fixed/smoke-unr/instance.json": "8f536d746fa99bd467e9c5d2ffb642c166665214366c73dce441a9c54c93cb08", + "docs/measurements/h264-rounds/gcp-1t-fixed/smoke-unr/verdict.json": "a406515971321016b78a24b6127d42acd2a247af92f1db10883b88b0368472df", + "docs/measurements/h264-rounds/hints-8t/README.md": "e81ace1357cd06c539629aa893766f89588cc4c7a8df16ffce716ea3c6a8897c", + "docs/measurements/h264-rounds/hints-8t/build.sh": "f7e5e6bc85b1ca99d84c262947a50281ba8ff2e1573a5c338178e73a1f9a2ed9", + "docs/measurements/h264-rounds/hints-8t/checks.txt": "3ff97a41ce082e39fbd86c10b61db588d008f7ef1ae61c31e9b456ec203362bd", + "docs/measurements/h264-rounds/hints-8t/gating/1t/g.1080p.json": "672a0bc562454b550faae5b469a40e94c63e8f6d847f6817afccb9b8f85e0544", + "docs/measurements/h264-rounds/hints-8t/gating/1t/g.1080p.log": "88ae307318f2eca0977d5bb9b125793bdc97ae448d91ba60a848dd1941659572", + "docs/measurements/h264-rounds/hints-8t/gating/1t/g.4k.json": "3bf126d3374469f7fa8533274ea9c3b88419c1c32aa6fac93f979dee60994559", + "docs/measurements/h264-rounds/hints-8t/gating/1t/g.4k.log": "6beca85c42d1514e1429e35378909e28c650bffb269742ec4919d69a57742b42", + "docs/measurements/h264-rounds/hints-8t/gating/1t/g.720p.json": "7cee55b36e9783e5cd360779181bf33abff530d2f2ced9c6fcc712305fa52437", + "docs/measurements/h264-rounds/hints-8t/gating/1t/g.720p.log": "4f0d08f42e154b66cddc437b293838627acdcb4973fd5f562abcd37ba1b52561", + "docs/measurements/h264-rounds/hints-8t/gating/1t/g.sd.json": "286a99e6ce43eec2d72c671617bfbc5285e20bcf66aae50f3fb9fca17f2240aa", + "docs/measurements/h264-rounds/hints-8t/gating/1t/g.sd.log": "68a6f7c0c2ad0618017d5b28df1eaed2bc32dd6b2b843afc92df276bda072ede", + "docs/measurements/h264-rounds/hints-8t/gating/1t/hostgate.log": "9fd5ac796a74609905ebcff400192e0aa568e482d7bcd7091a38f0890c91a776", + "docs/measurements/h264-rounds/hints-8t/gating/1t/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/hints-8t/gating/1t/progress.txt": "78f215197c0564d5aae8f3e97c7b829102266b93d14d74c28655dd78b08b50c4", + "docs/measurements/h264-rounds/hints-8t/gating/1t/provenance.txt": "217152a3474a53566235b4539ba81486918bfec424f330330e4d80daaca7075e", + "docs/measurements/h264-rounds/hints-8t/gating/README.md": "a053195b39804a5836d005e18c62a58d2815ce69d9c5a38fd145df1ce76aeea6", + "docs/measurements/h264-rounds/hints-8t/gating/analysis.txt": "0ffa91d09c5cae07262ddc326231a364a280aeabf903d2d069e9f8326b0f9952", + "docs/measurements/h264-rounds/hints-8t/gating/analyze-hb.py": "a9017ac7a5a9d56ecd8b92e2a790142b76113d083a0445e78172084e333bf9e7", + "docs/measurements/h264-rounds/hints-8t/gating/binaries.sha256": "46a2df9ebab92732dc675c561e9d86ccf940dcb3b15ca4de1099fa2e9ad01d2f", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/host.txt": "ff28735c950a73c0827f50019871d081e0cb8e567c8fa670701635618b90c9e8", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/job.sh": "af1e542e7802b809f67cbf1fedfd4193ff78881d42f391000376375e37efc560", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/progress.txt": "5bb5b265cf88981887fa8c94d454d4195611dc4bb8ebe4507e9098e08fd399b2", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/ref.json": "545c4538f78d3deea8413e2a9132738af610a9c5e21a6c8cc3e158b52501e81d", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/t8.1080p.json": "4db87e8e7e87a55866615bb368051ba93d96c941a041ba5fbc4bfacb626669eb", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/t8.1080p.log": "3f41d1fb79366098b8815bba67ed5a9ed31a56109bbef4e295c9072e3a34da28", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/t8.4k.json": "edd40f3ba9200700d8e04776ce33a094482f282678e6d463551c02a35052a37f", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/t8.4k.log": "e5d6f1ccf9846e7e2b4f2871b6980af61af40e0c292bb57f0d20af38b423de3a", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/t8.720p.json": "699b3d7d17897793c28e4e30c9030882d96e3c8aa0217cea998dbb73b620222f", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/t8.720p.log": "0208a9b9fca1f9284d654c7c4713c5470391e340f692bb1529dcda9aebc9106d", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/t8.sd.json": "cc69c4c95f8b4f0331fc59ca18e44802690ad9df6c2f8dec08b30d02ed3838e6", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/t8.sd.log": "fe2d697a352d0e867bd546a6c9d0840fe6c5fbc7f1ba3235c87879bcd9fe345b", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-heldout/verdict.json": "e7f4704a27fbd27d61735a0bd586ef3dfda9e6ac183837eaaa9c9cf30644942a", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/host.txt": "c640670fd980ac29ee758cb118aff21b29d1eb8fb5269549ace517371195322d", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/job.sh": "da6b70bddb2859228d8acac8020e84c2fcd4c9d33cfc4a78a80d5cc3ad7987d6", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/progress.txt": "2aa87cae684cd3471b4d4216212d08bdc480c78834d44b6163bf375f8d4d8f44", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/ref.json": "a09e5998915fa3fcfae39f2f8a5c37b98080d53eded7ad90fca9f9240940934c", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/t8.1080p.json": "20c00f20c49f597d2f562bba2f7596cc8395a5405a44db028ea1a6505abae0e9", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/t8.1080p.log": "1b24a7ab11e435c8a7afea2382de7149010ca5fc014a62d58697eea656c2d288", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/t8.4k.json": "d858c8113df042302e582d68cd400af2b098b654502e2ec80fc21ab2d96e48eb", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/t8.4k.log": "f2cc166abc072e8950fd1537a1907b04dde3b677936d0f632f6c3a5f8a67872f", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/t8.720p.json": "9b4a9a40bcf1977df082a160faf7262e357d543ce0ab61455623385721e508f6", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/t8.720p.log": "8fb01e8fcf71b97c6c3be8ca03559ee8286b6ef7fcb86bfc9b9879872438cb9f", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/t8.sd.json": "12b85b4651c4d7bdb8c9f9e7f7cdf0af5e2763ec7841419f45ad0b81f757bbfa", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/t8.sd.log": "03c99ee7f39b443018e46db825f5c6e503f5a527c7c399ea8e0fd28c1fa3b2fd", + "docs/measurements/h264-rounds/hints-8t/gating/gcp-train/verdict.json": "b7acf52b7140890c92fb281fbf8add4e6b8ec4dbb6ada7864ccb9688f82f68b0", + "docs/measurements/h264-rounds/hints-8t/gating/run-hb-1t.sh": "aef762d4bd3867faed6186889622d267c9e702f8244cc219355674c6205d4370", + "docs/measurements/h264-rounds/hints-8t/gating/summary.json": "80f462308eaaa52d28c038d198a5bbc7981115e97f99450c02b52274ac8b1921", + "docs/measurements/h264-rounds/hints-8t/gating/tools.txt": "0a4a5b63b074fbe43b7ae48c2e6ac81081c14bcc6e82bb0d3e5c865eee4ca5c0", + "docs/measurements/h264-rounds/hints-8t/hints.py": "dda9eb2f6d46e58bb7a61343fc5ae470e6f3f13810278ebb789ff79dde238b1d", + "docs/measurements/h264-rounds/hints-8t/identity.txt": "508940a3a38d15439e8625876d65043ac6434fd3d71b8a4587b288fa0587170c", + "docs/measurements/h264-rounds/hints-8t/job.sh": "50797377bf6abe64d21745a6e1b9ddc3898ccd8a52e9238f779114423bacf378", + "docs/measurements/h264-rounds/hints-8t/local/README.md": "4b229f9f8297a6bb1b6089550f802acc27144b652ac18516e5660f11d35aa13a", + "docs/measurements/h264-rounds/hints-8t/local/ab1t.py": "0ab774d534619e9cd5ef007fef9172453e9057c15779d5168f42ea3638972bae", + "docs/measurements/h264-rounds/hints-8t/local/ab8.py": "f89be51958228444dea89239235cceafca1b60505330570f1d5e2129065fa5e1", + "docs/measurements/h264-rounds/hints-8t/local/binaries.sha256": "878b976853b6d8809f57bd8e471bfcfba9102badb6b1b253a93f4af5e51969af", + "docs/measurements/h264-rounds/hints-8t/local/run.sh": "9d1e3f0ad924ffd9623fe0e1087d9a7b10d81732a9be5899d135a400783b4211", + "docs/measurements/h264-rounds/hints-8t/local/t1.json": "7b4a5359c9a2d36aee5f9aa02a4576592071099df30a2a07213c35846a2731ae", + "docs/measurements/h264-rounds/hints-8t/local/t1.txt": "3ccf0696bbd43af2724b3237fedc770cabf3426c84f2f9030d98b81e8bc9ceb5", + "docs/measurements/h264-rounds/hints-8t/local/t8.json": "b72d3cdae06e3e3aae042ea06a0da0dd585544f825adeaee1e07aed1a15ef3da", + "docs/measurements/h264-rounds/hints-8t/local/t8.txt": "b86166edeba18f17e65072e531e8d5969313603796ca8eef36b11b46bf1b20a4", + "docs/measurements/h264-rounds/hints-8t/rec_hints.py": "4d0de5ddb08898ec635198beeba01f314e4d76b97b22cc8a861c7d08d32f39b0", + "docs/measurements/h264-rounds/hints-8t/run-gcp.sh": "9325040c629aa8d74d076b5cd10ef50914052ec66987bdc355e8898948c1a270", + "docs/measurements/h264-rounds/hints-8t/run/events.json": "31204bafb2fd5fe718964b3bfd48882184d9a9529c86e7a8c3211cac78c98482", + "docs/measurements/h264-rounds/hints-8t/run/hints.json": "1f68fdaab514aabd7fa21a9077e6e258a03bc4417a4e006cfead1642184f725d", + "docs/measurements/h264-rounds/hints-8t/run/host.txt": "6014670935c14da2ee2570bc5cb211c7487ed9d676bc3cfcb6def3653fa7e34a", + "docs/measurements/h264-rounds/hints-8t/run/tables.txt": "66b21a57c5dbaa8fef9697805ff587bd177626a7788ef29dceb39770cc5fa773", + "docs/measurements/h264-rounds/host-gate/HOST-GATE.md": "279bb585f68d729123438381093b1c40fad7bc681fd51a052731245452b0edfb", + "docs/measurements/h264-rounds/host-gate/hostgate.py": "e849af973d2b27d159fc837e47d10c1f6c8bc4cb9df0960cf0f2232ca616c589", + "docs/measurements/h264-rounds/host-gate/scripts/round13-rerun.sh": "f14c33470a7ffcd06882bec13f192be6219970a07f8a102a1c79b67e44ddf2f2", + "docs/measurements/h264-rounds/idct-rows/README.md": "13e7315ed20b7ebcc64cb6b9e03c49cc9692383bb17db5c20f5bf2c00e3e57bc", + "docs/measurements/h264-rounds/idct-rows/analysis.txt": "43ee3ef5d692d391629e3ce8d2f47770c404c80deb7d70c4aab88d2f240c7ea9", + "docs/measurements/h264-rounds/idct-rows/analyze.py": "22320290469d465049e58e92fafb7adaead7d357db9a9b3561216a069b317228", + "docs/measurements/h264-rounds/idct-rows/g.1080p.json": "b89e40e54950bf2685f98a51e4af89f65bef7920dc8d795af0aac03455a6ad2b", + "docs/measurements/h264-rounds/idct-rows/g.1080p.log": "e601c139c71d6d66dcf3005140104097402fa59a9d40c2834690bfea180619c0", + "docs/measurements/h264-rounds/idct-rows/g.4k.json": "7bdb0a1bfbd8341db7ecd4009d191363302ba5d3cc4e21b89047521e594f77ba", + "docs/measurements/h264-rounds/idct-rows/g.4k.log": "1df1a57a1da08cbfb848866c79a9bcf54a155e30569874a20624f4d863bb51a8", + "docs/measurements/h264-rounds/idct-rows/g.720p.json": "2dd86ca3b0d5fc075f65de6ca82d0c3c94df56df193c87451392255d4c32848f", + "docs/measurements/h264-rounds/idct-rows/g.720p.log": "07304e5e0072643df86f995bc3b0648e8e95024527aa9009cf0d8e1a966b462d", + "docs/measurements/h264-rounds/idct-rows/g.sd.json": "0092f4d853dd777e1d9a2d8127f39b87f27639434f40447b2a69554770ebaee8", + "docs/measurements/h264-rounds/idct-rows/g.sd.log": "2b984545f81e3223a09e771b8354b9d7523432ca2ca36792fc425463ef34bd8d", + "docs/measurements/h264-rounds/idct-rows/g.summary.json": "10dbce41c7ea8fdfe8f094c5d75787b326fd03ee1edb66efc622ee34322dd9a2", + "docs/measurements/h264-rounds/idct-rows/identity.txt": "aecb218ccb0fb3eb34e293abc574f9cbe3b2909f784e5b8ac83d802a36bc182f", + "docs/measurements/h264-rounds/idct-rows/instructions.txt": "a44892afb053840cc780d95d6e6be3ae91e6ca76352226a771353d05ae30b7a5", + "docs/measurements/h264-rounds/idct-rows/local-timing.txt": "1d85c06d22ee7c9e544595ceb7ef54f503771498499578cf3d4fb01d924daea7", + "docs/measurements/h264-rounds/idct-rows/profile/rep.py": "1e0419ad789e61ed27d3631d2d483a1ec4e2c6710825a7c4c17f9a01c137ea17", + "docs/measurements/h264-rounds/idct-rows/profile/report.txt": "59c7c4abfa7cbeee10f7f4501d123b2235d4c5fa2b2875f8313086e08d7596e8", + "docs/measurements/h264-rounds/idct-rows/profile/run.sh": "3c989d7b576c9ae7eb996cc61256071273de14ef8b73e8a0d34629660bde4483", + "docs/measurements/h264-rounds/idct-rows/profile/stages.json": "8ab2d1e761c8008a9ded2dbad00e43fe9c2f87178a79e727700ebba37a128b98", + "docs/measurements/h264-rounds/idct-rows/profile/streams.txt": "74ae5ba0edfeaeb63b2de87cf2b8489ac39df10280925eb50cdd3daeec945ab1", + "docs/measurements/h264-rounds/idct-rows/profile/wall.txt": "1948f35adc2e8caae706b3eb842d9fc1b70dac1ecc8b52e13dff2cb720b35101", + "docs/measurements/h264-rounds/idct-rows/provenance.txt": "0f6af3c143a1ddb883b8eca008c28a0d7394726749d5ed69d51cae8708aad176", + "docs/measurements/h264-rounds/idct-rows/run-ab-helper.sh": "fd07075f856796fb484212b423be29fd7f204830876d2651def03415aa6daec7", + "docs/measurements/h264-rounds/idct-rows/streams-8x8.txt": "6dcb422633dbf8bf2adb05cce03c8eb90d6b5e4196a44031c75ee478bbf0690e", + "docs/measurements/h264-rounds/idct-rows/tools/miri/Cargo.toml": "cb03b90d5aa01e9e10361998215749dac428fcf7441a6500604a9f29409e80c1", + "docs/measurements/h264-rounds/idct-rows/tools/miri/main.rs": "b8f71a5fca927df44495e25e6d7ffc00cab8f64ab61f5cd2368a0ed3d8337818", + "docs/measurements/h264-rounds/inter-place/ab1t.py": "22049f3b0c9acb3cfabdd8871b51d278a8999334c875ce06c24a18e27f2aa176", + "docs/measurements/h264-rounds/inter-place/ab8.py": "1eff58080643ec05d653589aca0de1f9eae252f522d68a4ed2e17176b007d042", + "docs/measurements/h264-rounds/inter-place/analysis-8t/analysis.txt": "cd4c562dd783bfcf882f0f003166c93ec0d8c4360becc4c9d0dfca1508596cf4", + "docs/measurements/h264-rounds/inter-place/analysis-8t/analyze.py": "b81f01e5a7c45017ccc2454a21d8b279883bfc11ea74bf6434107d905c84dbf1", + "docs/measurements/h264-rounds/inter-place/analysis-8t/summary.json": "a6cad72216e23283bdfc9dd816c1383b7913288b8532b150f3daa21791522561", + "docs/measurements/h264-rounds/inter-place/conformance-round.txt": "56b58457f098a12e42a60d51102a214d5d9a9f7cfbf347fe5cb1fb26d69f8e4a", + "docs/measurements/h264-rounds/inter-place/fn-inter.txt": "fada6e8a77bc10593281417d758ecf6aa13e9c3ebbaeab638c77a4560c8a4fde", + "docs/measurements/h264-rounds/inter-place/fn.py": "7c7d925cba4b31955c8709215a060997548e8daa14d499a88be6fbc5527119f7", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/README.md": "e6305222183472dbc6706fcdf14b1c2bd31f799a07dad4e82069516464d1c749", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/host.txt": "d19a25580716f28e95694fade06b417dcc8a5e29b70d4e411b2eca0d9530cec2", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/job.sh": "06ad38fac2cdcb7c99e734a6403d7603d13fc8621da14db2157cfd318ed21b3e", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/progress.txt": "37929aef8b01d1449c23ca33674f85a8b9e9aaadcf978f52de8416364d113d7c", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/ref.json": "52f56aeb083d33ccd5aa91501b8bd5cd2ba18f62aeb078aa6eb8f144bcd6ea4d", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/t8.1080p.json": "d9ac77e690fc008f87050b4213cc114065457aacca3ac453333456e81c06f202", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/t8.1080p.log": "aa7fae9b4fd4bacb70f3f1222f2dca24287f5e816e99975e0a3362e94ad13dd7", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/t8.4k.json": "faf76304c55ba3370772f6a7b9da15811c8efd70e4af5a68ec8becec7bbdd378", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/t8.4k.log": "fec826456677144e567265405c185b5f851f2ec7775113544398a3a0d894c6d7", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/t8.720p.json": "867a377924e2df734b0c7137972fc80139604b7edaed97b4798a4b5eb6630748", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/t8.720p.log": "af0f61b811f89397ffffed89e218f27a32c5811e5cf01f69e06492b263f0a70a", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/t8.sd.json": "30427b3ff097ca0c1ba8fdd1e5f9652943867c247a9112425a976385106e3ac5", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/t8.sd.log": "efcd83e0b794e85874459a7610ea0f0faed18dd3dd318c615c9a3ef60f830c01", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip2/verdict.json": "ce6b68d8356db5170ede966c274da31fcbd5877f545348196976310aded32bd7", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/README.md": "2bcdfd7c10bd943313b4ed51f6ebf4d54fed3329de2fe04eee20782d2ebc2da5", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/host.txt": "5fbfcd0622673db607e519a30e4684d58249b3cb12b06536561c3cc2aadd0462", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/job.sh": "dd1d24ed811107d10d2cdb2ccd85fedc03672850f8243fc8e724493c1caa7fb3", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/progress.txt": "d2a57862e387dbce170957c18266a0e156d2568ddbbbb30ea8be6d5f79b19277", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/ref.json": "09c55d71201ed45b15dec9550a650e1b0e5aeae57ae20b63b9519a627306dc05", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/run.log": "7406fef0f7697da3858d8205efe480885800ef8a7ea322b0bdd481b00fc47f9b", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/t8.1080p.json": "9448ec406b16b23672c53a5b9443e67f7b43ddb8710baffff76eccc78b3250c9", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/t8.1080p.log": "1ed9d1b67d7b1bc672dd6c6119ca8951ea0404692f8d60cfaba47ba2b5096aed", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/t8.4k.json": "c92d1ea262279a00ca238730007bbfb319610c79eb123c4588d5db5d5d6dc7d6", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/t8.4k.log": "2bf0b4172e78675b477cb8eecbee1082d6254c1668944d606811f429b0518392", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/t8.720p.json": "c3904e731220659dd86c47feb9a7d659126f82eb1ce1772346cf549e41157236", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/t8.720p.log": "5fab62fcc71af6f11945e5f56cfdf1c95d3fd79024e93a33d323c5cbaffcb51a", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/t8.sd.json": "f482ba51ecd61bac55b4bc90fd5f500cb6faae753989d705bf42e7e494971cf3", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/t8.sd.log": "99e9e92df0bec9d8ba6ae93cdf9d211e31f4389932496f08e89b255c65589446", + "docs/measurements/h264-rounds/inter-place/gating-gcp-ip6/verdict.json": "aa4ab1f2f0bde61febec55c0f40e2638858fe91369967a5c8cff0776e11604bd", + "docs/measurements/h264-rounds/inter-place/gating-spend.md": "769a59a977e32baf60e02e22098817261791f395cede9c55530e6557930523f6", + "docs/measurements/h264-rounds/inter-place/grp2.py": "893260b4eed524cd19ee16491b86a3e18d0ab39bb4cbb5b8323ec3ca3428ebc3", + "docs/measurements/h264-rounds/inter-place/grp2.txt": "c8f95c1c8b2a6e4838f7fb0a77f0078a0149e74c36e8b64cadd41dbac00f76d4", + "docs/measurements/h264-rounds/inter-place/identity-probe.txt": "c21d94621c22adfd06eba945049de9f00e8a267d0f9f3a75ae7678d0f37cfbf4", + "docs/measurements/h264-rounds/inter-place/identity-round.txt": "ec0f2e663dc514d2ac742e18bfa43e3d0814bdc461df830f554ee3b431163777", + "docs/measurements/h264-rounds/inter-place/instructions-probe.txt": "e7f1e6533421e92872c9289f5aff73f3751b34b6facd94ba52ed11d921d1ef94", + "docs/measurements/h264-rounds/inter-place/instructions-round.txt": "1141b63d7c429b4183df05ac5ca63543e637ea7ed7826340f3c597e1455c5552", + "docs/measurements/h264-rounds/inter-place/local-ab/local-1t.json": "4d18e4eff37860b527a4db3b1868c926befe13c2c6815badb142758494501995", + "docs/measurements/h264-rounds/inter-place/local-ab/local-1t.txt": "7934c7db04188a46d3a237e4b71cd5fec1be05d91e34b7f1fe313e2dcfa66e80", + "docs/measurements/h264-rounds/inter-place/local-ab/local-8t.json": "a6b83aec50cda8396394029d808a45fc7f28b5b024f851d6749f30a61394637d", + "docs/measurements/h264-rounds/inter-place/local-ab/local-8t.txt": "8dc175f4b1d16c0125a5d3c80094f26f251563f82019b5b397f96cf26ffbb9bb", + "docs/measurements/h264-rounds/inter-place/plan-probe.md": "93a20a87e1dfa4db298852049d62468345a49c4cbd10399d630598a7c2e9ca21", + "docs/measurements/h264-rounds/inter-place/probe.json": "d449f0a4bf407f0b2d80cac5daca31098caad5c9b998acad2be3026981af0a3a", + "docs/measurements/h264-rounds/inter-place/probe.txt": "803e6b73ad48a5e094b908ea7df65b1680de5fe741ca7622c341c4436fd50a67", + "docs/measurements/h264-rounds/inter-place/stages_pmu-items.diff": "c1336caa6373a6cd0f371e4c10205814cf332d224d5bc857b608b8a1f9d1a619", + "docs/measurements/h264-rounds/intra-chroma/README.md": "83ddc26fc3c9c491e3e38f8b129947a2d458fe698b4e2ce5dd171a875fddaea9", + "docs/measurements/h264-rounds/intra-chroma/analyze.py": "4d86864029ee47e0ebc2928e91a5a2713cdd8f402b744db83cdf4ec3c829c108", + "docs/measurements/h264-rounds/intra-chroma/conformance.txt": "455fdfa981689ac0efc2fe7ead1fb5f3d8df6354ca81a879a64545f7ab94d89e", + "docs/measurements/h264-rounds/intra-chroma/fuzz.txt": "561f6d773c38527ac06b2a089399b1c7eff15f2027da4ba9728a5150a93db917", + "docs/measurements/h264-rounds/intra-chroma/identity.txt": "9de3a2becf504576ad05868f8f6fbaf6f9830e4304c7d6af70cfa166fb7ff448", + "docs/measurements/h264-rounds/intra-chroma/instructions.txt": "9280629696ce4b279eaa85ce756e11646dbf68da408e82d8df246e6565763396", + "docs/measurements/h264-rounds/intra-chroma/k.diff": "263177605a8e49e43dea9362248ab57672506b012e622723b00469e0947af85e", + "docs/measurements/h264-rounds/intra-chroma/local-ab/ab-classes.txt": "e8ceb6407cc18ea2d9cf02498d87ee206c76c0043a0d269254b0a272bf9b5179", + "docs/measurements/h264-rounds/intra-chroma/local-ab/ab.txt": "eb9f95f97e05f9f8adb99e371eae47ebae04301b6569978a4c0afb9be38b7d4d", + "docs/measurements/h264-rounds/intra-chroma/local-ab/plan.txt": "1f405f16a71a34463779a3272078fb169109c7bc1ac8ddb4cb7947440c70ee2f", + "docs/measurements/h264-rounds/intra-chroma/miri.txt": "67f315a1f38c44e66725a7b170bd07b3aa4d9b247bd2916c7bf9d85ec3b575b0", + "docs/measurements/h264-rounds/intra-chroma/probe/ab-classes.txt": "d3e218ba670d4329ddf4e241adc42907549137652565b9bd626ce749fdae4bea", + "docs/measurements/h264-rounds/intra-chroma/probe/ab.txt": "0c36b7881777cc6141253709fb94ed6e58070fc68b1ce98018c6af5a8ab66d9e", + "docs/measurements/h264-rounds/intra-chroma/probe/ann-chroma.txt": "043571f12713634c83e9733949855b73cd65ea234b2c89de7a0a922c9f787069", + "docs/measurements/h264-rounds/intra-chroma/probe/ff-pred-modes.txt": "8f8ee1d9b0856182fea9826a1663216859c4952c5f994e4fb2e23fc270c3d608", + "docs/measurements/h264-rounds/intra-chroma/probe/instr-1d4b1775d78a.0.720p.txt": "88dad6a445a3f15ea955f7e14bf1d7c14618e730e4be62f2ede64c6f56ccdc3a", + "docs/measurements/h264-rounds/intra-chroma/probe/instr-65ec61f95a00.0.720p.txt": "e2406c0b56c75a2684d36bbf60db84b58075f489b461224013528668fc6a6a0b", + "docs/measurements/h264-rounds/intra-chroma/probe/instr-9db41aa16b5a.0.720p.txt": "ba0a5b98b5cf010731e212565ad59d2bac6eb5a3bb983ddf7169a5ae1260bb58", + "docs/measurements/h264-rounds/intra-chroma/probe/instr-c7ecda16e4a7.0.1080p.txt": "c46f0477b20b4ea828636b2cb2882d28835f6dbf982923b4f6652460fe8032e1", + "docs/measurements/h264-rounds/intra-chroma/probe/items-recon-by-class.txt": "f267d822fec14329fcc1e85c708c6422e6adf5282808da336d7a4eb6ed65fa7d", + "docs/measurements/h264-rounds/intra-chroma/probe/plan.txt": "61c0e34d1a1b6a66487d41ea1ea82ef822afc1b86d5416969a759b085ffab0f5", + "docs/measurements/h264-rounds/intra-chroma/run-ab-helper.sh": "70558edd25afab84d9730a49dd47001840ce764fc8e586d161d0c66e9545de14", + "docs/measurements/h264-rounds/intra-chroma/tools/ab3.py": "4825e622c660bbb3c3f78ef04cc828935cb816ca973a3e952a26c6aa549ccc60", + "docs/measurements/h264-rounds/intra-chroma/tools/abcls.py": "c37aa727c3bef34b695340c15fa69634ba956674323108ce942dcbc22e9b1b79", + "docs/measurements/h264-rounds/intra-chroma/tools/miri/Cargo.toml": "f8d5d5300e60c30153b8207d0ab08d30051fbf4a30005ab2ab22d4cc5d158d96", + "docs/measurements/h264-rounds/intra-chroma/tools/miri/main.rs": "48fa73a6b995e33291d22e665b8b1bcf872fb9e9298be45308553a4530c7644b", + "docs/measurements/h264-rounds/intra-scales/README.md": "a5961718fe0a9d8585fa139962e569f0d487fb95977ae7c3557321562cdd9635", + "docs/measurements/h264-rounds/intra-scales/analyze.py": "6aff30f9944d7d30c0ae845dadd7f710429c15e72a0a8cb8a2a05d9d9f9c7101", + "docs/measurements/h264-rounds/intra-scales/conformance.txt": "93c7031a57bf34d0a6586010cb2cc2fc7bd1488bfef80434fb62af0ce17c8ab3", + "docs/measurements/h264-rounds/intra-scales/functions.txt": "794313bd28846a3458c13d5dc134ee3cecc40415a5bba18eba406623ffa34fba", + "docs/measurements/h264-rounds/intra-scales/fuzz.txt": "77e9ddeda98d8da968e22ce357dbcb11f68b78db914fa95806fc6d22cef45b2c", + "docs/measurements/h264-rounds/intra-scales/gating/README.md": "2ffba4ddde65a763413c1b217c43d71798c8205934386d5e38673669ca4cb4ae", + "docs/measurements/h264-rounds/intra-scales/gating/analysis.txt": "ecbf341c6c2bbd558dd90beaf8688c11392a577c9bfe508986e909e856aa82b0", + "docs/measurements/h264-rounds/intra-scales/gating/analyze.py": "6aff30f9944d7d30c0ae845dadd7f710429c15e72a0a8cb8a2a05d9d9f9c7101", + "docs/measurements/h264-rounds/intra-scales/gating/binaries.sha256": "f03625a43830b3219425c8632a13839e1911bd035dec36ce68ad79c3f1787eda", + "docs/measurements/h264-rounds/intra-scales/gating/g.1080p.json": "742c4889643def1e62894419b8eaa0b6cb185d70b991812b6ae3f4918406eb21", + "docs/measurements/h264-rounds/intra-scales/gating/g.1080p.log": "04e99ddbe8e52df27342777cf8b656ef04b17d4312b8f91b3f289ecf10589679", + "docs/measurements/h264-rounds/intra-scales/gating/g.4k.json": "ab04899bc01f27518545ded92f12714f16e65480c1ef0a74fc656fa21daf1909", + "docs/measurements/h264-rounds/intra-scales/gating/g.4k.log": "e94b26ee89e2dba74d27edcb90713127d332987cfff21d177e4d619b8c55687f", + "docs/measurements/h264-rounds/intra-scales/gating/g.720p.json": "d21ce2dd88e9c13edc668519b6a92ddfbfd6c3eb5c26805ee8c0fe2162e1e66f", + "docs/measurements/h264-rounds/intra-scales/gating/g.720p.log": "f6977e5200f8e7fdb30629e61f592cd222c481b96193ce7b28b861dafbf64648", + "docs/measurements/h264-rounds/intra-scales/gating/g.sd.json": "175d57d1f7d4da480ff8e4c2fac1d9c691a1e7febc68666683ec205750d14ca2", + "docs/measurements/h264-rounds/intra-scales/gating/g.sd.log": "e34d1a61da45c0349a37735e0a79cca6c393a6556907658e3bbfa270a41a2a4f", + "docs/measurements/h264-rounds/intra-scales/gating/hostgate.log": "0149bdfc3be66617c2b591b0994155354a346ec70da3dcd14ea81dbf66199d25", + "docs/measurements/h264-rounds/intra-scales/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/intra-scales/gating/progress.txt": "9c754dfc174f3c5ca852e3df6f9435b1f028590a1faa117da21589a712cb10db", + "docs/measurements/h264-rounds/intra-scales/gating/provenance.txt": "490da51feff2b5c84079181890bd2ab8ef8f2c5c2c126e432083d695f7ce7d94", + "docs/measurements/h264-rounds/intra-scales/gating/run-ab-helper.sh": "db191ced73fff38951d37fff9d63f13b6fba871842369a2c8e6e776ea42a7eb6", + "docs/measurements/h264-rounds/intra-scales/gating/summary.json": "2ad81b2793a2f7724b21c4a3f1eb19fb9ce9ea651b1a93b91efd3a2c9a46e418", + "docs/measurements/h264-rounds/intra-scales/gating/t8.1080p.json": "a706f4dd272c4765fd935b215a5953fdbda348a893c82bec19e153aece37b394", + "docs/measurements/h264-rounds/intra-scales/gating/t8.1080p.log": "f54cd0c5eb6d058ae508ffeebafdd48863a9d79c788acdfb2a264adcdcb87669", + "docs/measurements/h264-rounds/intra-scales/gating/t8.4k.json": "9eec856263ad17b03d0da07a9e3280b49c92a150c0ba85523faaa9a474606103", + "docs/measurements/h264-rounds/intra-scales/gating/t8.4k.log": "bc1c6303a878cb99541929c991dfbfffbc15356bc9397a717800d37e862ba3a9", + "docs/measurements/h264-rounds/intra-scales/gating/t8.720p.json": "a6caf407c61f427edd70e8412f3cba70e265f73b522aa74f48417c6a719120f7", + "docs/measurements/h264-rounds/intra-scales/gating/t8.720p.log": "4de9a4b5bafe3395a3554e21fe7ab47e3bfc6b28e5cdd7e1b6d72e098a76e3a1", + "docs/measurements/h264-rounds/intra-scales/gating/t8.sd.json": "1c00887085f77c9ac064fdee82b0428c56af726d4f83a67d065ea3d2e83556d2", + "docs/measurements/h264-rounds/intra-scales/gating/t8.sd.log": "f2fd1b9ed407a169cdf01b66ae0f0cb0092b8d2c8d96a17b66723a381886f9c5", + "docs/measurements/h264-rounds/intra-scales/instructions.txt": "5a62049615e7f202ea3aadd6b297bfb28b6d2a7d81859719cb2266004441a841", + "docs/measurements/h264-rounds/intra-scales/items_by_class.py": "55a8db2e7db47f05351d9c5334610fb145ed6a46d0ef844cc22caf0afd3db450", + "docs/measurements/h264-rounds/intra-scales/miri.txt": "fabb6ede4846b2c2eca7fef2e602bb6ff8e8f6cec0d125f67e0450ecd796baf8", + "docs/measurements/h264-rounds/intra-scales/profile-by-class.txt": "a63bbd6638d287a51c2a55d901758740e162498727bf616a57763464cf0952ce", + "docs/measurements/h264-rounds/intra-scales/run-ab-helper.sh": "db191ced73fff38951d37fff9d63f13b6fba871842369a2c8e6e776ea42a7eb6", + "docs/measurements/h264-rounds/intra-scales/tools/miri/Cargo.toml": "5ace817a7b478b2f52965ba6d91c97522adf1e61ad68ae52f76105ef337042a7", + "docs/measurements/h264-rounds/intra-scales/tools/miri/main.rs": "d075b0f4f4f205ce18fc8ae67d43a32d961c4f6895f1085fa6c8ad08901721a0", + "docs/measurements/h264-rounds/intra/README.md": "c90a8cf3672c74f166e8d8cb9916e52777e973e83a60f185a622df9029720d6c", + "docs/measurements/h264-rounds/intra/analysis.txt": "9353d1db7e1b2773553e1d22a5ffebd2ab7761547833824eecdf7ec6b0cf2d78", + "docs/measurements/h264-rounds/intra/analyze.py": "76508e6c3e92e08e50fb8dc82552f41b730c61cbb4e5af26fa67ee62282ba186", + "docs/measurements/h264-rounds/intra/g.1080p.json": "c748e082fe82839594fde75b3d1c81c749b170e5375d57604912995afd16caa5", + "docs/measurements/h264-rounds/intra/g.1080p.log": "9ba6890b17c4ee2589aef9f7a1d39e48c4cf750b0897fe36a6f838ee8a63ae67", + "docs/measurements/h264-rounds/intra/g.4k.json": "8f87019ef3f56ff55a6df9dc5cb0f9ae3d67b60787b9e7352d17b0f31e69db7a", + "docs/measurements/h264-rounds/intra/g.4k.log": "e3420695a02635b3fbb1dc54b251b784994de8cf33621f2cc3f6e10892cfc7ca", + "docs/measurements/h264-rounds/intra/g.720p.json": "f773c5061c96f0ed6cbce1fee8733304e7e82b9d91a9ad52bb399f59d2e053df", + "docs/measurements/h264-rounds/intra/g.720p.log": "3090e308673e225d9cbe46677f69f7bb491262b178f69a0567867eeeda701eea", + "docs/measurements/h264-rounds/intra/g.sd.json": "bd43cc0cc1fbaf261f5ef65659661a68eb6b9f28fdf5dfe7e6c1c94411e6e633", + "docs/measurements/h264-rounds/intra/g.sd.log": "fa7d63cb5595bc8f4ec5800c7e39ce0054272f055dc9b1ffba57d86850fd4292", + "docs/measurements/h264-rounds/intra/g.summary.json": "7a3d6493c69061c1df0a5380c57e8e8e536d9b5f074a158c70e17cdcb6baa158", + "docs/measurements/h264-rounds/intra/identity.txt": "60b0db690e4f24b02fbd617b71af317de998c91cd024285b756a0c422e8b9a5f", + "docs/measurements/h264-rounds/intra/local-timing.txt": "979830415c5f480c7446858a5792a6e7b7828973e70f443d177791c74528ef53", + "docs/measurements/h264-rounds/intra/profile-intra.sh": "0290205f8fe22a434d3ca22e4a783e402c11b72e0bd1c3cbf9db052492d12755", + "docs/measurements/h264-rounds/intra/profile-intra.txt": "0e31331e944120611bc0c64a5a06ca811d9fc7ab059efc0c93d3032558c1050e", + "docs/measurements/h264-rounds/intra/provenance.txt": "b0990d13ae292f4c3090be18b1dc8699f4b4e27eaa203a2626c56383e5731252", + "docs/measurements/h264-rounds/intra/run-ab-helper.sh": "2eb11695bb047ba5ac3a42e9b54b01f73e7d036c71887584cca812e94f9c081c", + "docs/measurements/h264-rounds/intra/tools/miri/Cargo.toml": "1a2203b7d3dda52bfd0f16a17ff15f7ac68d129d746b36e682b3e30b0f40ce2a", + "docs/measurements/h264-rounds/intra/tools/miri/main.rs": "58f39e1e5ffee249a11d7d9ae3182cd0158f683cd2c75c840cca57c5931fee8f", + "docs/measurements/h264-rounds/intra8-edges/README.md": "4e0c5b60ab901c0df120b4a5440268af06c1cbf682006252bb41cf2a08ff862b", + "docs/measurements/h264-rounds/intra8-edges/analyze.py": "f82345b6396dfb2cd52613b06544a8bad26bb4d991304304348c72198ce5410a", + "docs/measurements/h264-rounds/intra8-edges/conformance.txt": "72160a00144af0c1982dacd8b886f2ac03d387100a26f3cc57bcd64a00b19172", + "docs/measurements/h264-rounds/intra8-edges/functions.txt": "a65a6022dae913d2251b2842bd8b99bcd0ffe819700c0a5a107a9a80844ff335", + "docs/measurements/h264-rounds/intra8-edges/fuzz.txt": "a274ab5d70e58a5ced26a934c99519696819da20db236b2a58d6461f6671e4ee", + "docs/measurements/h264-rounds/intra8-edges/instructions.txt": "9f08433cbbb9a5f6c1052fbec67b246998df92a100061ee9ac4a4fe7a1e207b3", + "docs/measurements/h264-rounds/intra8-edges/k.diff": "c142dc84426c16e80b0a5218f316f2fd31607e26b553bc4d594e48411a1eb06e", + "docs/measurements/h264-rounds/intra8-edges/local-ab/g.1080p.json": "7c4ae0bd51a27882275ab38f88faf7119ea85d5742e4ec4cd9035655662afed6", + "docs/measurements/h264-rounds/intra8-edges/local-ab/g.4k.json": "bd2fdd069e2a9ac57391e917bb21eb5d8d1fffacbc79c5c6bca63e3d71304e96", + "docs/measurements/h264-rounds/intra8-edges/local-ab/g.720p.json": "82fcf8cd8edd96fd1f7a9963070b0e2a80664ce7ab925831c7098d88f378b719", + "docs/measurements/h264-rounds/intra8-edges/local-ab/g.sd.json": "a5e7f246ef516806696674a79744d2e60eada4d2826b7d812aad71657f4a4d6d", + "docs/measurements/h264-rounds/intra8-edges/local-ab/run.sh": "3e808bf1c30c4c578394b52f996f2206938b0be96b6b8712219d6ad5b04c9447", + "docs/measurements/h264-rounds/intra8-edges/local-ab/sum.py": "09c7d947204e8f62f9621cd23623d4bf302270adc0aa175a600a57e4a92b2682", + "docs/measurements/h264-rounds/intra8-edges/local-ab/summary.txt": "3a2cd4994eabd942289de3c0698b84e9711645b280b0b89516bb84d4965c9c0b", + "docs/measurements/h264-rounds/intra8-edges/miri.txt": "e4dbea9bfff71d51d1fac2f7344296efdfa4110fb9750be669dd41a48a4672ae", + "docs/measurements/h264-rounds/intra8-edges/run-ab-helper.sh": "80a66e8d54d8f446585099fa5b387686f1b9ffe153efc3190b5c1b126accbb9f", + "docs/measurements/h264-rounds/intra8-edges/tools/miri/Cargo.lock": "3c7681e89c585e1a0ff750b0268bac863ab2aabd42a3367829a36ac8dfd60bec", + "docs/measurements/h264-rounds/intra8-edges/tools/miri/Cargo.toml": "abf0d8ff0e8be002e0f5a9e7fae92afd45bc4735b753ffdf3f718b8846a3ef5b", + "docs/measurements/h264-rounds/intra8-edges/tools/miri/main.rs": "d4d6bdb7313552aa25a3a78c66c24df976cf293be7e075614413500153e84725", + "docs/measurements/h264-rounds/intra8x8/README.md": "0f1f8093f418bb7eb24c558dd75eaf38fc77fd8435903b0f5ec514053861d504", + "docs/measurements/h264-rounds/intra8x8/analyze.py": "46b58a98ed1d58c91035f6a60f3646209a0b80933e8f034c58128ebba13b4513", + "docs/measurements/h264-rounds/intra8x8/gating/analysis.txt": "79980adc8a6b4ca9076da1d6c3f8bc253efdb84a30bd8d2f8df89796b8436500", + "docs/measurements/h264-rounds/intra8x8/gating/conformance.txt": "3b95e38e5a0a4bc0e2e0e892de9f19348fee1cbfd89d752abb272b69252646a4", + "docs/measurements/h264-rounds/intra8x8/gating/g.1080p.json": "fec1804ee0ced5198cd69244882d3b06676f38904a536a2e6beb17eb3932b12e", + "docs/measurements/h264-rounds/intra8x8/gating/g.1080p.log": "f567290554f9904d82e45f3fb954b0831d7d50bbc647219be965137c29bc78db", + "docs/measurements/h264-rounds/intra8x8/gating/g.4k.json": "32cd9ef8472bb9b2191986cdf6e14e61a705fbb62f437a80b6d0ceeda0421d37", + "docs/measurements/h264-rounds/intra8x8/gating/g.4k.log": "9392a40a3a5f9620a46a062b72c4dc00117b893d275bc7156ee48922ea772e20", + "docs/measurements/h264-rounds/intra8x8/gating/g.720p.json": "3121e2836e3a85f386e784f42236801a28df1b9de228c3a68fbd7a3d5a5c145b", + "docs/measurements/h264-rounds/intra8x8/gating/g.720p.log": "a1a654fffccd355cadd9c47146c89cfdc406fcdf98709318c75daaa84ed75213", + "docs/measurements/h264-rounds/intra8x8/gating/g.sd.json": "199d3e82633d6621d142cf7dd70c8b07dfc0123d3e5852e2871aeea5f30a5486", + "docs/measurements/h264-rounds/intra8x8/gating/g.sd.log": "5ef82dddea5709cf2e23ab485fa70aca86bac755d7bda9b1465f611806f44b51", + "docs/measurements/h264-rounds/intra8x8/gating/hostgate.log": "20ccc4af357d68f41f811e03b3fe0bce01e54f0728ad1798aff0e233eb21cae9", + "docs/measurements/h264-rounds/intra8x8/gating/identity-rebased.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/intra8x8/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/intra8x8/gating/miri.txt": "19c3fe46f6a9cae7d05f9351a26ea36331d9805950b7cdc0791c3b2a9dcb769b", + "docs/measurements/h264-rounds/intra8x8/gating/progress.txt": "647955bb68dd3f7a051b1c628e851c40947d042cf8bbfc4f4e4fd845c2d70ab7", + "docs/measurements/h264-rounds/intra8x8/gating/provenance.txt": "898030f9c13ee5d30b0e7f36f89f306dcc72515a48c71eae5b947753c33630ef", + "docs/measurements/h264-rounds/intra8x8/gating/summary.json": "0c54c397014b728e7a649d22e8c95b657ba7c94141e43c51948852d42ae2446d", + "docs/measurements/h264-rounds/intra8x8/gating/t8.1080p.json": "da97f1e4d3181a1c85b2af3f59d7f21152b881176dfc0c412819dd9229950b2f", + "docs/measurements/h264-rounds/intra8x8/gating/t8.1080p.log": "235c81cd1c5e50aeda620686b826c03357c881385dbfab134bcc8148da2d0c78", + "docs/measurements/h264-rounds/intra8x8/gating/t8.4k.json": "a9f8992097fa5b0646a3a3f5e6ffedd1643ec5402fd27d06f0cb671164e11166", + "docs/measurements/h264-rounds/intra8x8/gating/t8.4k.log": "19a61e93a869c3f8a8ffb229d159d06ccab4687c8328c86d7f1df292d405196f", + "docs/measurements/h264-rounds/intra8x8/gating/t8.720p.json": "efe5eae99152b77198287d2e527270a467d9ad380d89a98f71c6c2ee64804a0a", + "docs/measurements/h264-rounds/intra8x8/gating/t8.720p.log": "85b7069fce0946cc14343ef0315c010e6701ad0566a345a04d90474d9b330055", + "docs/measurements/h264-rounds/intra8x8/gating/t8.sd.json": "347d5a2c8e2794f6b05385d60ef8917c0152dc5bf1e38241e783998c4d1a2935", + "docs/measurements/h264-rounds/intra8x8/gating/t8.sd.log": "288445fb273de7be333dd7cbf13f3778d56d759f27fb02b20024bb2a704905b0", + "docs/measurements/h264-rounds/intra8x8/level-checks.log": "9927e780c7e4d904f1e82e5c6327557f9a0af162bd503b7a1423002d4e250c22", + "docs/measurements/h264-rounds/intra8x8/run-ab-helper.sh": "4430f25644657f99908bdbe89e5aae078294cd2c9f5a7fb03b3826d8bd216048", + "docs/measurements/h264-rounds/intra8x8/tools/miri/Cargo.toml": "bd33eb0c3f494e3b6571618bb8e9ea3d4f2c3cf6861cc3620f7e90c38764a288", + "docs/measurements/h264-rounds/intra8x8/tools/miri/main.rs": "e115e20a1ab140b6f13eafb4ba0cbbd747d1ba3256074655ed59f385ee65361d", + "docs/measurements/h264-rounds/invalid-round1-pair-after.json": "c31d42d438d4cca169c86f8ba4afc36bd2c73bab2a6b2fb24cf8bf6440b40753", + "docs/measurements/h264-rounds/invalid-round1-pair-before.json": "d9a5b30035f703373d93030e33970c3584c232357e9508d5d85fd8049a563414", + "docs/measurements/h264-rounds/kernel-gaps/README.md": "c0a84cb5277b57ae7e856937fc355ceb813b6cde90e50abc2b0d7aa298fed633", + "docs/measurements/h264-rounds/kernel-gaps/kernels.json": "9741a8f45d1357770e487df8edd372616e34ce8a90a9b35eaab983ab87bdd3a9", + "docs/measurements/h264-rounds/kernel-gaps/kernels.txt": "88dfc74538251f8caaf69cb50dffd8dcb9ceb869e369d69476a17a2ffe528e56", + "docs/measurements/h264-rounds/kernel-gaps/kernels_pmu.py": "d6c5f56a79c5a6537e6d9bbea27e4d73e294dc35cd303c08625512a3fa6fbf60", + "docs/measurements/h264-rounds/luma-dc/README.md": "f808f988216a488198deb5096157bb7fd6400e2a8ecb3499afcc4d2e260e4145", + "docs/measurements/h264-rounds/luma-dc/analyze.py": "e274ec9158a45eebdea79ee3ee7773879f7bfc78aea951f617098854e1122ba0", + "docs/measurements/h264-rounds/luma-dc/conformance.txt": "32e359f603cc6c52f2791818bf62ccc143a1a6adbcc7c7ea23d6b1bab4fd26f8", + "docs/measurements/h264-rounds/luma-dc/counts.txt": "99a8a3ecd350a36805f66a6950a063ad0ac530a2f24ea1e95037821b25db9f21", + "docs/measurements/h264-rounds/luma-dc/functions.txt": "bdab147e31c4164acf34773f3b50a511fc2909c2852ccbaa71cde520ee734a16", + "docs/measurements/h264-rounds/luma-dc/fuzz.txt": "959e4aa0f8841a632097ff967b11febd7aac4a32cbd0e0d51408ba17ecf02133", + "docs/measurements/h264-rounds/luma-dc/gating/README.md": "412e453dc86d01b7333288e47150fd0efb6edeae00e696ad1640893e3c0947b2", + "docs/measurements/h264-rounds/luma-dc/gating/analysis.txt": "4a8f9a7bc5293a99ad0fa03c366ea0050853f98ca45aea42745cd7cdfac85d05", + "docs/measurements/h264-rounds/luma-dc/gating/analyze.py": "e274ec9158a45eebdea79ee3ee7773879f7bfc78aea951f617098854e1122ba0", + "docs/measurements/h264-rounds/luma-dc/gating/g.1080p.json": "25ff327cc5e8f7a0a2a4a68ddce7931d53c9fef47124c0fffe197ca1a20a68dc", + "docs/measurements/h264-rounds/luma-dc/gating/g.1080p.log": "c92a75ab1e2e88e13d18e52526b18b7c396d340ce066162f00459eb7785f4533", + "docs/measurements/h264-rounds/luma-dc/gating/g.4k.json": "f8134de9efe81a81e7ee5cac17fbf750c58cb6fa611cf7233e2ff208a82d555c", + "docs/measurements/h264-rounds/luma-dc/gating/g.4k.log": "8d9e881bfac61c47817fb6f22c3785c36344826f381b316ad32eddcc0a8e9cf7", + "docs/measurements/h264-rounds/luma-dc/gating/g.720p.json": "5048ea4f09a40e645d658e54363b27544b80b2b0c59a726d7cea30818ff13309", + "docs/measurements/h264-rounds/luma-dc/gating/g.720p.log": "14c9bee21ef009898b186a3c47f8cb0529e038eb180deca9f16864c250ed9ef0", + "docs/measurements/h264-rounds/luma-dc/gating/g.sd.json": "3660e01da05a8e6819fd90165af8f563598c6be0139a8036415c1c69d9817e81", + "docs/measurements/h264-rounds/luma-dc/gating/g.sd.log": "f1df9e7c092d6ad57ff2aa576af01fd3eb7a142a6c538efd42bdb65ba91c03bf", + "docs/measurements/h264-rounds/luma-dc/gating/hostgate.log": "1261a7082f25b4bd047f57ba4148d4ad05183657a6934fd6979b29a382eb457b", + "docs/measurements/h264-rounds/luma-dc/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/luma-dc/gating/progress.txt": "f2fb888efda6467d55a114682763e64dd236e64262d671931c8407805c1e606a", + "docs/measurements/h264-rounds/luma-dc/gating/provenance.txt": "12c109beb29680b241aa32e79b2262a9f8690bd596df7183d89f8e2031b45eb4", + "docs/measurements/h264-rounds/luma-dc/gating/run-ab-helper.sh.used": "a3ce11d0869b737457f6cd15bd0c72f775c4d1f3a89269d5ac8c7a295471c839", + "docs/measurements/h264-rounds/luma-dc/gating/summary.json": "68232bedf9d636e2028220a77293f31e4f74426aab7d925d6edda0fac757304d", + "docs/measurements/h264-rounds/luma-dc/gating/t8.1080p.json": "d2c65f8b1c3efe3c92bea750e445d49bec1a572673caf4a572eb43849ce93d17", + "docs/measurements/h264-rounds/luma-dc/gating/t8.1080p.log": "cca6884e17d0518b139bae150cc0badd1b273ca1351f3c1f6e6954e04ff39e7f", + "docs/measurements/h264-rounds/luma-dc/gating/t8.4k.json": "74929bce19d71138a80a2a0498af3bbe36d874597242a040ffe66bdf78f6c5b8", + "docs/measurements/h264-rounds/luma-dc/gating/t8.4k.log": "1070653155065e3b5506897390aa634ee994149b4ac7210617eaf904d6d0ccf7", + "docs/measurements/h264-rounds/luma-dc/gating/t8.720p.json": "3bde8d6a4d35b77160121647fdaf85e6375418177d1d992b57c0dc6d5b847297", + "docs/measurements/h264-rounds/luma-dc/gating/t8.720p.log": "7ed381fe17c53b2042ceaa06475cb75befe6fa6a5fd2331d039b6655f56af887", + "docs/measurements/h264-rounds/luma-dc/gating/t8.sd.json": "0746f4dc74ac9eace24ed15ccd12e599d23203306de651bbb789af1fd60fb63c", + "docs/measurements/h264-rounds/luma-dc/gating/t8.sd.log": "d692c8373ac5e3bba51fbd674c425e882f69f6f8b5d6ee66453b034daacff3f9", + "docs/measurements/h264-rounds/luma-dc/instructions.txt": "eb60eabedf0d4c9cdb84a7122b5538d64b687ff3f37f6405d5e93345d72656f5", + "docs/measurements/h264-rounds/luma-dc/miri.txt": "483e6c8fe84f3f42d305034fee309ac6f7af877debc43b842e0f569c02d6bd75", + "docs/measurements/h264-rounds/luma-dc/mutations.txt": "f4ee648fd1917759b24dfa24d10a54f40a456e6b073de48d82416e5d649edc41", + "docs/measurements/h264-rounds/luma-dc/run-ab-helper.sh": "a3ce11d0869b737457f6cd15bd0c72f775c4d1f3a89269d5ac8c7a295471c839", + "docs/measurements/h264-rounds/luma-dc/tools/miri/Cargo.toml": "6a5cf079493388eb7636fa4f713a3749162b32d903d07987f3b2d0fcac33a20f", + "docs/measurements/h264-rounds/luma-dc/tools/miri/main.rs": "18172ae4c9425e04c8a531bdfe33d291943120968953d171263e7eb3765ba358", + "docs/measurements/h264-rounds/luma-dc/variants/instructions.txt": "a069d50fdcf499119720f22533b16d2b4885e50a5ffd760ddea6fcbf6cd7bb80", + "docs/measurements/h264-rounds/luma-dc/variants/mark.diff": "12c7e4ca2d06c766bac8c9336e352d4785a8b975e6b297d166b2d9f6f2eac517", + "docs/measurements/h264-rounds/luma-dc/variants/no-intra8x8-test.diff": "66d1d300535e6711bcc8f9950a0a0bb6ca476d4082fc1eb1f7de54a3d9cacb04", + "docs/measurements/h264-rounds/luma-kernel/aligned/README.md": "9bcd37e520c5e77c7b7734756187d64019415cf9b94e3d1c6553cad1d65b57d0", + "docs/measurements/h264-rounds/luma-kernel/aligned/abn.py": "0b17b7a8efaa41d34808c2fb25e29dc465dc94a99dca7ef804318e122ebe595f", + "docs/measurements/h264-rounds/luma-kernel/aligned/probe-align-4k.json": "243e38a53bfb56a865285be02b815648211e18360e0fe63ec7fc6e0f75016b0a", + "docs/measurements/h264-rounds/luma-kernel/aligned/probe-align-all.json": "7299e3aca9f7410220ccf61d5771dee091472a2679cace62cfc664da485589a4", + "docs/measurements/h264-rounds/luma-kernel/analyze.py": "90559befc062eb4a2b103b8e837e2805f382c2b7290495460d8d7df008c7716f", + "docs/measurements/h264-rounds/luma-kernel/gating/README.md": "a08bbd58858b58ae58b0945e73754d5ded58eb0e4b8b80f2b04f265f114859c2", + "docs/measurements/h264-rounds/luma-kernel/gating/analysis.txt": "d55f51b4960d9f1fec7c0d01634c52c09adffc5eaa75b412b60b7eebdeb7b340", + "docs/measurements/h264-rounds/luma-kernel/gating/conformance.txt": "30a64542aac29243487aedabc18ab8c712ba69dc48c2ed02cd5cfa5ecfc94372", + "docs/measurements/h264-rounds/luma-kernel/gating/g.1080p.json": "c7bf4c144f0bcf767be8fbc1f30b53814f99ae0dfce50a8824ec2c754c687f7e", + "docs/measurements/h264-rounds/luma-kernel/gating/g.1080p.log": "2bb92ef61f9a74c69c12c2e16e55a3885d88eb2eef3b4649d8311e05892d1071", + "docs/measurements/h264-rounds/luma-kernel/gating/g.4k.json": "e3e1c972fb6b436c35f9eb42e225b345309fead4e29821155c4368d04f82fc36", + "docs/measurements/h264-rounds/luma-kernel/gating/g.4k.log": "e2c5dfc88e50311416a6148eb77bb9247d3232f01b432b355a76125d72c39381", + "docs/measurements/h264-rounds/luma-kernel/gating/g.720p.json": "9c94e72c53d69f8cf2c5f35b80a9c9ae96806bc4c3d35d84546eb93ccc32e9e8", + "docs/measurements/h264-rounds/luma-kernel/gating/g.720p.log": "e3b68241f3288a515d1880563613bde1287f87dc22f590eae819c5cc6c38fea5", + "docs/measurements/h264-rounds/luma-kernel/gating/g.sd.json": "5839885a6e50f3d1db84a17b28ea68f7875584fcfade5910e4bd4b535da33262", + "docs/measurements/h264-rounds/luma-kernel/gating/g.sd.log": "f3075c39abe280a76121dc425dd056e617658fdd744f0e2ef1c5965c7f9c5bd5", + "docs/measurements/h264-rounds/luma-kernel/gating/g.summary.json": "efbd00b2dee8370df8ef3222c652c1af8944502d10026be8c8821a40c6260fcc", + "docs/measurements/h264-rounds/luma-kernel/gating/hostgate.log": "c3c8e677b79f88b3b89c181072c61e06086e1e857879a16c5003c4b0e15bb19b", + "docs/measurements/h264-rounds/luma-kernel/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/luma-kernel/gating/progress.txt": "5a730e73f0dd2fdedd506649be6f59f38a5c42315013ca059f8fe4d028191257", + "docs/measurements/h264-rounds/luma-kernel/gating/provenance.txt": "822f33c05f68d3b25512ac3be3f6f802847b8fae280d72381b5da395f9523ed2", + "docs/measurements/h264-rounds/luma-kernel/gating/run.log": "0a055af285ea99c05da6889f9f6d990c9a60d8cd41d5a9cacea8343cef7eb50f", + "docs/measurements/h264-rounds/luma-kernel/instructions.txt": "6537530581dcabf39a6cbd68f3a12a1f22eb22ae983951cdd8b0790a831bf0d6", + "docs/measurements/h264-rounds/luma-kernel/local/README.md": "dfe7f84bc5ab2143c8c200a8aa8b9a54bc8ce4ba12a6eeb920053806a853e2e7", + "docs/measurements/h264-rounds/luma-kernel/local/upper-bounds.json": "eec3b70927533c6e294d34853acb69e71bc3480b70ee553161088b82a52da247", + "docs/measurements/h264-rounds/luma-kernel/positions.txt": "697a7335506221aaa8baf4cfadc6260e1808b2178f12549efcb9ed94e0d7af20", + "docs/measurements/h264-rounds/luma-kernel/run-ab-helper.sh": "1a0db59f8b792e413eca867c98c0e516efa0e91225e2f286710100d5d874cd45", + "docs/measurements/h264-rounds/luma-kernel/verification.txt": "ee148c2db56e790534698a461856a426261cc2932630072ed7da3e2e4b14a83e", + "docs/measurements/h264-rounds/luma-mc/README.md": "1e561a444733ec86c24d51ed70f0f824acceb9b1ee7713037df1d86ccd3aaed8", + "docs/measurements/h264-rounds/luma-mc/analyze.py": "a06d210ca68f1fe36e5b53d7cf307fb991d5d6acdf21f27aa63298554f69fff9", + "docs/measurements/h264-rounds/luma-mc/calls.txt": "30559614b7df895035cb21d8940d0a9ad03b27c6fec99b625eb1f64a8bc8c257", + "docs/measurements/h264-rounds/luma-mc/g.1080p.json": "30e3085fd3c9f8f6894b17936c04762cc2029bdabd03596b20845a4b8169a9f9", + "docs/measurements/h264-rounds/luma-mc/g.4k.json": "826801dbecd81a615a0650338cd27590b45896e320e3d0e9bb4e21cf8db4c683", + "docs/measurements/h264-rounds/luma-mc/g.720p.json": "8a005c68f8057a8aeee7eaceb2c7d0b35f46937a87689a98273b967b400872cc", + "docs/measurements/h264-rounds/luma-mc/g.sd.json": "e6133b7cb1ec915de3afffdda78c5e311c97e1058c42d373ab82bc2dbb7cc890", + "docs/measurements/h264-rounds/luma-mc/g.summary.json": "40a6f1dd9eb2014251e017391c6f412acc0635fdb5045aca89460b3c35497858", + "docs/measurements/h264-rounds/luma-mc/identity.txt": "21b426d52b85395c3de863cbea6c193fb912d7220587a04669f30d830cc1e125", + "docs/measurements/h264-rounds/luma-mc/instructions.txt": "965c138d77e4766eeb6ea998410b161542516f09ccf364a2a16c4803ae257cd9", + "docs/measurements/h264-rounds/luma-mc/provenance.txt": "a007a32019c7c4ac940e4fb1fae83d8cd918bd0b8236bc7a02f8507a52333e76", + "docs/measurements/h264-rounds/luma-mc/run.sh": "84bc24cdd296502ff496490e0c922323956a0eeea29ef2aa6b960134b32cab3c", + "docs/measurements/h264-rounds/luma-mc/shapes-first-version.txt": "e0bb9337e4b5b398bebdec516d9bfc3451f69758beae849029113d64d34e408f", + "docs/measurements/h264-rounds/luma-mc/shapes.txt": "d867915deb9b83cbd5b622fe6022637b407c63d41c21ef506fe86b6f961d2ce1", + "docs/measurements/h264-rounds/luma-mc/tools/calls.patch": "930712c06d06b8f6d65542b9ff571a0bd2493e32683ae2e62aba201d44691a51", + "docs/measurements/h264-rounds/luma-mc/tools/count.sh": "b369cb54511d4254c9b93a1b22ebacddebb303e80b18ff073d69320c23750d13", + "docs/measurements/h264-rounds/luma-mc/tools/fnsum.py": "b81af4b9154b5b28883539062c098755f3c007a7120594193a2b3f4fa7bcc979", + "docs/measurements/h264-rounds/luma-mc/tools/lmccount.Cargo.toml": "6246d612fc1e52529557c13adc753e13451f175d4d2160172527b4dfba4bc8ed", + "docs/measurements/h264-rounds/luma-mc/tools/lmccount.rs": "14f1b76bcacec7a2fd612293191a9c53c63f9a2cbc55193ee452ff51d954ae29", + "docs/measurements/h264-rounds/luma-mc/tools/weigh.py": "6c694c0415d08d5f2a0f9ad0e9e6a55bd9e0cf110b5fa3488606980177f33153", + "docs/measurements/h264-rounds/luma8x8-probe/README.md": "5d77d6e8741875da769b6575fb0791c97d68546f13347f6809d5874f0b2a8175", + "docs/measurements/h264-rounds/luma8x8-probe/bound.py": "a49bba4d192000ac205e9e3fe392dfea6fb91dbbe5ad35e9c7c12e45b4f1ba5f", + "docs/measurements/h264-rounds/luma8x8-probe/bound.txt": "d6aeebe21edba5d570d63ae1bc61924e76d86e46ea2c41a81143e67a3000ccf5", + "docs/measurements/h264-rounds/luma8x8-probe/cg.sh": "d96df90d5d41989e631be3eb58804e6af3919ecfbe55c6e1da9dddf0bb41bae8", + "docs/measurements/h264-rounds/luma8x8-probe/edges.py": "b158570917956cd78f81d2e79cf2c3c85057184b3a5b623e68477fe0ef157efe", + "docs/measurements/h264-rounds/luma8x8/README.md": "8731973a1c8406175da58a808226a65e41b5fb3b83e8a19ae917bf2c1555972d", + "docs/measurements/h264-rounds/luma8x8/ab.py": "88fee1dd7c20b3367d8200b4198f7b21a2cf2d9a1eddc270ef81ed2c77896b25", + "docs/measurements/h264-rounds/luma8x8/an.py": "d2a5ecc726f952a799d7c270fd32e17116c81f53bdc70ec698d7f17f322df3f9", + "docs/measurements/h264-rounds/luma8x8/instructions.txt": "73c4cbc34079fe601e1e793373e9efb53182bc68efe69673d3f27f0556b3147b", + "docs/measurements/h264-rounds/luma8x8/local-ab-one.jsonl": "8320cfc156cba583bd68380583d4f50b2407ede47f0f7ba64e68670ef424afb5", + "docs/measurements/h264-rounds/luma8x8/local-ab-one.txt": "6a391c269f26f28a79a1b353545e2d4030291aff20452dd1bd81ce17d2398aa3", + "docs/measurements/h264-rounds/luma8x8/local-ab.jsonl": "ff6640e483ab2a1eb34abe95ede8c2082b16549971c5696fa391671646222cb6", + "docs/measurements/h264-rounds/luma8x8/local-ab.txt": "b1ccd4f5326a7d9ff05d3a66e8e730dc4233da189e2f2deaafdd82f3336ebec4", + "docs/measurements/h264-rounds/mb-layout-2/README.md": "3ae07aaa26905a11861c9a752abcd011fc7a1817275310864990f75fd5d48cde", + "docs/measurements/h264-rounds/mb-layout-2/analyze.py": "bc3630be4427f390540fc945658007c41921fe9ec08113aa9cf503717c9dc028", + "docs/measurements/h264-rounds/mb-layout-2/gating/README.md": "b74c22771840b89b2ee11a819fb7cb5b6a7f9e5f54b9a2430f72c518a4a336a0", + "docs/measurements/h264-rounds/mb-layout-2/gating/analysis.txt": "bee832372c0f928cd014a3fab28ceebc1c8b4810420da47ccbcf3ddb3829db0e", + "docs/measurements/h264-rounds/mb-layout-2/gating/analyze.py": "bc3630be4427f390540fc945658007c41921fe9ec08113aa9cf503717c9dc028", + "docs/measurements/h264-rounds/mb-layout-2/gating/binaries.sha256": "43bcddd3b66cbf8842b53a45725689dc81ae94b79902f24ed789bd004ec5dbe2", + "docs/measurements/h264-rounds/mb-layout-2/gating/g.1080p.json": "1d31057355cc7f5e08de8b043a6e99d191b51c5c84929809b4f554745ba99721", + "docs/measurements/h264-rounds/mb-layout-2/gating/g.1080p.log": "bdb497efb44f98c12043e8e264189da312529178a531abf728fc79a562a1ab20", + "docs/measurements/h264-rounds/mb-layout-2/gating/g.4k.json": "91625cb4560854fa56d6e05adf3ca5b91ec8bc9b59f5d7ff12043a31b6c74a46", + "docs/measurements/h264-rounds/mb-layout-2/gating/g.4k.log": "231fdf054e13daec8a1a03eeaf4f64f8963f77353f33221573dcd9d034a19121", + "docs/measurements/h264-rounds/mb-layout-2/gating/g.720p.json": "e703197fcf183231628c6590b7dad6b7b8a95abeda76d2db1f23e96af92c6b08", + "docs/measurements/h264-rounds/mb-layout-2/gating/g.720p.log": "cb4f7528f642a6ec4a97cf31d97f882d6b75d5806c1018e9a31ff98019761306", + "docs/measurements/h264-rounds/mb-layout-2/gating/g.sd.json": "48b2a17820165102b443149726e1baefe6115e5a5722f7013899e01318bdb4b5", + "docs/measurements/h264-rounds/mb-layout-2/gating/g.sd.log": "457bca1efb58cc1256c4086bac0efabc8edab036fb0f51c6bc1c88c9410f19c0", + "docs/measurements/h264-rounds/mb-layout-2/gating/gm.1080p.json": "3f5ec984582da4dd7f27b5da1f96bdd2c7dfd615ecfb4196dec26e0082242720", + "docs/measurements/h264-rounds/mb-layout-2/gating/gm.1080p.log": "cd08ebbc203cea30e640e4a2ca64bef7f83c1f6128fe250130e99ef56a309bde", + "docs/measurements/h264-rounds/mb-layout-2/gating/gm.4k.json": "200c906ffe9f9c8a7029193fd0eba7b719aabe2284998640e0c505f316fb7052", + "docs/measurements/h264-rounds/mb-layout-2/gating/gm.4k.log": "2901ee243fc71f1103aaadf6eb580d40b8cf42e0dc7396bc071dbab7ceaf630b", + "docs/measurements/h264-rounds/mb-layout-2/gating/gm.720p.json": "c42e5344fb381053530ea924120dfb4e541ee29a2ecec5cfe7c2bbbee5cd062d", + "docs/measurements/h264-rounds/mb-layout-2/gating/gm.720p.json.void1": "9919bc5b1d0461cc81de8253a1b3d78d5f8dc47a75464ce4132fbfe5d82362cf", + "docs/measurements/h264-rounds/mb-layout-2/gating/gm.720p.log": "7bef3d38a0804d6656494b2476b93f8e6c52232431db901783bb9f5a59c16ac8", + "docs/measurements/h264-rounds/mb-layout-2/gating/gm.720p.log.void1": "4ab1afa7e6fe8889dbf788ec1b373ee6e713385c3dcddb28e79577b542f89f76", + "docs/measurements/h264-rounds/mb-layout-2/gating/gm.sd.json": "3adcc6a53388aeda283ad58e8c2971f7c2b495e0543a0595fb0f63ac107f6234", + "docs/measurements/h264-rounds/mb-layout-2/gating/gm.sd.log": "95a8e9a9842f7ac2538d936b36abef4ee545359ed8306722f98b364b1ba45971", + "docs/measurements/h264-rounds/mb-layout-2/gating/h.1080p.json": "d14a5eb27505cd2cdf5e9136a52e336391a434450b9be8ead8df733b81ce39bb", + "docs/measurements/h264-rounds/mb-layout-2/gating/h.1080p.log": "a84a6c2d62c3636eada577c5b9d84119556e61d5b5a54566d9d7c3e083222123", + "docs/measurements/h264-rounds/mb-layout-2/gating/h.4k.json": "7b5b2549a1354574de34dba36536d2017f027c1689bc79ee973f795ac92484d8", + "docs/measurements/h264-rounds/mb-layout-2/gating/h.4k.log": "94baf85464a2c0cdcdb689f134bdc14f9b3be3f6253b7db4a27a3cb2009766f5", + "docs/measurements/h264-rounds/mb-layout-2/gating/h.720p.json": "686de6e68de489cc4d340754c7825843583d81d5c4c71726c55551de79b0a1f1", + "docs/measurements/h264-rounds/mb-layout-2/gating/h.720p.log": "b2849e7e735374f5f933cc164ca693ff9226c8b26ce9cb04d5342517e10ab67a", + "docs/measurements/h264-rounds/mb-layout-2/gating/h.sd.json": "f6a33ba13e48d35a685a95d70fe5b1646ae1a24a79df5d2b08293b4a68334487", + "docs/measurements/h264-rounds/mb-layout-2/gating/h.sd.log": "af8085fbff094867b61c7689ddcd123826649bba6c5e5723afc5bf962aee2c7a", + "docs/measurements/h264-rounds/mb-layout-2/gating/hostgate.log": "63aa972670442da1e7c6980ff40bb04d07e1e225f9a991dd53b8658c7e8a50a8", + "docs/measurements/h264-rounds/mb-layout-2/gating/identity.txt": "563c3767066b96e067a866c60fd69533cc94d4040545a5cda2dd31775bae4d86", + "docs/measurements/h264-rounds/mb-layout-2/gating/progress.txt": "3418e2f0b6df2e740c3c5b0dcbf21b2a887c42b2253c894992232ffbbde1356c", + "docs/measurements/h264-rounds/mb-layout-2/gating/provenance.txt": "dec6136c1040fd47c49af41d07c5ae2e0888d9b99d0517d80ee79b95f55f3a34", + "docs/measurements/h264-rounds/mb-layout-2/gating/run-ab-helper.sh": "50288040c86b327c691f1b4f9497ebf50a089b44b0ff180d680a098506ef3c2b", + "docs/measurements/h264-rounds/mb-layout-2/gating/summary.json": "1dd006fdfb1056b8ff14b7a25f6d3a1ff791c55e55048a548911871ecc7b2886", + "docs/measurements/h264-rounds/mb-layout-2/gating/t8.1080p.json": "0e93ce913771cfd1df2f855263cd93e5e7b4d3dfdbccc29086b1f847194f84a9", + "docs/measurements/h264-rounds/mb-layout-2/gating/t8.1080p.log": "16feb390644f37374ed8b531a7e605c365e115ca83c6d9d10c83fb6da6ac90d7", + "docs/measurements/h264-rounds/mb-layout-2/gating/t8.4k.json": "fdbcaa168315cbdea30766aaa027347c8a89514e980059ca564e21b6dec47653", + "docs/measurements/h264-rounds/mb-layout-2/gating/t8.4k.log": "65dc4ff93f5ce76f14e3a38662c3c4f184f8c8978dbfd45b088e0fed04237416", + "docs/measurements/h264-rounds/mb-layout-2/gating/t8.720p.json": "45dbf84b03b412da06be91c9328c834de3f6ade5d7a01be55187f3e826089f5d", + "docs/measurements/h264-rounds/mb-layout-2/gating/t8.720p.log": "7d01dc31212bc6f80a248a75e9f27e67dfa0e3ad9ce9f3fa0a051a7ddaeb2d81", + "docs/measurements/h264-rounds/mb-layout-2/gating/t8.sd.json": "0a9b43813737f4c1313b785e4a05f621dfeff60423332e37f5c1e46a875624e6", + "docs/measurements/h264-rounds/mb-layout-2/gating/t8.sd.log": "af6ba4b517edd52f9f926a13ef84b52d5f741352bd85ff498fbd1a54bc7307f8", + "docs/measurements/h264-rounds/mb-layout-2/local-ab.jsonl": "55d001f1f9f1552ceae7c756cbee7b44dbfc08a51a52dc9eb185f2bd88c7234f", + "docs/measurements/h264-rounds/mb-layout-2/local-ab.txt": "18afec43084fb7c540e6e0dd0a6168c4cf438e44ee0db5ec184222028fc6d55d", + "docs/measurements/h264-rounds/mb-layout-2/run-ab-helper.sh": "50288040c86b327c691f1b4f9497ebf50a089b44b0ff180d680a098506ef3c2b", + "docs/measurements/h264-rounds/mb-layout-probe/README.md": "294ce82679df6261f6293d5079d5c24a6370c1a2d3095c51a0c18a474b506cec", + "docs/measurements/h264-rounds/mb-layout-probe/bound.jsonl": "5f6ad301905a4781d5f84bf7634a31e8fbaa72564741370d0ec21fdaea7a9e69", + "docs/measurements/h264-rounds/mb-layout-probe/bound.txt": "ac6608fbf85e1f6efca3be966ac908f98e37031b5c779e976bc53650487f3e6f", + "docs/measurements/h264-rounds/mb-layout-probe/cg.sh": "dcbdeedef42a56569e155715d461b3393a03025671950988d30c506c0239cdc4", + "docs/measurements/h264-rounds/mb-layout-probe/mbs.py": "eb0a10b06ad621caa1686aa249da82d36d12cbe3505ffc429fec3be739045ce1", + "docs/measurements/h264-rounds/mb-layout-probe/nmb.py": "c1d28c938b4c64ce7d53db0470ac99649220214f55362e2a9dd09a80d02d24a5", + "docs/measurements/h264-rounds/mb-layout-probe/nmb.txt": "c667c9d1a2f5a984017c86c1dc05a2e694bc8e2e7ad587c4b33b3cbfc6ec6a56", + "docs/measurements/h264-rounds/mb-layout-probe/perf.sh": "fc1861500058ac76e33d0a3345581d33497109d2fd1cd92f3ac443a54f842e84", + "docs/measurements/h264-rounds/mb-layout-probe/plan.txt": "17bc5513ddc7cca9da51d44f2116a8fb9ed76aa5dc9c23cb0f630e3a4632b9d5", + "docs/measurements/h264-rounds/mb-layout-probe/table.py": "5e401f09d0945bde2ee20249557e7ce75a3262753577bebe1fe512ee2d77b626", + "docs/measurements/h264-rounds/mb-layout/README.md": "4e31c10deb757c65d3aec0d92cfde78c0cb5bd525a7b08d872a3610c570e8a21", + "docs/measurements/h264-rounds/mb-layout/local-ab.jsonl": "c686f1ca00f096296fa92e7f13a26920946f774e3f9f4c7851303532fda3c5cd", + "docs/measurements/h264-rounds/mb-layout/local-ab.txt": "ddb3bc5ff5ff5f70ae226e6776d4edaa52c89b08613144e6c71a5ea18e2f5a8d", + "docs/measurements/h264-rounds/mb-stalls/README.md": "48ffe19310b183e074c9a3fb61b12ef130f7bf92ac8b0760d73c5b931a7bb1f3", + "docs/measurements/h264-rounds/mb-stalls/ab-layout.txt": "8f4c5776cbb4656173e00468a5689cd4498cf0e7523d3ea01323743a7d33948b", + "docs/measurements/h264-rounds/mb-stalls/ab3.py": "4825e622c660bbb3c3f78ef04cc828935cb816ca973a3e952a26c6aa549ccc60", + "docs/measurements/h264-rounds/mb-stalls/abcls.py": "c37aa727c3bef34b695340c15fa69634ba956674323108ce942dcbc22e9b1b79", + "docs/measurements/h264-rounds/mb-stalls/cachegrind-main.txt": "859bf9eb04f1868fa7ef64365f46d3599efe96240d7e2349fcb345cc7bf024a7", + "docs/measurements/h264-rounds/mb-stalls/cachegrind-r24.txt": "60394fe5ac36a9db5a8eaa8b5c952d67dd4c64d52e7aba6f14e589d8860b7125", + "docs/measurements/h264-rounds/mb-stalls/cgcmp.py": "86c5737b07a17d8857dc3c06e914a1c513e8426132bac3b510763dec92a9cd92", + "docs/measurements/h264-rounds/mb-stalls/cgcmp_lib.py": "fdfdc694a5c692ed8ec55f09664ed02376c89f67ddf16afd1bc10e67dbb84b18", + "docs/measurements/h264-rounds/mb-stalls/cgs.sh": "a0464807a6be20b76e4ee66462124ae9596a2ab71496370d117ad0b50c1207b7", + "docs/measurements/h264-rounds/mb-stalls/cgtop.py": "4dc9aaad914628d640aca399d2b944920eca5a93ccd7b3ced7c4c05ee15a95c2", + "docs/measurements/h264-rounds/mb-stalls/ipc.py": "c10cf104c92a8c6bea8dd6a2401137692e32a3a1ceeb8d3c8691f64ffdd44112", + "docs/measurements/h264-rounds/mb-stalls/mb-items.txt": "91448e631306c58dad2fc6edd4691a3b4a1c8b4b74e52d9a02c2c23f922eeecd", + "docs/measurements/h264-rounds/mb-stalls/mbrank.py": "f4caa1272f1f0a22e4f166f0be69fdc4c9b9b97840bf6208c2fa168f6ec24ff5", + "docs/measurements/h264-rounds/mb-stalls/perfab.sh": "75be8f9699f9e3d4bad39b97999cefdfd41f4261b154b7dd4417eb78a36e0fda", + "docs/measurements/h264-rounds/mb-stalls/plan.txt": "2a4a6dd581f630f4ea9b85a8a61b93819791a12e60c1adcb7215212c2b6dfb8c", + "docs/measurements/h264-rounds/mb-stalls/time-vs-instructions.txt": "5bb2a7f6445345d4a125c6baa3b30dc2577819a3d3a11f36277e4668ae91ed5a", + "docs/measurements/h264-rounds/mc-ahead/README.md": "a3b96b0c684dd3ee26caabe2fd2d19988fc2f7801217a1df9fa08e7415b8586d", + "docs/measurements/h264-rounds/mc-ahead/analyze.py": "8c4e5fed167606685af44aa53d2f91677a7709af91712eabd39bd525f182c055", + "docs/measurements/h264-rounds/mc-ahead/conformance.txt": "fe5f55bfca75505518b9fd3a2cd3347a1f692056cf21de3098e3e482041f927a", + "docs/measurements/h264-rounds/mc-ahead/gating/README.md": "72c64c0d7a9523396d9fdc2338b998b0fe8bc4557053502965fda9d06c22228e", + "docs/measurements/h264-rounds/mc-ahead/gating/analysis.txt": "ca56811a399f6dacd665065b942b84c32428a19f887d4e2b681c6899f9501b8d", + "docs/measurements/h264-rounds/mc-ahead/gating/analyze.py": "8c4e5fed167606685af44aa53d2f91677a7709af91712eabd39bd525f182c055", + "docs/measurements/h264-rounds/mc-ahead/gating/binaries.sha256": "93e470a09cb010c71a66b3143d68742ddd4e6feb453309d0198e2ad5b2fa76d9", + "docs/measurements/h264-rounds/mc-ahead/gating/config.json": "27a710b3c373b6211db1cd0875b402208ced81271472b52d1af87174a785b901", + "docs/measurements/h264-rounds/mc-ahead/gating/events.json": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "docs/measurements/h264-rounds/mc-ahead/gating/g.1080p.json": "12a29c3d166d4c21564456da9600f35bc59fffc4a859d60427157b32caea92a2", + "docs/measurements/h264-rounds/mc-ahead/gating/g.1080p.log": "26cc82008972b78dcd9e6141637f8776238ecd2a0456a0732222bda72f07542b", + "docs/measurements/h264-rounds/mc-ahead/gating/g.4k.json": "e3abb70b1fda45b9641463fe9dbfce20a8399815ff905a968d7b5007a742bfea", + "docs/measurements/h264-rounds/mc-ahead/gating/g.4k.log": "6ccaea9c8dff0c6254e5266880349b3d3f90b2182871b08488da968f2b31f170", + "docs/measurements/h264-rounds/mc-ahead/gating/g.720p.json": "960fe856cec13db16c615dd692e55118866138e897c88f52784723fb3abe9452", + "docs/measurements/h264-rounds/mc-ahead/gating/g.720p.log": "40ceabd1d041138c0186fb7c6ddbfa6500475c7625d45e4f3cd268b0b81e6f7a", + "docs/measurements/h264-rounds/mc-ahead/gating/g.sd.json": "a68a795a8517b04840dd7d9deb3122d0b0fb0f27aaf3d77a6b6fcb56d53f74af", + "docs/measurements/h264-rounds/mc-ahead/gating/g.sd.log": "bdfde2f5100cf4735fb963f469b69d3c170381bf1252a75d5595f9b7f276ce14", + "docs/measurements/h264-rounds/mc-ahead/gating/g.summary.json": "1ba11dcee18938da4348d26d1823b280f02c7107e2e2de9a01b4a23f5b1ce689", + "docs/measurements/h264-rounds/mc-ahead/gating/identity.txt": "3980bdde6c8a232105cf508e121242d10b5582b01ed3f60e53dc880551d9a14b", + "docs/measurements/h264-rounds/mc-ahead/gating/log.txt": "54c1e68d85078bcd4539fe413d0528d9f462d5396a23d820f91fe4745de8fe9a", + "docs/measurements/h264-rounds/mc-ahead/gating/state.json": "33ab589b7615f5565c569b58fd1708ce8a3be51db8699fca8af8db094bae731e", + "docs/measurements/h264-rounds/mc-ahead/gating/t8.1080p.json": "ab61070a31dfe363b68996db559add192ac68b565ca7e4d976c5b8efd899bf03", + "docs/measurements/h264-rounds/mc-ahead/gating/t8.1080p.log": "627c5c50a7b0f40f123c50e769f7f0a9724c24b4ea1550921982e5671f0fc9e8", + "docs/measurements/h264-rounds/mc-ahead/gating/t8.4k.json": "c74bd6339a885371915fed3b660381066cb6d106251e4711ee4eb5e7c5fbb791", + "docs/measurements/h264-rounds/mc-ahead/gating/t8.4k.log": "919bf244fd4db2378849ea1d28b458a440cafbba5484df5cea152dd21d1b6f8f", + "docs/measurements/h264-rounds/mc-ahead/gating/t8.720p.json": "4f8da54077d04b2cf6311d43016eb69321cf381c8f6d0e18ca9368e237d728bd", + "docs/measurements/h264-rounds/mc-ahead/gating/t8.720p.log": "416c960d022531e8236148d42b38b9e9d379e1bf085838bc99c09151797c772f", + "docs/measurements/h264-rounds/mc-ahead/gating/t8.sd.json": "a765e8756ce020d0dfebb8bc0c926f169e8fb5e9cf69d63e6d2428fb3d5f390e", + "docs/measurements/h264-rounds/mc-ahead/gating/t8.sd.log": "510edcd9da47d158301fec7af2dd5a4f45c3b6e9bcd5a79b312305be212d9d9a", + "docs/measurements/h264-rounds/mc-ahead/local/all1.txt": "5cad220c9db75aa89cc3926cdf5dcf30cf783205d71900410c4258effeb70079", + "docs/measurements/h264-rounds/mc-ahead/local/c8.txt": "61f5a6bd63daebd68969be87575de0f11cb9a438503368a1e7ecbf73bcd81d86", + "docs/measurements/h264-rounds/mc-ahead/local/cachegrind-3b1b.txt": "a895dadc3cdd84c405e802387f1f8726a2b3911001fb5b7b621de2e3d7a4d998", + "docs/measurements/h264-rounds/mc-ahead/local/identity-after.txt": "70781389806b68fca0c2e8162175475f52f57b671b9a747f34c8f82f26a8ecac", + "docs/measurements/h264-rounds/mc-ahead/local/identity-rebased.txt": "44671d51044004b2f61628c1188136a0ebbd201938626f70f3036e6ac8745dde", + "docs/measurements/h264-rounds/mc-ahead/local/instructions-sd.txt": "2a2fb96bef45b256628c23faba0f1de20532150f868fe9bff99e3441309a1d18", + "docs/measurements/h264-rounds/mc-ahead/local/local-timing.txt": "f199536b9730f6071beb16c38262f8ac6ba1b1d5db46d7c450989b5ef1f5bea3", + "docs/measurements/h264-rounds/mc-ahead/local/profile-4k.txt": "13b9bcea4198a0f2901f5eb7a0cdfd59a0ceb146230e32c707603a8a7f5f5186", + "docs/measurements/h264-rounds/mc-ahead/local/thp.txt": "e5751caba1d7e082147141f97300ea11390e630ffb113717c21e3bd1698fb0eb", + "docs/measurements/h264-rounds/mc-ahead/local/variants.txt": "1a556431e1f83b09da8759079cd8520aa8e53e898731cae59c468f215d17c679", + "docs/measurements/h264-rounds/mc-weighted/README.md": "7e541abffe9d2b2970fafe86a9253dfdcf4bae86c755cdc12154f8ff638698c5", + "docs/measurements/h264-rounds/mc-weighted/bench.txt": "0b1ab9c061fc88a267a479dc8668fbdc274fd7f41944675885221c61e3f3e539", + "docs/measurements/h264-rounds/mc-weighted/tools/miri/Cargo.toml": "d50cdee65f045f50648887ad4187bcea8b98c5ddb39ed22381b63de87d370f57", + "docs/measurements/h264-rounds/mc-weighted/tools/miri/main.rs": "ff59284e631a7f035f43e46fe9cf78eb56f00229d20d3a5fe7d6f6b9941e625f", + "docs/measurements/h264-rounds/miss-8t/README.md": "b486209bac0bd61de78ad7c33210af30936150aa9a9b5d7e3b5f02d7961f8208", + "docs/measurements/h264-rounds/miss-8t/build.sh": "f5fe267fb87b2e92d7e73c3104434e9e09a94a463bc3cf6518fbc50bd3eab364", + "docs/measurements/h264-rounds/miss-8t/job.sh": "5c050b9f88a45e68a12739352d7be5f9c675ecc43b6c3446f611f4d0e63e88ec", + "docs/measurements/h264-rounds/miss-8t/miss.py": "9d2bdadc5d7a401f46e4c51e69b866cd448911a97c471ea55787c923de6bb7e1", + "docs/measurements/h264-rounds/miss-8t/rec_miss.py": "1a25d246e0f15806868f02f182cab72b55310aba19041670ffd66fd42efeff4c", + "docs/measurements/h264-rounds/miss-8t/run-gcp.sh": "298e29101eee3a39de99d6725b864250c807c2013db15ee39347593c065dae26", + "docs/measurements/h264-rounds/miss-8t/run/build-order.txt": "aa6cea0244178093fe58d498ced1a78ccc1c707a58e3b1bd73f05a18d4a645b1", + "docs/measurements/h264-rounds/miss-8t/run/events.json": "4a09eaa578bcc03cb6b8f806cefeb33d4624e107e2dcb99d34dcda4b898ed2d2", + "docs/measurements/h264-rounds/miss-8t/run/ffattr-output.txt": "4a3ea8cc897c3e4b14084dd2a826b872d1eda040442ea14dbc5a9f5f9be31935", + "docs/measurements/h264-rounds/miss-8t/run/ffattr-sections.txt": "87cdfbe7602234128481ab30cd89c2cca0cfeeeb240c20d645f60532e6a27e81", + "docs/measurements/h264-rounds/miss-8t/run/host.txt": "ba2274db99cdd5a29d7835f9a136ccf59e75312bf4267eba836593c4249047af", + "docs/measurements/h264-rounds/miss-8t/run/miss.json": "0f73e2b0baa21a959ecf9eeab5f1f5a1df0e2e109f20a00e2af43a6217d98e46", + "docs/measurements/h264-rounds/miss-8t/run/tables.txt": "5ba6bcdee019b760265b882e0b89ff62c86534a5734c1129147f51da571ea20f", + "docs/measurements/h264-rounds/motion-12b-r2/README.md": "c4ddeb2af375b3b3d36f2567a21793d02e42fff95eb79414fae5f6f21f40bde6", + "docs/measurements/h264-rounds/motion-12b-r2/analyze.py": "2fc951e2da15fa1d53e77633a6d9815e573f4af83bfe4dbd7c1c4cc4545bd4ba", + "docs/measurements/h264-rounds/motion-12b-r2/conformance.txt": "6f9c520664d63b973246b339bc078fcc77c81a855655149d2a557bce0724a940", + "docs/measurements/h264-rounds/motion-12b-r2/gating/README.md": "2bf0fda3ad7d1daaccc540f4abfb91ae8d9cd08df3a3604efcb321fef4130542", + "docs/measurements/h264-rounds/motion-12b-r2/gating/analysis.txt": "8c864baf699ceaff3707ecefc8b88205c93ccee32161279d3618c46a28422036", + "docs/measurements/h264-rounds/motion-12b-r2/gating/binaries.sha256": "3ef4bb9aa055ee91838c848b41060e306b3c353e0ad2e04dcb4bccf1b7541680", + "docs/measurements/h264-rounds/motion-12b-r2/gating/config.json": "7755a4ca7b5c4e930edef6f32e46925edd34c76305a99e08cfeac4004d9558c4", + "docs/measurements/h264-rounds/motion-12b-r2/gating/events.json": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "docs/measurements/h264-rounds/motion-12b-r2/gating/g.1080p.json": "259ee522414dd2e711477ebc79cd172bbc23b050d0b18550c2ab96a4c38f7c68", + "docs/measurements/h264-rounds/motion-12b-r2/gating/g.1080p.log": "5e856016d82ae855e002c817702573109320d7511c72c1af099c73e428e9afc9", + "docs/measurements/h264-rounds/motion-12b-r2/gating/g.4k.json": "6e164fe6fc62629ec607824b62454004683e9c288e864f27afd6630b16bd4b48", + "docs/measurements/h264-rounds/motion-12b-r2/gating/g.4k.log": "1af66cf47ddc2dcff2e7ffc015fb8ab6d17ba3ba5864168d1fd3a80c216d3ecb", + "docs/measurements/h264-rounds/motion-12b-r2/gating/g.720p.json": "0bf6649d476cc6430ec4be555818a0484b957a53adbfe51fdfdd56886eb1a384", + "docs/measurements/h264-rounds/motion-12b-r2/gating/g.720p.log": "4c2ecefc4908463bb3188338000ed3a3271e14de99be84c399c36804c6df87b1", + "docs/measurements/h264-rounds/motion-12b-r2/gating/g.sd.json": "b3d908d52972a4144fada6a3903dd1140b53949a994276af4801253d57da91ee", + "docs/measurements/h264-rounds/motion-12b-r2/gating/g.sd.log": "ef31c7c4eccb9424a7c98b8ea4450741ee0618c2c2cb847a03ce09b1cce666ea", + "docs/measurements/h264-rounds/motion-12b-r2/gating/g.summary.json": "7c04888a658d69bd602fc068d83d8f6b28fdf20ae167d4fef2104ec24f00aec6", + "docs/measurements/h264-rounds/motion-12b-r2/gating/gm.1080p.json": "0be754cb2d39f44f088e0bf427f0747a0aacc09bc9efbbf1a529c4733bb9a497", + "docs/measurements/h264-rounds/motion-12b-r2/gating/gm.1080p.log": "1d654de37328c4715c177843acf92541033289cd4c8bb0bfdfe0c96a6d741967", + "docs/measurements/h264-rounds/motion-12b-r2/gating/gm.4k.json": "8fdeaed8f1da10afeec35a875e598cecc351c0cf0016e81cb4dbc52210edd04f", + "docs/measurements/h264-rounds/motion-12b-r2/gating/gm.4k.log": "3041500fbf071696e96b6ed5193870af938ce0e995bb0d1cd09ef25e9cd1a097", + "docs/measurements/h264-rounds/motion-12b-r2/gating/gm.720p.json": "7c550a108f5860a7d274dc1fa5949ad981fa9a609a7425c7a77fa5b2f6bf09dc", + "docs/measurements/h264-rounds/motion-12b-r2/gating/gm.720p.log": "e9296a9d389601c631c802864cf8080ae195a67f78a727271d577f00978c4322", + "docs/measurements/h264-rounds/motion-12b-r2/gating/gm.sd.json": "6fa783b90c188612b249c54f5f09ce9dea8cb093f02df360cf78d6d7726cdb98", + "docs/measurements/h264-rounds/motion-12b-r2/gating/gm.sd.log": "ae5e7dae91ca209dc08a471636ba0d7f683a0e406d1ea1baf9ddc69dcb5921e0", + "docs/measurements/h264-rounds/motion-12b-r2/gating/identity.txt": "3980bdde6c8a232105cf508e121242d10b5582b01ed3f60e53dc880551d9a14b", + "docs/measurements/h264-rounds/motion-12b-r2/gating/log.txt": "cea22269abebb0d21289da4f33c1e9641527f230e8267ca5d7d91fb6b239549d", + "docs/measurements/h264-rounds/motion-12b-r2/gating/state.json": "dd047d20b9c68c07299eae8b63c0b10f20a179362532cf1ae98b1654207c7ef7", + "docs/measurements/h264-rounds/motion-12b-r2/gating/t8.1080p.json": "e152456c76005d1d352d975fe12ec9b1c572c89d235448af6eaacf119084ad69", + "docs/measurements/h264-rounds/motion-12b-r2/gating/t8.1080p.log": "4de08a68e1b369dae58fda6d9f65ddc11b45a30a71f02c1058b6ac6e3c501a33", + "docs/measurements/h264-rounds/motion-12b-r2/gating/t8.4k.json": "0e4d7c5fb1ad2e7dacacdc23763c35814bb6951321bd32d8dad335fb1ad1ab11", + "docs/measurements/h264-rounds/motion-12b-r2/gating/t8.4k.log": "510040c1665245b755e63881bbea87c5a3b3ce77289ec00f3f6a6973c8a19640", + "docs/measurements/h264-rounds/motion-12b-r2/gating/t8.720p.json": "0b0c1a2b5eb75007c52d17bc27221456b0a78f79a61375f9272440a966ec4859", + "docs/measurements/h264-rounds/motion-12b-r2/gating/t8.720p.log": "8ab2d352cc1c50a48a408e7d94b6391c75c38daf1738d0eee3b6547fd39d54d3", + "docs/measurements/h264-rounds/motion-12b-r2/gating/t8.sd.json": "dd4fbfe21c750ca97ebae887974ae8eacd493fb25cf14a97dc14795309b0215d", + "docs/measurements/h264-rounds/motion-12b-r2/gating/t8.sd.log": "8e3d155da13fda48b7cead9d346324179c44665c880a5c4cf823d762cd874092", + "docs/measurements/h264-rounds/motion-12b-r2/identity-rebased.txt": "da7a342bc0fa54590ffadc6492816080ca454babe8342450ec81e795bd01bb3c", + "docs/measurements/h264-rounds/motion-12b-r2/identity.txt": "5c90298d3adcda481c87d4975c6ecc898659fb76a8d5c4ce44b2e5ff8b39f153", + "docs/measurements/h264-rounds/motion-12b-r2/local/instructions.txt": "fe217dc51000bea1a3eada9a239fee5a3bcef4ff28e8abaac871d89d4bb6d364", + "docs/measurements/h264-rounds/motion-12b-r2/local/local-timing.txt": "cc3d2195cd2cf19b9970b4b0d358f9fc57e8d9660286295de172cfcba0b48f54", + "docs/measurements/h264-rounds/motion-12b-r2/local/profile-mb-items.txt": "c1443ab9a83e44fce32b005c2d7a648e1bdf42c83e96d058e2a0fff316df1d76", + "docs/measurements/h264-rounds/motion-12b-r2/local/profile-stages.txt": "ebdc5ebc5ecd53f916f5f21519dbc2892a14336cff216131d02d9bcc00820256", + "docs/measurements/h264-rounds/motion-12b/README.md": "6f9f53c8f066b4a45139ed0b554b13868b09cdb3a3d3f31f064256af881ebe43", + "docs/measurements/h264-rounds/motion-12b/analyze.py": "9c892872a66cce82e347ce4229317587f728c50fe0f4272a3c9330da75d8fe9a", + "docs/measurements/h264-rounds/motion-12b/b-streams.txt": "73550b377a262bdb7729c299aeffcfbc7b5aa3db25ab38a3609b5578aac106ae", + "docs/measurements/h264-rounds/motion-12b/gating/analysis-g.txt": "792397c4ec2688af10e79ed54e5ee4e06c9211fa5d6bca9477d3b4ec603978a2", + "docs/measurements/h264-rounds/motion-12b/gating/analysis-gm.txt": "4ed4df3a7ecbf15e51af472cd8d5e72aed392fbdfc4f293ce074b60a219300df", + "docs/measurements/h264-rounds/motion-12b/gating/analyze.py": "9c892872a66cce82e347ce4229317587f728c50fe0f4272a3c9330da75d8fe9a", + "docs/measurements/h264-rounds/motion-12b/gating/b-streams.txt": "73550b377a262bdb7729c299aeffcfbc7b5aa3db25ab38a3609b5578aac106ae", + "docs/measurements/h264-rounds/motion-12b/gating/g.1080p.json": "136db7299c436761f5fd12ea418f62a3d535667ec1694ec1bf532385004689ed", + "docs/measurements/h264-rounds/motion-12b/gating/g.1080p.log": "ce201758cd7c0c211c49b6463a8be6d18259abd6fbe97b5e8079af0c229687ca", + "docs/measurements/h264-rounds/motion-12b/gating/g.4k.json": "a46910d47c3ed7a53d440251a5aadd4b230f07366152064be57319d18161a5a3", + "docs/measurements/h264-rounds/motion-12b/gating/g.4k.log": "fb3feadb8344582350923ce28da8ebed95a5bdc9af0cf0dc17fc1f06a9a19265", + "docs/measurements/h264-rounds/motion-12b/gating/g.720p.json": "589fc92a801f70543f4be72d501bbd6b276cfcf58eb045b2666db3740594a7f0", + "docs/measurements/h264-rounds/motion-12b/gating/g.720p.log": "428a088b3da0c7c5c9ca9b712ae7e653042812a8246392f87993b14eefbcdbc8", + "docs/measurements/h264-rounds/motion-12b/gating/g.sd.json": "364f29be683e49fae643003e34e5de48b009dd9c82d118c780042eb9823674bc", + "docs/measurements/h264-rounds/motion-12b/gating/g.sd.log": "e760a25edaae09ce892108917f650b944253e334d891c55a7469ed5085231345", + "docs/measurements/h264-rounds/motion-12b/gating/g.summary.json": "3d5759ac1f13d5a7f7e15ad706d9229d3e7846f47d07aada4da01a9b9bf583ce", + "docs/measurements/h264-rounds/motion-12b/gating/gm.1080p.json": "10d9e08141c41bcf7b8a00070c5626d3f10c790cb6f37e4a0c97153432795db9", + "docs/measurements/h264-rounds/motion-12b/gating/gm.1080p.log": "1652534ac4580d1b359e540ab1c8f909ec9d5d829d439ba8e59632c932cc03d5", + "docs/measurements/h264-rounds/motion-12b/gating/gm.4k.json": "18bc1e541a7767bef4431bb4579bf6dba16cfff5886222b03a6a1d6a61494ec5", + "docs/measurements/h264-rounds/motion-12b/gating/gm.4k.log": "69d191c77f0a583454c2017c599aec9987cc515705ce961320ca95a300a7c1dc", + "docs/measurements/h264-rounds/motion-12b/gating/gm.720p.json": "b913c4dd2506c7c601a1b996cee3df720a946353d464cb79d834e350c71d7290", + "docs/measurements/h264-rounds/motion-12b/gating/gm.720p.log": "4afc62768f44976ce129816b3edd7826c8d21e6d12bd98d40ee6e8e851eea017", + "docs/measurements/h264-rounds/motion-12b/gating/gm.sd.json": "677f72ae455518c3a9ed21b48121956bc72a9484a7fcfdd968781d9ef86a3539", + "docs/measurements/h264-rounds/motion-12b/gating/gm.sd.log": "015c0a1648fa09493880b4c79d408a9ae5fa0e95d0e07d18b58baf10874cb33b", + "docs/measurements/h264-rounds/motion-12b/gating/gm.summary.json": "e7d7d688b7abc63ce3cffc003de75770207628833cbf2689a916f39718e4afb3", + "docs/measurements/h264-rounds/motion-12b/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/motion-12b/gating/progress.txt": "14cd22ebc148c7f88352fb3e5a9a5e01d70a9fdab6c93a6831f44236c4c86876", + "docs/measurements/h264-rounds/motion-12b/gating/provenance.txt": "e0b6767da92fe81b54327d6e3bf28bb0bf812313ba5c6d3caba75108264b391f", + "docs/measurements/h264-rounds/motion-12b/gating/run-ab-helper.sh": "e8faaf919b4e03ac2f189968653aa3848b1816641a6654636a3010e9954d9dfa", + "docs/measurements/h264-rounds/motion-12b/local/def.1080p.json": "cb11c4200695f1ae9d2e498314cb4fc731236236ea41bcb99f03098523c1203b", + "docs/measurements/h264-rounds/motion-12b/local/def.4k.json": "0eeb37ee32c687d0cba61397721b19c6b26d294de5b9f5f6369a80fa1fe616d8", + "docs/measurements/h264-rounds/motion-12b/local/def.720p.json": "00e64b89ef6b486188390e608592e70da409063d553f5d7123637064ff2673be", + "docs/measurements/h264-rounds/motion-12b/local/def.sd.json": "8afa7bace686b9de2ca25f448219579280faa824e2d07850b71d5910bb5cf6d1", + "docs/measurements/h264-rounds/motion-12b/local/local-timing.txt": "4739716350ff79edbe1b79747203854dd1240a657df7558224e133e8d6c80792", + "docs/measurements/h264-rounds/motion-12b/local/mmap.1080p.json": "5d98707fd5067c937d09fae3f4a87ca8a4b342f47195ffbac5df7d19067a7506", + "docs/measurements/h264-rounds/motion-12b/local/mmap.4k.json": "8f317036dcc5132b18b17797562b957744a973058a5ddad70663b81ed3c807c7", + "docs/measurements/h264-rounds/motion-12b/local/mmap.720p.json": "e32ab84ad744f9c3023baddf65964265681a58d61f5a3dc5ff06b2d8334e05e1", + "docs/measurements/h264-rounds/motion-12b/local/mmap.sd.json": "2c70731d44449a22accda1c4fb27107ffd98d07695116497cbedeff9961b2007", + "docs/measurements/h264-rounds/motion-12b/local/r2.def.1080p.json": "d1fa5e0ba37094e31cb2b352d93604da3dfbc70c4696ff09799a318b36084a7f", + "docs/measurements/h264-rounds/motion-12b/local/r2.def.4k.json": "a4144b8364c8c31979e422c03e070585ec9cc39c45e0b85253d5cdb90f6b93cc", + "docs/measurements/h264-rounds/motion-12b/local/r2.mmap.1080p.json": "b1c6668694112a6bae3d5d32b1dac70a4fba9e85a4f0ce53701c5bf15bdef311", + "docs/measurements/h264-rounds/motion-12b/local/r2.mmap.4k.json": "7fa21145d27df29d1706f924dd0f4c90a07b926f7df88cd30d6b9768fdfaf3ac", + "docs/measurements/h264-rounds/motion-12b/local/r3.def.4k.json": "e61e64512e4851c4edef560f50315b293e201c11f1df159fcd8cd8050a94514f", + "docs/measurements/h264-rounds/motion-12b/local/r3.mmap.4k.json": "cff8a676a60ee8354ade460c179f939c2e906df501c1d9d7cbfdbc15efabc75b", + "docs/measurements/h264-rounds/motion-12b/local/r4.def.4k.json": "666a9521d5b20a6d692ecadb4f72f7dbb8329678b871cc6da44e67ccb86650a7", + "docs/measurements/h264-rounds/motion-12b/local/r4.mmap.4k.json": "5fb43d2b2c1fbd9fa2822083209318d7ec52c67340c2ca270fe273594bca7750", + "docs/measurements/h264-rounds/motion-12b/local/ratio.py": "ad671fa935d96eb3903348b3235d7bf95e8459ddcfaf9dda3f58ff302dbd9c3b", + "docs/measurements/h264-rounds/motion-12b/local/run.sh": "1af74287559fb2105aef6b647878409e5498334ec9fb11fcb542633d5ed31e9f", + "docs/measurements/h264-rounds/motion-12b/local/run2.sh": "2cbc7c8eb880871942314cef95c2b246000e6b2130ab4fd0043da16b1244ae39", + "docs/measurements/h264-rounds/motion-12b/local/run3.sh": "40fe7e305a1a5d3b17a80c9bc9e435b2fdc9b796b6be8e8ad3db27077c5ed141", + "docs/measurements/h264-rounds/motion-12b/local/run4.sh": "0105b10ad714067c4e188dfde2f6df94958096c372b95599ecededfd2793a727", + "docs/measurements/h264-rounds/motion-12b/local/simulated.txt": "f80280e4a87b1bfe7ce31f860deb34a2b5b361cd3226b30138fab43acd5702c1", + "docs/measurements/h264-rounds/motion-12b/profile/attribution.txt": "337d98c693890d844c987a604b20d7076b4bf4fbd2732f995902ae3b5751235c", + "docs/measurements/h264-rounds/motion-12b/profile/tools/attr.py": "4352ed0bfc2768ad8f290fdd8ed46d09aa94a9eb03b22ff853cb230803a0ac82", + "docs/measurements/h264-rounds/motion-12b/profile/tools/callgrind.sh": "2c5ae21eb135ead2532eff0bfe9f2ad1b9efcfdedb556a81fe8547609a168287", + "docs/measurements/h264-rounds/motion-12b/profile/tools/ipline.py": "11d7585c37dcc98364d97bae10a3713bd9eb1c388938cef48a5262a260f5f99c", + "docs/measurements/h264-rounds/motion-12b/profile/tools/lines.py": "e886cfcc661d6aa8a60ada7b9ef039555e887ec680102ea8393c0e1610167cfc", + "docs/measurements/h264-rounds/motion-12b/profile/tools/perf.sh": "a0468ffbbb0a003633152d526fbcefe64ae1c4c91cefe239867de8c5e7231e13", + "docs/measurements/h264-rounds/motion-12b/profile/tools/rep.py": "140b3c232b4cbdaefa9dd5f5c076ba7d84aa58d50fd0c1c1ff26abd01467dfbc", + "docs/measurements/h264-rounds/motion-12b/profile/tools/stages.py": "9eb5af837aecdacfe5ec8e8fe4357fa50ea09dc4263ea6b1a19b178ff97bc114", + "docs/measurements/h264-rounds/motion-12b/profile/tools/time.py": "5f8cc6aa085ca8c1d9f1c3588be3cb5a4f306a72a87b274f10c99530cb7b8533", + "docs/measurements/h264-rounds/motion-12b/ptypes.txt": "8eba3e7005c0a702ff0c2973d1f634c8530d24a7ab1cd7851b5c9f2cbfb2ef41", + "docs/measurements/h264-rounds/motion-clear-ab.json": "4f0be19c01158ebe0cf0edd0092b6dbf62d45c9029794f3fb1c27525cf8ce036", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/README.md": "866dc7f1552a4f4ed92965dee53db10950fd80ac6f37526cfa9074fea0297a47", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/analysis.txt": "8517cc9834b13131f555966f0928d70b59ba0a533d3180db558aba8d13555d2f", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/analyze.py": "2a54325590ed833a9bb9b8816a458ec0a40513c547d2295258771452d0cf15a6", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/host.txt": "453b0473b8acd48f0e96ef8a62009e79491fd2a3abb8ccd15fdcb992239a9b79", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/job.sh": "06ad38fac2cdcb7c99e734a6403d7603d13fc8621da14db2157cfd318ed21b3e", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/progress.txt": "69d75c30167c8cc63f5c6b4e5c023c2e6befd346c8bd2b5c858a2242bffba04c", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/ref.json": "899b24c9f169f278ef025402d6f530125a0e7f989295aa674fb25da95aead885", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/summary.json": "93a353a3bf9ea74a85c769dac63791316f3f0b6fa80a63835bf189f0f7b540c4", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/t8.1080p.json": "ff48a1222fb25dc83681d9282f0175b554f7bb873b1f1f68b48ff889f1619326", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/t8.1080p.log": "6137c5469827faa18c0aabf615ed677d03ec18dec6dd024aceb89786f0ec3fc7", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/t8.4k.json": "86ff308569ec72bfe60791b19fc75c6a4665c10aeb783f96d42dbb43755163b2", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/t8.4k.log": "a4fa7c6ba4b79f7a3a31210bc1b7b1f6d4051507eafa207aa22bfc3bbf57596f", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/t8.720p.json": "1575ffa195a83e0ceec473bbfeb048c4f56103f55dea7610aad8f8d39d237e8c", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/t8.720p.log": "1cc42a8eabc7c72017fd048cbbcb26939a0ee890dd17b62b43c8f86d43e4b053", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/t8.sd.json": "086a28f8ce65dd763daeb86679cb4a6a24095ad3a17cc0ef0edf6af13e190aa0", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/t8.sd.log": "e194bd1db20ada72dec8b2e58e7a12049d6c13a0614dfa66e86eca1b3b8b2c6d", + "docs/measurements/h264-rounds/mvd-packed/gating-gcp/verdict.json": "92cb7dd793aad43bdcc93149934c512f1a4c2ffc761151b0815094e946968307", + "docs/measurements/h264-rounds/mvd-packed/gating/README.md": "9b2b6883f5b8c836dec9a0692d9c7d305e5933f4b27a760ec9b368632a7a1bc7", + "docs/measurements/h264-rounds/mvd-packed/gating/analysis-1t.txt": "57f06e2525bc8113c6e1ac144bd2a3c635ef28d50af2b6460a5056af30d5980f", + "docs/measurements/h264-rounds/mvd-packed/gating/g.1080p.json": "28b7f5d6b3bf619cfd918b66afd16bbc314aa9f3c9c1d0b1b46eeaae203b5aea", + "docs/measurements/h264-rounds/mvd-packed/gating/g.1080p.log": "23fcd382b54368b0197e6a0a4e00ad5d07f0a63c9ad701cb78bbbe5cf267d8b8", + "docs/measurements/h264-rounds/mvd-packed/gating/g.4k.json": "d43c81487791d1d5afbfb60f5fb6bf95896d72cf76f1b0b3e8de69aac22b96b8", + "docs/measurements/h264-rounds/mvd-packed/gating/g.4k.log": "9f742f70f948d2a8e9aba0cb5565892945db883c7d4c697966ddf2bff113a263", + "docs/measurements/h264-rounds/mvd-packed/gating/g.720p.json": "adca6e44bc8e1c6cc7a7020e07f65012ff28940989cdf21d079b56278922ba29", + "docs/measurements/h264-rounds/mvd-packed/gating/g.720p.log": "b9fc9edf053fdf649486b7beccf05279601144fd7062eb916f5c14bd2cf43592", + "docs/measurements/h264-rounds/mvd-packed/gating/g.sd.json": "8b759a4ff3a6e09fbe54c04198c88e1a4b8c1f1cb48686b7fef51f0020da6182", + "docs/measurements/h264-rounds/mvd-packed/gating/g.sd.log": "a8618227af8b7ccc6801fa7e01a84f34f0d095edad545a90ef54c5b42aa9017b", + "docs/measurements/h264-rounds/mvd-packed/gating/h.1080p.json": "9a557eea15fb391ea162046f94ae3a60e27deb29fa57bad315adbbbcfa33dedb", + "docs/measurements/h264-rounds/mvd-packed/gating/h.1080p.log": "bbde3480a0bee0c22b722bb7ee43e8245014617e323fca23533c830f181778eb", + "docs/measurements/h264-rounds/mvd-packed/gating/h.4k.json": "88920d05c73505b006fb85a93beb3d8e03695f0f91780c22a62348cd09ac1054", + "docs/measurements/h264-rounds/mvd-packed/gating/h.4k.log": "8a366a5fa1409138550048338168ffa1843220937488dc1dadbeed502b0104ef", + "docs/measurements/h264-rounds/mvd-packed/gating/h.720p.json": "9f8fc979bebfb211d2decc20033bc1dd834f47c5dad9454257565b8951d88139", + "docs/measurements/h264-rounds/mvd-packed/gating/h.720p.log": "1a972d61ebf6a190e9f8b55300fb6aa48879fcb7f22b315dc6c0e50e65d79c2c", + "docs/measurements/h264-rounds/mvd-packed/gating/h.sd.json": "e73e80c2bda22f6f71ab403a31ba4124462f04c82c7b4dba4b2e3de9c7d5ad53", + "docs/measurements/h264-rounds/mvd-packed/gating/h.sd.log": "eca534d26c1a8b4524961b1c5c647a875d1b819e44b7aad340338448f2c1c15e", + "docs/measurements/h264-rounds/mvd-packed/gating/hostgate.log": "156536d635e79abe01be6ce5d956e7fcb61634651b8984afc0a209e0861eaa74", + "docs/measurements/h264-rounds/mvd-packed/gating/identity.txt": "895eaac4d3308327d074a4daf0d600989a88496500bd716fbc77dcaab2f3063f", + "docs/measurements/h264-rounds/mvd-packed/gating/progress.txt": "eb4d275b78eafa498d2c6072e731875e241753131ffb1bd22606d492279e4e74", + "docs/measurements/h264-rounds/mvd-packed/gating/provenance.txt": "3b880f1d90a7aa5ad827c86d6e51f9e389fded95db9577987c70c20a8e20cf75", + "docs/measurements/h264-rounds/mvd-packed/gating/summary.json": "cc70d00631c1c1ebca487b1fceda2b9f6552596d6d0671439159b4e17095123e", + "docs/measurements/h264-rounds/mvd-packed/merge-identity.txt": "44f48919f7d1b0f2a128dc285edc41b29a15dd182747f46df7db2d5aa52b4577", + "docs/measurements/h264-rounds/mvd-packed/mv6-merged.txt": "13fe7d7cfb48293ad6c95a6407f058b19906fae51171db045c0b5bed765c988b", + "docs/measurements/h264-rounds/mvd-probe/README.md": "c81a3d0579a2ceb0101f06b991712d2ce92f5dbf43686f02eb75e69248edc973", + "docs/measurements/h264-rounds/mvd-probe/ab-summary.txt": "cf2ff77283f37c510758cf693643a771ee9958a8ab7f8008e77de2935d808073", + "docs/measurements/h264-rounds/mvd-probe/ab.txt": "058dfa6101e6178e0bc25592a2e651989f4823d07c9b3325b3979ecc81e102d8", + "docs/measurements/h264-rounds/mvd-probe/ab3.py": "8f0abb2a95718ed2ff5f6ada28f9cd811315bfdf9dda3d81cde00e9ed8678ab9", + "docs/measurements/h264-rounds/mvd-probe/abq.py": "978032f511d6e115d8e586e26153990c107f109529a264af5f9b9c253393fedf", + "docs/measurements/h264-rounds/mvd-probe/binaries.sha256": "aaa5127f419cd04cdb65c1cae3d42aca3dd590b9c987649111c6e86c738e4368", + "docs/measurements/h264-rounds/mvd-probe/c-ab-summary.txt": "c9a9e0a4f8e47bc56f92c8af68da7849130f1a5da8ea1c22cfffa832e5231171", + "docs/measurements/h264-rounds/mvd-probe/c-ab.txt": "aaa5240ece9715eda2982207d5252186fcf5ce88ba72748db084200062462f2d", + "docs/measurements/h264-rounds/mvd-probe/c-conformance.txt": "c694dc9ca0c5dc8fd401d02b63b53349422746f38e67e80495967cca603e1a02", + "docs/measurements/h264-rounds/mvd-probe/c-count.txt": "ba6f36065b9eace6bb059024790add459535604c564b709cd203fe5cab72f29b", + "docs/measurements/h264-rounds/mvd-probe/c-identity.txt": "7f31fe15e953159a19ece3034b794b19ec96bc38102b5640abf4a6a3c30212ea", + "docs/measurements/h264-rounds/mvd-probe/calls.py": "30286a953158963d35a98f47f0ee62fa452fe919e22c808f5189476d84d662c0", + "docs/measurements/h264-rounds/mvd-probe/counts.txt": "e1e0a124beb2d3b2971beee0ec507f343276ad1289f5a11e8583a21448430ff9", + "docs/measurements/h264-rounds/mvd-probe/plan.txt": "ba179b5dd04df17313a90f58f3d76d304e51fd2ca72a62bdd6dc7252b2e9272f", + "docs/measurements/h264-rounds/mvd-probe/probe-pad.diff": "38eeeab06b9aad0a689fe2523ecd78e15f2359630d332903fe620e62197fd71b", + "docs/measurements/h264-rounds/mvd-probe/sites.txt": "276189e1af1b575158d56b208bbc90e2a91164b15efa7b5a81edd2faa30694a2", + "docs/measurements/h264-rounds/mvd-probe/verify.txt": "3b794b70057425aa92e99a35e7254fb3a55bf4fd651974986341ca5ed96ee1aa", + "docs/measurements/h264-rounds/pairing-comparison.json": "c14e7556b0b055dc0903a91c03e0e2fe3ad68cf98d87014ec71ab72439ab5136", + "docs/measurements/h264-rounds/picture-clear-instructions.json": "1157023c6dadb76b597f15abcc897490620e9300aeeffa9cd97b3d1d6f37d76b", + "docs/measurements/h264-rounds/place-interior/README.md": "29faa9ae4c98547a90838500aef213144667a076133a86fe6088c990ef99f0d2", + "docs/measurements/h264-rounds/place-interior/analyze.py": "e7cce7155190de750a143bbcddb0ff4985892889ce50505b9263fc3c86ce43f2", + "docs/measurements/h264-rounds/place-interior/gating/REBASE.md": "6ca5aa28da584cdd783a53036bc06ea4ed4591fce0961c377c48949fc0ec43cc", + "docs/measurements/h264-rounds/place-interior/gating/analysis.txt": "a91d8794d2ddc3cba5a5be5e946fe3bbf00af14ce8a2dfd4ebd5495374764015", + "docs/measurements/h264-rounds/place-interior/gating/conformance.txt": "677baffa2bd2550e7768c449aa0b8cbc4e9950d28a5d45ec1b0e34f9ca05564a", + "docs/measurements/h264-rounds/place-interior/gating/first-start/STOPPED": "76374b561462c27b10078919b91b14b117656fc9de54a390010e4f0ae93c4f73", + "docs/measurements/h264-rounds/place-interior/gating/first-start/g.sd.json.void1": "cd7d6b22aea3dbf49ddc70c6cb440411ec0e3876484e41036883425319318efc", + "docs/measurements/h264-rounds/place-interior/gating/first-start/g.sd.json.void2": "75ace41b01e6c3285011f701c2439464f76ffd2f24e3f30cd8a1ab82d87ec10a", + "docs/measurements/h264-rounds/place-interior/gating/first-start/g.sd.json.void3": "fea454bbae28aa699dfdeebd3bf086bba35eb3aaf0edc6302674f9b7d68a8947", + "docs/measurements/h264-rounds/place-interior/gating/first-start/g.sd.log.void1": "bfab7b4078798e51bb921fc46a10451c23acd2a023257c3723b86b97338ecc91", + "docs/measurements/h264-rounds/place-interior/gating/first-start/g.sd.log.void2": "71ded97b4a1fa1ec6d6dcc3acaf26d818a9de0a10121234dd77481d8ad4aef96", + "docs/measurements/h264-rounds/place-interior/gating/first-start/g.sd.log.void3": "3d385baec625c8b674bab1c4fdcf5ca44bf8dfdabdf2b74073149cbd75c81054", + "docs/measurements/h264-rounds/place-interior/gating/first-start/hostgate.log": "af0e58de7b64cff92934d18a6a061b9d5bf84a10f3df5303221134a4c5d13242", + "docs/measurements/h264-rounds/place-interior/gating/first-start/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/place-interior/gating/first-start/progress.txt": "411b13273e9266e30d6a044c10c49f18403d1e84713b394f0b2c1924c116760d", + "docs/measurements/h264-rounds/place-interior/gating/first-start/provenance.txt": "811c98c2b13f037bf12a93822de1809bb1ea35b8f5780ae2f97244c37e5723da", + "docs/measurements/h264-rounds/place-interior/gating/g.1080p.json": "bf731cd5fe3ec1af51041b2878b63ff154f908b90d7c34d7d6fefa1fde0035ed", + "docs/measurements/h264-rounds/place-interior/gating/g.1080p.log": "c2b7e6de099ed8cd4ff655e42264441e9254bb00c949c582b4957551a08fbe35", + "docs/measurements/h264-rounds/place-interior/gating/g.4k.json": "60ea9113904f16afec3cfc04e1bcb806ff6fec8c907f34339807b3dd6c05a86a", + "docs/measurements/h264-rounds/place-interior/gating/g.4k.log": "c5e3f131189ba719042e56cc8d7db00472ad2b9ec17e403ad145e378045c2982", + "docs/measurements/h264-rounds/place-interior/gating/g.720p.json": "0c9f066ab1e91947409072c3ab4e48dd9064cfd1fa128341e6cd43e467f8b030", + "docs/measurements/h264-rounds/place-interior/gating/g.720p.log": "7d6c064a4d288ff1827c96788ea9cc7fd26fe44e3bba1e18f1103f7f65182763", + "docs/measurements/h264-rounds/place-interior/gating/g.sd.json": "797e8a2211e6504ecc15ea167cf6398d029afd890aa5fdc630b888efe8994e9b", + "docs/measurements/h264-rounds/place-interior/gating/g.sd.log": "3fb2d677a84adb8702b8266262701743a846174300eef2ac718cc461c41fb595", + "docs/measurements/h264-rounds/place-interior/gating/hostgate-rebased.py": "db2835ada5d3268d0544c5b22886806e0bf7db770f94e622a70508952f71f93e", + "docs/measurements/h264-rounds/place-interior/gating/hostgate.log": "b70c72bcae44180a5985569b1bd2a9077aa32e13a9cfd0cd1aa9d7630f010e83", + "docs/measurements/h264-rounds/place-interior/gating/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/place-interior/gating/progress.txt": "6f8ed6e040f60ffe7f69df4f6826620ee37067939b3320b4ee5ef8aaf969c3ed", + "docs/measurements/h264-rounds/place-interior/gating/provenance.txt": "7d9c0acd68f01c2cdbd4dde12c99228bde4445dc5fec38dde83c557a67aa9a5e", + "docs/measurements/h264-rounds/place-interior/gating/rebase-checks.log": "0c7b6c4edf125447552f78089271d2b78c1c717cb805f2315891bdb65b1b68b9", + "docs/measurements/h264-rounds/place-interior/gating/summary.json": "2e96879ef5b73158f9ca879b1f7669966aa0e4ee549bb107e51cca7536201bb9", + "docs/measurements/h264-rounds/place-interior/gating/t8.1080p.json": "98f6581cfe440cdedc4aaaf25c7e564a9fe1f21d8993da9a6200c7b2a97b4b70", + "docs/measurements/h264-rounds/place-interior/gating/t8.1080p.log": "77f53f5acbec1d5a1158e3ce7de317f7a7b4931e29175dcf4ed4251756734374", + "docs/measurements/h264-rounds/place-interior/gating/t8.4k.json": "996b045c03706965e842e575f22b3f2b67a8585f72d77649308c00d0c7cadb01", + "docs/measurements/h264-rounds/place-interior/gating/t8.4k.log": "52ef6a589158a46e89fbb7b76513a04e65eb0785b38ced6a2f0100915007a2cc", + "docs/measurements/h264-rounds/place-interior/gating/t8.720p.json": "67abd87588e844d09dc360be224148dd90e4eb24a27c099d6913cefe17ce10c8", + "docs/measurements/h264-rounds/place-interior/gating/t8.720p.log": "51ce95affef85d5cb3b4bfcaac1aa2fff84f5dde4e755ea6c62002dfe8947eb1", + "docs/measurements/h264-rounds/place-interior/gating/t8.sd.json": "e3660148784b6b410fe2f2f0735cdd66fde311f5516401ad4ae82cd34ff391dd", + "docs/measurements/h264-rounds/place-interior/gating/t8.sd.log": "bb3fa25b1e71b75d77038629d389a4c826d31037d491ec43dccb9ba7c687a974", + "docs/measurements/h264-rounds/place-interior/instructions.txt": "e96878ccedbb5586df13df21cf7154e2874e7a5cee497684f0a509abfb545f87", + "docs/measurements/h264-rounds/place-interior/profile/cabac_split.txt": "a86275167d4d77c49ad1a6bee12fbe089d776bf7e3b7cf1618fdb3e64bd8da6a", + "docs/measurements/h264-rounds/place-interior/profile/chainsplit.py": "970dd7f20200b1640561c2718b154871ffe096a2142699793d6d6d8d0805c16c", + "docs/measurements/h264-rounds/place-interior/profile/classify.py": "c554a8ad6a66d4bf911442c1ad7950883b4b017a7961f0452cf9e664374f37a9", + "docs/measurements/h264-rounds/place-interior/profile/hostgate.log": "fd9fcac16e1f2b43f3d6626492c9dcd33be1a3a9d73216ed42e786678c0ef5d8", + "docs/measurements/h264-rounds/place-interior/profile/inter_items_by_class.txt": "d22fc31ba83b2a08803db0e95833819ad8848663689a8cb86ca24bdb7136b21b", + "docs/measurements/h264-rounds/place-interior/profile/inter_split.py": "6980f33d77b91defbd740d7d4ae7f618d1ab0177541af1979ad366daa1a5a26e", + "docs/measurements/h264-rounds/place-interior/profile/inter_split.txt": "4feabcd83137382aa5fa58637be09cd4638cd7c55ed85ffcf0c87a63b61bb075", + "docs/measurements/h264-rounds/place-interior/profile/items.py": "d3af163b0d2b8d7db28d5099e143e4889d7059cbe4920c63040af8ccb48d7f91", + "docs/measurements/h264-rounds/place-interior/profile/items.txt": "8a2434c92608dc263faac7ce284bed026ba5577a9fdde317751ffdd0058639f1", + "docs/measurements/h264-rounds/place-interior/profile/kitems.py": "172f6591d0fa2faa1fa28ad743018c98b93211d5b6f74ddf05b18e88917fdad3", + "docs/measurements/h264-rounds/place-interior/profile/klines.py": "02eec8c32fb4adb021259920dda49e21dfef3f96ccecc55a76167482b5d1672f", + "docs/measurements/h264-rounds/place-interior/profile/predict_items.txt": "14c94ba63e4862c816fa92c15c28ce92cdb4d00f913e53f27a8d022c8d532f8c", + "docs/measurements/h264-rounds/place-interior/profile/predict_lines.txt": "d69bd1bf1da7e9e5aa3abf8614a55cba59d7be92ab34b49b512f6fafe8a0c4f5", + "docs/measurements/h264-rounds/place-interior/profile/rec.py": "1504934f5dfcf4e0ed2b536fa620df07c57529a14c271777e2006835a766ea1a", + "docs/measurements/h264-rounds/place-interior/profile/rec2.py": "ed5ac2e2cf381f095ef4f88fbff1d058812225627b3207e87bd1497f5aaa38c6", + "docs/measurements/h264-rounds/place-interior/profile/recon_split.py": "0eee29c049d98b5aee6bf0d66a6f2e28f4b596ff0a2e00e8253d0e6a55663e79", + "docs/measurements/h264-rounds/place-interior/profile/recon_split.txt": "584d3684cd003e534c3ba7414908a72de38750ef3db2dc0f0bcb9fd185f94eaa", + "docs/measurements/h264-rounds/place-interior/profile/resolve2.py": "91f011a6504abca99a6154335055eac414a300b424d81dbb3752c9bd9f7f177c", + "docs/measurements/h264-rounds/place-interior/profile/stageitems.py": "4f4fb86d53683481f88b2a45a8fa4bf116c7c2e8ba7a952a5594a049e57ffd6b", + "docs/measurements/h264-rounds/place-interior/profile/table.txt": "bf3477dd773ed72589faa60d15077551bacf2601793b22f0af53236a640d42f6", + "docs/measurements/h264-rounds/place-interior/rebased/analysis.txt": "b83e55c441bfebe17222c5f1388626a4549331d087a8c0ef394a053d0204f055", + "docs/measurements/h264-rounds/place-interior/rebased/analyze.py": "99f7ee6fe7ba9c9c238552f097bf055de88cd2884593e3a945133750851c9fdf", + "docs/measurements/h264-rounds/place-interior/rebased/conformance.txt": "6c619974dcdbed6e6121fe4b16a87d9ee42601425437d87988f3691d96c11b12", + "docs/measurements/h264-rounds/place-interior/rebased/g.1080p.json": "851cd3ead0c5d3175ae05ed7262f167c74548c86e044c7bd58a8954e785d7d6c", + "docs/measurements/h264-rounds/place-interior/rebased/g.1080p.log": "972f3790ea389bb234b8a3e4b31f1c2b357b706ccf6c5356dc7c016f98f7adef", + "docs/measurements/h264-rounds/place-interior/rebased/g.4k.json": "6fc876e3728a9abe7533b2f14365fae1877af7a5b080f01123508fd2b4308bcf", + "docs/measurements/h264-rounds/place-interior/rebased/g.4k.log": "66916b417a44881d3a25c94c9db8ec3344137b99afa9ba6bc850f1d00730e4e7", + "docs/measurements/h264-rounds/place-interior/rebased/g.720p.json": "a701ff99102565ecdbd20bc2d9d5250ea8757aa13d82d5e22a7e27f16621d3f6", + "docs/measurements/h264-rounds/place-interior/rebased/g.720p.log": "616bbd265b4cecd84404de13f4f89fd7deac082794e0fbcc7980ff6802db5abe", + "docs/measurements/h264-rounds/place-interior/rebased/g.sd.json": "1d048b32cfdaa7b44bab20ba1ac43eedca0c20080a75cc9b03e17e9da934a9df", + "docs/measurements/h264-rounds/place-interior/rebased/g.sd.log": "198a7f8bb79581ad50b708cfca2a7620fe6bde58e5404cdf58343cf381daf2df", + "docs/measurements/h264-rounds/place-interior/rebased/hostgate.log": "86900efa1df5b55cfcdd1ed82e88d5b71001d216ce6c11fb34b1d8ea5950b252", + "docs/measurements/h264-rounds/place-interior/rebased/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/place-interior/rebased/progress.txt": "1d1a7794cab3f65c665bbd01d7d5e0695f6a683bfb943f787daacc83a5cc3db2", + "docs/measurements/h264-rounds/place-interior/rebased/provenance.txt": "7918942ed3e2259e4a6fe4e13bb98e912a83b9f82b6b5c43f951407bcde7aeb7", + "docs/measurements/h264-rounds/place-interior/rebased/run-ab-helper.sh": "6d15d9b20dc5295d18de7ee5ba4e368c839a7bd1f41579462e888e57bc4406d3", + "docs/measurements/h264-rounds/place-interior/rebased/summary.json": "5e4695a9f724db4a9816aac878765330b5201cc2ccec7d12493d9d90222868f0", + "docs/measurements/h264-rounds/place-interior/rebased/t8.1080p.json": "36ab9e5130295f08ce83f8a1187cfee25b496d14c26ef72d7856f1a611dcb54b", + "docs/measurements/h264-rounds/place-interior/rebased/t8.1080p.log": "f1553a0a45dcc00afb102fc173ad72821c26da013516d799e0f3526dd86179d5", + "docs/measurements/h264-rounds/place-interior/rebased/t8.4k.json": "55019e0c22df57774c2653571e76489830a6cc8ebdb39684221050cb602da619", + "docs/measurements/h264-rounds/place-interior/rebased/t8.4k.log": "f0eec743dc39b1e1c1c84a24f2cb369c5a00ac689905f9eefb029df06f3b41ff", + "docs/measurements/h264-rounds/place-interior/rebased/t8.720p.json": "1d1d64f91b64e824c9ae196875a43999d4c1ca8305d0c091919b4768c1bc8eaf", + "docs/measurements/h264-rounds/place-interior/rebased/t8.720p.log": "e580103f0bac1704024c85af995bad6f8861e965ed1488ef0aca9b4a8ec24182", + "docs/measurements/h264-rounds/place-interior/rebased/t8.sd.json": "aa3b1fa1c7c5787217041c6125c361754450f1ea6d744bf0f1da307206359852", + "docs/measurements/h264-rounds/place-interior/rebased/t8.sd.log": "49360552b416f8880863860380cadd5f87cd042750206343b56ee578c41baaff", + "docs/measurements/h264-rounds/place-interior/run-ab-helper.sh": "da1ca9c6e15c6fe76990ba2c40713ae512046265052ac4e320486e0d40072d0f", + "docs/measurements/h264-rounds/place-interior/verification.txt": "35eeb9d7ca98e277c67be7a5d617f76557d04148952b140b7c2b7013c68ef34e", + "docs/measurements/h264-rounds/placement-control/ab.py": "eb892d69a29edfe5deaa16dedea4e76620e1fb176ee983c1b95795b0ebf7160a", + "docs/measurements/h264-rounds/placement-control/ab.txt": "b299accfa7bef1628a070c4b4f8727bde59ccc81d15d2f730a11e76f5e1bad14", + "docs/measurements/h264-rounds/placement-control/analysis.txt": "43cc832c279dae65b94b82b978d721b9d86bcd5a02df57055eeb65710c671792", + "docs/measurements/h264-rounds/placement-control/binaries.sha256": "85dbe95819ee7e5828fd4af27efe8710056619fc08866264fb5ee3b022be42a3", + "docs/measurements/h264-rounds/placement-control/build.sh": "edafefef2f7d5eb1fa7b9c98674a7679b219f0238baf9cf7c2ebc005d567f678", + "docs/measurements/h264-rounds/placement-control/gen.py": "86e2e8f793fe15eb33243ab349971b39cb2322520697a19ac477861fc24ec463", + "docs/measurements/h264-rounds/placement-control/host.txt": "3460da82d48490cf908547b739e5021fba47119efeee706a794b6f81cc216b70", + "docs/measurements/h264-rounds/placement-control/hot.py": "c4989a4a9ca6fb12f0304692cc5250ab5d5e425ce7492d1929946d311bdc2fb2", + "docs/measurements/h264-rounds/placement-control/n1.patch": "2f8da20cff0fc706fca18291e26ea200f9cfb9d39c618b35d5e820ffbf101f12", + "docs/measurements/h264-rounds/placement-control/n2.patch": "16528e9e9c9ee3ea1849cbcbffb7846368663eedd2623a6ec0e46e6cf2f5086a", + "docs/measurements/h264-rounds/placement-control/order.py": "063e94ed6d0ae3743416c22ce9fb0a2ce6d66af976e0632a2290c70939b2ac9a", + "docs/measurements/h264-rounds/placement-control/order.txt": "dfe663b3be5a752e59aa1b0597e19ee152bab2268dc2bd891a79c766653ebf7d", + "docs/measurements/h264-rounds/placement-control/pc.py": "d364459e090c74fcb996c164949bcf4223f1e98fdbfdb96eda59e8be0234087f", + "docs/measurements/h264-rounds/placement-control/place.py": "893acac1709f73bb9cb9ad3d0844bc62340abe91ca655ca4c4119b4e4f0d6c98", + "docs/measurements/h264-rounds/placement-control/plan.txt": "9ac5b3f40908e28a5b699c8f38f7b34187aa0713ffa1966cda4cb9b01efe6188", + "docs/measurements/h264-rounds/placement-control/static.txt": "d4584966df7ce8c85431422f79b8269784ac9e82abb23cb9a3289ecbf5ba9ca0", + "docs/measurements/h264-rounds/pmu-profile/README.md": "baf6d59b136b4878287935730d372190c877cbe502a3c08b292d8960187705a1", + "docs/measurements/h264-rounds/pmu-profile/dims.txt": "5a8f893b25ba9e8baee966923c98cb8d360ed6943c448d12af6016422e8f1855", + "docs/measurements/h264-rounds/pmu-profile/job.sh": "99136674f42be44564bfbf960bef1f1c750da74b1ca8f89f08760d8e6d4b5255", + "docs/measurements/h264-rounds/pmu-profile/rec_pmu.py": "fbe4a34e1e33b5ae447d6fec5d344247bdf4a0a7d5870a6cee97214e1c01c8b6", + "docs/measurements/h264-rounds/pmu-profile/run1/build-order.txt": "0570a07051d5d0a601c67ea53740dead2fd359a750a3cc36cf4d9c6f67a22487", + "docs/measurements/h264-rounds/pmu-profile/run1/events.json": "8e8a0394f9ecdc090b207a90588a384fe8e947f3993e4099a7b27ed77b7d905d", + "docs/measurements/h264-rounds/pmu-profile/run1/ffattr-output.txt": "4a3ea8cc897c3e4b14084dd2a826b872d1eda040442ea14dbc5a9f5f9be31935", + "docs/measurements/h264-rounds/pmu-profile/run1/ffattr-sections.txt": "87cdfbe7602234128481ab30cd89c2cca0cfeeeb240c20d645f60532e6a27e81", + "docs/measurements/h264-rounds/pmu-profile/run1/host.txt": "c4fffd95efa44e23be23787e15d72741cfdc6cf4ed8e2928db77002be26bd5e7", + "docs/measurements/h264-rounds/pmu-profile/run1/stages.txt": "a53356ab8652d4cb4218748ec43c53e29c44cc851e7d104c5603b95716ae68a7", + "docs/measurements/h264-rounds/pmu-profile/run2/build-order.txt": "691eb4ac9edc77b06f642e6139136e0e3060e036a46ae82bbbfc3d4e3c184403", + "docs/measurements/h264-rounds/pmu-profile/run2/ffattr-output.txt": "4a3ea8cc897c3e4b14084dd2a826b872d1eda040442ea14dbc5a9f5f9be31935", + "docs/measurements/h264-rounds/pmu-profile/run2/ffattr-sections.txt": "87cdfbe7602234128481ab30cd89c2cca0cfeeeb240c20d645f60532e6a27e81", + "docs/measurements/h264-rounds/pmu-profile/run2/host.txt": "b3303af9d31dd42e57334e5ed394f500e6649051be1f61e13f71609e8aa1a71a", + "docs/measurements/h264-rounds/pmu-profile/run2/stages.txt": "b4083491b211347d6831ebb84833576abd369259422cb89e13e663f3f1755009", + "docs/measurements/h264-rounds/pmu-profile/run2/topdown-probe.txt": "1f0673e3674c24f2ea42c8cc0b16698d81583dc42b6db598afa88f48130250bb", + "docs/measurements/h264-rounds/pmu-profile/run2/topdown.txt": "af2f26570c563ba60a9e494f342d73f5f40877f0d65c2a6a678ac88f65b6ecb1", + "docs/measurements/h264-rounds/pmu-profile/stages_pmu.py": "09bc53b1a4053db724aca5301a733d1071430ad0e0243ca654fc9a240b16770e", + "docs/measurements/h264-rounds/pmu-profile/topdown.py": "38eb6cef35cbc30d7010ccb02542bd653d7457901f8365e7ba64dcd64eafac06", + "docs/measurements/h264-rounds/predict/analyze.py": "4ebd1a72886f4d8c016851006cd169b411b66705ea6dacf755ce85a332cf9d2e", + "docs/measurements/h264-rounds/predict/gating/README.md": "187fc9ec31e4cf82b9ecd45e4f5ada3afb11805840b6d6412da8966f32763818", + "docs/measurements/h264-rounds/predict/gating/analysis.txt": "4c1022bfb40fd7d267637522e983d4d1d5b5b96e5fe654494b895484bcd59c3f", + "docs/measurements/h264-rounds/predict/gating/g.1080p.json": "4718285efb9511502cf2c69802d293ab0b18111eaadda00bac1b335b30335405", + "docs/measurements/h264-rounds/predict/gating/g.1080p.log": "eb3c04790d858fc45c60606cd352a3d18a655130b166ed861c33a1683fac68b5", + "docs/measurements/h264-rounds/predict/gating/g.4k.json": "9adc988ee6b745a97c7494868d6219a6c66f0891ddc70a006d36a5d8b158366f", + "docs/measurements/h264-rounds/predict/gating/g.4k.log": "4a18207ebc5f7b528e34a1c16f04db57838b7289f3c033cbc7d1ebe9ff3c8c3d", + "docs/measurements/h264-rounds/predict/gating/g.720p.json": "736a94b2f840ea299654aad7f4a70b445cdc812b0c4ff281908567c6cdc16d78", + "docs/measurements/h264-rounds/predict/gating/g.720p.log": "03498d10782c0b39efa0044a1b8f04a6c5e6b066f0ab930194858c6f94590aab", + "docs/measurements/h264-rounds/predict/gating/g.sd.json": "a4d2d2cdc56f48ebd4c2e2102eb4c42400617307a9dc324862e3ee0edfbe8e58", + "docs/measurements/h264-rounds/predict/gating/g.sd.log": "bb6d3bc3f3700571f925be34045f50302a6884180b9245c1fa6d22a832d7090b", + "docs/measurements/h264-rounds/predict/gating/g.summary.json": "d7edea872f7f41aa9189bc96f5b927bc432ac1105af1a0389b55506b4f00ce2e", + "docs/measurements/h264-rounds/predict/gating/hostgate.log": "2f6d8f107d87c9aa52738c0222bde011246e1fc3b09d806d7e981e641634dbf0", + "docs/measurements/h264-rounds/predict/gating/identity.txt": "6852ff62d0c87548b821d4c9ef06756591be2e3a609b0af123baedb3b9166a68", + "docs/measurements/h264-rounds/predict/gating/progress.txt": "18bc5c10be1f8ad306090c65c4c92493ce3771db8f91e60c3529c93d72bd74ec", + "docs/measurements/h264-rounds/predict/gating/provenance.txt": "37d9346d5f732cc0b37c372f7b78894e4be62416cbbd1ce8df4a7e224879f120", + "docs/measurements/h264-rounds/predict/gating/run.log": "f80f4da33acc9080cb3fabe0db8b0e5febb1ddeafc9d13cf93d100ec81063f04", + "docs/measurements/h264-rounds/predict/instructions.txt": "e6008bfcd13b1be788c9d0fa41eccd62c6380ae15cb08d3ebd6212b112debed6", + "docs/measurements/h264-rounds/predict/ir.sh": "ad7b5d017e395024f9c2726df59d8ea7dab345f82cf4bcfb79529976119c545b", + "docs/measurements/h264-rounds/predict/local-4k/README.md": "3082656855b96d22ebf31f91786d1bfab776897aa46f53ba265c090ef9afc279", + "docs/measurements/h264-rounds/predict/local-4k/binaries.sha256": "e62a173b4a1eb29651200d496dcbd0f486dbb076d2729a24f9f25fe6f13c0235", + "docs/measurements/h264-rounds/predict/local-4k/g.4k.json": "1496fd505719fd3cf0a78b186e04a82ee0400681a7137f7f9484daa395bd9e8c", + "docs/measurements/h264-rounds/predict/local-4k/g.4k.log": "7b416c64f9eaa7775971bade16ef6cea9b7341b039bb27cb875e5b14be532430", + "docs/measurements/h264-rounds/predict/local-4k/hostgate.log": "aeaf8b3c1b6ae8969df959fd185da561fdfd9f9bdd2e7c1730e72ff14b005f82", + "docs/measurements/h264-rounds/predict/run-ab-helper.sh": "8d8325346f30620dc1001d3fa8d2622506cc3660dac181f25d6eb5fd72f13ab6", + "docs/measurements/h264-rounds/prefetch-stalls/README.md": "9cdd0f718567bdaf98cfde31b7ec4a9642f95afed12e984218e259c5df83ed7a", + "docs/measurements/h264-rounds/prefetch-stalls/ab3.py": "523ed9577e773ddcb94cc86e425997aaec0e545336d9d04c40347f93018218df", + "docs/measurements/h264-rounds/prefetch-stalls/abset.py": "b49648c5cf886cf1f5bd0c95cecc7c49765deaf1a434d9db6d9f86f3478fa4e4", + "docs/measurements/h264-rounds/prefetch-stalls/dims.txt": "5a8f893b25ba9e8baee966923c98cb8d360ed6943c448d12af6016422e8f1855", + "docs/measurements/h264-rounds/prefetch-stalls/job.sh": "db48dd3bd0eede648e3189287db109ef1547290e09db232433e15112232a5f1a", + "docs/measurements/h264-rounds/prefetch-stalls/pf_stalls.py": "47651f03820c5bede093a93af683c7e8c131d2f1e2bbd0ade74a675d0d9d6883", + "docs/measurements/h264-rounds/prefetch-stalls/rec_pf.py": "3c312790330d08ed5573bee7c5baa8abb725881b3a1e860211214230ae36679e", + "docs/measurements/h264-rounds/prefetch-stalls/run/build-order.txt": "102977c6e4a96350eb1c98cbc7fbaa5b488bc957abeae3db18acb94564c104d1", + "docs/measurements/h264-rounds/prefetch-stalls/run/c-ab-summary.txt": "0b93104927ebf47736db8ab6e0aaca261dc219ab02486d7802563bd110d10ff6", + "docs/measurements/h264-rounds/prefetch-stalls/run/c-ab.txt": "16bd9e7bcb49dc4ecb4b6cfbab40a8705ed73fccde37efbec95b812f0f49e997", + "docs/measurements/h264-rounds/prefetch-stalls/run/c-conformance.txt": "cb812f39e5f22f5aafc994dbdb5a547b5b4133ca60de0f571c8555ebe15ef0f9", + "docs/measurements/h264-rounds/prefetch-stalls/run/c-identity.txt": "97b98718036d03e0df32ec9e48b546a93fe4a5ba6cc5aebc446282815a4d2cb1", + "docs/measurements/h264-rounds/prefetch-stalls/run/events.json": "f9bccb7ca522a692b839669688be7156b3dd36194833146396e3630bb119369d", + "docs/measurements/h264-rounds/prefetch-stalls/run/ffattr-output.txt": "4a3ea8cc897c3e4b14084dd2a826b872d1eda040442ea14dbc5a9f5f9be31935", + "docs/measurements/h264-rounds/prefetch-stalls/run/ffattr-sections.txt": "87cdfbe7602234128481ab30cd89c2cca0cfeeeb240c20d645f60532e6a27e81", + "docs/measurements/h264-rounds/prefetch-stalls/run/gcp-job.log": "181fa8794d104c9b46d7856e6ed37cc7f38c3e30c75b497c5333cb07dc3f2182", + "docs/measurements/h264-rounds/prefetch-stalls/run/host.txt": "e9abd6d565a472f3c1bbc0732b3e48e1e1304e0fe695ddc45d1e46c696fbb249", + "docs/measurements/h264-rounds/prefetch-stalls/run/instructions.txt": "01375ab8e06ec4523981860aff53f814c300ad537730d0887de8fb590affd88a", + "docs/measurements/h264-rounds/prefetch-stalls/run/pf_stalls.json": "208551b53f0002217975f265db39b50cb8fa77766360ead2190a7ec1100f9753", + "docs/measurements/h264-rounds/prefetch-stalls/run/pf_stalls.txt": "4405ce97fb167d32b01eacb6e0363e8a393e466d981e189bb3ca89bc627b347e", + "docs/measurements/h264-rounds/prefetch-stalls/run/probe-ab-summary.txt": "7f81a7c5d0d639f1b75f2fed5f70e30c1f77997288dad15d24ef3ca8aeacbdc2", + "docs/measurements/h264-rounds/prefetch-stalls/run/probe-ab.txt": "277bf6ae72f8714058d4293bd4a36d5cc4bf924941385bdaff48e1aed95a10a4", + "docs/measurements/h264-rounds/prefetch-stalls/run/probe-identity.txt": "1caa09ae4085ad9235c1de9c6b557373a4a7b5e436d4a7768b4bad18b68a2667", + "docs/measurements/h264-rounds/profile-40f29a6/README.md": "b65ead3ce68929a061f8ccd8532763b953ec6d79a29bc2107ad43711b5075f96", + "docs/measurements/h264-rounds/profile-40f29a6/classify.py": "c9fddec1a80456641f1475ad3d1965ff126082e5196ea3b22f611b6d61ec0fc0", + "docs/measurements/h264-rounds/profile-40f29a6/items-mb.txt": "24161f39ea8345e0cd947f88a8029fec4d68ec89229a9e394a3b2b13b412da0e", + "docs/measurements/h264-rounds/profile-40f29a6/items-rest.txt": "8723caa806a483ec432b7bb43e2b27f1ee9515ce9d3ddc8ba6cb57a17e7a6644", + "docs/measurements/h264-rounds/profile-40f29a6/items.py": "bd17220a9463da873ca6480be46f1e9718d42df0e0474d51e3ac1d3933a26825", + "docs/measurements/h264-rounds/profile-40f29a6/rec.py": "a497b925a3652759d32655202058564c771067d91da3169569b1ab8448870be5", + "docs/measurements/h264-rounds/profile-40f29a6/resolve2.py": "91f011a6504abca99a6154335055eac414a300b424d81dbb3752c9bd9f7f177c", + "docs/measurements/h264-rounds/profile-40f29a6/stages-old-classifier.txt": "b135b7064ecb3d711643d05981d2c517e3784d30c6233b50b8113dd8f4f79d92", + "docs/measurements/h264-rounds/profile-40f29a6/stages.json": "bde99225bae3229d39958fe4b474cd9ef69ac37246a06daca80848dca835ab4a", + "docs/measurements/h264-rounds/profile-40f29a6/stages.r0.txt": "f62432d27eb469374a88cd4ca02188735ac6972d43c75db5a51a48b996734449", + "docs/measurements/h264-rounds/profile-40f29a6/stages.r1.txt": "38b7c5e4f515132c9b1f3c80f60425c282a33732e392a3247dee013ac6ff33e9", + "docs/measurements/h264-rounds/profile-40f29a6/stages.txt": "c319b52bc75678433ea4597e1bc6292890f0d60b23c7dc85840c7ea5ac63e9d5", + "docs/measurements/h264-rounds/profile-6c9e240/README.md": "c3b78fe9bae556f81ec573de5ebe264fb5c7a04da461217451ce6eb8d177f68b", + "docs/measurements/h264-rounds/profile-6c9e240/classify.py": "5d206425193bda1d12ba48cb2012608339b8cf1e0e8bd61b44fd6473ad65f120", + "docs/measurements/h264-rounds/profile-6c9e240/items-mb.txt": "2f3ccd1e79bc8c2c574a5df21cd8d6d1e19cb956f347cc35552ae28c7001841f", + "docs/measurements/h264-rounds/profile-6c9e240/items-rest.txt": "fc0b84b23103e22d9c0139fa49fe62c27d17fd43ee3499b5cd6ab40d7c611459", + "docs/measurements/h264-rounds/profile-6c9e240/items.py": "d9b338d79359929aae1bc6cd43c50885b3033ee14f114ad3bf835e39e7e049cd", + "docs/measurements/h264-rounds/profile-6c9e240/rec.py": "a497b925a3652759d32655202058564c771067d91da3169569b1ab8448870be5", + "docs/measurements/h264-rounds/profile-6c9e240/resolve2.py": "91f011a6504abca99a6154335055eac414a300b424d81dbb3752c9bd9f7f177c", + "docs/measurements/h264-rounds/profile-6c9e240/stages-40f29a6-here.txt": "dc64b45b93d36a47314a6e8b7df9519fc6d5e60e97be2ee6046180695ad2589b", + "docs/measurements/h264-rounds/profile-6c9e240/stages-old-classifier.txt": "5078a9bea624f6a883e2bf72222693744e8b1889a1fc5b8a20c80536f028e62e", + "docs/measurements/h264-rounds/profile-6c9e240/stages.json": "6d38b50adf83687b8ea63a1df41d7d69c8d6374ee4c0f284b47f4db7e799d5e6", + "docs/measurements/h264-rounds/profile-6c9e240/stages.r0.txt": "f3e07ff095c5b8d332fa965daf833b77e0a1836aeabfedc688f7d87b799c57f2", + "docs/measurements/h264-rounds/profile-6c9e240/stages.r1.txt": "09df9a4611b8747d7e6c4aae9b7b3f14d2ae25f19fb7ed2189c51b69b91c8364", + "docs/measurements/h264-rounds/profile-6c9e240/stages.txt": "15c90f1ff48eff1d0c6583dbb3dd0d5aa449f6773001418b0b6957afd4917739", + "docs/measurements/h264-rounds/profile-6f-af20b62e/README.md": "a00d82ddfe4dd721741f5f679fe8a31d2f551b36b46ffd724f484f807b375a51", + "docs/measurements/h264-rounds/profile-6f-af20b62e/job.sh": "0bbff73da8d797051176ffb55572f5c41ee0a5018d37e95b5789c323c523dab2", + "docs/measurements/h264-rounds/profile-6f-af20b62e/lines.py": "07bf1b06d744b1864c177aee6caabb0a882a01af3f945179af05cc9d87af57de", + "docs/measurements/h264-rounds/profile-6f-af20b62e/map.py": "609a74993cbee7e036b39851c4d480458b1192d46cbd49670d17767f66c788c5", + "docs/measurements/h264-rounds/profile-6f-af20b62e/run/build-order.txt": "4d19d36b66a9233e5349a9e2417de0fb346aa8152b9c6a6d3696401880ca95b3", + "docs/measurements/h264-rounds/profile-6f-af20b62e/run/ffattr-output.txt": "4a3ea8cc897c3e4b14084dd2a826b872d1eda040442ea14dbc5a9f5f9be31935", + "docs/measurements/h264-rounds/profile-6f-af20b62e/run/ffattr-sections.txt": "87cdfbe7602234128481ab30cd89c2cca0cfeeeb240c20d645f60532e6a27e81", + "docs/measurements/h264-rounds/profile-6f-af20b62e/run/functions.txt": "3674d4c776db97c8d0597dca002f50006783cb563afe2937e24d8bd3978860b2", + "docs/measurements/h264-rounds/profile-6f-af20b62e/run/host.txt": "e5eb98d2ae2c98812632e82af8b2bdb8b557f3815bb485ab181d216f7f88bdae", + "docs/measurements/h264-rounds/profile-6f-af20b62e/run/lines-decode_cavlc.txt": "af7bf8af2d48eb11b597909d2727cfbc106203856d70d0f58f9480360663a6b3", + "docs/measurements/h264-rounds/profile-6f-af20b62e/run/sha256.txt": "24f11b2997af499184213c07f9487d7e8fdc4399d2e58d88eaf54d86b2ca5632", + "docs/measurements/h264-rounds/profile-6f-af20b62e/run/stages.txt": "3f3f7e9987be7bd89da71d971d553d29b8c0b79ba7d35dffe8b0da858be1d6da", + "docs/measurements/h264-rounds/profile-82ad7c31/README.md": "f370726009c42fa372fb35df3d3f813430295937241ddd9049f706f7a516d69a", + "docs/measurements/h264-rounds/profile-82ad7c31/fn_rank.py": "cce2b8f83d3abbb395a9c7dd9366e05b5c100f3a72e4760115c7d34a9dfcf144", + "docs/measurements/h264-rounds/profile-82ad7c31/hot.py": "30c51dd27e8c4d9c765f580127e24edd83d4bfed49cb04da55a262b6f416dad1", + "docs/measurements/h264-rounds/profile-82ad7c31/job.sh": "5e93ea1122ccd9d2d92bda177301b4aafb1bfa33f260f5b9c0467cf510fef9d0", + "docs/measurements/h264-rounds/profile-82ad7c31/run/band-view.t8.txt": "a6d75eabe7e50d66f37164f09eba1b8f15ae4454c5156f92e99ea5ee80326ede", + "docs/measurements/h264-rounds/profile-82ad7c31/run/build-order.txt": "a6318dee4bc25064502938813c35e005098e6af915d9cadc8425d003fd696153", + "docs/measurements/h264-rounds/profile-82ad7c31/run/ffattr-output.txt": "4a3ea8cc897c3e4b14084dd2a826b872d1eda040442ea14dbc5a9f5f9be31935", + "docs/measurements/h264-rounds/profile-82ad7c31/run/ffattr-sections.txt": "87cdfbe7602234128481ab30cd89c2cca0cfeeeb240c20d645f60532e6a27e81", + "docs/measurements/h264-rounds/profile-82ad7c31/run/functions.t1.txt": "627eba68f5bf00fe165cb85dbd34520531b0e3847163f0bdd00e0945e5ebea63", + "docs/measurements/h264-rounds/profile-82ad7c31/run/functions.t8.txt": "ea6da22646e91ec04fb7f3f5d10d52547e1548c304ee7ca65c1748a634d6a759", + "docs/measurements/h264-rounds/profile-82ad7c31/run/host.txt": "548da075dbda7fccdbcf7a385e3fa67d33469e04c8248dd5fd071a78cfb27e86", + "docs/measurements/h264-rounds/profile-82ad7c31/run/sha256.txt": "8b7b8f43726e261b066aaf083800761af9b294415b27ee7f189bd958779ecf29", + "docs/measurements/h264-rounds/profile-82ad7c31/run/stages.t1.txt": "d48c70c37be454381ef119cc99b9e7fa0e42d360e4cee448ff571b955b85c7bb", + "docs/measurements/h264-rounds/profile-82ad7c31/run/stages.t8.txt": "3beaa6291beb8055c8a2fc696fe31c1ed8b44f74d0289b527006be36c808671c", + "docs/measurements/h264-rounds/profile-82ad7c31/run/streams.t1.txt": "9acb0493db2344f8c33f25de3353e86d87d4455ff98bb92b58d626c193ab5ddf", + "docs/measurements/h264-rounds/profile-82ad7c31/run/streams.t8.txt": "01762b509006efd7cfed3f09850fd26e8cc66ea50a1a23ef9ef21dc73e415d02", + "docs/measurements/h264-rounds/profile-82ad7c31/run/top5.t1.txt": "5d1f1447dbfbf34c382c3110a17cd8ca818781220d6fc3484542dd34a1cce7ef", + "docs/measurements/h264-rounds/profile-82ad7c31/run/top5.t8.txt": "fec97f23b1ce84e164da957780e963c7b572ad4f1a2626060c0364d6af798bbc", + "docs/measurements/h264-rounds/profile-82ad7c31/run/topdown.t1.txt": "2991e28a303b60ed8e5464a5f01f6abad90eefe356515e9513087970658b9ddd", + "docs/measurements/h264-rounds/profile-82ad7c31/run/topdown.t8.txt": "d4c30007b165e85e0e798e20b7548366803698aaad8503faa36675b0c27905f8", + "docs/measurements/h264-rounds/profile-82ad7c31/stages_fn.py": "aec3f6fd33e7bdb7b4ba61c65510a5ff2e4b1abef4637e38bfb7e4eea5fe55b1", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/README.md": "69655f6be8d5e9b89518a800a5fd3c5fa6934ac90362dca2eed08b49c695eada", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/dims.txt": "5a8f893b25ba9e8baee966923c98cb8d360ed6943c448d12af6016422e8f1855", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/job.sh": "99136674f42be44564bfbf960bef1f1c750da74b1ca8f89f08760d8e6d4b5255", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/rec_pmu.py": "9a0ba46975e9cf82f8fbe6bd6693ce62fbce0f605eec5873e7cb9ee90e101228", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/run/build-order.txt": "3ebbd1cb2827b1b7257bc058569d59a5e4ad2e12699f1d0d68a0d4b784ba7d11", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/run/ffattr-output.txt": "4a3ea8cc897c3e4b14084dd2a826b872d1eda040442ea14dbc5a9f5f9be31935", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/run/ffattr-sections.txt": "87cdfbe7602234128481ab30cd89c2cca0cfeeeb240c20d645f60532e6a27e81", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/run/gcp-job.log": "a45551fe31112616f53ecf371917d71b6c835defcaad35ff43b5be12d2d9b8be", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/run/host.txt": "d038b596488cd2f11e1a0863c66c7f73eafb91e1c12bccc4763b24ee02e91089", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/run/stages.txt": "689b5e0ed84b4111f7999c1d26953291c1fd9613f4d3c9d3371c87405619290f", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/run/top5.txt": "dd6efe72489e55316d759c55feb7bb80d40b60f8d3b4920e9fcef06e6d06b4b0", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/run/topdown-probe.txt": "212a46572a9876e8101f0d9de927404d7fdbd8b21c499eead2194501fb024a93", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/run/topdown.txt": "0ebfb55eda901b92dd0efc7ea114024e6dc408e8419e062b219df2d638b2232a", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/stages_pmu.py": "0ad26b201f3d2ac60e1e9795b87ed92051819e8920f0c678ad4449c7d7f928c3", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/top5.py": "5fca4bbda3ffd2a1cea0345559f88159bcc1831d4808e175541297623b9f4602", + "docs/measurements/h264-rounds/profile-acf3ee2f-pmu/topdown.py": "38eb6cef35cbc30d7010ccb02542bd653d7457901f8365e7ba64dcd64eafac06", + "docs/measurements/h264-rounds/profile-ae609547-pmu/README.md": "3ada156088908181cca123f9ea0a7387943c21aab7f02839024b249745a98f08", + "docs/measurements/h264-rounds/profile-ae609547-pmu/dims.txt": "5a8f893b25ba9e8baee966923c98cb8d360ed6943c448d12af6016422e8f1855", + "docs/measurements/h264-rounds/profile-ae609547-pmu/job.sh": "079895beecb2b0c937242331e996a6fe95351b386bbd53a621dc928132320edd", + "docs/measurements/h264-rounds/profile-ae609547-pmu/rec_pmu.py": "eaf4b3a78baf12c2673ab6417c7a8bfb4f117116fcb32306e608e5e4da5c1f29", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/build-order.txt": "c36a696e58b9ae55beb2ee2f714f5668f06147d7de34ba6275f3c40fe79d5ab6", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/ffattr-output.txt": "4a3ea8cc897c3e4b14084dd2a826b872d1eda040442ea14dbc5a9f5f9be31935", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/ffattr-sections.txt": "87cdfbe7602234128481ab30cd89c2cca0cfeeeb240c20d645f60532e6a27e81", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/gcp-job.log": "8117ff4c9b7d96e76f5fee8c796da71b4622bad7dfad9e8e8e9cd013f5e5120c", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/host.txt": "f7eab30987c6741cba08ac5398dec6a8835b30621201c78f28174c6a71052a0a", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/stages.t1.txt": "0fb35c3f3e7ee905572dcc72d69bcf2354e5cfd3f78c51699d8f9adc9c86586c", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/stages.t8.txt": "c2d1ed73083ae3ede60d20c88f9d593c9886941cd854cf16a9e34d3383ff7aa9", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/streams.t1.json": "7a0f1c84b043b1a802d99e04d9e5fb62405fa3f7435672408ded35ea2b74e899", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/streams.t1.txt": "7b2edad5132f9e4a3b4f187c22a3651a3935840ff88e878344e1a2df2f089fc6", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/streams.t8.json": "6607a630db1481458b6cdea8bae5b9c3457ac568c3b91fceb44e26bfa82f60c2", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/streams.t8.txt": "a0ec6e936174867e12c8b1f3378e9d3fcfb0d41dc6a5263949344f872bf3e8bd", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/top5.t1.txt": "ca0597921dffec3593b83b2ce56bc5d81104f660a6335ec3bb6efb153309f750", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/top5.t8.txt": "f741fe302fcbf990efcb5b6002578e31843bb593391359bd8a43893d4411930e", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/topdown-probe.t1.txt": "81c37e963f86afb383090afc6c06e54cbc8f9e032c728c1accd80a31944e4167", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/topdown.t1.txt": "8289c5afe783f936e23b088e0344664f1db96072f6ac6a8e200dc6a8a3471a92", + "docs/measurements/h264-rounds/profile-ae609547-pmu/run/topdown.t8.txt": "bb70a37812078d1966edda97484d6647f6b7a9054b6b6c7bc5348eea0b14da16", + "docs/measurements/h264-rounds/profile-ae609547-pmu/stages_pmu.py": "5c4373668901713dfbf92d879788452335e199aa1a24ce7f44422d258adb10e3", + "docs/measurements/h264-rounds/profile-ae609547-pmu/streams.py": "70087c10f54b31158a161741c6157ecce4182658b77a98e623c0bb24f2f236a2", + "docs/measurements/h264-rounds/profile-ae609547-pmu/top5.py": "5fca4bbda3ffd2a1cea0345559f88159bcc1831d4808e175541297623b9f4602", + "docs/measurements/h264-rounds/profile-ae609547-pmu/topdown.py": "38eb6cef35cbc30d7010ccb02542bd653d7457901f8365e7ba64dcd64eafac06", + "docs/measurements/h264-rounds/profile/README.md": "38fd00608b16e092e626c70a0a79aa9b5dfc3d1868bdcff3b031380feb750f17", + "docs/measurements/h264-rounds/profile/classify.py": "c554a8ad6a66d4bf911442c1ad7950883b4b017a7961f0452cf9e664374f37a9", + "docs/measurements/h264-rounds/profile/edge-counts.txt": "312268177cdd5ec6309b0141f57a633261d467e73c2b617c7a8b6935d5d0fe76", + "docs/measurements/h264-rounds/profile/ffmpeg-builds.txt": "70d3a18efae7cacdd9f0094b89fba7fe01a83e8ab0c22c8ff8983380a8b8c8d7", + "docs/measurements/h264-rounds/profile/inter_split.py": "6980f33d77b91defbd740d7d4ae7f618d1ab0177541af1979ad366daa1a5a26e", + "docs/measurements/h264-rounds/profile/inter_split.txt": "974eab43a65f3c03ac1fee8cc17ef449ec7984d070b2287322dea1f3e322d99d", + "docs/measurements/h264-rounds/profile/items.py": "d3af163b0d2b8d7db28d5099e143e4889d7059cbe4920c63040af8ccb48d7f91", + "docs/measurements/h264-rounds/profile/items.txt": "b532bcdefd118bb8042874227f1f87cd03a5bbf055f7bda357a9ec40412e0bac", + "docs/measurements/h264-rounds/profile/rec.py": "a497b925a3652759d32655202058564c771067d91da3169569b1ab8448870be5", + "docs/measurements/h264-rounds/profile/rec2.py": "ddf262ea51da5ec20704aa60b953633764b2bfc610bb2c08225c10d0df25efd3", + "docs/measurements/h264-rounds/profile/resolve2.py": "91f011a6504abca99a6154335055eac414a300b424d81dbb3752c9bd9f7f177c", + "docs/measurements/h264-rounds/profile/table.r0.txt": "7b37e7ceeb945f43efc2f7599a6e2993debab56e0e2d2762a022daa8a9347601", + "docs/measurements/h264-rounds/profile/table.r1.txt": "daab31c945a7fad6fe7a1e6d5b7e13a0d6239e562acda68ec69cff7f4773bc36", + "docs/measurements/h264-rounds/profile/table.txt": "9181bd8c6968899ea71263a681675076034158a0af328ebf1ccb53939d5593fd", + "docs/measurements/h264-rounds/publish-wake/README.md": "8a0c15039b9a6bca2201e9ec63499c0801b4d1bd41dcde1411fc325751261338", + "docs/measurements/h264-rounds/publish-wake/binaries.sha256": "2cba6e79b24476bbb2031b9871e29cde1d79ab39c350621f4497ca2e9f829981", + "docs/measurements/h264-rounds/publish-wake/fix-checks/binaries.sha256": "2465535e2137ac05d7ec5cf04324c13f1a6fbc92abb3c3d8796e063ef6f606ed", + "docs/measurements/h264-rounds/publish-wake/fix-checks/conformance.txt": "2287bced8f0b1d32a2368e312f7529e8b64cbe7ad625f45cbaf5732d5e240c27", + "docs/measurements/h264-rounds/publish-wake/fix-checks/identity.txt": "aed0ae22c8d6551abd496d4b63e2e1b8d1860dbb80f25c84ea62cc8be9bb80ae", + "docs/measurements/h264-rounds/publish-wake/fix-checks/stress.txt": "568c5bd01a841d71b0c336417cde0d97011ae4cba81d2748448170149315fd7b", + "docs/measurements/h264-rounds/publish-wake/identity-probe.txt": "aed0ae22c8d6551abd496d4b63e2e1b8d1860dbb80f25c84ea62cc8be9bb80ae", + "docs/measurements/h264-rounds/publish-wake/null.py": "10705aa97c005a0cacd3a9216e9b875115ebf8dd837464118cb5b813f63be835", + "docs/measurements/h264-rounds/publish-wake/plan-probe.md": "47440512c75068a72e346627b514da68830047b0cb0d3888357110033ec6a2dd", + "docs/measurements/h264-rounds/publish-wake/pw-run1/host.txt": "e52c314c9b75b18e6803a0d08007e416b156dfc55479eb672d277a153ea55ec9", + "docs/measurements/h264-rounds/publish-wake/pw-run1/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/publish-wake/pw-run1/job.sh": "4649dbbff765cc07887f6f2e5830d9634a4898420f6838f018dc780c6a2f20f2", + "docs/measurements/h264-rounds/publish-wake/pw-run1/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/publish-wake/pw-run1/null.txt": "57c816529eef596a54d5ee97d7e5cf326c8b8a4c01d378449af4c54d2f65713d", + "docs/measurements/h264-rounds/publish-wake/pw-run1/progress.txt": "05e886329e2eb20207d2918713d45cf1cd4c29282e1c2bb18c22da87ff9a2406", + "docs/measurements/h264-rounds/publish-wake/pw-run1/pw-summary.txt": "2747988c207c5c3d91a99683ef361794faf7cc6ef926c40c4d34d66f3f966342", + "docs/measurements/h264-rounds/publish-wake/pw-run1/ref.json": "60f40b9e2495d6a6328bf05ab99d357e2257570290c8f7b8728ebb6d4a62ac3a", + "docs/measurements/h264-rounds/publish-wake/pw-run1/t8.1080p.json": "40aab01abd49de9e30588a2ad17a1d98327bcdb0bc9463cae45abb386b4c5928", + "docs/measurements/h264-rounds/publish-wake/pw-run1/t8.1080p.log": "48a7c43b31c876f583724082d0deb3ed901726c51d2ef852ac64d58597363d75", + "docs/measurements/h264-rounds/publish-wake/pw-run1/t8.4k.json": "61d9e8cc1d2422b969ecb2fefadec00d43b2b233c9df761cf73a8d58ee9424ea", + "docs/measurements/h264-rounds/publish-wake/pw-run1/t8.4k.log": "8cf2e4136e5c707ac59dc6db00bc08874ac66ecb3f721c0819543c486bad1b32", + "docs/measurements/h264-rounds/publish-wake/pw-run1/t8.720p.json": "a9c70b09d6756939bc28791d4e9526553b949476d6bb4cd4e6cdb8170a5be3fb", + "docs/measurements/h264-rounds/publish-wake/pw-run1/t8.720p.log": "15f5c69b4bd9f1457205c987f633f3bb3a423239f8eba1a6175dee012867e5e6", + "docs/measurements/h264-rounds/publish-wake/pw-run1/t8.sd.json": "0591dfb28042600043c08706deef208164cec940c745a1ab5d8b314ae64d820c", + "docs/measurements/h264-rounds/publish-wake/pw-run1/t8.sd.log": "e5bc32317156a15c3cb7990011d8ce6fe0ad39e3b1750bfde555292681b8ae7e", + "docs/measurements/h264-rounds/publish-wake/pw-run1/verdict.json": "3813e839f75c3bedcea94990f50cd1f9ec7482acc3aa3fa6037a94a3d2d8d4fe", + "docs/measurements/h264-rounds/publish-wake/pw.py": "c8d86781010efb46680b2dc99220b33011d64a6c3427d968993b542ed57f9634", + "docs/measurements/h264-rounds/recon-probe/ab1sum.py": "7254eb53992d91e148db99429d31b0a851f8cf711a3c7b2a0e2a486c56120981", + "docs/measurements/h264-rounds/recon-probe/ab3.py": "4825e622c660bbb3c3f78ef04cc828935cb816ca973a3e952a26c6aa549ccc60", + "docs/measurements/h264-rounds/recon-probe/apply-asm.txt": "4b8b2686da2b9b6d7bb6b7959ec0c3d17f87146acfa423c3753c7671c1c5d69d", + "docs/measurements/h264-rounds/recon-probe/bound.jsonl": "30c98571a60b5b47e9729e36f285176f3e8e7b4ffd754f4ca5cbf9dfec426db7", + "docs/measurements/h264-rounds/recon-probe/bound.txt": "7302773bbe7bf61b20fc4303b9682933e4a3eb5530b8bcc03092c240864fda25", + "docs/measurements/h264-rounds/recon-probe/cg-exploratory.py": "90f6b0eef5b5e80a285be50c8e68a883d04706d047ce334ad56ca3e8f85587d4", + "docs/measurements/h264-rounds/recon-probe/cg-exploratory.txt": "0e7c1e857f9a2edb734e6f8d863e87178115d125c9fc152851cfe1b000e01055", + "docs/measurements/h264-rounds/recon-probe/cg-lines.py": "229c3ecdd171d2875cde3799b0ad7b5a5ce0a1076c9b3491681092d20675ba4c", + "docs/measurements/h264-rounds/recon-probe/cg.sh": "a5b77d70a23bc8ae8389ebaa9e8cd4506efc0ee91f404ed05511dbace34c5888", + "docs/measurements/h264-rounds/recon-probe/conformance.txt": "6cf525d684acd511a34d822dd52a9616a4dc22910e7f49fe0bc68c0272e2452f", + "docs/measurements/h264-rounds/recon-probe/ic.sh": "17159db7ac4ef463a86205073c10d26cfbc62ee6aa3c5931e45d803251d6bd3e", + "docs/measurements/h264-rounds/recon-probe/ident.sh": "7ef44e1a9f089538fa5c33a187e6f0d208a6be4166fd4d29e366808f9160bad0", + "docs/measurements/h264-rounds/recon-probe/identity.txt": "3375a5afb0d8a9ba85c092562689b32c50ad8936abfca154e905445690466011", + "docs/measurements/h264-rounds/recon-probe/instr.py": "bf77c13d5d7fd9ac5061c45bb6daf7552c3efa1dfec73ec4567ffa523cf60fb4", + "docs/measurements/h264-rounds/recon-probe/instr.txt": "67a2472febffe30163c33ff63469ca68a86a91c70bd397c84a9739af97d49155", + "docs/measurements/h264-rounds/recon-probe/instructions.txt": "ca7063d71d85ad68d06afaf613c8db2f16f04ff523297e599440a7499e5a78d8", + "docs/measurements/h264-rounds/recon-probe/local-ab/README.txt": "1acafb022b2b9869d26e5967f58f0fa55e7c155c490c8e9b630ce5ba668308bf", + "docs/measurements/h264-rounds/recon-probe/local-ab/ab1.txt": "b555805ae67e8718cdcc23a3d9f671280ea1bf9cc0b15043e3f343d9ad1be67f", + "docs/measurements/h264-rounds/recon-probe/local-ab/ab1sum.txt": "9d4dfd2b2354a4cd47ecb59330346e65970bc225ed74618c5d961eb581de3477", + "docs/measurements/h264-rounds/recon-probe/perf.sh": "e2061ac046032b78323cd5e5cfe9771ca9d54092652e38687be63f3d68245cc5", + "docs/measurements/h264-rounds/recon-probe/plan.txt": "2c103ac97b275762ecb9dc96dc0159b04b0ea0d59cf31cbdb007b147f696069c", + "docs/measurements/h264-rounds/recon-probe/rb.py": "149595748cddab005e6913c303607ce9367a36a39918b0f6e26364bf7f310a79", + "docs/measurements/h264-rounds/recon-probe/table.py": "f6cf0d009b1ce1a80319ba767ba24590781e5c092d12331897926f43e87f6014", + "docs/measurements/h264-rounds/rejected-luma-fullsample.json": "5b11657ae96b54aaa35d5403cc64f092ec21e5cc7e336d44da66da08de014343", + "docs/measurements/h264-rounds/request/README.md": "4616485df9fb3d7fec42fc32ed5cd9ce82fd4c0f56a9c037afcb8b8e62e19d18", + "docs/measurements/h264-rounds/request/an2.py": "f549295ba9396956d2b2e6169d16363e330e2de23bc83c3d5894aa4b61c139e7", + "docs/measurements/h264-rounds/request/profile-4k.txt": "dbc32770cba217ab070c3c2f7281efb67a8e2666309964a7ee4f2d3c89124c3d", + "docs/measurements/h264-rounds/request/screen1.jsonl": "80b115c40c39f69856af6222e3ef8da00231f92057f0e061f4844a14db2603f9", + "docs/measurements/h264-rounds/request/screen1.txt": "763070547df351b453a5d5fb7b40fbf2003eb641b4f3b5b97e3d1f0a2cf40202", + "docs/measurements/h264-rounds/request/screen2.jsonl": "dc1fdabdd71822416a89fc256e23ce2fb8c3e2656692dbf0e31cffd77e32cf04", + "docs/measurements/h264-rounds/request/screen2.txt": "7af612515e90417ee97ae7af3ad9b208b3d631ad421a5915a63e6899301e1b90", + "docs/measurements/h264-rounds/request/screen3.jsonl": "c8ce6cbd622006ee90e42ce2182e297fc2caedb5649d977bb224adff3da1ee96", + "docs/measurements/h264-rounds/request/screen3.txt": "a7c659e39153d05b89a0887a54bce243a7e85b76090a41b55e016d49c1481f33", + "docs/measurements/h264-rounds/residual-calls/README.md": "2a3c87212f312c3208eba9dcfb183a2766cf9a9a01b27db61fe2e10ece76a119", + "docs/measurements/h264-rounds/residual-calls/ab-k-summary.txt": "d3f25fadba661c6699046dec5de54a5573aaf289ecef447808cd25ae63793b51", + "docs/measurements/h264-rounds/residual-calls/ab-k.txt": "563d20bab825ccbe8b1ffc37afb5a3d209892cc71f0e958923cd1679e062ce9b", + "docs/measurements/h264-rounds/residual-calls/ab-probe-summary.txt": "85215495ee6b17630245406b0cf8d7905afca6a4b6f63f44a455569e828dfd7a", + "docs/measurements/h264-rounds/residual-calls/ab-probe.txt": "9ab1f275c520b2540f40e74ab30d9a05f0d32e68b8f0fcd4c3b444bdf45cd05b", + "docs/measurements/h264-rounds/residual-calls/ab3.py": "8f0abb2a95718ed2ff5f6ada28f9cd811315bfdf9dda3d81cde00e9ed8678ab9", + "docs/measurements/h264-rounds/residual-calls/abcls.py": "c37aa727c3bef34b695340c15fa69634ba956674323108ce942dcbc22e9b1b79", + "docs/measurements/h264-rounds/residual-calls/cg32.sh": "98065fb6d5ac8c249a9dabc0289083651a0e14c75a675941431abdca087f878e", + "docs/measurements/h264-rounds/residual-calls/dispatch-lines-base.txt": "cad1fdda351f9d0cdac92c4f7f0ac185d76cbd0054f782a2f3b706afc3cab1fd", + "docs/measurements/h264-rounds/residual-calls/dispatch-lines-k.txt": "bc382360c235d994f943491865ee29feef57c183bfeba821177a30083b3e9590", + "docs/measurements/h264-rounds/residual-calls/ident.sh": "ffa55e2455f4c709649e0a903a71665192509d271f0b235e3536df49bac4bc4d", + "docs/measurements/h264-rounds/residual-calls/identity-r4.txt": "6f580268170281286ee0785c0ef4c477918e03633faa7501aa71241cb972989a", + "docs/measurements/h264-rounds/residual-calls/instructions.txt": "1b4edf412500a4445a7756a04e460e6983f70a5fc145e7abe796eef1da345671", + "docs/measurements/h264-rounds/residual-calls/lines.py": "2b48eadd8ed74b421c1a5ec5276384c4d1e3bc8d159a8f3db49845344a2e88e2", + "docs/measurements/h264-rounds/residual-calls/plan.txt": "df9fba0064f14097cb61e5cbada0294c3d725ee6067f6b8af9e1451b07fa8643", + "docs/measurements/h264-rounds/residual-calls/probe-pad.diff": "a093eb3731ab4a5336073abefb2c67135fd76635f202d53391ef4666695fb99f", + "docs/measurements/h264-rounds/residual-dispatch/gating/README.md": "27a43ded8f295e86e1ed3c59a1112175c9b49b4041f1a3d8e25cf3793c660ab5", + "docs/measurements/h264-rounds/residual-dispatch/gating/analysis.txt": "317720be2fd6bcf23abad5fee92efd27acdfe1ba39760a76b9aa7ed1719d038f", + "docs/measurements/h264-rounds/residual-dispatch/gating/analyze.py": "57ed98e282c8f0865d8f570424ad30553ca53d0616c9a56270dfe15d5ded60c2", + "docs/measurements/h264-rounds/residual-dispatch/gating/binaries.sha256": "5904ac542314962067d184e37a960b16d55a329b1871fb35b833ca1700dc84c8", + "docs/measurements/h264-rounds/residual-dispatch/gating/g.1080p.json": "04dd802658e47e7827c9b4fa89a1e0e8bf44bbcbd54cf6f9ef7b93818aa78efb", + "docs/measurements/h264-rounds/residual-dispatch/gating/g.1080p.json.void1": "a1805810cd68793908f73435d995bebe317d3d1bc1637baa1b7d74f4c259d0de", + "docs/measurements/h264-rounds/residual-dispatch/gating/g.1080p.log": "08937056cfb3bd0af160a8f254ad7501c3a9801cdf2971462bef7d72d463254a", + "docs/measurements/h264-rounds/residual-dispatch/gating/g.1080p.log.void1": "9f466d7c9d76cc0ea3f9b08e98b5b290af626761c5ab6ceedc1f02d9c733c0ac", + "docs/measurements/h264-rounds/residual-dispatch/gating/g.4k.json": "175b80dc7e9de96943c8245023893646f63c0a14d597c3327482e9c6c2e0b2db", + "docs/measurements/h264-rounds/residual-dispatch/gating/g.4k.log": "30fa436aa9be6d41437cc6224dbf41ab6de5297875e4b83de79c45843b75a714", + "docs/measurements/h264-rounds/residual-dispatch/gating/g.720p.json": "2625bc39f423ba1ba53b8c8d6babca9f29d812b38c4b89ed5c0dad805c62fdd3", + "docs/measurements/h264-rounds/residual-dispatch/gating/g.720p.log": "25a6bac42ad4d6aff74dfc78985acda13587dd52be3ae4f956d69687ac05d680", + "docs/measurements/h264-rounds/residual-dispatch/gating/g.sd.json": "285dbcfe43b5ecdf77aa64cd7c7217c9869c4a17631bd0cb9cee2f9719fb3d53", + "docs/measurements/h264-rounds/residual-dispatch/gating/g.sd.log": "182c7774a6d909b6189ccf03f5bdfdfb8f52b8e2c2a775d6a7a1f5ab761a16e1", + "docs/measurements/h264-rounds/residual-dispatch/gating/h.1080p.json": "ba1adec8aa2a7dee1ab05572d2097a459e2afd3d045497efb7af1fc04de815c6", + "docs/measurements/h264-rounds/residual-dispatch/gating/h.1080p.log": "1c2cce3f16f7fa391098a8fe088396b5fe7543cb980e1883079259097bb34b92", + "docs/measurements/h264-rounds/residual-dispatch/gating/h.4k.json": "f29e83c8afc8d18a66a343e8d614efa7561feb73e5f91e3ace20a7e96cf74abd", + "docs/measurements/h264-rounds/residual-dispatch/gating/h.4k.log": "3d7fdc83df1b6a474342da2406eef3d6724eebb268deeea584e322fac6adb721", + "docs/measurements/h264-rounds/residual-dispatch/gating/h.720p.json": "1c16c79d2603d12f0c5a181426a7b10b8232e01a6a512a9cf9909acccab97af0", + "docs/measurements/h264-rounds/residual-dispatch/gating/h.720p.log": "96c16068e78c994fc55159cc4abf2f84b0ce4ab917acc80feb73b0f1733cd890", + "docs/measurements/h264-rounds/residual-dispatch/gating/h.sd.json": "68b49f392cf7c78955e6fcd7ac44ec5e29ec6868e99af408484af729e0a12ac0", + "docs/measurements/h264-rounds/residual-dispatch/gating/h.sd.log": "af30c8cce4ea3f60163697942bbc5fd6f1224bba5d2565513e44ebc19985c3ed", + "docs/measurements/h264-rounds/residual-dispatch/gating/h264_parity_acf3ee2f.py": "66495d433e8e7454ae8844e2c0ea6d18f269cb296bd2b48acecc81a680c43923", + "docs/measurements/h264-rounds/residual-dispatch/gating/hostgate.log": "032e5580c09ca941496f08cafe9c607305575bf2ac18a15aeff4ee9b13c251dd", + "docs/measurements/h264-rounds/residual-dispatch/gating/identity.txt": "859e17e5923e2e0719c658ccf405c14f23201e19d3ef6d21d2226c9b93edf8b3", + "docs/measurements/h264-rounds/residual-dispatch/gating/progress.txt": "0f85e229acbd62158768218684434dfd6dec22e6b148ffb6654bd9b23327c22f", + "docs/measurements/h264-rounds/residual-dispatch/gating/provenance.txt": "18f9b9c6e636910d3365b8bcb10b634d348bee8ed31f743672049ce684d0284c", + "docs/measurements/h264-rounds/residual-dispatch/gating/run-ab-helper.sh": "daf3283a3d61bb02749090b9b695cb08889d5b17e7514aea2629c4bc2d651c7b", + "docs/measurements/h264-rounds/residual-dispatch/gating/summary.json": "e288e0a02b3dc025a7b9d0f19101e9d8583f4ca6f26a0ffd4d4675c612275bab", + "docs/measurements/h264-rounds/residual-dispatch/gating/t8.1080p.json": "6fcb5e301e7181b693d9a2771534cfde3956733c22f581d06567def51496824f", + "docs/measurements/h264-rounds/residual-dispatch/gating/t8.1080p.log": "278684c94a46b88e4fc7bc16ffedf843016406e594f4621052e82730a0371e8d", + "docs/measurements/h264-rounds/residual-dispatch/gating/t8.4k.json": "d52f0f9479de318d0b7418d2467ebf4fb9237cd879af2605c983ca98dfcb4fc2", + "docs/measurements/h264-rounds/residual-dispatch/gating/t8.4k.log": "f425ea09f7ccd8b970ea7ebafe227cfdecdea6cba037cc0a75b0f5b28f546d77", + "docs/measurements/h264-rounds/residual-dispatch/gating/t8.720p.json": "68c6141a1d5db11fb9f4927ce58dcca12d24f93c4dfbd13155d5963f01d384a1", + "docs/measurements/h264-rounds/residual-dispatch/gating/t8.720p.log": "c472a623e6f3b18d1c4805778c2934d56cf190a4e068f222b420ee7379d1dd76", + "docs/measurements/h264-rounds/residual-dispatch/gating/t8.sd.json": "cf0dbb80eab950baee1ccea8268390a410532e94a1f863c43a3f6cc108ff6f52", + "docs/measurements/h264-rounds/residual-dispatch/gating/t8.sd.log": "157b8490ca85901858e775e13d44ef75441839b998d54f449417a0e962791ffc", + "docs/measurements/h264-rounds/retire-any/README.md": "7d5333b8a0566dd0be279ecf2bd25507c480ee1a95fb454eaa24333f0bc03000", + "docs/measurements/h264-rounds/retire-any/analyze.py": "0c502b55f7b057dd321007bae28a2de599b6c8e9edc5c9b76c54015fe03f614c", + "docs/measurements/h264-rounds/retire-any/gating/README.md": "10dbef3f9e9126f9a732466123ec8a7a737343ec6c6e22ff59dd8096c6867bf4", + "docs/measurements/h264-rounds/retire-any/gating/analysis.txt": "63d66ee861694894ffe2c7252fa34f2ede1d04a253a1da37e902a58d8d4ffc63", + "docs/measurements/h264-rounds/retire-any/gating/analyze.py": "0c502b55f7b057dd321007bae28a2de599b6c8e9edc5c9b76c54015fe03f614c", + "docs/measurements/h264-rounds/retire-any/gating/binaries.sha256": "e60605600a0e270b64a5c414ee5167ef5dc612d21b51060ecfd9a11ff1616aba", + "docs/measurements/h264-rounds/retire-any/gating/cpu.txt": "9e1592a3439afeb74ef13a6306b9b38cdd803d36e3c4eb239405c8bd2e548f10", + "docs/measurements/h264-rounds/retire-any/gating/cpu8.1080p.json": "087a73756b0dde3e3adbeefab62fa8a1c36e6270990ac5ba0913c45001b0c892", + "docs/measurements/h264-rounds/retire-any/gating/cpu8.1080p.txt": "ae23b243138e5fc00e803b825d5f33f15f548b57dd177f4795ee0ef6cdd03383", + "docs/measurements/h264-rounds/retire-any/gating/cpu8.4k.json": "394e86095704d425cda5c51e8adac256b1018ce14bd07b5b556b9426a2d44e99", + "docs/measurements/h264-rounds/retire-any/gating/cpu8.4k.txt": "ca3e99c8481a897cacfb0f70b9ca917055b4f98ffffeb3093e5223108cabd4d1", + "docs/measurements/h264-rounds/retire-any/gating/cpu8.720p.json": "e536aaaa99395283a2f8337e5d2e48412de53d4db861f996b1b0cd75f5e4fe78", + "docs/measurements/h264-rounds/retire-any/gating/cpu8.720p.txt": "5ab5555a9a4ed6a5f5463663ab877c8cd95bd7e1dda5e9f5e9f79478b334c3f0", + "docs/measurements/h264-rounds/retire-any/gating/cpu8.py": "a728aa9cc1cb0744f05bdd3021dddcbc7a8e26928802f533c5da4dda7cdb947d", + "docs/measurements/h264-rounds/retire-any/gating/cpu8.sd.json": "72a8fe6bc56be5b408e55f313ac811303ba4f50282b35fddd8ac8805f8d058e2", + "docs/measurements/h264-rounds/retire-any/gating/cpu8.sd.txt": "54dc82992213d7f7aae74c4850fe12b8fa0e76bb81950da0eca090fc67ed794f", + "docs/measurements/h264-rounds/retire-any/gating/identity.txt": "e9d8c9e4e0cd42cc6747816d0ebfc0f03b07ccae807154c24d47c1b186bcaae4", + "docs/measurements/h264-rounds/retire-any/gating/log.txt": "8eff59f8903eb53dc304b4217bb078538ac33981996d899d77a66d035ea487a0", + "docs/measurements/h264-rounds/retire-any/gating/p.1080p.json": "7896a30fdfab239534e0ca8a36039edcdd91f5784e24d7eb8b2297df13c4f6ee", + "docs/measurements/h264-rounds/retire-any/gating/p.1080p.log": "15ebe3bd6288484b7fb908d6e5d01217def93b8bf24d6f6038aa42e43a8136a6", + "docs/measurements/h264-rounds/retire-any/gating/p.4k.json": "17d6d3f3a32cade4ab8eb3c2d18989e80021142a3cb6dbd99f595b0b7fe20742", + "docs/measurements/h264-rounds/retire-any/gating/p.4k.log": "a509c83b08e13b74e04d677255775ae0440213f1d0c938a2d849ce53207695ec", + "docs/measurements/h264-rounds/retire-any/gating/p.720p.json": "bb21fdf73669d8441293ca0600896c54e2494786b8c5d08d2ea988084487255c", + "docs/measurements/h264-rounds/retire-any/gating/p.720p.log": "48cbc0635d0c16d4b2d0516a06d85f51d9c50c266b7f6a1cbf970019d553e592", + "docs/measurements/h264-rounds/retire-any/gating/p.sd.json": "8cb28c3ff1bb9ecdcf3335afe3c8539f158d8c40c023c1fbbe020f0c3c83b21c", + "docs/measurements/h264-rounds/retire-any/gating/p.sd.log": "7d161c05fa31655ad27cf3ea7841a224468d2ff683cdb5e275437e7b0ff1d7bf", + "docs/measurements/h264-rounds/retire-any/gating/reference.json": "48db5be29be47fd3f7fa9938dfb917e340c27cfd6d810dee9c75dbae79df32cf", + "docs/measurements/h264-rounds/retire-any/gating/summary.json": "c71b9af869e9606bfa6585fec241b422ec1d4f4a95eadea70c28d5f9bd7c8142", + "docs/measurements/h264-rounds/retire-any/gating/t.1080p.json": "b6d7745efc8c9839b466bc953ce88b5537423c28a5cf78fc7f034917099c35e7", + "docs/measurements/h264-rounds/retire-any/gating/t.1080p.log": "6dc499c973eafabb53519f2cfd01370f6801fa4fadcaad50a02fd8503dcb5a3b", + "docs/measurements/h264-rounds/retire-any/gating/t.4k.json": "d659598fc3a8f9bc446bbdf36c717c33118daf48b7cc701661aea838b23e8091", + "docs/measurements/h264-rounds/retire-any/gating/t.4k.log": "6e0a2426c398ef0c954c0c8246222e178d6c4872a34e16f2633fb09732d6e750", + "docs/measurements/h264-rounds/retire-any/gating/t.720p.json": "270bd581497ddb94e6a0ffce4b5962c7ef986839d031b3c21386b9e7a26e6794", + "docs/measurements/h264-rounds/retire-any/gating/t.720p.log": "6efb095b1fea93721a91a882621bde9970d2691d2cd152503c18d8a30f5c4b63", + "docs/measurements/h264-rounds/retire-any/gating/t.sd.json": "9786d0e182714abc7c463a3fca6498c6098fd94bbd8e9364fd68488d68e4757e", + "docs/measurements/h264-rounds/retire-any/gating/t.sd.log": "f2068b7b2f394458bae397185eebde28e260635c1e0723bb05238502ed0e0f2a", + "docs/measurements/h264-rounds/retire-any/local/r5.txt": "e6a4d84f9b253bdb9f21c7776ffcd1391c57badec124690ae250cf54dd03f4a3", + "docs/measurements/h264-rounds/round10/analyze.py": "b659afe5d61909d6161b412285415fd6100c36f0408ff863ca02fba34a4215a3", + "docs/measurements/h264-rounds/round10/conformance.txt": "0c7a6d4cac51ce9a98b6fc38be9d1af0fee46793dbad76565286e05ddcc27abf", + "docs/measurements/h264-rounds/round10/g.1080p.json": "5e726d82df796bc0b013be24e369b2414d8bd01c0c78d76f005d9213d154d7a4", + "docs/measurements/h264-rounds/round10/g.1080p.log": "d1ea2b8f25833a3480b52df936b2c6f3ddf82598ca919a024c227c05eb234bee", + "docs/measurements/h264-rounds/round10/g.4k.json": "da6db8b3a64b20c4a6d6bee9ead4895878d103d5bdc9c370f816d0eae6a3fa5f", + "docs/measurements/h264-rounds/round10/g.4k.log": "a7a964cd7983eb34e018bd424dc302aba8b51ed9d421e2f66b3c4557ec212f47", + "docs/measurements/h264-rounds/round10/g.720p.json": "468de25c289102453ec6e2897bdc2d96b8a62673ee0028e3513de0a09d4cd583", + "docs/measurements/h264-rounds/round10/g.720p.log": "43980ff061220dc64b15f341e646016711b384580225ca62183a5ba71ffecdbf", + "docs/measurements/h264-rounds/round10/g.sd.json": "aecf0aee414440285e7e810e032dbacb643e5d62756b6fd119e2aa83de0cf404", + "docs/measurements/h264-rounds/round10/g.sd.log": "689046efd844e54fa62d206bdb913f0f039090aa406d2d5aad6d86e1cee0c20c", + "docs/measurements/h264-rounds/round10/g.summary.json": "a40bc8f124cc90db70b04dc9d16957c4ed3f51d27a8648259e46226e6576c630", + "docs/measurements/h264-rounds/round10/identity.txt": "32d1483f26447a9f5cad6345dce752f7ea01b56838577a00164a51adb5235d3b", + "docs/measurements/h264-rounds/round10/provenance.txt": "2600ddf15299ea2ebdf611d078f9daf084611af2e6f40853419b6b4726333ce8", + "docs/measurements/h264-rounds/round10/run.sh": "7c297604823bfc9724012acfb919a1c34e25363a16b67ef261366059a1968fb3", + "docs/measurements/h264-rounds/round11/analysis.txt": "4d696228b0895e0280d6eb5415d4829343ff1907040d863f19badcfca3b26e03", + "docs/measurements/h264-rounds/round11/analyze.py": "0d5d1096f9b610ed8f0fde49d95296ac4f1b7bc1f9eaba965316ffdf86de7a4a", + "docs/measurements/h264-rounds/round11/evidence.txt": "2eee0b63d4b55eba54823672c4eabcd5a0adc6bc5691045ad2764250a82063ae", + "docs/measurements/h264-rounds/round11/g.1080p.json": "29650cbc9c6d6103f46b82817e3f339ce8e9f90dda1301307317052bdd2709d0", + "docs/measurements/h264-rounds/round11/g.1080p.killed-by-restart.log": "78dcfe83edc61c6ae669ca7fc14074406c90742afff351c605e45da7d95fbf81", + "docs/measurements/h264-rounds/round11/g.1080p.log": "5c1e95802deaae10760cb8fa5643cf71b39e5dcd9fb63a222bb20d598ae81dae", + "docs/measurements/h264-rounds/round11/g.4k.json": "ab5c1ca47c9a8e2eb2971d76b2335f692cf5b19496ac05b2b8970f2f70447968", + "docs/measurements/h264-rounds/round11/g.4k.log": "1915622ff0d045ad2c4c3bcf9b58b76251677c85b30de21e9aa680e9ca77cc98", + "docs/measurements/h264-rounds/round11/g.720p.json": "7414e4c1ea2106cdaa0f1a9e44b9dce717be5564a3018ccf80e87c87e420f5f9", + "docs/measurements/h264-rounds/round11/g.720p.log": "907f76cb1d8ec3657807d164489a204fd8802cd4325f7ef1ad530fc2c2925cb8", + "docs/measurements/h264-rounds/round11/g.sd.json": "c4113197cb7234788fb02c5b6ec4fcc5c611942496db82bdf824b99a67f4f55e", + "docs/measurements/h264-rounds/round11/g.sd.log": "f1bfbb4185c791e30736f44de59e916086cbc37dfc816aacb1e9584ddbeb6498", + "docs/measurements/h264-rounds/round11/g.summary.json": "d253ae9335a864aef028dc80715e174c0b4df875405a6e9858559fa9be8d9a2c", + "docs/measurements/h264-rounds/round11/identity.txt": "de90aaa563cfddf29640d8ad84a56e2b83c2f345d85371f928850768152c39e8", + "docs/measurements/h264-rounds/round11/local/README.txt": "8a0c57b5ad50037ac1d09609ba8e55e9a5d9bef711b2613f8a8faada7992572f", + "docs/measurements/h264-rounds/round11/local/f3.1080p.json": "382b6a1340cf73b6a27bf6ba52393c4ca2acb368c413bd213d37183234d57ac3", + "docs/measurements/h264-rounds/round11/local/f3.4k.json": "29b01c1269d9d9dae661b72522cb64c68b2ee2e07aec0cb4eabff2d3fc38daeb", + "docs/measurements/h264-rounds/round11/local/f3.720p.json": "34416310bc39bec4ef10ee7671fb027f86b129612bb4df3a0baa721b497e4627", + "docs/measurements/h264-rounds/round11/local/f3.sd.json": "7b5fe2aeaa797a0dcb618dddbcdbefba08fc77c01512031b5a68160d2cae3a5b", + "docs/measurements/h264-rounds/round11/local/fact.py": "e4449987acd79d831c9b74fef2f5ef3e533d4c71f95abbce0f3ae275c4a830c4", + "docs/measurements/h264-rounds/round11/local/thr.1080p.json": "8bcedc8846989c96be8d2d081f43c7df83194e310cc917ee0f708b281d0a1727", + "docs/measurements/h264-rounds/round11/local/thr.4k.json": "4e385abe525360a4fd363cf7ee1ef42b03074ddec6c0cb16cf3994c5a008689c", + "docs/measurements/h264-rounds/round11/placement.txt": "4504610b09a803125ca2eb2b2c5fb21fe19a0615753c912c3e36df9ba82d783a", + "docs/measurements/h264-rounds/round11/profile-main.txt": "0c33608964b41a0e97b321841b797ea6dafbc1a4c23328889766661764a3405c", + "docs/measurements/h264-rounds/round11/provenance.txt": "28e66827781d82c996df925704ee50d0bffe55e979b7ce1d2b4ce798f1ebc03d", + "docs/measurements/h264-rounds/round11/run-ab-helper.sh": "808f25be10587ce9179e120f9830fb58e2a08d1378907f65a16e2907d0ee5625", + "docs/measurements/h264-rounds/round11/run-notes.txt": "73f3bfa222a2bcfad309d505c59613fa00664400ffdb09dddf67fb10f7775129", + "docs/measurements/h264-rounds/round11/run2-resume-after-restart.sh": "a7abdd39bdc61bf9e939c4d6e3387d345617e3df44907cb55aa373ea1cf87957", + "docs/measurements/h264-rounds/round12/analyze.py": "e218acf0e07acf9f5d6352da6d2de7c52a0a77f5eb66b6650da63fca10b4d6b9", + "docs/measurements/h264-rounds/round12/evidence.txt": "22531bef64474cf95d967c7831ae901dae7771739194979093e8fa2d1e419e80", + "docs/measurements/h264-rounds/round12/gating/analysis.txt": "584b5451749fefab32f347f528b71f7da4cecf8a9580503fd82afaca79436b5b", + "docs/measurements/h264-rounds/round12/gating/g.1080p.json": "381537552308c3448ae5239bfa5ceeed519acac1d165790b82782fe19c3e9603", + "docs/measurements/h264-rounds/round12/gating/g.1080p.log": "a6c46fef74c628389eb0201e0233419bc7a08d4a9ff9274320027938e9ae2ad0", + "docs/measurements/h264-rounds/round12/gating/g.4k.json": "fc00ac3a1802a72620d62cb7192e481a3b1cacfd616ac493e26b46ce48846666", + "docs/measurements/h264-rounds/round12/gating/g.4k.log": "80dad0ad68c5183e3e946dac28100c566629a3d97b1499c75030c6c33139d57a", + "docs/measurements/h264-rounds/round12/gating/g.720p.json": "5a1d7b2ee130d8a1f6695a8741a3cfeac69a401da50b6d61915a6219cba97d17", + "docs/measurements/h264-rounds/round12/gating/g.720p.log": "ac019f7c5c218ed426d0a690a7a12a032d6ae8276b3b318dc17a94693e7313aa", + "docs/measurements/h264-rounds/round12/gating/g.sd.json": "ec0cfea961f7365efab0b2b3aa5fd20c0d8ad329387cee61cf548ee1610f9f3b", + "docs/measurements/h264-rounds/round12/gating/g.sd.log": "481262bbe9eea3fe264859b8375efc8570d2427b928e132996625a9d4e30ad71", + "docs/measurements/h264-rounds/round12/gating/g.summary.json": "e1f70b62b4408950cbb1b6cf4efdb1ace2a9d2f4fbf1daf87bc67ddd06f1b842", + "docs/measurements/h264-rounds/round12/gating/identity.txt": "aa19652d562c22e3085c849063944eabfef97ba4701b8d3d444769007d89ec0f", + "docs/measurements/h264-rounds/round12/gating/provenance.txt": "0fed9c7f584921ed92877c35a8b45a9e3d08a06cb3d64bc6d260ea10ff09145b", + "docs/measurements/h264-rounds/round12/gating/run-ab-helper.sh": "ed3e1ce10f6d421cc41a2eaf39b74021125366c6dbde7c859ba8b58dc56b03e0", + "docs/measurements/h264-rounds/round12/local/README.txt": "e1cd6943d60c3ecb32371ae53b5b23626371719b3eddba50ec3f03ee782c07e1", + "docs/measurements/h264-rounds/round12/local/fact.py": "e4449987acd79d831c9b74fef2f5ef3e533d4c71f95abbce0f3ae275c4a830c4", + "docs/measurements/h264-rounds/round12/local/main.1080p.json": "d78ebde07273226ca79c85940715a420c572db6c1e3c46ce9a3598a830a0c039", + "docs/measurements/h264-rounds/round12/local/main.4k.json": "7e01e8a33de6107a06d661c25e7f698b162e3fad94f41c52b8c11a443cc50428", + "docs/measurements/h264-rounds/round12/local/main.720p.json": "ddfed7139e5e015bbdf61720b86c690b313e645ccf4282614c764a635f72367e", + "docs/measurements/h264-rounds/round12/local/main.sd.json": "5683bde403581d20271b6eb918b5f08ca9f519a08802a4039c59b847b1d2d3ba", + "docs/measurements/h264-rounds/round12/local/onr11.1080p.json": "b9203034b2d5960938c08862153248f4ed4318b42cc0c01db55bb3a838ca0cd5", + "docs/measurements/h264-rounds/round12/local/onr11.4k.json": "6a7202c447b5f4e1773a1ccb27d154df4b0ddd00ba2de9a4de0314156a457913", + "docs/measurements/h264-rounds/round12/local/onr11.720p.json": "826c16162c6fb30ec21144cbf10c064b3ecd5dab555f7b2de6b4ad378b2fd42f", + "docs/measurements/h264-rounds/round12/local/onr11.sd.json": "171f0f91fd7311d3ae03722aa995e6c5eb5331317fd6664d8703e6e6630ac1b8", + "docs/measurements/h264-rounds/round12/local/parts.1080p.json": "aa227fae261c597550d715dca17217be4c75162e49c08793f203f168fd9d6e37", + "docs/measurements/h264-rounds/round12/local/parts.4k.json": "bd3beb25843579258f305d5ef2e9541876aadc7b1831fe2f1faaef4379a88827", + "docs/measurements/h264-rounds/round12/local/parts.720p.json": "6574863d502c377e371c26c2203fa4d1301b427270ce09b5e3421212fe612098", + "docs/measurements/h264-rounds/round13/analyze.py": "61989905b0c36f4f3af618cd8a4b3d2837cf3b668035c5e817a9d3581561c61b", + "docs/measurements/h264-rounds/round13/conformance-scalar.txt": "c73b9407fc099e7338d02dbe81c939878a715cb759c54e253835977d6e78499a", + "docs/measurements/h264-rounds/round13/gating/README.md": "48d0e391e7ed596ce3f4f88c47249b7e9395354a5812b43f381b7b2659b41e27", + "docs/measurements/h264-rounds/round13/gating/analysis.txt": "39d6c1555cf92f8ca405bff49b01d5e8554e10b8881007af13d90f32cb8c06a2", + "docs/measurements/h264-rounds/round13/gating/analyze.py": "61989905b0c36f4f3af618cd8a4b3d2837cf3b668035c5e817a9d3581561c61b", + "docs/measurements/h264-rounds/round13/gating/binaries.sha256": "773547bcd77a78b12e11d2b13261f0b93897cd681c94b4f915caac3ba2e6ce43", + "docs/measurements/h264-rounds/round13/gating/cpu.txt": "1f4d3f82deb3eabae423d5d56236e8129866d6a09606f725f846c843ff491180", + "docs/measurements/h264-rounds/round13/gating/g.1080p.json": "751a445ecc60abd6ca818561c89fb876c06bb2cf32f03222eb107eb735c3f417", + "docs/measurements/h264-rounds/round13/gating/g.1080p.log": "47df0b1f196940403e6fefac8afcf6ef41837829ba1a97ebb8e7f57597e10d8d", + "docs/measurements/h264-rounds/round13/gating/g.4k.json": "42f9ede75c337e93c19b1e5afd056b0c6795837eaf23b25d6579507cac4b843b", + "docs/measurements/h264-rounds/round13/gating/g.4k.log": "0a17db5fdbaf7ca6327ad7b876fb80d03a5d2a3e7231fe042f050faefdbe678b", + "docs/measurements/h264-rounds/round13/gating/g.720p.json": "0d61d0f879972f9dc3654e8bf3f871ab76577d2e211c6f2c9c8b2112e22bf446", + "docs/measurements/h264-rounds/round13/gating/g.720p.log": "e1de00cf98ba698192c7032434d83892d79658c4dd43a0cda5706460cb5a39a0", + "docs/measurements/h264-rounds/round13/gating/g.sd.json": "46382a36dfbe185a30e9edb071911ec51b0616a02c74984762ec11b727bb03e9", + "docs/measurements/h264-rounds/round13/gating/g.sd.log": "1792b52c012120ef6cc652b49cb20a1cd0ca898f9fdbbc33794d6845d9ea230b", + "docs/measurements/h264-rounds/round13/gating/g.summary.json": "95088b1f47d1e72ce8d57aab8dfaa0b313a6a89ec4305f0f6be948f374e0da07", + "docs/measurements/h264-rounds/round13/gating/identity.txt": "afc498180582c719b51de3792ecb62a249b5a1aa26e832cc6f231da67c6d900b", + "docs/measurements/h264-rounds/round13/gating/log.txt": "af6320609f4a7e6be3bc4bc016697d632d9c0eefd1ce6062c9dbe9e727e37b8f", + "docs/measurements/h264-rounds/round13/gating/main-at-start.txt": "c959662037c75531c746bc2905349aaca5f990e0f7adbc3888abd7b41ae496c4", + "docs/measurements/h264-rounds/round13/gating/provenance-builds.txt": "c59e0996116987cb8c74e4cf3994e6ec0c2c66a4fd397cfad66a6a01e7eeb9ce", + "docs/measurements/h264-rounds/round13/gating/reference.json": "039eb80e96f012627d5b65bab4b33ca9c97ee1d6326323f4bb70daf177d0c21e", + "docs/measurements/h264-rounds/round13/gating/t8.1080p.json": "6f8dcb6a827c0860fb9b5ed7609ce14947606d34310a6352fe3c911ba29b4d8e", + "docs/measurements/h264-rounds/round13/gating/t8.1080p.log": "a85b28745815bc2535036100e4b2752ef1a12de42602feb0e4ecaec3e1abaa8e", + "docs/measurements/h264-rounds/round13/gating/t8.4k.json": "c253b2c56cc91ee59d6dccbb0efca16e10c06b1dbf6ab3258c4c731ee2db5e6c", + "docs/measurements/h264-rounds/round13/gating/t8.4k.log": "d74e70a17ddf3d345db30e5bd4dbeecbdb7969e7c39dcf08bbef784ca867cfc1", + "docs/measurements/h264-rounds/round13/gating/t8.720p.json": "b0396c82928f8d3315aa01bebc8ac42751d5e88ed6f47f07b881200f2b6f4364", + "docs/measurements/h264-rounds/round13/gating/t8.720p.log": "0cbdce4d31e84bc77a2e9bcf7e803225aeca228e329fb1f88bf35e7d944314f1", + "docs/measurements/h264-rounds/round13/gating/t8.sd.json": "215d9d60d36e64e23482e941c5e50a5cbbf8659110494da13298d908974704c9", + "docs/measurements/h264-rounds/round13/gating/t8.sd.log": "7b57dc407c51ed850de8d79bcc068b76cfa623d7661e56a4c98a9e6e5e42069b", + "docs/measurements/h264-rounds/round13/identity.txt": "032bd838d454771b0ef9ca1321fee2845353f11a37a0aace1e612bcd678da993", + "docs/measurements/h264-rounds/round13/local/README.txt": "7cc4af8fe9af183be3a7e4b0144702f1b045c7f928997afb05febf5afa8620bd", + "docs/measurements/h264-rounds/round13/local/analysis.txt": "e340766ee81bdeabab60682367e5ef8f870271b3d63837d09232ba3db16d6e8e", + "docs/measurements/h264-rounds/round13/local/r13loc.1080p.json": "c906eba86411e3046ffd14a3ee1a80d7add2b36945fd1120a11dd40e9295179a", + "docs/measurements/h264-rounds/round13/local/r13loc.4k.json": "8b85df733f98b60ca873af70c58cd75cdd9fcda054acaed3db1a0262bcf4cf8b", + "docs/measurements/h264-rounds/round13/local/r13loc.720p.json": "6065a6de84b685df24102eb4283baea730d163f839bf739117a27b584cedd1e6", + "docs/measurements/h264-rounds/round13/local/r13loc.sd.json": "69b1d9db783884fd7a4a4b90e2dff5affb8cb4da6b6ef03eb633ae3a22d176a2", + "docs/measurements/h264-rounds/round13/local/r13loc.summary.json": "62f7c9d75bd2466125e277024784a8bf8a269813d57f3f18a9e68ef1f6b5be90", + "docs/measurements/h264-rounds/round14/analyze.py": "44c841cb553e95fcab623e7ba333141850fc6ee786a866da7ea24aa11d4cc74e", + "docs/measurements/h264-rounds/round14/combine.txt": "73505badf0e72517730c1e3769d555ba3f162843e31ef14b3feac63bc15efbce", + "docs/measurements/h264-rounds/round14/conformance.txt": "130db374be092875de346dc3447f87f66d0ed5ca631c1e29c40c30921a3f0cac", + "docs/measurements/h264-rounds/round14/gating-1/README.md": "96990b96948aff1bc1c13200e5200487b31300179aac662328a5e57e3a96ec28", + "docs/measurements/h264-rounds/round14/gating-1/analysis.txt": "59722bf423e6dd4d81df8612e6c7514cf8576b2db1ae3afbe40cc72c8a4115bc", + "docs/measurements/h264-rounds/round14/gating-1/analyze.py": "44c841cb553e95fcab623e7ba333141850fc6ee786a866da7ea24aa11d4cc74e", + "docs/measurements/h264-rounds/round14/gating-1/binaries.sha256": "d4239734e75daa41f27cde40c8e4e253d7609783b068bab18b4d42f84ab797a0", + "docs/measurements/h264-rounds/round14/gating-1/cpu.txt": "1f4d3f82deb3eabae423d5d56236e8129866d6a09606f725f846c843ff491180", + "docs/measurements/h264-rounds/round14/gating-1/g.1080p.json": "78c47109c151a9d7424e14e619053708545c495c9077cf12c8abcf8c8713c56d", + "docs/measurements/h264-rounds/round14/gating-1/g.1080p.log": "a0d12e2daff81a1994096eda3893e28f00839203cb482d56c96369f6e1792a28", + "docs/measurements/h264-rounds/round14/gating-1/g.4k.json": "7da58d4c35f597a50b250537c2b3b7ad7212538302e70031f240832a6f5b13f2", + "docs/measurements/h264-rounds/round14/gating-1/g.4k.log": "4271e6a71341e698b084f9e69f93a59b6255cbdd6b70acca7b83f6057772cf82", + "docs/measurements/h264-rounds/round14/gating-1/g.720p.json": "614778431b1cd1b8361eac09a19aca1a27288558972b26698f10e6d85a27948a", + "docs/measurements/h264-rounds/round14/gating-1/g.720p.log": "0283e7e34536c9e531840987320d1dae19b7f1ab6e9ab5fdf8195703104b6809", + "docs/measurements/h264-rounds/round14/gating-1/g.sd.json": "b8fe9dd3d181ae62ed09e489999718669719144dd60d0f21f6ded71d3730a4fb", + "docs/measurements/h264-rounds/round14/gating-1/g.sd.log": "a24e5ca1e6e74753f818e08ff60911324e80f1bd809e89a607cee4ccb576fd18", + "docs/measurements/h264-rounds/round14/gating-1/g.summary.json": "d0db95b565861c57aaac5c07a9d71b82094b95ba16d7df01a5d408b941ca096a", + "docs/measurements/h264-rounds/round14/gating-1/identity.txt": "42a6a89c91e8a9e7c0624e66f1c266dfc8dcb99b7e82e9d4cc0e107c3b7b0921", + "docs/measurements/h264-rounds/round14/gating-1/log.txt": "bc3397dd3bfed2fc02dd83232b7aa93cc10c867574a2cb1ddd5d83b83c23222e", + "docs/measurements/h264-rounds/round14/gating-1/reference.json": "f92f7609ef211ad62316e987ea1d5a546256964971efe01ba553e836c418286a", + "docs/measurements/h264-rounds/round14/gating-2/README.md": "6d2dc8b6072e94d31c28b6f8b813e1325875e3ad700033b8be213cc4a4665767", + "docs/measurements/h264-rounds/round14/gating-2/analysis.txt": "20c06488cdaf29799af5e6522da27bdf7cd9af01b076764ce1516b98dd55c7c8", + "docs/measurements/h264-rounds/round14/gating-2/analyze.py": "44c841cb553e95fcab623e7ba333141850fc6ee786a866da7ea24aa11d4cc74e", + "docs/measurements/h264-rounds/round14/gating-2/attempt1-unstable.txt": "c6bcb6da208a010bfa2592cabe2b44a60e2024e2df6cba6506d075ea1585b98e", + "docs/measurements/h264-rounds/round14/gating-2/binaries.sha256": "fd47c3423d1a641af4988cd2e6c93aa7660686eea6bfa2c333480a13c35bfad9", + "docs/measurements/h264-rounds/round14/gating-2/cpu.txt": "b134a3c9284c5c994b2c7ea27f9959130b33ef4bfe643cee179525268c882aeb", + "docs/measurements/h264-rounds/round14/gating-2/g.1080p.json": "b09b09f57293e497db801b4992e5431f2bfe2a09894045af324df6eef7706912", + "docs/measurements/h264-rounds/round14/gating-2/g.1080p.log": "d262bcb88919b35f77a4ba176f77d2f8ac62c0957405f51d3c091b56329655b1", + "docs/measurements/h264-rounds/round14/gating-2/g.4k.json": "d9832f51756ace6340b2c778e897dde0b228f26db61bb57bd083c80cb54058fb", + "docs/measurements/h264-rounds/round14/gating-2/g.4k.log": "cadb1260ddbbe1c82a3a146386ffc559deaeb2ac9b2724b6fe20e22129ebd538", + "docs/measurements/h264-rounds/round14/gating-2/g.720p.json": "f35cbf875cb784792dbf7639aa150dcc2f3be0ad6cacc747c2154b4bb44af3e2", + "docs/measurements/h264-rounds/round14/gating-2/g.720p.log": "c7a7360970daf0b179d0e3ae6192ae2280050432e44e84be343e787acdb3d85c", + "docs/measurements/h264-rounds/round14/gating-2/g.sd.json": "ea609a4a903e068a2eb00aa163ad698f792fda47d47cebed476f0a67ff22788a", + "docs/measurements/h264-rounds/round14/gating-2/g.sd.log": "11069ad22e399002b0fe59ce9013e826b3cf098d287ac5475765c4e4128f949c", + "docs/measurements/h264-rounds/round14/gating-2/g.summary.json": "2f197d91e48b1306397ce6ba5d614af003e6d1ca5f8f77556df0730552ce7c6e", + "docs/measurements/h264-rounds/round14/gating-2/identity.txt": "42a6a89c91e8a9e7c0624e66f1c266dfc8dcb99b7e82e9d4cc0e107c3b7b0921", + "docs/measurements/h264-rounds/round14/gating-2/log.txt": "554ac46705d741af0837f64dd0831511e2a93bbb8b9157dea8b1021f2e1a7b17", + "docs/measurements/h264-rounds/round14/gating-2/reference.json": "29ead002515442a0e3ca91d42a471814d58dadcdde2fc687e225bf55dacb54d7", + "docs/measurements/h264-rounds/round14/identity.txt": "2a5fab21214cef5f725cffd3d89831db4430ac23909be4abf787ccc395cf9021", + "docs/measurements/h264-rounds/round14/instructions.txt": "f171439ed1182dbdc028b67b47a6397b535abc16a31f635ad8ffd908b993511a", + "docs/measurements/h264-rounds/round15/analyze.py": "2374074842340b5d412fbaeb8b6926ae1cbe7fa625ab96911c6dd22757e59f79", + "docs/measurements/h264-rounds/round15/conformance.txt": "a97db744cdef4ce43f38e487854bdde1255291e758205f7cac76ad010d9e7f76", + "docs/measurements/h264-rounds/round15/design-time/conformance.txt": "3916749a08c9eb66147f3f1c30b2a808b1c16071033e4eb1d61ed76fb026f985", + "docs/measurements/h264-rounds/round15/design-time/identity.txt": "47ae0ce6c4fdebd7abfd8c7f555c7afd8a6e92b7a1ef9c4325d5e6ee1e783e1f", + "docs/measurements/h264-rounds/round15/design-time/instructions.txt": "82c4f029db781063e385e6ac93a633742460c2b3f44a0bae3f6a92323f37c5c4", + "docs/measurements/h264-rounds/round15/design-time/per-macroblock.txt": "cec64993423af4ccf2c27b2bf2fa899c6d9fb7ff1f31d6e01b940be4ae1c8d24", + "docs/measurements/h264-rounds/round15/gating/README.md": "209979e091fef09cd29f0f257ab7fb654b657fc36d2a050b17156a0936753701", + "docs/measurements/h264-rounds/round15/gating/analysis.txt": "2e9f5b37469366aba608f8ef8e3b7c8850c185793360ebc5d7a36f6b037a9c5e", + "docs/measurements/h264-rounds/round15/gating/analyze.py": "2374074842340b5d412fbaeb8b6926ae1cbe7fa625ab96911c6dd22757e59f79", + "docs/measurements/h264-rounds/round15/gating/binaries.sha256": "3f52bda75044f7ea8f923a5ba7c50fc9c3d5d56f1acb2d68eabf589a32cb2f3c", + "docs/measurements/h264-rounds/round15/gating/cpu.txt": "cc53237758e3677dc5ec6336660721f1fc18d46f5a1f7082ffd87799c8a14992", + "docs/measurements/h264-rounds/round15/gating/g.1080p.json": "0225023ba8778d08ae466a36d49883ea35b615371094d7bd08c341138599ae13", + "docs/measurements/h264-rounds/round15/gating/g.1080p.log": "da7b1cac92ad71ec531a51b24976d5466877f6a406e4b5d28461e561964e0be1", + "docs/measurements/h264-rounds/round15/gating/g.4k.json": "45be3a26d35c79245a7017538998363882bc088771801c087e5d229a01013ce8", + "docs/measurements/h264-rounds/round15/gating/g.4k.log": "66a2e8d6a3ce78aee89fab1ca5d8494e78dd80fd2ea8a395a08710645fb2e2b4", + "docs/measurements/h264-rounds/round15/gating/g.720p.json": "c1077147622ff846ded44efd562f6c39a760f0908b22be489d94fbb5ea200e8f", + "docs/measurements/h264-rounds/round15/gating/g.720p.log": "e5ccbb3e3f962ce0fe8df4f55cbfdddca67387f1cfd59fa023f268c5130cf79f", + "docs/measurements/h264-rounds/round15/gating/g.sd.json": "71f75120d5deb5abc7d0807c4e6e19b5f5421e33d2ab7b98963d4c740e4f8024", + "docs/measurements/h264-rounds/round15/gating/g.sd.log": "82f5d34560f0f9d2f07c2fe269933039859c4de32415547da87f2e56754c3814", + "docs/measurements/h264-rounds/round15/gating/g.summary.json": "76bd0c6e3a018b4212cc29a57e3b355a0655e8dcaac50e7eb17fd82e848a18d5", + "docs/measurements/h264-rounds/round15/gating/identity.txt": "42a6a89c91e8a9e7c0624e66f1c266dfc8dcb99b7e82e9d4cc0e107c3b7b0921", + "docs/measurements/h264-rounds/round15/gating/log.txt": "879ca993936587402941dd1c83f356643bb9c7ff7bf8cccac96264d35ee1c382", + "docs/measurements/h264-rounds/round15/gating/reference.json": "d58ce3a5487db064918cb613f6f9f8bb68dd0d1a3e19aae94d27dc5c05b66195", + "docs/measurements/h264-rounds/round15/gating/t8.1080p.json": "e54a04d22fea5437eea49ff3550b7c9668577abd7d5e801559792ae300d30ad5", + "docs/measurements/h264-rounds/round15/gating/t8.1080p.log": "12bccd20a87838d52b0ac2738affbe5a6ad66ebd462cf2b2259031b3d8b1a422", + "docs/measurements/h264-rounds/round15/gating/t8.4k.json": "61a2339705cda2d9d9b2d7065bd96eb37d6b6156b53444807a568534167b1d79", + "docs/measurements/h264-rounds/round15/gating/t8.4k.log": "ba42c7ea072fc270a5fdc8025ebecb88a6eae26096d6b6b1b482935499951e5f", + "docs/measurements/h264-rounds/round15/gating/t8.720p.json": "c2afa7bba17145c2e23cb610648a7bb9326c9a70318a21d47dddbb90c109b8f1", + "docs/measurements/h264-rounds/round15/gating/t8.720p.log": "e69458fe03bcd558da03fa3b870c191bdfe02d79227169e5f0ca523a6f8b5100", + "docs/measurements/h264-rounds/round15/gating/t8.sd.json": "49d8981622c0f023337568374e2fbc6c44bfc6422c00248964dd3c8c06685d55", + "docs/measurements/h264-rounds/round15/gating/t8.sd.log": "bb85b1bc134a5d21d94cd588c3687b68b275fca5f773343f8135c032e30def2f", + "docs/measurements/h264-rounds/round15/identity.txt": "c019c042c7c5faa75f578e1dd9a2f76361cc64fac15c1631cb192441281c36d4", + "docs/measurements/h264-rounds/round15/instructions.txt": "23e23b38889038c9beb1621ce9cf04cc9dce6ccca4637d48593fbb3528366616", + "docs/measurements/h264-rounds/round16/analyze.py": "96a6f141a51726aa3b22cef2f8a2f063c19695564b2a4d69773b88a36c7b2ddf", + "docs/measurements/h264-rounds/round16/conformance.txt": "7c1066bd17cd1510bb6e8a442e51fcb5f99a0ce353fc2741cd419c24927ea1e4", + "docs/measurements/h264-rounds/round16/declines.txt": "dc000e7ff24e2c90a29da33ce31596aeeb717793fc06f68edd9942214f178903", + "docs/measurements/h264-rounds/round16/gating/README.md": "4e46b1d22c709f1c5396e3084839eeedc6d66cb2ddc279e2ccc03a5801b5e2de", + "docs/measurements/h264-rounds/round16/gating/analysis.txt": "6178b4354585d79505524e4e251ce888d580e1678a3eb662b05d6c2a7105f3f5", + "docs/measurements/h264-rounds/round16/gating/analyze.py": "96a6f141a51726aa3b22cef2f8a2f063c19695564b2a4d69773b88a36c7b2ddf", + "docs/measurements/h264-rounds/round16/gating/binaries.sha256": "2fda695da6424df9f0e1fa09422d19b8ca743742ed36e74f4913ea2404d0a9b9", + "docs/measurements/h264-rounds/round16/gating/cpu.txt": "9e1592a3439afeb74ef13a6306b9b38cdd803d36e3c4eb239405c8bd2e548f10", + "docs/measurements/h264-rounds/round16/gating/earlier-attempts.txt": "41529abd763717ea199a172f72ed66f8098bdee5c51b59dabcefdfb8f9284c6a", + "docs/measurements/h264-rounds/round16/gating/g.1080p.json": "2894fb0b4ba254f9173a24dd69d4a2a9a3b9d2ebc42a18935e28e134575be1e4", + "docs/measurements/h264-rounds/round16/gating/g.1080p.log": "aa730b2d3b967e424e62fa87935ede40169363d56461f662fb11e3e5bde71c09", + "docs/measurements/h264-rounds/round16/gating/g.4k.json": "7f38d0cd12b4a669b855017c6a12fdfba0c87c7f4850a608229fa3e6c2100cdb", + "docs/measurements/h264-rounds/round16/gating/g.4k.log": "933628717e1e7e75f62928b35cb2d06c9922b2f82aaac29506b925b3a3456fbb", + "docs/measurements/h264-rounds/round16/gating/g.720p.json": "69e30ef32e03e48e0528bb680bfcd90d29e02507bb5e9696084b26c2db9fd956", + "docs/measurements/h264-rounds/round16/gating/g.720p.log": "69faae9bb7e5bba16f9ae123ba886c97010bde525009a9c56835c101aeb157df", + "docs/measurements/h264-rounds/round16/gating/g.sd.json": "967f533809467e5b385951be05d3345a062f05911f09e316dd00b6627ead07b3", + "docs/measurements/h264-rounds/round16/gating/g.sd.log": "85cac3f4656ca706c9c03b3f33e96d89fb1f00f838455ecb33f515259a8df501", + "docs/measurements/h264-rounds/round16/gating/g.summary.json": "507f9b4e072e170b250f97fee94c2c12680c53df4d990fcc255c4f340b868299", + "docs/measurements/h264-rounds/round16/gating/identity.txt": "42a6a89c91e8a9e7c0624e66f1c266dfc8dcb99b7e82e9d4cc0e107c3b7b0921", + "docs/measurements/h264-rounds/round16/gating/log.txt": "e92b9c909dceb149a0c22a1edc80c4b2c1ea86e87b15ade3fc47cb4c0be4da1b", + "docs/measurements/h264-rounds/round16/gating/reference.json": "600ccec3119a2a9d2f243fb6d21cae2d43826d270121483e234ffdf7991faf11", + "docs/measurements/h264-rounds/round16/gating/t8.1080p.json": "1ddbfcf63362232a601783ba1103b5e52d897d38cbe2f15d11f84c44a9549f61", + "docs/measurements/h264-rounds/round16/gating/t8.1080p.log": "6590a398a4a99a413fa8656ce623e431592b42da7e84cf35dfe8741df596da09", + "docs/measurements/h264-rounds/round16/gating/t8.4k.json": "4a6e10de96a6e51e6c3d11f85105da9774aee17621ef6096cae0f3bb90efa5ac", + "docs/measurements/h264-rounds/round16/gating/t8.4k.log": "16b826a0203d86138f2a4779e8289fcc2415e2e3fd0ffd41253045dc8c1d0b17", + "docs/measurements/h264-rounds/round16/gating/t8.720p.json": "b7d278cb5ae5fb2c5696e5be7386b70e10b986b528f0700a95dd68e6429c37bf", + "docs/measurements/h264-rounds/round16/gating/t8.720p.log": "7af94d5b407a9fbbdecbef7c925edbf7d21b36501517cc8975dc37273c58455e", + "docs/measurements/h264-rounds/round16/gating/t8.sd.json": "55925c90783db1bece4b0bef08974e9ecae53ec8d74003dd8fca60921bf586f6", + "docs/measurements/h264-rounds/round16/gating/t8.sd.log": "6e9b412805ee3df9d5b0444dd665f6f37e8fad76612b478175cf037090417c5e", + "docs/measurements/h264-rounds/round16/identity.txt": "7c51e32647694912965f32abfbe088980fe6e697091c4ce41ddcb297c68204a3", + "docs/measurements/h264-rounds/round16/local/README.md": "a7cc13a4229882a827f604367dc1f2cbdd465bdbb840572ff8aaafe92fbf17c3", + "docs/measurements/h264-rounds/round16/local/ab-border-widths.txt": "37db3dc4e348969a5db77b4ce805c506035d8f3930ab044e7c650cc411716259", + "docs/measurements/h264-rounds/round16/local/ab-border.txt": "16a14959180feb8e978a45620d799e258491376483c3efdda387f12d5a839923", + "docs/measurements/h264-rounds/round16/local/ab-tight.txt": "2238103d62d6b37801eb953d8eb9012fad3aab2598eff6d9a3252e73751b4330", + "docs/measurements/h264-rounds/round16/local/ab-upper-bound.txt": "939add3ae3e7d076576063ca77ce8308e256c95ce650d10d3c6fdb8f31c43693", + "docs/measurements/h264-rounds/round16/local/ab.py": "ef1ad071f67c1806d15390e4d5de251dd6263a31a9489d92f345d26972f01f3e", + "docs/measurements/h264-rounds/round16/local/ab3.py": "2c8e903a993ab5d73a42fbbddc443b330b99b231eed30944b1d190035a47f758", + "docs/measurements/h264-rounds/round17/analyze.py": "b399f89de2d84b19a4c86255fb449362cb12cb4b01b391761a3b65b8eb186ce0", + "docs/measurements/h264-rounds/round17/conformance.txt": "bc2f39d6f8fb0fb8d9f173472c3e6ea4e01319de9c1d86dc800a608f0ea5c586", + "docs/measurements/h264-rounds/round17/gating/README.md": "b5096f519d3058ebec2847113e8b92ef70345e46c001412c8929c5496f904e85", + "docs/measurements/h264-rounds/round17/gating/analysis.txt": "2b2b1d4dc58f499d9bc7b1f85153bb39c08464bdf2da45dd2dbdfef6f192f21b", + "docs/measurements/h264-rounds/round17/gating/analyze.py": "b399f89de2d84b19a4c86255fb449362cb12cb4b01b391761a3b65b8eb186ce0", + "docs/measurements/h264-rounds/round17/gating/binaries.sha256": "3572386a6c075828fa38061b3c00f829e816851bbb4062d45fbfb9008b744f33", + "docs/measurements/h264-rounds/round17/gating/config.json": "59602dd71bf52b79bd98b2f330ac1d55f533dabf4af1ec56d2f4d9ceed9afa88", + "docs/measurements/h264-rounds/round17/gating/earlier-attempts.txt": "fe0562ef43b1437aeed63b21bbad64bbf951916439a40b2b9d91af55d91b89c6", + "docs/measurements/h264-rounds/round17/gating/events.json": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "docs/measurements/h264-rounds/round17/gating/g.1080p.json": "a258e48714c598216cfccfecea834b9373539c8adcd38932685118874e051342", + "docs/measurements/h264-rounds/round17/gating/g.1080p.log": "395810cb6f373754f686d462ed62f6098b7b6d6b732c8843c975cf4eaf09d875", + "docs/measurements/h264-rounds/round17/gating/g.4k.json": "a5b4352f338bedaf0db5caf1589776ed6d74d3f3ddf3eb31a0323f218478bb4c", + "docs/measurements/h264-rounds/round17/gating/g.4k.log": "05928a87e2098c964cb7d975e6e42bc02c80d263540339531f8bf00506399d11", + "docs/measurements/h264-rounds/round17/gating/g.720p.json": "4bd24af1a9dff1a7e82d1ded5f4fe5c1b5aeff61b838489fcb77fa1be380f1e5", + "docs/measurements/h264-rounds/round17/gating/g.720p.log": "eed078685a514210b2fbc814a870f034a33602379de137293530e0ba446a496c", + "docs/measurements/h264-rounds/round17/gating/g.sd.json": "0c5a97a2a25f48ed31353e3be334a129d7e74c6324dd4baddf2d7459af6141dd", + "docs/measurements/h264-rounds/round17/gating/g.sd.log": "ae99d355501afbd2822143e62c467bc254b1dd7bdae08b0c3a0058ae2bd0605a", + "docs/measurements/h264-rounds/round17/gating/identity.txt": "3980bdde6c8a232105cf508e121242d10b5582b01ed3f60e53dc880551d9a14b", + "docs/measurements/h264-rounds/round17/gating/log.txt": "f8e4bc38076b8a02ec7626b3b4c6dc8db64105693fbd9aa418aae7055f066981", + "docs/measurements/h264-rounds/round17/gating/t8.1080p.json": "3c07c6917467e1b1fd7cfcdaaa7943aeec98a50ead0a8b6c7cf2c284eb55bcd1", + "docs/measurements/h264-rounds/round17/gating/t8.1080p.log": "76674ddcc5b4b8f7f9a17e0274c6ce4d601dbf6da535a7c367b6d8252e8827a9", + "docs/measurements/h264-rounds/round17/gating/t8.4k.json": "6d0d94620cc7618c4388fd7efb0411e93d9b85c28de0682f5414563e59f9aca3", + "docs/measurements/h264-rounds/round17/gating/t8.4k.log": "2a10fdc2f8af2b4dd705383a51de0f09b132474b215178303669666d4976067b", + "docs/measurements/h264-rounds/round17/gating/t8.720p.json": "11eff331d779a0672452d7197ff74fab5d4b480a67f5414bf958b597c1f438f9", + "docs/measurements/h264-rounds/round17/gating/t8.720p.log": "ea1fdeaa5ac9cd05f5518b6471a2dbb21957cb3d67b9318ec111e51ebec6cc25", + "docs/measurements/h264-rounds/round17/gating/t8.sd.json": "40460b03033a1efd4b34cad3b5910fc8640cfb09f126df3880bf8b86e59d519b", + "docs/measurements/h264-rounds/round17/gating/t8.sd.log": "d23776500985f15788fc187629a7e4afdfc5b1e32957f6e6037247a108d72728", + "docs/measurements/h264-rounds/round17/gating/t8.summary.json": "2db141749469fdbb70f5bfd8a2562106357117aa6d769fbb16fbe3f25ce715af", + "docs/measurements/h264-rounds/round17/identity.txt": "2c9c7e27085a10696c5ad4d04e42f708a94acc571fe3d3fff67e6a116d83547f", + "docs/measurements/h264-rounds/round17/local/ab-1t.txt": "9cf599398a07d5cf4cae903105c9683ec944f00919a46c7cde3acb560e998883", + "docs/measurements/h264-rounds/round17/local/ab-8t-1.txt": "ea714a26ff38bb30229f8371c5c770c898a761e74cfe192309ad645d8cde2755", + "docs/measurements/h264-rounds/round17/local/ab-8t-2.txt": "bd869a90ad13d644ed4458c5f24b8771f936d18ec2334eb3c133c306859c30e1", + "docs/measurements/h264-rounds/round17/local/ab-banded-path-1t.txt": "2cd25a06c6c83e6f04f758c330d5eafbdb02cde3edf393b67c3dab7a91fc1172", + "docs/measurements/h264-rounds/round17/local/ab3.py": "4825e622c660bbb3c3f78ef04cc828935cb816ca973a3e952a26c6aa549ccc60", + "docs/measurements/h264-rounds/round17/local/ab8.py": "6be11fef06e0a4dea41b90a9ea3cd4731e2e6dcb980f0ca88b864e18a8a5f91e", + "docs/measurements/h264-rounds/round17/local/cls.py": "9d3df2884394a13293a9b87bed91713c214ac6335ff2ca455e6c8024a521bf8c", + "docs/measurements/h264-rounds/round17/local/instructions.txt": "f1496063bcf6e2c14aa6800333188a6d6bf55c67b8f5dc1bf65bbb246db5ac06", + "docs/measurements/h264-rounds/round17/local/prof8.sh": "93c8d128e6399a46bb528f64e2ee77a3802173583d6517f2991992f0aa0f02a2", + "docs/measurements/h264-rounds/round17/local/profile-8t.txt": "87f3911d576fe470717dfe4c6b841f02eb555437985ed3555963d8e39606c924", + "docs/measurements/h264-rounds/round18/analyze.py": "d4e0931a6954fb5703eb606b935e73996895cf73f442008bb65a6d6dd2701c28", + "docs/measurements/h264-rounds/round18/conformance.txt": "503443eaa82465b03a607cd2c173b5c4c0f488e8e5ecc67ac61e9fc671a30b88", + "docs/measurements/h264-rounds/round18/gating/README.md": "dcd2077128769aac5490966e0e412bc398ff94e5bfdda376ab5bb1bdd317605a", + "docs/measurements/h264-rounds/round18/gating/analysis.txt": "ef60072aa224ef59c0558eec5c20f0e6b400906d1cdf25de0f07eb054c46bdc0", + "docs/measurements/h264-rounds/round18/gating/analyze.py": "d4e0931a6954fb5703eb606b935e73996895cf73f442008bb65a6d6dd2701c28", + "docs/measurements/h264-rounds/round18/gating/binaries.sha256": "1e1030fedf6020801c77bc9dd4944b9a888165c314413597408a55de8c2bbb94", + "docs/measurements/h264-rounds/round18/gating/config.json": "0cf4e064aa28c1a403ae6f1ee49a6c6de1f937101b04f712733dfb792170bc3f", + "docs/measurements/h264-rounds/round18/gating/events.json": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "docs/measurements/h264-rounds/round18/gating/g.1080p.json": "74b96d1a06ae35f50307a518127372104c8a19a31041cbd4c9647df60a314054", + "docs/measurements/h264-rounds/round18/gating/g.1080p.log": "919a8bd75700756a01ef63fb6486e42be12f05f66e7fd8ba87a769186f4d2c20", + "docs/measurements/h264-rounds/round18/gating/g.4k.json": "b92bd2b04e2c8a47ab5020916f14a1a5cef07ef37dd96410e0c2db398c78772d", + "docs/measurements/h264-rounds/round18/gating/g.4k.log": "3ad3f8dd5339b47971666f858e6f339430a487dcef5ada118f1b7362029d478f", + "docs/measurements/h264-rounds/round18/gating/g.720p.json": "610ad62823930c51303b22045031693fc9dd8a10a3d0937534049b985b83d4eb", + "docs/measurements/h264-rounds/round18/gating/g.720p.log": "fdf6f607687dc5e74fbba1ddb3f5a7495ddb9942118c7952dda4b69416626afc", + "docs/measurements/h264-rounds/round18/gating/g.sd.json": "12af26b6d5f11269af1ea0dd51dc3ba6770320f231b1e21854f8b9dc8b6c86af", + "docs/measurements/h264-rounds/round18/gating/g.sd.log": "2605f49b444b34d48e795ecb9bca95abe61da58d2f8758cce82e691ab5a3c66e", + "docs/measurements/h264-rounds/round18/gating/g.summary.json": "31bfa0c390acc3e75af99ba4fe841a6fa939d1851601b351119a1c0e0a75ff88", + "docs/measurements/h264-rounds/round18/gating/gm.1080p.json": "21efdc8e0af078c930c4793625dc1c883bb42be48c6be2ceafd8a9a3ad6606b7", + "docs/measurements/h264-rounds/round18/gating/gm.1080p.log": "11978bd9e7eb6dfe29c880a934d9e3dae75a3097dce121194f3caa4e954536d5", + "docs/measurements/h264-rounds/round18/gating/gm.4k.json": "f8bedf3283df117a7f7e0326a679432fcde05a8d562e321d1c50db48e07967e6", + "docs/measurements/h264-rounds/round18/gating/gm.4k.log": "9e5ded9a07d05480454aea6788d3f0bca0be0ed4e2eea4bcb9d292fc62b70c8b", + "docs/measurements/h264-rounds/round18/gating/gm.720p.json": "c99c445350e02bebb93df05c9b63f1c5264f25d0d26f8cacc978ac25b2fdd633", + "docs/measurements/h264-rounds/round18/gating/gm.720p.log": "2a94d2ef5695a18e0c0c9c4028c353955a3598d63e9c99c6f02452ac12fc4c5a", + "docs/measurements/h264-rounds/round18/gating/gm.sd.json": "49292bbb15aa41d0ac3f4adcbdd7ff7c5b3bb0cb7f8a8f817383c0351890a479", + "docs/measurements/h264-rounds/round18/gating/gm.sd.log": "fa46cd147c4da664f1f8bfef1593810d3b4b3a6d627e39e5c45a4c85ee6b932e", + "docs/measurements/h264-rounds/round18/gating/identity.txt": "3980bdde6c8a232105cf508e121242d10b5582b01ed3f60e53dc880551d9a14b", + "docs/measurements/h264-rounds/round18/gating/log.txt": "68ab97d216baed49a83ce138d113a95db77bf464fd2325c9670dd084d62f9dcc", + "docs/measurements/h264-rounds/round18/gating/t8.1080p.json": "dc4e685b6d84edca123377c295023e15fae418d4db0dc6fa9883beb36bb9d3d5", + "docs/measurements/h264-rounds/round18/gating/t8.1080p.log": "6339be13fcc5c43a2397505f72aa1f5420686e8e7534e5d6ab8c57f233032911", + "docs/measurements/h264-rounds/round18/gating/t8.4k.json": "c36b724b43b149f777fa5b651c4b2a8fc38364ad581d125183b3790b4fe168b0", + "docs/measurements/h264-rounds/round18/gating/t8.4k.log": "431c5a39f109b8731759c343105b58d2f312d683587784aa2fd3061d54205be3", + "docs/measurements/h264-rounds/round18/gating/t8.720p.json": "b4141330e69f69619c18cd06bea18394dca90d619a7917335cd29c4b28dd5f26", + "docs/measurements/h264-rounds/round18/gating/t8.720p.log": "510d6808f75d17ba1384737dc011eb6e5fcb8e27c59cae1b56c06211f7fbe632", + "docs/measurements/h264-rounds/round18/gating/t8.sd.json": "ceb1d69ef38852af27b65695351045e1f81cfb8cdd58180f26ad7b4c9dd99825", + "docs/measurements/h264-rounds/round18/gating/t8.sd.log": "1685e92ab6931a53f98dcbfdf4f6e876eaa75ebca7bd84947c5b119451712fdf", + "docs/measurements/h264-rounds/round18/identity.txt": "a957755f5c2270f60bd7e2440b2a326b75924966803d552496887b6eda140ed7", + "docs/measurements/h264-rounds/round18/local/ab-1t-1.txt": "3dcc9ab54dc1c475afabfa4a28ce42811e0a011ad07d35f1abca07ca61202e6c", + "docs/measurements/h264-rounds/round18/local/ab-1t-2.txt": "64cbdee32d509be4269654cd1b68bca5b41ca3280dd7ed83d9002ea9b7cbf6da", + "docs/measurements/h264-rounds/round18/local/ab-8t.txt": "cfb548203a20d43e807b6e573e7e2ac68a3ad248e0dc13c798f02f8d32542823", + "docs/measurements/h264-rounds/round18/local/ab3.py": "4825e622c660bbb3c3f78ef04cc828935cb816ca973a3e952a26c6aa549ccc60", + "docs/measurements/h264-rounds/round18/local/ab8.py": "6be11fef06e0a4dea41b90a9ea3cd4731e2e6dcb980f0ca88b864e18a8a5f91e", + "docs/measurements/h264-rounds/round18/local/instructions.txt": "8ccfc565cb4670a9f1976406453d3da010e63ab0608e5ee8f72212738648fc18", + "docs/measurements/h264-rounds/round18/local/probes.txt": "c62b099fc3134cc0a1cf89040f3ed73a9790602d463a25f310ba62a270c83621", + "docs/measurements/h264-rounds/round18/local/profile.txt": "385eac508832a524af91c14f828c8fe43389629233363cf02d50f589932ad729", + "docs/measurements/h264-rounds/round19/analyze.py": "c1cf501689ae8ed2a1f163bca3d0bbfeb7c6e3e7c813356ea5afd9d4156aa3d0", + "docs/measurements/h264-rounds/round19/conformance.txt": "5586c3e059914c4aa8010fc8b14eec23e38eb87e486dd3b4a271824cd9fa6fc2", + "docs/measurements/h264-rounds/round19/fuzz.txt": "845935e3faf08e70d1c4188b016348c5af5372f8ad0143a99da2fa1a865e4ee8", + "docs/measurements/h264-rounds/round19/gating/README.md": "176165b29edb6ccbe4ce78d73482fd4e2c90a5f81b4cdf3579f2ee17165db593", + "docs/measurements/h264-rounds/round19/gating/analysis.txt": "084b49523d44ea93dd5b9a97c1f15f9f19d5e8d64b35bd3a15dd11a40bd3128b", + "docs/measurements/h264-rounds/round19/gating/analyze.py": "c1cf501689ae8ed2a1f163bca3d0bbfeb7c6e3e7c813356ea5afd9d4156aa3d0", + "docs/measurements/h264-rounds/round19/gating/binaries.sha256": "02b214cf48580f70ec3522faf615d0a21eacf2a576af83d16d9e8691b7d6651f", + "docs/measurements/h264-rounds/round19/gating/config.json": "27a710b3c373b6211db1cd0875b402208ced81271472b52d1af87174a785b901", + "docs/measurements/h264-rounds/round19/gating/events.json": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "docs/measurements/h264-rounds/round19/gating/g.1080p.json": "f006f2eab5fe3242520edca77a4be9a6ad5560c7784469683a3b7fc72ec1af5a", + "docs/measurements/h264-rounds/round19/gating/g.1080p.log": "76e1ef1ad7a4c712879107bb48ba26aec66a43d7099d53a3dab50617ee1fc30f", + "docs/measurements/h264-rounds/round19/gating/g.4k.json": "3bfd2ffc6ed10eda8549a91bb18e26caf3b9d5e919c1a2f69fbe59c3216a358d", + "docs/measurements/h264-rounds/round19/gating/g.4k.log": "fff3b17bb602ed657482579ec0b24e524b621fa43533ae04e234dba7dfb82c67", + "docs/measurements/h264-rounds/round19/gating/g.720p.json": "968eea1a6111e8f74b5a142948919a51a6024f2397d716853981dc349b8d6abd", + "docs/measurements/h264-rounds/round19/gating/g.720p.log": "b567c6db8b7eddee1f91835665ae9c68c197cad5c1ace671ffc6ba56c74ddd72", + "docs/measurements/h264-rounds/round19/gating/g.sd.json": "2ce2fff04a2add1a3dc31c4e7895a9198e685c444bb251fbbe718b7a8b68e50c", + "docs/measurements/h264-rounds/round19/gating/g.sd.log": "e402e8532e8e110d42ea921325328f5e22c4ca086f2af194c10cc49fda64e312", + "docs/measurements/h264-rounds/round19/gating/g.summary.json": "495e4323c0ab814f4bfaefc7356b5d0ef2ccff5ae0e2388d1cf5629537eb8db0", + "docs/measurements/h264-rounds/round19/gating/identity.txt": "3980bdde6c8a232105cf508e121242d10b5582b01ed3f60e53dc880551d9a14b", + "docs/measurements/h264-rounds/round19/gating/log.txt": "5ef71e5d467532866a2584710baae5017e45a445c87ba62e002a40330ca37505", + "docs/measurements/h264-rounds/round19/gating/state.json": "b816801d5a549fce586c768b9df79f2cc67c4901183164c1f03e55b5c5a89fdf", + "docs/measurements/h264-rounds/round19/gating/t8.1080p.json": "ce61ceb19bb3c956ee6706f3db9d8ffccb02a3c0023da695d8d185db8ceff20b", + "docs/measurements/h264-rounds/round19/gating/t8.1080p.log": "3a3d52c63b038d810e53f07c7e7cad674939b8f0444c26e70f549eaa5ffbf837", + "docs/measurements/h264-rounds/round19/gating/t8.4k.json": "915f4ad04d2200e170776d6651413d13cd94ec62cb982cf98bc9c4a5a7be6f9a", + "docs/measurements/h264-rounds/round19/gating/t8.4k.log": "6961b47f02aae14572e48723ce88f59fc9ec3c46d8437579d12e10e45ba13f67", + "docs/measurements/h264-rounds/round19/gating/t8.720p.json": "a5ba9dd3bca8065cad03686a9a18d01e8d723547ada3bb3a796a50030e8914fd", + "docs/measurements/h264-rounds/round19/gating/t8.720p.log": "ef1d6dba27d80f683654380e1bb6a5e4635078a5c48702fcc293e226f551a339", + "docs/measurements/h264-rounds/round19/gating/t8.sd.json": "6ec0cba6a101e3ba4e08fc72bf3fc48b49097018c45d5aa14bb554fa6c5e9630", + "docs/measurements/h264-rounds/round19/gating/t8.sd.log": "7539f45e9387b1505a264f23e0b96d90028ad904fe82f8b606734f8a9b6344c9", + "docs/measurements/h264-rounds/round19/identity-merged.txt": "9a79ac5252b4988633561a9af593f78cf591e36f7b064197476311dd2e7c541a", + "docs/measurements/h264-rounds/round19/identity.txt": "dff6359ae6212c2fc5b1ae3dcb273d8bfe754e236a9b3d80e8222b9507b9ac80", + "docs/measurements/h264-rounds/round19/local/ab-1t-1.txt": "70ba313d0231eba3e2d9309c5c3c9c06bd654883598f686c806313372af7efdc", + "docs/measurements/h264-rounds/round19/local/ab-1t-2.txt": "d480efb7690c8ef5577f92d94e46dd72ed66fd33f769ce06fdbe3e723a2c6f3a", + "docs/measurements/h264-rounds/round19/local/ab3.py": "575d40464c003345aee3d7de8536659cdb8357d93ff95b1fff5931764359ec22", + "docs/measurements/h264-rounds/round19/local/instructions.txt": "2193d5a151cf1b88735dafa9c922bc757bfe309377e4e6d2f4cfa971eade26f4", + "docs/measurements/h264-rounds/round19/local/profile.txt": "86e04999aac7210c17ad2ae40f7ed56b8d524281189d939407d8b150c54d6b5c", + "docs/measurements/h264-rounds/round2-cumulative-ab-pinned.json": "ca647a8586bfe673312601d10a8953c232bb2aacb6f5bdf62dbb5a859e63e0c9", + "docs/measurements/h264-rounds/round2-cumulative-ab.json": "b332bdb0cf7809eda43be6c1baf2fa3f5e22b565eaccbbbd44a97ed7036ed159", + "docs/measurements/h264-rounds/round20/analyze.py": "e04b0231130148fb404992d9131646a1dceff26acbcdb271e64dc11a137cb920", + "docs/measurements/h264-rounds/round20/conformance-v3-merged.txt": "1f919d776714a3132d9e6793216c92e4aa5b9657531706871bfef6723f07ed61", + "docs/measurements/h264-rounds/round20/conformance-v3.txt": "18a1251c2dbc677d96ef855ce3961aef8d7876df0a2d243c7f682baca570ce88", + "docs/measurements/h264-rounds/round20/gating/README.md": "3ccd40262c0c0a79315ea55e926c02d63a617981a85f35c5347a00414d9fc495", + "docs/measurements/h264-rounds/round20/gating/analysis.txt": "6f569db30d7871c370f7c8d516dd44ece90e0d7b063fcfc1f1e8a5359464bd6e", + "docs/measurements/h264-rounds/round20/gating/analyze.py": "e04b0231130148fb404992d9131646a1dceff26acbcdb271e64dc11a137cb920", + "docs/measurements/h264-rounds/round20/gating/binaries.sha256": "4670c2eef1fe68a585a17cb5e6981943fb724cc38b5f6a138e71fe82d7472660", + "docs/measurements/h264-rounds/round20/gating/config.json": "27a710b3c373b6211db1cd0875b402208ced81271472b52d1af87174a785b901", + "docs/measurements/h264-rounds/round20/gating/events.json": "325ff54637ffa8f6acc15032b26b505f555f521d72c74ccd574bc14df56ce73e", + "docs/measurements/h264-rounds/round20/gating/g.1080p.json": "358717b385a4e575a02622d0983bbce75a82b8c9d00fa07769310b1e9d3f5b13", + "docs/measurements/h264-rounds/round20/gating/g.1080p.log": "1443c53a94df020254ab75caf3e16ac50cdee5ef436f0bcef19009a49f954ac7", + "docs/measurements/h264-rounds/round20/gating/g.4k.json": "acb6f748772a2740b35f6184be488eaf0e7901ddbb0db531fdbdaf6a2620e98a", + "docs/measurements/h264-rounds/round20/gating/g.4k.log": "e1693833face015c809712e81e5f94aeced5c043307fa46d20f82d80b9f136ca", + "docs/measurements/h264-rounds/round20/gating/g.720p.json": "49159f23956dd001f598150d52752fd6b458e5d80980bc3aa487f82cf05b25a8", + "docs/measurements/h264-rounds/round20/gating/g.720p.log": "0b523e784a41f2da4d4d7c9d63800bc906a885cdafa714688acf68559d4b1ee3", + "docs/measurements/h264-rounds/round20/gating/g.sd.json": "730c39f958449ff2c733bc48c0b1024699ecd0b6155484008a5b9f50665cdee9", + "docs/measurements/h264-rounds/round20/gating/g.sd.log": "f014cffb6dee4d681337f006fd7fc7a1edfeaaed2ed31e3170922506e25b25c2", + "docs/measurements/h264-rounds/round20/gating/g.summary.json": "8aaab4f4fe44982331263c1ffdbbb1d5aa51f3f18d2f5e769121243e46c9d9f1", + "docs/measurements/h264-rounds/round20/gating/identity.txt": "3980bdde6c8a232105cf508e121242d10b5582b01ed3f60e53dc880551d9a14b", + "docs/measurements/h264-rounds/round20/gating/log.txt": "b9a595291933fdd31b67d6fe4add132802c5842e96094d1c3762472dd69181c3", + "docs/measurements/h264-rounds/round20/gating/state.json": "6585ed48c1b2d9ab46cb99a955851c02cd63d08ca5de130b8f42d864507e8e0e", + "docs/measurements/h264-rounds/round20/gating/t8.1080p.json": "086565fef50f2635c7b522ba9e5625548f7a26e7b74d4a72918d6d3ef79b0402", + "docs/measurements/h264-rounds/round20/gating/t8.1080p.log": "9f8cb26f612edf67098eb9272fec029f36e94a591d2d50ea39b35633b7828862", + "docs/measurements/h264-rounds/round20/gating/t8.4k.json": "03454f00cea5ce3959741bd2a9d607c8c2c14a1a601b3abe8f5e27dcd3c16a1d", + "docs/measurements/h264-rounds/round20/gating/t8.4k.log": "6df604b0dd84b8fdbdf8af28f28d5293b3e92ece255e22e5b154e4a64953c942", + "docs/measurements/h264-rounds/round20/gating/t8.720p.json": "ded06e7854416497e855d8f314850880de0f9a8c3fc226111f85646632e00a47", + "docs/measurements/h264-rounds/round20/gating/t8.720p.json.void1": "2cce7ff0045cb3fac95673c9b5d48f271a7abc5a8d30d8d54046738f6e83628d", + "docs/measurements/h264-rounds/round20/gating/t8.720p.log": "a40291c8b13202832effcf247473b6a785ad7c2fc618d02f7a67ad11b02bb564", + "docs/measurements/h264-rounds/round20/gating/t8.720p.log.void1": "e93b7694fa39d13ad43dc74b8443784982c436fac62d26df53931a5d563f8440", + "docs/measurements/h264-rounds/round20/gating/t8.sd.json": "423d438661691d8899e662cb912ad363f3e806ed2e101c36fe8bb28d2455da7e", + "docs/measurements/h264-rounds/round20/gating/t8.sd.log": "ed78af297d6a5459b766cbbab127ff19666146cd925fc8223e03aa33ea59e0e0", + "docs/measurements/h264-rounds/round20/identity-merged.txt": "31b80a5a3240c952b47e97301d6ed3bee38d5dff150ced3817d7c6acffde6b48", + "docs/measurements/h264-rounds/round20/local/ab-whole.txt": "e91f6b36081fe0ef1f1ddcdbc254c0d85491bad07a26ce8343bf44f1a31d44ef", + "docs/measurements/h264-rounds/round20/local/ab3.py": "4825e622c660bbb3c3f78ef04cc828935cb816ca973a3e952a26c6aa549ccc60", + "docs/measurements/h264-rounds/round20/local/functions-v3.txt": "3d817d0dd9a67ac72b570d621eac4340d86bdb094fbed1feb851b335cb4058c2", + "docs/measurements/h264-rounds/round20/local/identity-v3.txt": "476a039a5e19648ea4d7a1597cec66e81952da2a8d061b59a57ec7c56346781e", + "docs/measurements/h264-rounds/round20/local/sizes.txt": "c4fc287f71b67b2f9de3c7807b4fe937ccfac13ee75b8966fe6958455c34fa32", + "docs/measurements/h264-rounds/round20/local/sym-6da34958296c.prof-c17ae06.prof-v3-a7d8e4b.raw": "939abd4456e9e3ec7be293c896f53cda317870a7699f1099195ca3db00273151", + "docs/measurements/h264-rounds/round20/local/symdiff.sh": "c6a01f695d4ba1fd1f8d32dce698861c4eaa74fff7bda0f968320535d81da56b", + "docs/measurements/h264-rounds/round20/local/symsum.py": "6fb5e12370043de806689a63b1a66bc69e736dd4ca2cc8240fa8fbab1ced49dc", + "docs/measurements/h264-rounds/round21/analyze.py": "9f5d5fad84a134139de9fd6a4b7a6d21de938b9f36b485ac9e4b3d54910ff297", + "docs/measurements/h264-rounds/round21/conformance.txt": "097904301d6fc1d0cf0e81000acfb51b824bba7e8f80802fb950df928cccfd29", + "docs/measurements/h264-rounds/round21/fuzz.txt": "a909c13e3e5c4e2a7ebb1d952636ecd604bb077fbe347180a6a969e1fc3af14e", + "docs/measurements/h264-rounds/round21/gating/README.md": "9f8ee3a32ece44ff444b1697081daf48aa37f474a1330ae8f3a946ab061cc809", + "docs/measurements/h264-rounds/round21/gating/analysis.txt": "c18e4e31db49cab1c18c0774e15d915242775e0398677c00c29beca37de81c6d", + "docs/measurements/h264-rounds/round21/gating/analyze.py": "9f5d5fad84a134139de9fd6a4b7a6d21de938b9f36b485ac9e4b3d54910ff297", + "docs/measurements/h264-rounds/round21/gating/binaries.sha256": "88516c64b1a6e824b69866446f75833b2e52123a0f44e90542ff4c7a6fb45f01", + "docs/measurements/h264-rounds/round21/gating/config.json": "27a710b3c373b6211db1cd0875b402208ced81271472b52d1af87174a785b901", + "docs/measurements/h264-rounds/round21/gating/events.json": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "docs/measurements/h264-rounds/round21/gating/g.1080p.json": "de158f396e6753efe5ab241262cb063d081b649ba712030c1dfe9f260ba57d34", + "docs/measurements/h264-rounds/round21/gating/g.1080p.log": "23cafa5fdb69514910924a33209ad9bb395e846843c9f7552a400a972f4c5282", + "docs/measurements/h264-rounds/round21/gating/g.4k.json": "f54aa51deaaeb8c306bdff3589cc6858a6f805158e28c3e1af43622d0fc0de8c", + "docs/measurements/h264-rounds/round21/gating/g.4k.log": "86a6daa24ccfa3658ad63f65fbbcefeb4750016dcbbd8662fee4efd1ef0ecd2c", + "docs/measurements/h264-rounds/round21/gating/g.720p.json": "1eefa04994d51e6bf4e6c82967db8a717bcb6b1b66d81a650133850536022c6c", + "docs/measurements/h264-rounds/round21/gating/g.720p.log": "ef130d9c95c6a5dbabeafa86bb6432e26c14f44e8419c3e020e70628420d3f98", + "docs/measurements/h264-rounds/round21/gating/g.sd.json": "0e9b7a244cbc8dda21c81e15a1a68983388f5b64e88450e0a8fe2bdb85538bb7", + "docs/measurements/h264-rounds/round21/gating/g.sd.log": "1b1c5181809093776eedd175f464b9e52dfa6eec6c20d30bc02ccff2e07b5e5e", + "docs/measurements/h264-rounds/round21/gating/g.summary.json": "48da7f0277384cd63e183f9c945121d61ebd28f86e9dda99f91dbeba3d760b79", + "docs/measurements/h264-rounds/round21/gating/identity.txt": "3980bdde6c8a232105cf508e121242d10b5582b01ed3f60e53dc880551d9a14b", + "docs/measurements/h264-rounds/round21/gating/log.txt": "e59b073059f404ea7de8d0d17d4bc6181614d98033bfe4033f60ed99e0fc5c2c", + "docs/measurements/h264-rounds/round21/gating/state.json": "f8ac2004b720b9ed805245322131ad651601d32c937aa8adc615bfa56020e739", + "docs/measurements/h264-rounds/round21/gating/t8.1080p.json": "d34967694205c735999f2552920e3134b411c54ca9336d5ff0f2c7066b59e809", + "docs/measurements/h264-rounds/round21/gating/t8.1080p.log": "02182b15c31e1f46cb82862a6aa68b07ca0f9f1e1704bb700ac30617bac74961", + "docs/measurements/h264-rounds/round21/gating/t8.4k.json": "aec450c9c2f1b5fbfcdca4e0896ebd329c48b7bdf5d1f7ab449965eb4e18f7a9", + "docs/measurements/h264-rounds/round21/gating/t8.4k.log": "27656007c064ac6907251520d2e6a5d73caec581db6efacc7837e30a35381ecf", + "docs/measurements/h264-rounds/round21/gating/t8.720p.json": "e374ac09bfbeec13b6975c1633aa57cc885edf17a182cd2de20a487d8ca7c5e4", + "docs/measurements/h264-rounds/round21/gating/t8.720p.log": "4aee589e4262c0ce0592025e20448544ce4f17f360329c8b4a905e885980af5b", + "docs/measurements/h264-rounds/round21/gating/t8.sd.json": "40d6df7b0525c5f7d6f936c08d9804f8f1818d6250a341e1c97ace9075f74aa0", + "docs/measurements/h264-rounds/round21/gating/t8.sd.log": "147d33ad04aadffb8d068b6aa00a7c975481d3760131704acab5b06969d00fa5", + "docs/measurements/h264-rounds/round21/identity.txt": "16363f2f266868048a333e731d42b3e5a48b6d4d2a7d48a2c1567ada1c6d4ec5", + "docs/measurements/h264-rounds/round21/local/ab-whole.txt": "e91f6b36081fe0ef1f1ddcdbc254c0d85491bad07a26ce8343bf44f1a31d44ef", + "docs/measurements/h264-rounds/round21/local/ab.txt": "1d2a8430c361750c7b0f57c121d49ef137b12cd87667c9680e9eb3fecd275972", + "docs/measurements/h264-rounds/round21/mvd-histograms.txt": "f426015f5dd1b55d065c9d4a5fa483da69d5dc54a549c790278aad35c3d15791", + "docs/measurements/h264-rounds/round21/mvd-subset.txt": "3840a5eb0c6cc1522f044c27bf2a8437dedc837203d388f767e109a970fde7ff", + "docs/measurements/h264-rounds/round21/mvd_subset.py": "90d26355b02de89fed01182be98e33990a2d680ec013e5f1b9bbbefcb050e722", + "docs/measurements/h264-rounds/round22/analyze.py": "0e2b52bebc05f5b1ef4f295bb6cdf8e1c4fb8b34cadcd4b1c76be6b378f6e1a5", + "docs/measurements/h264-rounds/round22/conformance.txt": "bdf6a0ed8c8ff7f079e74722e464e4af89b25622a745b1827f84c80989b498df", + "docs/measurements/h264-rounds/round22/fuzz.txt": "9c754a60b350c425b4d511c4dae0d5292179b2af186c81ee0424fe77fa790833", + "docs/measurements/h264-rounds/round22/gating/README.md": "eef80ded55b5f94be5a24dc6ab4a64912f101da48d8eb354d85fbbe92a369a52", + "docs/measurements/h264-rounds/round22/gating/analysis.txt": "a96becef4b097550569b98924b42e291bdd2a5a6824dfc9f096e1ba431d00275", + "docs/measurements/h264-rounds/round22/gating/analyze.py": "0e2b52bebc05f5b1ef4f295bb6cdf8e1c4fb8b34cadcd4b1c76be6b378f6e1a5", + "docs/measurements/h264-rounds/round22/gating/binaries.sha256": "04347802765d46a906d9e1388fdf55c4151f142187d643d8d043b17df00e7ac0", + "docs/measurements/h264-rounds/round22/gating/config.json": "7755a4ca7b5c4e930edef6f32e46925edd34c76305a99e08cfeac4004d9558c4", + "docs/measurements/h264-rounds/round22/gating/events.json": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "docs/measurements/h264-rounds/round22/gating/g.1080p.json": "90a87a7c8967822c3150dba8a110bf3474df28523d0ce2dc0aab32a36c205ef0", + "docs/measurements/h264-rounds/round22/gating/g.1080p.log": "fb8632ec5b1b0046c717104d5786a75bec9d5e80a745478906abf6e4b2ede789", + "docs/measurements/h264-rounds/round22/gating/g.4k.json": "4a192e0e5a720812f8c48853ad3bac0a87e7dff18215fbe663e2310384239405", + "docs/measurements/h264-rounds/round22/gating/g.4k.log": "8d86fd9bc22b0c4bd707f98fad503be7ebcaaf519ba1b30b34520cb374e082ed", + "docs/measurements/h264-rounds/round22/gating/g.720p.json": "d50b83b68a15263a3234abc2bed93dd7d25b9935aaec54911c6da337fc67fd98", + "docs/measurements/h264-rounds/round22/gating/g.720p.log": "77d80bcc776df1a353fee8e9a6037b4297576e6d6d6bef856683770a922de144", + "docs/measurements/h264-rounds/round22/gating/g.sd.json": "50dbff3f5bd3af4e141e9153ae4f718ab84d31fe2017bf5e670a33aeff463bb1", + "docs/measurements/h264-rounds/round22/gating/g.sd.log": "e20a6a92186c06135e66afa0be4e269dcf98d299204fab7192cd3f43cc2dabe3", + "docs/measurements/h264-rounds/round22/gating/g.summary.json": "3248e309bb8cbb2f0daccbec1cba0f6c67543662785da00a546df3f9b79f519c", + "docs/measurements/h264-rounds/round22/gating/gm.1080p.json": "23e0f9d464049e7b9033d141db38ebed808269ad104a017a4b4192de15eeec16", + "docs/measurements/h264-rounds/round22/gating/gm.1080p.log": "afe1674307172c8717f442a9b7940052326f1d0854af976eb7672f0ef7106206", + "docs/measurements/h264-rounds/round22/gating/gm.4k.json": "6362294248d41299eeb225fb2ef2615aa20a285db85b1ab44df7105a18e5c0ea", + "docs/measurements/h264-rounds/round22/gating/gm.4k.log": "5e3c60fb5c74c054ffdd44f3dcf59f2160e6674d9a3fbd2cc164fb515d8fbf29", + "docs/measurements/h264-rounds/round22/gating/gm.720p.json": "785d0c40f1a5188957dcdafd5c132ea712dc60e596bb26460cbf174cfe4a5ba8", + "docs/measurements/h264-rounds/round22/gating/gm.720p.log": "7e73d1b007ddf582f972759b8f09a4751779a77b4cf26e9d3a9b4c2502b677ca", + "docs/measurements/h264-rounds/round22/gating/gm.sd.json": "48b336b1f55c7f21a2f24547fca7efd47e6c21eb18fe45039bffe058d871995d", + "docs/measurements/h264-rounds/round22/gating/gm.sd.log": "447254b9361626d523b1721c6a759cee1f8d72a85fca73e14fad08a5796068e9", + "docs/measurements/h264-rounds/round22/gating/identity.txt": "3980bdde6c8a232105cf508e121242d10b5582b01ed3f60e53dc880551d9a14b", + "docs/measurements/h264-rounds/round22/gating/log.txt": "97f8feb29f084a93c1794e994a9e11db3505cadc755b3befe0717e6b7e7b8a17", + "docs/measurements/h264-rounds/round22/gating/state.json": "4f977453f23af62442104c60627056c124c01afefb7c6dd5a57c79557a593fb8", + "docs/measurements/h264-rounds/round22/gating/t8.1080p.json": "bbde74633d7463d9d2d5223c6d3ec2b26eb7cd981e116ec94205cd66a56a25c9", + "docs/measurements/h264-rounds/round22/gating/t8.1080p.log": "503a764874cd7abbb87eb825b3379239677face99c5398b16e035c6447912dcd", + "docs/measurements/h264-rounds/round22/gating/t8.4k.json": "223d9db2c08f6c0e357ee1a2741eda8d3eb3cf7e3d3fed6fa6da4cb91d8d0b5e", + "docs/measurements/h264-rounds/round22/gating/t8.4k.log": "95368cf1a9df885f87d8dd97dea55e827c9f0b9ba751d0397dde848c21775522", + "docs/measurements/h264-rounds/round22/gating/t8.720p.json": "a408b0ebdf04cc431959fc99aacecc50fbc07414fd3d1e976e76eb734f517832", + "docs/measurements/h264-rounds/round22/gating/t8.720p.log": "8f3f93a6082ae61616b6c9c5c76696511c0c53a28482e332ca02ef004a4a8f7e", + "docs/measurements/h264-rounds/round22/gating/t8.sd.json": "e644ed3a761971ecfbae8d6724918b3b3f41c6ce6d7be27b9b2a12b07491ca4b", + "docs/measurements/h264-rounds/round22/gating/t8.sd.log": "956429783a0502f8fe5e0911204dd67296bb92e591010358b360c28469a0e215", + "docs/measurements/h264-rounds/round22/identity-local.txt": "7fda0d5ea79009be04e17a21ca73754cb2b6c48cedc25cb452d83b497ce67fec", + "docs/measurements/h264-rounds/round22/local/ab-record-only.txt": "2a7a8e449fe455b012198853c91a8356fe5b99824dbdecae5fe4949c8f65fd40", + "docs/measurements/h264-rounds/round22/local/ab.txt": "1e24e3f7c40d5dd8427af2acef3ca60d894cb4690e353b8d077965fb54d74334", + "docs/measurements/h264-rounds/round22/local/instructions.txt": "dca7d0cd999ee901e339c3f75a430509018b7a9f355f6977a9bac78ad8573d8b", + "docs/measurements/h264-rounds/round23/analyze.py": "9574086cf8354f2f99a6ab364f452a078c2a98f1664fa464029f999343495060", + "docs/measurements/h264-rounds/round23/conformance.txt": "c50198c8cdb9e8feda82ba8f41fdeff26d6f21312e8f4823b4f9734348907106", + "docs/measurements/h264-rounds/round23/fuzz.txt": "594b7c5731c0707aacc69168b9f902ff37f0b30a34885835a2e41a41afcb884f", + "docs/measurements/h264-rounds/round23/gating/README.md": "a5668a8cb679709bb7ae208e31c4efd151bd089cec618bc329044acbfaca7101", + "docs/measurements/h264-rounds/round23/gating/analysis.txt": "88f6b0fb1aeca9f590c2ed7825c866c1c347da44f054a196290a914255d9c9f8", + "docs/measurements/h264-rounds/round23/gating/analyze.py": "9574086cf8354f2f99a6ab364f452a078c2a98f1664fa464029f999343495060", + "docs/measurements/h264-rounds/round23/gating/binaries.sha256": "245f3b010aa36735175583da82e69911975b952a1ec980a453d78ded7d22d8fa", + "docs/measurements/h264-rounds/round23/gating/config.json": "216a0ce44809c92fd27a601dcdc5d55f9ace46cc51f0010e243e6b2daa1ec132", + "docs/measurements/h264-rounds/round23/gating/events.json": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "docs/measurements/h264-rounds/round23/gating/g.1080p.json": "8e44f1c7d5fe2ee46d7ed423c1ff0f27eb1c064fccac407db70b64ae1b2e22eb", + "docs/measurements/h264-rounds/round23/gating/g.1080p.log": "22aadf7ddaac625ed5b4acbf79a07122fb132a633e5426de7fae6e26fb54c1e5", + "docs/measurements/h264-rounds/round23/gating/g.4k.json": "eef3a86f57eab55890f862e66e2dd28a23df36c0be8d957c6a1f8ec32dd67dbf", + "docs/measurements/h264-rounds/round23/gating/g.4k.log": "e70842db757f8c0f1f88162cdbe81bbe5822fa4d08b00df097abef36ade97783", + "docs/measurements/h264-rounds/round23/gating/g.720p.json": "06e12b615b88c68d1747be76ef89dc5134122972a82c6819e11f307ba8d19951", + "docs/measurements/h264-rounds/round23/gating/g.720p.log": "bffc98eefa2be68bca88914158dbcdb8ecf7db9775beb3109ce494fa2373ca78", + "docs/measurements/h264-rounds/round23/gating/g.sd.json": "d0b08d2613feee06875db49edd45e369ae027c7d7faeb3592981f1f3733bcefd", + "docs/measurements/h264-rounds/round23/gating/g.sd.log": "4dfec4105968876145f1124bb4871f3c5dffbaafe722d5e29b9fe68f7772067f", + "docs/measurements/h264-rounds/round23/gating/g.summary.json": "689dc245ab8f2b73840ab2b5cd0076f63adefb8c2f8f0846cfd125b9499f3704", + "docs/measurements/h264-rounds/round23/gating/identity.txt": "3980bdde6c8a232105cf508e121242d10b5582b01ed3f60e53dc880551d9a14b", + "docs/measurements/h264-rounds/round23/gating/log.txt": "95c74264fbcc3e10eea80a3e85e01f9863a64dbf118c5ede427c3842d523860c", + "docs/measurements/h264-rounds/round23/gating/state.json": "8bd832b07be075a0a9b213fe06177dca11d73f126f88f4ef9ddedc8da742e56f", + "docs/measurements/h264-rounds/round23/gating/t8.1080p.json": "43170a59c13a89e84d09e79178ddb0f1d586268867914f203957cf7a8ff80b05", + "docs/measurements/h264-rounds/round23/gating/t8.1080p.log": "4be09c75a645b6cad57e33cc1bf4904bde8b602a31b0991157b7d4c48d4508fe", + "docs/measurements/h264-rounds/round23/gating/t8.4k.json": "6828884e63cd50c7968b38e39631c5e58786e3c908941671d8afeb8876bec1e0", + "docs/measurements/h264-rounds/round23/gating/t8.4k.log": "d5712c0edc2a1083b4c54fe7aad20551795f6c3e3e4ebb19d2d128bed9a9fae7", + "docs/measurements/h264-rounds/round23/gating/t8.720p.json": "d77b9a73b7e28e0fff99f2fc33942eb7b41b144f8cfd5dcd63cf7c42a23fd3fd", + "docs/measurements/h264-rounds/round23/gating/t8.720p.log": "6ac02556ef62bd7cbacba797f11525e0b96ba150ddf4cdcb924a22869f907aa7", + "docs/measurements/h264-rounds/round23/gating/t8.sd.json": "f6e64c860efb1db6250eeec6ce2d645c78b6c0d0f93bf27214a26361d2af12ae", + "docs/measurements/h264-rounds/round23/gating/t8.sd.log": "cfa9fd56c45ae2ef9e9e746d320e62cddfc844048b1fadd2a5d34bd2d78a9335", + "docs/measurements/h264-rounds/round23/identity-local.txt": "203512927a008f42f90f59ce68f2b84ac72282ba9165777ac85b5edcd12d687e", + "docs/measurements/h264-rounds/round23/local/ab.txt": "ca67388f3b511b1c8fffbc21f93fd98984b035953a829bd0b1f3666f5c504fd4", + "docs/measurements/h264-rounds/round24/analyze.py": "f28ea1dd0180313eb03989a290613671d2e349b044f546cc076f6fcacc3f8feb", + "docs/measurements/h264-rounds/round24/conformance.txt": "80ee7db82bbea30df5b8d91817d2779e89de2b389201eabb615e35befd9207bc", + "docs/measurements/h264-rounds/round24/fuzz.txt": "5f75892dc66de9e5e4496642aaabcb649c0dc5d4e534ca79db4db3ee7aa739b6", + "docs/measurements/h264-rounds/round24/identity-local.txt": "86351fd3e9bce679df73bcf55afc0ff3fcc368451d06e4a31ea2a8b4412df3c6", + "docs/measurements/h264-rounds/round24/local/ab-056bd25.txt": "d754957ab43f0ee340ec62b8fe695dfb0e32d2c06150c8051fd91d4a05ba4c93", + "docs/measurements/h264-rounds/round24/local/ab.txt": "5d4de3714a3d2df3c627f57dd834b6eedeedb103c06404db4a314b06146f4b61", + "docs/measurements/h264-rounds/round24/local/instructions.txt": "e0b4afe02e319038ea33ba890d792a71120c83e7c9c8fdb02811db4ea564dc13", + "docs/measurements/h264-rounds/round24/local/perf.txt": "4eb569077bfc995e2100a533036b31afbc75719d2a26e5130b309e5de93c3737", + "docs/measurements/h264-rounds/round24/modes-identity.txt": "673a2b0afbc135cac196f25d84b8adf04120604a3e4b48f572d2fab09b458fc4", + "docs/measurements/h264-rounds/round26-screen/README.md": "ab6ef5dc516d6d6b0b08a9a3dfd1101847419be0a0f19797fbde330089ac4968", + "docs/measurements/h264-rounds/round26-screen/ab-colocated.txt": "dc1d8aefe409a868f0de5a44608a0f37386707fb11791342c9532d669b399174", + "docs/measurements/h264-rounds/round26-screen/ab-record-p1.txt": "b49415e9ca266bf65eca12e5954a7532f28c7371dc34a9dbed5be6562b7545b9", + "docs/measurements/h264-rounds/round26-screen/ab-record.txt": "f6d42988f2600b90b1994cb3cf9bc3018a1a61708358f3dd820d6660e630eb18", + "docs/measurements/h264-rounds/round26-screen/addr.py": "4493d7f4ea1d37dc30755dc0ddc99c97683e01f132b170a099dd0b734ccc9d58", + "docs/measurements/h264-rounds/round26-screen/classes.txt": "39498cef63b40a0db42e15e6008af01c1a0f13d3403be888e7689de73753be3c", + "docs/measurements/h264-rounds/round26-screen/d1w.py": "356e7e1b33d94efc24b3f2465333e750f949837897aa38aded434014aef49c36", + "docs/measurements/h264-rounds/round26-screen/identity.txt": "c5f5d5bb1c954126d8ffa741282677d74b3a22f219faddd1fb74a8ba4b75c877", + "docs/measurements/h264-rounds/round26-screen/lines-sd-6f7799768413.txt": "0123ca28d8a26e90f6d4e6c2d7e1fdc3c9b4d688bd2404f34eade77a110aa22e", + "docs/measurements/h264-rounds/round26-screen/mbdiff.py": "9e27005d2dee1dafa475cdc779074a2e58397b912b7a80bc1e5f8b64b2ca4c83", + "docs/measurements/h264-rounds/round26-screen/mbline.py": "8ea9fcdcae0d4337b2f634ff5523253ef0c6a4fb144cdc878688fd54bb08c014", + "docs/measurements/h264-rounds/round26-screen/plan.txt": "9766ce29a7710ce22ea42ccfa5cfce30d021cbfe6bbf4a2b61b411b979c0dce3", + "docs/measurements/h264-rounds/round26-screen/record-misses.txt": "2149e192b03bc4aa952653b4c4e15b21ead0bf51c1886b6e4e25d9360b792dd1", + "docs/measurements/h264-rounds/round26-screen/record-p1-shift.txt": "e1da40f3c6cb34c8404f15adfb4e376f72bd47f233b6859af8cb633347f53fae", + "docs/measurements/h264-rounds/round27-stores/README.md": "34a9ef2e59e42f60f869f839f3280cf1139bd032375a6f9c71cb09eadf679ef2", + "docs/measurements/h264-rounds/round27-stores/ab-lps-pair.txt": "7d784c7e31784991d8552c57f711937c8a3c4d5cdcd67993ba44818eff763e34", + "docs/measurements/h264-rounds/round27-stores/ab-probe.txt": "35b26f51017a877fce25d99235db732223a3e2a88e4c7e33049f694d89dabb4e", + "docs/measurements/h264-rounds/round27-stores/chain-1d4b1775d78a.txt": "0d01ccae3e3b74678f8cddc587de769a4d6829310487d68aa5fd5e57a79e5e39", + "docs/measurements/h264-rounds/round27-stores/chain-3b1b441e23ae.txt": "a588b99615c983af3830b805689f6523142043e240f07645a16d41d980c32c7e", + "docs/measurements/h264-rounds/round27-stores/chain-a81de82106be.txt": "a86dfcbbdc3e7a4384a4b626760c50a37019ff6d084f66de5277708083ffaf3b", + "docs/measurements/h264-rounds/round27-stores/chain-sum.txt": "ddf16ff492dd5d7d43c687a8608586395886399fbe86f3ae5833f8b372515a7e", + "docs/measurements/h264-rounds/round27-stores/classes-lps-pair.txt": "f358f254b3e647e8ab8e60737695ebf21adf3c9c350a1d4a3d3160b086c0909e", + "docs/measurements/h264-rounds/round27-stores/classes-probe.txt": "d1988bb9929169959b8047551ae912b243e4da769a22bb66b9a809af73e3d728", + "docs/measurements/h264-rounds/round27-stores/d1w.py": "356e7e1b33d94efc24b3f2465333e750f949837897aa38aded434014aef49c36", + "docs/measurements/h264-rounds/round27-stores/ident.sh": "030ad13252517187a8f915b47f0b515ef1c1ec1398846d5d4b3aa8eede0ee891", + "docs/measurements/h264-rounds/round27-stores/identity-lps-pair.txt": "2902ece8e526b509041a962da039e673d18206137ec4e9e6e17813fa2eb78bab", + "docs/measurements/h264-rounds/round27-stores/lines-1d4b1775d78a.txt": "1b5fa26aac8acbb4c40d6d4592edfcfa4970875f977687b0b2d965d03ad2b967", + "docs/measurements/h264-rounds/round27-stores/lines-3b1b441e23ae.txt": "0546b41c4759ce8dc538c9a60b37326783608e7d5fcb6129c7f85c93ed1502de", + "docs/measurements/h264-rounds/round27-stores/lines-6f7799768413.txt": "0123ca28d8a26e90f6d4e6c2d7e1fdc3c9b4d688bd2404f34eade77a110aa22e", + "docs/measurements/h264-rounds/round27-stores/lines-a81de82106be.txt": "f5dda9507f44b70aba5978850f2d34497fe2221f530609c0091f130b4b2fc16e", + "docs/measurements/h264-rounds/round27-stores/plan-lps.txt": "87fb9db681ed52fba85f5370e6c29db1cd6bd316bb50888eb2c1f7061202ae80", + "docs/measurements/h264-rounds/round27-stores/plan.txt": "ff642be66b20c6d32f0e9a6c447b95641d4548810bebb500916c3df90de58b2c", + "docs/measurements/h264-rounds/round27-stores/probe-instructions.txt": "df0862037704cfde089e114483ebfac646c809a704eaa496733fdc18febbe8b0", + "docs/measurements/h264-rounds/round27-stores/probe.diff": "7d98ac8188af6d7c55b8fe730d68f513f4e1b6aa0c07db0b56fd598d629ea066", + "docs/measurements/h264-rounds/round27-stores/stores-1080p.txt": "ca2e78813c7507bedbb83536b3c3abcad991a3de638ef717804b5863b552f618", + "docs/measurements/h264-rounds/round27-stores/stores-4k.txt": "4e7b497d8596148a70453690632556f55df3c2dcc0de28effbe1e559e70c3e99", + "docs/measurements/h264-rounds/round27-stores/stores-720p.txt": "28df14b6dfb7e9b5ae9437eb520267345369d8702366cf643be317aba780819f", + "docs/measurements/h264-rounds/round27-stores/stores-sd.txt": "05c2e54972aaacf8d10f5f43acd7aef172321065fc58eb4e5174a506863a007b", + "docs/measurements/h264-rounds/round27-stores/stores.py": "1c56b1ee24d89ffd101a7a4001226ac915c3399c40d286dadfbc5efe9d4b9cf2", + "docs/measurements/h264-rounds/round3-cumulative-ab.json": "0eb72f4ad7ed0e4f1d05a58442978de3b4ca9b74310a6ac37d5e45d64b00d518", + "docs/measurements/h264-rounds/round4-cabac-ab.json": "5efef4f6a99ce9354a712bb313df5f4c22d8461c66af156c42065c852e38f45c", + "docs/measurements/h264-rounds/round5-candidates-ab.json": "9d29a7e9d52d76338ebac879e3a86f85e3c44cfc338a07d51bf6c32e44bb817b", + "docs/measurements/h264-rounds/round5-chroma-ab.json": "3b8093264ed4bd922c39851fd19f71206f61e51d0e1462874cf9ea57729eb8b9", + "docs/measurements/h264-rounds/round5-edges-ab.json": "145da4b8ec301d6f98c301a72cbe2352f3888d4ba23ea172945574bb37ce6648", + "docs/measurements/h264-rounds/round6/analyze.py": "b659afe5d61909d6161b412285415fd6100c36f0408ff863ca02fba34a4215a3", + "docs/measurements/h264-rounds/round6/g.1080p.json": "0217bf0b05b2fba9de3b28e9a3fb34e5b0d816a294fc79711422552f5dc81a48", + "docs/measurements/h264-rounds/round6/g.4k.json": "102af54a26a1e4d748904bd3ebf03bbe531df6c2dee6b134dd1c882d7521bfde", + "docs/measurements/h264-rounds/round6/g.720p.json": "7effe6ce0e3dcb1826c94b491bcf5fef98ce660abcd0302a2e5459f628abf49c", + "docs/measurements/h264-rounds/round6/g.sd.json": "27f2b190d6fbf5353ab56c626a539094692a8b14aacb4923e9d6e1f5165cb896", + "docs/measurements/h264-rounds/round6/g.summary.json": "b95b0a23fd8ed37921f1beec07463b789e5c94381a76f69b3da86ef04916f4b5", + "docs/measurements/h264-rounds/round6/identity.txt": "d42e01e47d7e96fb067e6d8806c6223ff15ca0f561720f4555b211f2d94287a7", + "docs/measurements/h264-rounds/round6/t8.1080p.json": "c68dc73b2f4ae46dc910b107d32bed5fa59236faffd1f9ada61bfdc65dbfe7fe", + "docs/measurements/h264-rounds/round6/t8.4k.json": "2cd46b2a0e62956a30264553a3c48f21cf3e837a665bb43c9c1a1105c71ae18a", + "docs/measurements/h264-rounds/round6/t8.summary.json": "ff2468ed612530117ccaee08b84a9bde1e4e1f7b64cf271796813e50756f17a5", + "docs/measurements/h264-rounds/round7/analyze.py": "b659afe5d61909d6161b412285415fd6100c36f0408ff863ca02fba34a4215a3", + "docs/measurements/h264-rounds/round7/g.1080p.json": "eab3cd6e15190cf7c1e0fecd8d9ba9856ed2adb30eabb80848c5b24b74a89c34", + "docs/measurements/h264-rounds/round7/g.4k.json": "4bed18a47d38b3555f56efdde116cc58ffdc94ea3937efc0881dd8269c449e7c", + "docs/measurements/h264-rounds/round7/g.720p.json": "3b536674fdc4fa037002b416bc1673425b55c6e2f1bc7c49ce58daa3961d43b5", + "docs/measurements/h264-rounds/round7/g.sd.json": "03c8a68c38ddcbac17fb0e82e24254fbfa15779c548239532e412744a8866c01", + "docs/measurements/h264-rounds/round7/g.summary.json": "f22971517a74011734b681c67d9e8d9d68d617eabe7ae0bff9e344cf8b8d126a", + "docs/measurements/h264-rounds/round7/identity.txt": "f32b7b71f190a7fefa4d113bfe16a9855c368f2cd35f94592baa9deb1bce98e4", + "docs/measurements/h264-rounds/round8/analyze.py": "b659afe5d61909d6161b412285415fd6100c36f0408ff863ca02fba34a4215a3", + "docs/measurements/h264-rounds/round8/g.1080p.json": "9d8586e55bd983adefc1b6ba6d4715dab531045229887d82ed19eea55a2b7422", + "docs/measurements/h264-rounds/round8/g.4k.json": "653d29d4285c15787039b84d7530de9987e717466b414714c959b8d12a6d55ca", + "docs/measurements/h264-rounds/round8/g.720p.json": "aa60cf5567c0c5934dcdb49caec2faef712b33d652d5258c15c5d8ff1290a289", + "docs/measurements/h264-rounds/round8/g.sd.json": "d1fba7326909aed22aac70944ccf63e5c353d6f87602a2aeb03c98609253a234", + "docs/measurements/h264-rounds/round8/g.summary.json": "2ef2383ba8b91850fab1dacc7441b18eca51b623e846a77e37a7d2c79e7223e7", + "docs/measurements/h264-rounds/round8/identity.txt": "31e2409deb4bdda6a6d86488a77de1a47c212db6fcc60d84ea75ea6a5657533f", + "docs/measurements/h264-rounds/round9/analyze.py": "b7e2ccf9427558eb208016ebae79c3552f84cc9e35f50c3a2fe9cf33b1a074ae", + "docs/measurements/h264-rounds/round9/g.1080p.json": "5b3e55ae3e0e9c2626c6cb76388abc51c77ac2065a4366e077d0509ae8b41854", + "docs/measurements/h264-rounds/round9/g.1080p.log": "da0cd0ee535cafb1b4ad074a3c758cbc82235aa90d6819bca538ae152cd61e86", + "docs/measurements/h264-rounds/round9/g.4k.json": "a5079a970f961fd53bd68b39343a048b6aa5dd6b5f8dc852fb47bcddda4f402e", + "docs/measurements/h264-rounds/round9/g.4k.log": "f8d52ff8ad70d0c31b76f1eac09a6a20f64fadd246db466f9589615d7c2cc3e2", + "docs/measurements/h264-rounds/round9/g.720p.json": "91fe9f7cd53382def40f6214a044e3b3fd6cf7447fba17fd3b70bd732d68c507", + "docs/measurements/h264-rounds/round9/g.720p.log": "5caaa19d7cd3e1a4fadd2921d718b977028305470eddec6466e7498a60568e21", + "docs/measurements/h264-rounds/round9/g.sd.json": "7788fbb8f267fda94b9c66d1f71708943dc8c133a01f51e4ef6f4eed55d9f2bb", + "docs/measurements/h264-rounds/round9/g.sd.log": "da94a52464537b5a3e8e2b13fc7aa25e57e713d9e29489f5ef7c5d48ca66b31c", + "docs/measurements/h264-rounds/round9/g.summary.json": "5f3f47dd8142ca7ab1c90297ed04f3cae797814ff0ba0c3942f276ca7f064f7c", + "docs/measurements/h264-rounds/round9/identity.txt": "8b7951425d9da30bafaeea018bf4a0aa6d3a1fb61445191881f58b15ab3d7f3b", + "docs/measurements/h264-rounds/round9/provenance.txt": "6c5a72a66bc04c4062ace3e65913970f01ba4a6f74305c1142e6dc1153f00286", + "docs/measurements/h264-rounds/round9/run-notes.txt": "2cdbcefaea385b90a6b4dce3f5bca99820bd98bdef8c9bd4bd0235a64dc1763b", + "docs/measurements/h264-rounds/round9/run.sh": "e26fc211e3ed10a3195751219dde35844a3887904a752502d7de6f81f1b26ecd", + "docs/measurements/h264-rounds/scaling-8t/README.md": "a9270057ffd852070c45add8111c4e871abee3e5c0334d9555db484c30575f74", + "docs/measurements/h264-rounds/scaling-8t/analyze.py": "b0a7779b8bce213ea824838483c251e6fc04a118fff06634208c4042f861f158", + "docs/measurements/h264-rounds/scaling-8t/binaries.sha256": "94881af07c3de1fb6cfbfff9b00ffac214e4c5df287fc37302bffb93840e83e0", + "docs/measurements/h264-rounds/scaling-8t/callers.py": "511121d4d431277adc4383142879196719da17b485b5ee4431fe8610a031e6d0", + "docs/measurements/h264-rounds/scaling-8t/callers_items.py": "f88469c3993454b12d0a5bcf4584a65b43e611ce1d8a81ec5c87786eae0fe055", + "docs/measurements/h264-rounds/scaling-8t/identity-probe.txt": "809a420a865329610e2e0b358be25d938e3c59ec272880af02b75352d7eadf36", + "docs/measurements/h264-rounds/scaling-8t/job.sh": "3fbc4337ca8ed47664a1cd1e8a90425fcde4fedfd120c50a510ff8d9911a68d9", + "docs/measurements/h264-rounds/scaling-8t/job2.sh": "a8aafb8ac9b6ddd7faf83a9f340b1b39585f44e87b955304055dbf47a6543ac2", + "docs/measurements/h264-rounds/scaling-8t/plan-probe.md": "d408c73bb3e258b95522a928cce5c0e9eeea48ce0af78482ab11e6c8fdad5f5b", + "docs/measurements/h264-rounds/scaling-8t/plan.md": "067ccffc25862a8c9cfe0542aae1c1c6696441e4ab010116d5bbae72df2ffa24", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/gcp-job.log": "e0de2aa75648e074b93d2c3a8289bd034e25891ae7ecbe335e379a8c51564234", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/host.txt": "5570aa0b5257954ddb0c1e47bd77720a7aae6b0a03c78ac7606935207e8c96af", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/job.sh": "674417b930423416d7d35b73ecfbd99dd09b0a2aca96df388f302b7fd1f76dc2", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/progress.txt": "293fb2442c46ffe84ace60ddc0864a1a8473883916c4b55865a948412a8a70f3", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/pv-summary.txt": "a4099f1b02ebf9004cf262d81368485c10b1d6de8f439abfd87ff33023f5f905", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/ref.json": "29bdd4a02961e86f915d7c123d919206cc826713043632f0b77ca1872731ebe7", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/t8.1080p.json": "1f1689a876a62eba57d91752e902bd600b990c6b076a32a8244afdc1847d391b", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/t8.1080p.log": "b195476713b2eaa09e22866a9bf1df2868b50be44a99ed14c6b120248b8c6694", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/t8.4k.json": "c1b4362e63fad4579afd514a2371c6049d03aa16393235f77edbbc54b09225ca", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/t8.4k.log": "94e3209cba89fa3f7baa04a21473d3da8af47cce967ee1bd4da211e31e38ea3b", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/t8.720p.json": "cdeb96a45c97749f3dd072eb45afc8f8612f5784ff04097794de3faad7e027bb", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/t8.720p.log": "34b1fb7cde5f8892fc4928241572753eba593184d853bcdc2ac35588092026a8", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/t8.sd.json": "72149fc5f3eb4ee56b8a480a0ffdd6d03c8a6495323545c1e2d8ddfe54ca8487", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/t8.sd.log": "e42c2fcf2c2f21a5b3026e9e7274059690813e9b4cccea56db9319b6ac662837", + "docs/measurements/h264-rounds/scaling-8t/pv-run1/verdict.json": "0a4ebd07ca953412b4c89f2c1e124fceae11f941ca3676ddd2c9432eb5166536", + "docs/measurements/h264-rounds/scaling-8t/pv.py": "da10bbf7baccec27179de147b4268907295b0c5a0e6d75d508ee9d364008942f", + "docs/measurements/h264-rounds/scaling-8t/run1/factors.txt": "8515a0bd564c20d73a48922e4abc3a96323c0c035486f306320b0f1a6a69bb77", + "docs/measurements/h264-rounds/scaling-8t/run1/gcp-job.log": "10b157d4fa5efbc2fa9eaf041ad7acf264467116a9f35aa4683ace975ec796c3", + "docs/measurements/h264-rounds/scaling-8t/run1/host.txt": "3944a9764c9e78a6c499856771e346ff693e61b0570c31e1088d532c72c3184c", + "docs/measurements/h264-rounds/scaling-8t/run1/items.json": "a584e695b303c1cc417c60840181e21af562784be4d3e5e7fff97bce6e0fae47", + "docs/measurements/h264-rounds/scaling-8t/run1/items.txt": "4ff84222da5e258d9816338b2fe6deb211c6bfb46fcab9918a28a3fb340af275", + "docs/measurements/h264-rounds/scaling-8t/run1/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/scaling-8t/run1/orders.json": "8ef3ff23f54bc189bd3e7a45aa74ce5338c605ed81f47ba059b65f83bca8009b", + "docs/measurements/h264-rounds/scaling-8t/run1/scale8.log": "719a34b1a7b5d09640abd7595cb5713936d8336c2b3c3843b066d50a6ef2ec90", + "docs/measurements/h264-rounds/scaling-8t/run1/stat-rec.tar.gz": "abd17315d228d1ddaa95cac9652fdf4d2bc82e4770aa97e8efaa91e39ae75fbe", + "docs/measurements/h264-rounds/scaling-8t/run1/timing.json": "93aac72ec79fb1a197f6f0fd8851f173ff1a95e927f15c6a98acb746d3ce461f", + "docs/measurements/h264-rounds/scaling-8t/run1/viewpath.txt": "49bd7b5d91a836619d70790da42e13fb044b76662141f343e1555891569df614", + "docs/measurements/h264-rounds/scaling-8t/run2.void1/gcp-job.log": "16636a3327c7e0e6a39e85d583a12799be080225fa3c6f0548ec74e939ccb9fa", + "docs/measurements/h264-rounds/scaling-8t/run2.void1/host.txt": "7b258621d36bdef2b0158e10582730196130ed4b20088aee6cbd041950dcef6a", + "docs/measurements/h264-rounds/scaling-8t/run2.void1/job.status": "85a0e6eb5530a682fa88345a5e7a144248f49e5b71b3eb587a9db5cd2957495a", + "docs/measurements/h264-rounds/scaling-8t/run2.void2/gcp-job.log": "704991832e30ad130313d1cb5172543e445b06e54280957c20a1ecbe713b312a", + "docs/measurements/h264-rounds/scaling-8t/run2.void3/gcp-job.log": "559c6cac656b854af87ace58099698c9ebe198da864e3abb08e75387290362dc", + "docs/measurements/h264-rounds/scaling-8t/run2.void3/host.txt": "2a5f22b228920a05176760e999fba07f54345320523a066ff7ed973059499c3e", + "docs/measurements/h264-rounds/scaling-8t/run2.void3/job.status": "85a0e6eb5530a682fa88345a5e7a144248f49e5b71b3eb587a9db5cd2957495a", + "docs/measurements/h264-rounds/scaling-8t/run2/callers-items.txt": "a0cecbd13b0c85ce081dc120fa2b5aa321c752d8fd6ab577ceb1106f3d773769", + "docs/measurements/h264-rounds/scaling-8t/run2/cg.tar.gz": "def19db3c01b186caaae391555444e8dce0740ba765b98f13fa15d5762290ea8", + "docs/measurements/h264-rounds/scaling-8t/run2/gcp-job.log": "b89d0662c2aff41f28ad2fe2d9e052ba0c885d8fcb7ae5deb45195ae1aca29f4", + "docs/measurements/h264-rounds/scaling-8t/run2/host.txt": "dc322e3d18c3b58d6f294736de796273155b5fb189829a81f74c3c729e9c92e1", + "docs/measurements/h264-rounds/scaling-8t/run2/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/scaling-8t/scale8.py": "c4ba5917b363cc5660ad222061e8680ea74b5e217f897ee555f2b417152c203d", + "docs/measurements/h264-rounds/scaling-8t/viewpath.py": "b7ec03d4bad517fc5130d6b9be566843bb5dac4343d40b82a60e55fd97c970b9", + "docs/measurements/h264-rounds/slow-streams/README.md": "1fd8437e6e24232acf0e40310697171ab70223b6ba53b1d62c214b898c49c753", + "docs/measurements/h264-rounds/slow-streams/causes.py": "0b608affe9ab09d48e9c32640ac3391a04d9fd8ea6c1b01779b687363bcd8576", + "docs/measurements/h264-rounds/slow-streams/per_stream.py": "60ac608b195b852fddb15ae2d1dcbc21577ff89e16ac857b6a5bb3e5325a7aa7", + "docs/measurements/h264-rounds/slow-streams/qp.sh": "49aae11181a7b688c5b7f7044baf46a6c8c8d4ff9084c1814414fafd256b8f68", + "docs/measurements/h264-rounds/slow-streams/run/binaries.sha256": "f6775bb26f2ee79873d45c9b6143bce62b8d219850cc56060ec1d838cac1ca54", + "docs/measurements/h264-rounds/slow-streams/run/build-order.txt": "b4f00e3c0512c84bcd78e35845116049ed333a52c5a4999b66f4419e748df611", + "docs/measurements/h264-rounds/slow-streams/run/causes.txt": "053acc3fce150f81a0b306aeece8e936ae3e4b5c4a52465958b508b25ce28c60", + "docs/measurements/h264-rounds/slow-streams/run/ffattr-output.txt": "4a3ea8cc897c3e4b14084dd2a826b872d1eda040442ea14dbc5a9f5f9be31935", + "docs/measurements/h264-rounds/slow-streams/run/ffattr-sections.txt": "87cdfbe7602234128481ab30cd89c2cca0cfeeeb240c20d645f60532e6a27e81", + "docs/measurements/h264-rounds/slow-streams/run/gcp-job.log": "30c1f342bd1846247013cc3d45efaf07047121859a48acd6965d1ae235741ba4", + "docs/measurements/h264-rounds/slow-streams/run/host.txt": "d7a1491156262a808a49fc06100a38cc9cf3e9b957cf7d0480621bcb40170bad", + "docs/measurements/h264-rounds/slow-streams/run/per-stream.txt": "474c4d419247b4d67fe3b2e6e93a97ce25583137c16565556d53fb92f8a0d1ac", + "docs/measurements/h264-rounds/slow-streams/run/qp.txt": "2206b0832ee1069ec13394094229929a0029f954d550847c03b91f192dd9b118", + "docs/measurements/h264-rounds/slow-streams/run/stages.txt": "102d227f273be89d15c7d2b4647742e46c05c68924d30a9b70dbfccc58dd5818", + "docs/measurements/h264-rounds/small-one-band/README.md": "a781b258c31c524c019f5b1ed1b7ba448282c54e7c3442fe1256b15005691d6f", + "docs/measurements/h264-rounds/small-one-band/bars-1t.json": "0e1bfd7726ce912c23d8b65e8d5f43babbc5fdeab22f30caebeb4ff420ec9141", + "docs/measurements/h264-rounds/small-one-band/bars-8t-heldout.json": "98b6cd1783f4dd5a6c461e820f70a7c0753f122fea53c67af122a854ff94d2c5", + "docs/measurements/h264-rounds/small-one-band/bars-8t.json": "4bc2a87a0dd8d84d58f6fa101011c2fc559d616b8617395289f571b699d059a7", + "docs/measurements/h264-rounds/small-one-band/binaries.sha256": "b748744743e2192610a2a6f734923c4b4ceb4c055eaa29ae23fe1356d0879012", + "docs/measurements/h264-rounds/small-one-band/gating/analysis.txt": "781134567315a828301ce4cc833cfe5749f13251d17f9ddf9742242360ce34a6", + "docs/measurements/h264-rounds/small-one-band/gating/ffmpeg-summary.json": "aabcb06cf70933fe241e1b1e87d8b1c963851a6e8f6b1be9cc3e3f7be0b33dc4", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/host.txt": "4bef1d0f5352e8ac68287a494e3c04465a815f60f446883e830c4bd5ccad0133", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/instance.json": "f97896bf30c18f8ad89081a9b0a21d31802a69d7bcf157eba40e99e96707a298", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/job.sh": "2e82f209a3b5307f1ef149ed11eec32306dc121a9aeb63891e9da1161b76658c", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/progress.txt": "1de46024f8723c3c033c0468d879f3a37f66ba4b69284e38747c573dc3d03c50", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/ref.json": "0e443ff3971a78b99c934fa0a7077f54c9012b034613a2d5152022d7401a2b41", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/run.json": "7a9ccd4e0e0e5d4c589783d45242b7ac3c75fdf7bf435f08819baf766077d9e9", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/t8.1080p.json": "b6c05ba0f6ec1e314bc640f64065b7b902c99d091fe9460bfea6c4e2d035c116", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/t8.1080p.log": "76e26380e06c775de6933db01d2850623f25a78018b6580d3a055dbba7aabf16", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/t8.4k.json": "0ecf44fccad63eb51538fbe86287b37c69a1882d66b2f97ba503de3e1fff429d", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/t8.4k.log": "b1aa0125fb9d2902f86e066b40800ca62a9c97400636c097044c5dbf3f6dc759", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/t8.720p.json": "c251d4ec3640750f3009bc7942e1ff2e5acbe4301b5f553ebcbd2c8c2821ee43", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/t8.720p.log": "c56e423fd55f5b4498d717c824458c0efb5aa8912ede29eacd1df26dc8ea6c2d", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/t8.sd.json": "851901786273876eef473d252c03720ef270d2834d6e33cef6ec32d1a65388f6", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/t8.sd.log": "316bd6c2d703d3c65fb0da39a9aab32ee53ed134033535125abbeadda653fad1", + "docs/measurements/h264-rounds/small-one-band/gating/gcp-8t/verdict.json": "9be969929a31672bc79d46d8dae055858367cf978bfce3e2384e7077a32ffa4b", + "docs/measurements/h264-rounds/small-one-band/gating/summary.json": "2dd9efc3919b7d1244928fa12c5ae08fa66cd11567d8aedef69b9fc6dcd1c135", + "docs/measurements/h264-rounds/small-one-band/identity/host.txt": "3926c1872f85178484c2f45096c6da73595a4073efdc0271b18eb23a38726599", + "docs/measurements/h264-rounds/small-one-band/identity/identity-summary.txt": "269936df45bbf8617210d3d25de68bd3797f6fbf9075ea1726b217760c59f789", + "docs/measurements/h264-rounds/small-one-band/identity/identity.txt": "74a321832263024186cd3fbe5a5f3e2e1fc5961999287f43c03cf9eaf8b3ae1b", + "docs/measurements/h264-rounds/snapshot-361cd29f/README.md": "4af4ac768cf8c5b8902c553c0435e5df22b8311cac33b1c9e45f0b5bf5ac398b", + "docs/measurements/h264-rounds/snapshot-361cd29f/analyze-snapshot.py": "3dd3d899ac15eea21bc9fd9f5796803e5e1bc2d2e1c78fb592c26bb445557f6a", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-analysis.txt": "f720722bc8a2ae1a50fb148289b72fe6f4a296419848aaeb9e1167cc37701925", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-heldout/host.txt": "eb22019aab8a33b9b68766ccac38eee1f4a8306eea0b9675aef9be3660093724", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-heldout/ref.json": "05e0f85745c81b45e9b48259b8280d495b6bcc0a5d0b029fec84c3e293e21861", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-heldout/t8.1080p.json": "7a979ee02ea33f400c3bacbc32007d847e73876e2383d11583d60c2fd7218298", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-heldout/t8.4k.json": "b157c89331f77b505a9697d234f7bbdfd03c66e4166a76b155f3739d8458ebb7", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-heldout/t8.720p.json": "7f1929ef093129af69c660161481bcb61a91a445b32d2e59d44f71b544b66674", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-heldout/t8.sd.json": "51fa45fb452f266c51e2aa37160ab322c937170ad9874d783f9edee2452b1661", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-heldout/verdict.json": "57f713d6b5bf89f1d4249233266a066dd9f3b5b0c964ebe2a424ec72f73849b8", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-training/host.txt": "34e7b8e214323d8480429b6c5d5b54842f21046cadddabfc5bb73c0be3d596a2", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-training/ref.json": "ed95b8181deae0c37344428abc21bb60a2236ab16def354493064894647d31e9", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-training/t8.1080p.json": "09749c08ebfbc72e38f87409e7c54fb9d9e9b47be5c389fc32de961a716fd39b", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-training/t8.4k.json": "273bfce23c8e5ea1d1bbdda433686428a85c567925d6215040d25f02dab4f499", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-training/t8.720p.json": "8ae88c82068c0552e5cec7621f2614f588aa5efbcd905601483959d19eec8b2e", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-training/t8.sd.json": "b0af6a133e9f83d0f340383afeaac38b0ec5adb446c7b389141636ee277b9468", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/eight-thread-training/verdict.json": "ff6b400f0bb3862fcbb3da87c03cd0da7bcd0b1580592d6c22a6f6e96c051447", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/analysis-1t.txt": "c11a1f06346bf652916e82ade040405ddeb500792b53bc74b2aba9fe486b3865", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/g.1080p.json": "ac1554cd25d53268093f6b59edd13eb4bc3742178acbb37513ec199a1f4ca736", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/g.4k.json": "60e1a9b63865a5e27549d20acedcf707efddb78a6f70d7ed10eb49f036497bee", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/g.4k.json.void1": "467c0afee81aac3bb7c4b4769600af3ae4294675c8e3fd4683e4698888b8bb2b", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/g.720p.json": "239847c6fd18cce3a6daacf51b90401fa0b3a82408863fb4936ce7b0b8579320", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/g.sd.json": "b164c589e55d80f23dc26f49a2dd590cea4234984686550aac358bcaefc13a7d", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/h.1080p.json": "78392350a60d7c681934b971b74fe9991195b4aa81cf52420d653baacb83294f", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/h.4k.json": "c59ba2be197da35f4c6b47b7b7559c374d33ce01c2e00f9c5ebc0f1be67cd378", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/h.720p.json": "c7ca096615691704da29d87a60a9835b18383664a36ac3cf2e6fe48cd4eb327b", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/h.sd.json": "d03b37cfa0b6b0a84e0d7d1101d40bacdaf7edda9aa1db4b86fe294acbd94a71", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/hostgate.log": "031844bc6fdad0e2b57ef8020f54c0d052224b514ac4baccc40bfb340c5ae3d7", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/provenance.txt": "caf3a53447f405394dfbc0e5f922a8be10513b7cbfa986ec94fc888215c8a603", + "docs/measurements/h264-rounds/snapshot-361cd29f/raw/one-thread/summary.json": "d68eb6db42dd2fa3dd840bc59725de6f88a45be86442f0bf4d776b934c7bf246", + "docs/measurements/h264-rounds/snapshot-outliers/README.md": "39865ffafa895edcea37b0c085339391a22073089e7bc921af6cda18cab48370", + "docs/measurements/h264-rounds/snapshot-outliers/cavlc-two-level-ab.json": "e20db66532536baefe5e9e964d846e7eddc45317d7226af045b2635bf5561e64", + "docs/measurements/h264-rounds/snapshot-outliers/cavlc-two-level.patch": "271e6fd8da2866a34a7879b44ac935972debf08ba798b395c0855a253a61a0d6", + "docs/measurements/h264-rounds/snapshot-outliers/classify.py": "91446c9a45b874101014f45972868c8d1b9bb4d28fd5cae2b89b8cabd1729728", + "docs/measurements/h264-rounds/snapshot-outliers/corrected-medians.txt": "d156898218ef484e1015b55a5193e2b001c025742ee9327304d4e29b5f6206dc", + "docs/measurements/h264-rounds/snapshot-outliers/corrected.1080p.json": "7fe991770ceb2f6fea07aeb499e8cda8afde1b50f53a598ffab3b3895ac5ce5a", + "docs/measurements/h264-rounds/snapshot-outliers/corrected.1080p.log": "e4a420178a5780d702aeba49979cef9e2b33f545be6e9be6a36c188177cc668d", + "docs/measurements/h264-rounds/snapshot-outliers/corrected.4k.json": "e43175f55d396d9544ae02684581581e729cb8eeac7288cc4375fe72c5e0199c", + "docs/measurements/h264-rounds/snapshot-outliers/corrected.4k.log": "5d2c06d2a3ee652fde4028df80f602e4bad24f9e3cba7c1948932fecb78d9243", + "docs/measurements/h264-rounds/snapshot-outliers/corrected.sd.json": "c8f649db28e7efc89183fb479edd2378d215282ff87578b64913933dd8fc07b3", + "docs/measurements/h264-rounds/snapshot-outliers/corrected.sd.log": "c2fd8e44fba8bddc8f96ee499f91a37b29ca4d7ab493820084c948df6803b910", + "docs/measurements/h264-rounds/snapshot-outliers/features.py": "9454c1c6e7217e88e9755fff31003c1a4236f3f94a528b927d61e52116111660", + "docs/measurements/h264-rounds/snapshot-outliers/features.tsv": "fa9b10851cb29f7c1f26373d65be1d1f1846a4e9106179d88b4d240e2d6f5167", + "docs/measurements/h264-rounds/snapshot-outliers/numbers.txt": "08bde0c566610048210b54f83035bab66ae6e65275ca28a00e308417fb4f8b0f", + "docs/measurements/h264-rounds/snapshot-outliers/parity-b41f-passthrough.json": "e32582253eacd72bc0421b226ec1b15fb3a4b65cb72fb79e74dce2d509eeee83", + "docs/measurements/h264-rounds/snapshot-outliers/stages.txt": "2fc7453205fc803a11250ce161b8d50784895b7b51caa0ce5816b603f40149d5", + "docs/measurements/h264-rounds/snapshot-outliers/table.py": "120d26bb13d2abcb8b252f004b116d84816c3d3ca4184b75f1f40f40733742f2", + "docs/measurements/h264-rounds/snapshot-outliers/vsync.py": "f63b151cc357a9d22f1f9d04026085ed77c72d28be1d65acf1306ffa1f979e01", + "docs/measurements/h264-rounds/snapshot-outliers/vsync.txt": "f524896836b8d66d0db4169a4d7919d8d7c5121f845c415bc90adec6c32b59a3", + "docs/measurements/h264-rounds/stages-after-chroma.json": "62b99b2e8fcd6aa123928402ba5847e37b852cac1f34bd88e5622dd9f8aae3b4", + "docs/measurements/h264-rounds/stages-after-deblock.json": "d14a686abd49254f7c4a9edc9ae730453c34f6e9d1f04327c07fd0e351f6c879", + "docs/measurements/h264-rounds/stages-baseline.json": "e4d69cd7ac42f32576ed5fd0a3af6b0ec7bf67b4cab23371ba61cc6a1995a1c6", + "docs/measurements/h264-rounds/step7-g1-conformance.txt": "446e7427446690ada95bb2cc897040ab1106e43d501c3ce243c336c89d5c47bc", + "docs/measurements/h264-rounds/step7-g1-identity.json": "5605a30268234777c79baea23c8b1adfb8421106875200219e16f823cf886e81", + "docs/measurements/h264-rounds/step7-g2-fabea0a.json": "a9d613f1f1a8467e4c7630e233e3ca36dbefe32258ea89b54acde01d342e25a9", + "docs/measurements/h264-rounds/step7-g2.json": "acdde5ca0c67f74cf528c762b39f06e1dc6011310f707d4eed823b887647059e", + "docs/measurements/h264-rounds/step7-g3-fabea0a.json": "c785a7f301fe9f315cff26772e9591a6079e8b771b326a250de29b3403c8e8f6", + "docs/measurements/h264-rounds/step7-g3.json": "5f179ef3f912ff08cc7be537805b7795a20d0dadc02cbd3fe154b645c7f9c683", + "docs/measurements/h264-rounds/view-path-1t/README.md": "8abc3f38c48a9114cb367da38b450f77e975e64143e4e93c511201bdcc2d0f4d", + "docs/measurements/h264-rounds/view-path-1t/plan.md": "fa1fbc2f38514990ac0f5a27cb064ed8c7ac91497d5cd6a4a28ba7d3a0483c46", + "docs/measurements/h264-rounds/view-path-1t/run/host.txt": "71cfe514441dc7d80e3d202496546bd3dd21754a505e7b28d4bbd6f66d95a9f7", + "docs/measurements/h264-rounds/view-path-1t/run/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/h264-rounds/view-path-1t/run/job.sh": "9950cfc449fc62fff8fdcd2cb9705acf1baed943adde30f30b6b1ab204b5307c", + "docs/measurements/h264-rounds/view-path-1t/run/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/h264-rounds/view-path-1t/run/progress.txt": "635a6101ee3aaf2794ec3de5ed86480560ea3e3a43e14157240bd91716afac90", + "docs/measurements/h264-rounds/view-path-1t/run/ref.json": "ad9cac64ceef823d1d2ea3f08b80506af220ef5cf6150d760861edcacc9809e8", + "docs/measurements/h264-rounds/view-path-1t/run/summary.txt": "3b1da6a16b7ce648485654051cf909177f987a1dd449d5b5b403952890a05a42", + "docs/measurements/h264-rounds/view-path-1t/run/t1.4k.json": "ca24265bbb1a4d758328a5b48b093d7cca1fa1025e3866d7fbe85c9e2b775b3b", + "docs/measurements/h264-rounds/view-path-1t/run/t1.4k.log": "be68962c87d93d63c012bc55b55c7005b48073087937b2f15891f10ae15fb614", + "docs/measurements/h264-rounds/view-path-1t/run/verdict.json": "4c329dd5b1c1f59fa25386f5cf477819f8469c0b236af2ee4c276148cc9c8837", + "docs/measurements/h264-rounds/view-path-1t/summary.py": "ddf036b60c40f9ce59908fb9bf8b0b8048d44b543b06298ea3d0946749a91861", + "docs/measurements/h264-training/README.md": "8c30de1bbdfb6ea848205ca88bd11dbce106ed1e49698f736f603e0775d27d9e", + "docs/measurements/h264-training/es.json": "7977398aace20aeac335a8a39ad423b18da7ba2122cb06fe2a99cf0fdc48417b", + "docs/measurements/h264-training/list.json": "2dfed9c93718643a2b378ccf00f7bc492000a971f132ea539cd0cda0991394b8", + "docs/measurements/h264-training/profiles/dd8e81c.t1.json": "7b25b2ba9a56e895eebfbe32c8cc57a3bbda82acb0eeb3701135a879ab18d57a", + "docs/measurements/h264-training/profiles/dd8e81c.t8.json": "1198e7964854398008223f80528f806816d1cb3b39b7566506ed40939500539d", + "docs/measurements/h264-training/reports/calibration-ca5e4bc8.1080p.json": "3c53b5e87ee07aa123fe6f1ab4c557f15f6b6f0e8e29707c37ee3ed9618e104a", + "docs/measurements/h264-training/reports/calibration-ca5e4bc8.4k.json": "7ea1d02ed3f3169c1f0bff93d3f8fe33cc901560c7beccf7137ae020416b7299", + "docs/measurements/h264-training/reports/calibration-ca5e4bc8.720p.json": "fbfd1c74f21b10d62b65dd4ef194cfb52dce16a29d3237d65bcd419e52c62f42", + "docs/measurements/h264-training/reports/calibration-ca5e4bc8.sd.json": "270e62eae8594d9218e6091a21ce90f890909ced417a4aaccd4bbb791932d372", + "docs/measurements/h264-training/reports/calibration-es.json": "a6370125cf87891d095f28fc49317336833b4000d17568bb772590a4730b896e", + "docs/measurements/h264-training/reports/check-dd8e81c.1080p.json": "3643bbf85dd5124d1f285529ef1c2d89332fdcf76ebaa34c08c2066ee7753742", + "docs/measurements/h264-training/reports/check-dd8e81c.4k.json": "130a681823c2d4e13b07add37fb52dab530bf6e4f71c9225e80e8eb52fc8a23d", + "docs/measurements/h264-training/reports/check-dd8e81c.720p.json": "e63980f659fd9f32c5ece913c68508a42ca41d72218d694418c1cb7df756c2de", + "docs/measurements/h264-training/reports/check-dd8e81c.sd.json": "bd1706d971c6a4e314d9a8a5e737f7d346771401be44ed6c6b3c6b4dffdea4f6", + "docs/measurements/h264-training/tools/compare.py": "850cd2287568a592aa0c3a5af23d73c7079b3c7e7d9a0e4ae09226edfaae4275", + "docs/measurements/h264-training/tools/extract.py": "078373f6d1ff4e58bb53d230bef18c57f75e19941b635f32124d085050c510f5", + "docs/measurements/h264-training/tools/install-extractor.sh": "f2b869c4aad61fe7a00e2f9f3bed11748718237de056f791d9e1a29ef32dc2ce", + "docs/measurements/hevc-native/roster.json": "c0771e00a1b1c422df704d174acb60bbd0a9f1bf569458d462881cb90ab2770a", + "docs/measurements/kd-audit-writers-box-checks.json": "6d7bdce29125d1bf7e4d85d1a4b55491ce0cfe316544a2ef6788d42813f1eb09", + "docs/measurements/kd-audit-writers.json": "a2f9c4c8528300ff7ab8e2118b8b488b91b2bc0e8614dee90f3c526c283c9093", + "docs/measurements/kd-audit-writers.md": "7364dcd6fb70add7e2217109a0f950021889c172be26d716f20dc78ed82ca8d2", + "docs/measurements/kd-audit.json": "4b2c81669722c00a59d3e839afd899d5d54056b7dcac0bf105aad417b3f9d515", + "docs/measurements/kd-audit.md": "61b2692592a5eee6bb1ffc430f6c586bdeca092c57a1716a43ba174487391ec4", + "docs/measurements/mkv-demux.md": "116de4fc11baa4b219f611f32d168c038b933271047cecf84f16933fd4b059f8", + "docs/measurements/mkv-one-pass.md": "627295448b94e5a53d100194f2e251eacbcf18db556000820583b421984f7037", + "docs/measurements/mkv-one-pass/corpus.jsonl": "919c44b0b41ad5fa3e5c872460ee4d9630ae4af580e82449f4b31f2d2b001cb3", + "docs/measurements/mkv-one-pass/harness.rs": "8882bc8c1e5a269711bd7372acd953472f0a0705e21d220e7940985abd0c8242", + "docs/measurements/mkv-one-pass/native.jsonl": "d156a42b874ea9de9d6204c9673dd7439f3ac6ff2b735f6c1857cd685d5c2a2d", + "docs/measurements/mkv-one-pass/run_corpus.py": "8763b2b23b864e1ed973914bdee26516d45475002acba8426f71d290da9167cb", + "docs/measurements/mkv-one-pass/speed.py": "385f2cb217822fd3c28787b1fc736663f032b7f0e8d9dab7f3bbb0f31c1ed1af", + "docs/measurements/mkv-remux.md": "bbf23bccf4d7967b10c5a24c657f9ab508255534f2fa873e3665cf601b33d6cc", + "docs/measurements/npx-coreav.md": "6cc3496f00b818885a29f2603ef39b90a7300dcc21aa26ad3f1eec7d5f54922d", + "docs/measurements/npx-coreav/final-spot-check/meta.json": "157f74f494f9b1ec449ef953bb5cbd811648c80df02aa9f3e68e38b4a65f32b9", + "docs/measurements/npx-coreav/final-spot-check/results.jsonl.gz": "109838b0789f60dc8258a0d3cf580f62e75fb685aa22b60cdf086f84fee353cc", + "docs/measurements/npx-coreav/final-spot-check/summary.json": "3fc2a23c267fe36560afddab30a8981746f11948b3acaf914e5fe3bbb582662f", + "docs/measurements/npx-coreav/round1/meta.json": "5e03e0d75f81eb3859675db60ceecebdb3605d5191860d783a1decdb595dd305", + "docs/measurements/npx-coreav/round1/quiet-check/meta.json": "6bf8a05161b1ae4ab71ba7817236516321d2219ce8c5854d60da8c2fab23eb5c", + "docs/measurements/npx-coreav/round1/quiet-check/results.jsonl.gz": "b1ed4aefe76dc0885ad27267e7d6fa2c9126afd7579295f24773cea33fbe0d59", + "docs/measurements/npx-coreav/round1/quiet-check/summary.json": "dde52e748326f61ed48c6fdcbdd40a6b6e770c9607f3de1c4293ebdae4f94244", + "docs/measurements/npx-coreav/round1/results.jsonl.gz": "c4a3bf3f31a706458c193671abeae7d4fc1888ee96bf1b565f3a096b362f2e4c", + "docs/measurements/npx-coreav/round1/summary.json": "8de60a8e210cf815696215bae9a0bfa0491c38b74bc8e922df97b1d242682b72", + "docs/measurements/npx-coreav/round2/meta.json": "084d54ed52129dd93c2be730de99ae94ae4737ca8fe0806be66212bfd533aadc", + "docs/measurements/npx-coreav/round2/results.jsonl.gz": "6e22f860e0fd79440deb7a45c8514372c4c7cb4365a6b3d32a4766bb4eedfd87", + "docs/measurements/npx-coreav/round2/summary.json": "296e98fbe1a60b56cc46ab8d1e4f7f66fb5dacc8655b92f483e9a32ee732494e", + "docs/measurements/pgo/README.md": "acc8d365fe5390b6c33231ed4d812626029cffbb046efc3a9dd86350b8895613", + "docs/measurements/pgo/analyze.py": "98e29758d1654c9c9dd6d78ac1867fbd2a14fedf6f12b9f1b1d53b0dccaa2ee8", + "docs/measurements/pgo/gating/README.md": "a208430f53f407c04762074020ed7be20c7477b4ed8ccf1e21fa1702470cbe69", + "docs/measurements/pgo/gating/analysis.txt": "747d3544e51170119569ec548da1c0043ca1d72dc16b3a93ff98aa7fb3733fda", + "docs/measurements/pgo/gating/analyze.py": "98e29758d1654c9c9dd6d78ac1867fbd2a14fedf6f12b9f1b1d53b0dccaa2ee8", + "docs/measurements/pgo/gating/binaries.sha256": "8df136e086376d57e72d666fdcdbac8a6d9062a6975ba8f55c2ce90cc0d1ba86", + "docs/measurements/pgo/gating/g.1080p.json": "b60646b8a770f30f92cbc31181a23b319774e95a1529d8898cfabca5b6394889", + "docs/measurements/pgo/gating/g.1080p.log": "71865f41a3a9e59533fe1f4502fec6ba3d30c42e0970fea4bea65a72bca1ffbe", + "docs/measurements/pgo/gating/g.4k.json": "9bb396a99b6179efd97ab9a57753db6d76bdb264f550fbbc78fbf9ae936b8d3e", + "docs/measurements/pgo/gating/g.4k.log": "a348533d293cd2e47e93442cddba27f3de3aab5c743d67ad9a1adba402e1d733", + "docs/measurements/pgo/gating/g.720p.json": "731ff04b8778a31f588ef6d0d44a7f44ca1e6b7cebd5064c32b47aeee9d4c643", + "docs/measurements/pgo/gating/g.720p.log": "8c32b51f7d617ebe884ce41bce5319e881329309313e37c54c97f2ed5a76abda", + "docs/measurements/pgo/gating/g.sd.json": "4ea8a054d81ca03e42feb6ec74009d7c5ed7f5d2111c397ebd319d499a30aeae", + "docs/measurements/pgo/gating/g.sd.log": "ae05d8cfb627b6754f468bea781acde8537658c4aa0f0e15a9bd61bf475466e8", + "docs/measurements/pgo/gating/gs.1080p.json": "57967e55abc66993ec4b5fb820004dfe4d14c51239f3babc33b7e5b4bb740c5d", + "docs/measurements/pgo/gating/gs.1080p.log": "69ae39729b51797f6c7b93eacd8e50d532d35fe8d8949a2d95af8ef65c9e472e", + "docs/measurements/pgo/gating/gs.4k.json": "484666ea5410a2a56d7d4a68c1097b2f418d40529ca174f908195471e5a71f56", + "docs/measurements/pgo/gating/gs.4k.log": "215fc37ffd4918ded8d7ee63b0abb2803402d5aeb163ff47518372bed35677af", + "docs/measurements/pgo/gating/gs.720p.json": "2473ca670c9f84401fa3b57731c95e17ff8dfbfee1dc26470fc5a752932af451", + "docs/measurements/pgo/gating/gs.720p.log": "33782508f7227af971804892a8df8faa713041d4b60c9405be54400fec2e51d8", + "docs/measurements/pgo/gating/gs.sd.json": "c0b88bf063d35a46c320fde830e1d2a3a3d2ce0a692129538b4063c2244ddc69", + "docs/measurements/pgo/gating/gs.sd.json.void1": "c8bb7be686cd8a6d346f849bc2501cc463adc2fed87fbda5f94cec20e919e012", + "docs/measurements/pgo/gating/gs.sd.log": "d2edd18e2adfc4f7a7a6ce45b14ebea5647fdf67439d3eddbba9e3c90b4dd27b", + "docs/measurements/pgo/gating/gs.sd.log.void1": "0cfb7f3aa632a0faf228b3637425e23874de32f070dadde62d3700a2ddb8a0c2", + "docs/measurements/pgo/gating/h.1080p.json": "dbef3186091911288c24401752b51fcfbedc4b93075f93cec3fc462b9c68c11a", + "docs/measurements/pgo/gating/h.1080p.log": "558d110932a7ce5c9b3241abc0b327a066363bd843e5b0d3246a7a7453ec8d2a", + "docs/measurements/pgo/gating/h.4k.json": "ae968dd37d2c193ba89aaf3c8e0c7781de4aecaed31d701515604f313d247852", + "docs/measurements/pgo/gating/h.4k.log": "259f113a3c2e349da35fdbbb137e8bc1dfa7df74e439bad087d2284716d55e1b", + "docs/measurements/pgo/gating/h.720p.json": "628e701c56ee1430b629f4a944ba5099e26da61db4c45344e9aabde0f33b76e5", + "docs/measurements/pgo/gating/h.720p.log": "8b5f11fbf66298716f42719e0cbb8fbac6e548911ff4f02e95be196299167e2c", + "docs/measurements/pgo/gating/h.sd.json": "6b5ba170fe58722de8f20196a09e376e3d4a16b810bda6c3de39912f40cf1535", + "docs/measurements/pgo/gating/h.sd.log": "dce0d3e360a416aa6b6cb7cdbff6cce2184716ab332d773523fefb95791680eb", + "docs/measurements/pgo/gating/hostgate.log": "0b68a9a1f2280e77f38a638e80abe0482fa4b010d0ec650380883281fb3c5877", + "docs/measurements/pgo/gating/identity.txt": "4b835d7d0f807b7bf2f6c40de0fc18a96da12b986397df9de16a079660d74d31", + "docs/measurements/pgo/gating/inputs/extract.py": "fca30ef84b2f4d363c450f07c643bf4d820b2ef61601bc8315eee060b10125ca", + "docs/measurements/pgo/gating/inputs/fetch.py": "73cd119fc4e35e07df897dd5d44c4872e4ec85523dfb2078f426d3a95eefb164", + "docs/measurements/pgo/gating/inputs/prune.py": "44851aaefd85077538205bffb7d3d069824ad00fe0a266fd14fe2b37672406b9", + "docs/measurements/pgo/gating/pgo-build-fast.log": "d6cf573f6bda69a69667b93d5438de64b62e0f5e2385b9429ab63772410b802a", + "docs/measurements/pgo/gating/pgo-build-safe.log": "bf2eb8e8b47bdaf1aac09ba12837a81d2edb7c05368ef7b016cf1c723b5ad6b8", + "docs/measurements/pgo/gating/progress.txt": "058865fa5a5aa9f129b1c4fde98139df99675b77fe76f5ccb52393b2254ea150", + "docs/measurements/pgo/gating/provenance.txt": "e76d9ae0fd5c492a4941afd4b016ce3ba3b600e6c373144fe480e7d4a63827c7", + "docs/measurements/pgo/gating/run-pgo-helper.sh": "547b477851fb9936be595fa9340a3839323d5d4c9da5330650e14dd1127a9cd3", + "docs/measurements/pgo/gating/summary.json": "61ba95b3745ca3f802b3e7117a7385d2b927beb4e2f511656bde834ef620981f", + "docs/measurements/pgo/gating/t8.1080p.json": "caf420d3bc75bfa7f269948bb85da1f6aa4294ce63f5443b6246e1ccae870077", + "docs/measurements/pgo/gating/t8.1080p.log": "5e3fac000b202e59a2d99c0eddf742bb81ad0763d3291062023015d5b82e362f", + "docs/measurements/pgo/gating/t8.4k.json": "033672419da18448dd107a39867dc70bffe9c7be278c51916d056bb5875848cf", + "docs/measurements/pgo/gating/t8.4k.log": "3485e1d062398e710d62dde96a7d159e5f1d4a03ed025ac5a435195283f2c695", + "docs/measurements/pgo/gating/t8.720p.json": "552a3fa7f615d480d3e73333a7dbba0739dcf0616a2f74ed151affb467f0051c", + "docs/measurements/pgo/gating/t8.720p.log": "27b72f007ff72afcbcac455533c956b549d1025f5bbc4af5fb514d13014e11cd", + "docs/measurements/pgo/gating/t8.sd.json": "4f1bb55b2c039b92e8598004575649af78ba986ade759ee0b3fac3f2c488b875", + "docs/measurements/pgo/gating/t8.sd.log": "c8067f76df69ed939ef782e6a05ae52a7fb980cf7b3248e2b41bd27554c03deb", + "docs/measurements/pgo/local/ab-1t-a.jsonl": "4c7d7cc357c2107fe3ea81da8162c9eb378c51fcb49249c8d3b2f10ba64b4957", + "docs/measurements/pgo/local/ab-1t-b.jsonl": "9c264845ecf194c48a5aae2405b8dce635325506c7614fb389a0f1943a8554d3", + "docs/measurements/pgo/local/ab-8t.jsonl": "f5593414168e23523b230aba0a9b450831c9350bec607040b59c13922c729ed7", + "docs/measurements/pgo/local/ab8.py": "b1197849451d5216e4dc58ec7f41d3d32661b074d142e88614fe84a88d44387c", + "docs/measurements/pgo/local/an2.py": "f549295ba9396956d2b2e6169d16363e330e2de23bc83c3d5894aa4b61c139e7", + "docs/measurements/pgo/local/local.txt": "d4525f681f2596b2886fa766e440b2d2b1caae6b036ede5f5759df888bd15a86", + "docs/measurements/pgo/local/synth.sh": "ac3cac805fee48b37e2732cfec8cc33694d86801e646a561a7dcdddfab52faf2", + "docs/measurements/r3-deadline/README.md": "2a82c04ecb7c14a6c537be486a4653eeb4fe7e4403d05abe44e07d3dc69637e3", + "docs/measurements/r3-deadline/checks.csv": "ec4a338f8a2d076ab2b7dd2d0c0cbe2101c61b72bd7934a8a26521a1124177af", + "docs/measurements/r3-deadline/sequences.csv": "aa0c8cde6153546b07e118f2ddf366c535833190f2e55f2dd22ac682cf967a36", + "docs/measurements/r3-deadline/summary.json": "252e83b732bc32b458194fbdc9e3aa774d5eb5e16b6cc53377004e2f2f42693c", + "docs/measurements/stage3-correctness.json": "7db6a1eaf22c404cddb088a1bbbdb3888164f5963d3cef02092522d94c5101b8", + "docs/measurements/stage3-correctness.md": "f417417d063e254465ff317fa50d3058b27b522f9f907f3030c563d9ce9d6dc7", + "docs/measurements/text-corpus-v1.final.json.gz": "1ba73d743ca62c8613e4e3451c034744a25200e5b05e04755c082f5a51f4d602", + "docs/measurements/text-corpus-v1.md": "edcc532c283078c9cfd30aa2928a1680fd781878399a901c1d5339348323b103", + "docs/measurements/text-corpus-v1.recheck-quicktime-text.json.gz": "d1746eee950211310d4c4c865f9c3a7248b335f23e7d986cb75d11c3c209a870", + "docs/measurements/text-corpus-v1.recheck-quicktime-text.smoke.txt": "c4a25fc81d0b45a20eaa2b542bb9837c1d216b8385e1afa14b49070a3f1048e8", + "docs/measurements/text-corpus-v1.run-01.json.gz": "c48db045b6a856ecfa94c7e56840bbd6ba2ff99cd2f898ed14245847ca567def", + "docs/measurements/text-corpus-v1.smoke.txt": "e0f07560820fad030b5eb59879a9e8395973945be3e098aa4cc17222a857d036", + "docs/measurements/text-several-edits.corpus.json.gz": "8109cfdcdf82a03fc2981045dc380e4920a4fadd9cf7385d9185affbbd5423ed", + "docs/measurements/text-several-edits.md": "a43ddd6d906a2603b8fdd4c5a6349867a1b8e24e5713c9d179a0f983a06ee89b", + "docs/measurements/transcode-decoder-host.md": "8b332867eecf595946f17b5237834d155931d31cca3edfb7c17245f422504e8c", + "docs/measurements/transcode-decoder-host/valid/evidence.tar.gz": "c2a1d8ffeac10f2cdfa8e6c4743397ea8b2e2f4b7f10ec4922e2ac435c1515ac", + "docs/measurements/transcode-decoder-host/valid/summary.json": "3891125604b10f1aed8d70f08aaa463d1c8d5e1af5a1ccfa1e7ecc191f0e58ab", + "docs/measurements/transcode-decoder-host/void/evidence.tar.gz": "40ec315051f7a081cf09a6a98c846fddaad7654b653ef72dcd7323201fd19f0b", + "docs/measurements/transcode-frame-handoff.md": "612ceff7c1758cd6b74ace4b8a660cdacb34a9ea21d5456f7390c3a0f9f78245", + "docs/measurements/transcode-frame-handoff/reference.json.gz": "25a2e3dfa83390a4ec87c007b9bda53ba8337790829877c1736a9ce4ccd8e873", + "docs/measurements/transcode-x264-10bit.md": "e3822e30601973988db8f6f9d23a00e7e78fd425c5470f5207acf8e07ecad3be", + "docs/measurements/transcode.md": "ad346af01e86d14c8780c8eada6a1804bda50c792afbb85c4998594f67d03a84", + "docs/measurements/transcode/b9/calls.jsonl.gz": "5a2f192fd965bf1d66e1a902d7af4bad9e70aa4ff642ea7ee5a9d48dd4695442", + "docs/measurements/transcode/b9/manifest.json": "7d2576b2b6d2b09b145fbdde6231be1c53f7b170bad7c16a14bf7dea1c19b3d6", + "docs/measurements/transcode/b9/results.tar.gz": "7ceafbfd21e12d423a925085acd44c1dfe457b2db5a2f9ed606201deb10bb721", + "docs/measurements/transcode/fixtures/check.log": "6d0a7c090b9764614f95d5c04549a930ab15c25fdb33c1f184d973a9828df5df", + "docs/measurements/transcode/fixtures/hostile-transcode.json": "7c4a1d20754585bed49bfd6c592e3a564e3f9e4769121338917284fbcb536d02", + "docs/measurements/transcode/fixtures/results.tar.gz": "d4be09eadb6872451c2bc7d3594a808809f0a86a4c640dc9325a7def2046be39", + "docs/measurements/transcode/fixtures/summary.json": "4792d4a0988adefaf2990e67436c390d58b2894d575318ecb7fa851bb1e10730", + "docs/measurements/transcode/round-1/build.txt": "d2f0a7e2201c6c6400164ec2faa53470c403f66122c128e501df5a38bc6c8813", + "docs/measurements/transcode/round-1/corpus-results.tar.gz": "62516714ef553b5f5b43911ebefa6aa3c195fc06b518fe186d70d99f29ad433e", + "docs/measurements/transcode/round-1/corpus-run.json": "01be995ace42790e596ada545815e52034978aeef380ed5f8392f1e661f7a9b2", + "docs/measurements/transcode/round-1/corpus-selection.json": "b292abf372a5293e0b01379e7f49f4599716c0dd88b255b680d17e0d437553b5", + "docs/measurements/transcode/round-1/corpus-summary.json": "5b371b35f8af38aa39a7e2f9bb3dcf197aabbe968da121189eae745bcb7cd709", + "docs/measurements/transcode/round-1/corpus.log": "ee8666cb9c30b15e37c73d42a98f644a57d35c388874e1f28256a47fba08a0de", + "docs/measurements/transcode/round-1/speed/files.jsonl": "e8606d08f417858abed5f5a5c207d12dbc52fb76053cca105cbe80f944223d49", + "docs/measurements/transcode/round-1/speed/gate.json": "8ed73d6fdb133bf8d6c0716db3c8b20e95f3fa4b4fbfa55837658c1d5abdb1d9", + "docs/measurements/transcode/round-1/speed/host.json": "20a17ec11dc5d2e2055c89321ccc2b6e35866dd99690e6a1a529de5521b3abf9", + "docs/measurements/transcode/round-1/speed/host.txt": "5ba74933521d6841b5ed558ed3fbcfeb2d4bb384bc39ae59877b890e39c9171d", + "docs/measurements/transcode/round-1/speed/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/round-1/speed/job.sh": "fd97f48c096878b7494216be66dcb26d21f7d567532db1c17806ceab9cc4a8b6", + "docs/measurements/transcode/round-1/speed/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/transcode/round-1/speed/plan.json": "7d7b713553c53969869905824e46745bfdf5c923d652fd70d80a01d1c383e09d", + "docs/measurements/transcode/round-1/speed/progress.txt": "81aaae0a72dcfa9d3f6b582123155303a586917edce1a7b97d6e8d60b5d9cdab", + "docs/measurements/transcode/round-1/speed/speed.log": "6b3f11077ecbc0ed5ab85333570b117bb2f23fc76faea6ec6c73df45ab3aa270", + "docs/measurements/transcode/round-1/speed/summary.json": "73c4999cd4bdcda96b64a7ac66f3f3415c85a1794dbb86b3897f962a6d32e8f2", + "docs/measurements/transcode/round-2/build.txt": "19a94b426b2afb2692a76f1b542694354feea4bcba050f0fe840edd219675a41", + "docs/measurements/transcode/round-2/corpus-results.tar.gz": "ab3184ee1c65d3e90dfc8aef8cd52765c792c927e20adf1c4f828a7c28bc6195", + "docs/measurements/transcode/round-2/corpus-run.json": "d40d08fde2a799732a7f91a8da68ed6ecd5043b048e7114a29d8a4ca52f71449", + "docs/measurements/transcode/round-2/corpus-selection.json": "b292abf372a5293e0b01379e7f49f4599716c0dd88b255b680d17e0d437553b5", + "docs/measurements/transcode/round-2/corpus-summary.json": "8cbfac5f7a2044bb456ec20c9fcb11854ec49dc202972f8c79b314d86346f83d", + "docs/measurements/transcode/round-2/corpus.log": "9a109214314c2ce6d43c81cbc59b7ee2c30b2ade74060f0d63dd909f053553e0", + "docs/measurements/transcode/round-2/speed/files.jsonl": "6a6e296b001da4cc1749ed18f39e05415fae927edd08a70118cbd8d364382701", + "docs/measurements/transcode/round-2/speed/gate.json": "bbc8c20041062358e6d723b24dfaa080ba8d393017b10c0e0e1c7425af26c25f", + "docs/measurements/transcode/round-2/speed/host.json": "b4ca0e0bb7e1ed87ff677a5ed679ddad71caab698d9a5edda78af42d5d56928b", + "docs/measurements/transcode/round-2/speed/host.txt": "09a3450cdd72f347308dfb19223abb9db00582684bfc98f0959054816f844290", + "docs/measurements/transcode/round-2/speed/job.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/round-2/speed/job.sh": "fd97f48c096878b7494216be66dcb26d21f7d567532db1c17806ceab9cc4a8b6", + "docs/measurements/transcode/round-2/speed/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/transcode/round-2/speed/plan.json": "69d1f89f55a3be8ab9b59d48ebf191c5dc28f78ea869b0b9e6c40a438bb4e102", + "docs/measurements/transcode/round-2/speed/progress.txt": "e6c581153a253e7db77900914b04ee7c388a07c6b8dff4578a73c6f9a5b53b63", + "docs/measurements/transcode/round-2/speed/speed.log": "7a004bddedda3a4ae321935be6b23854bc3803213cf863841e26b0091e34f044", + "docs/measurements/transcode/round-2/speed/summary.json": "3e922bb810a59c69241a4f83c65a74e39b2001c41bede8726e327d1e1dc9d5a4", + "docs/measurements/transcode/speed-selection.json": "3a7771e8ce3b7122867adb64011616f5a4bc13947859287ad966c55410108c45", + "docs/measurements/transcode/x264-10bit/ab-job.sh": "5a9d0e79c33a36f4063bc99c43389f870a80c533cc22cfb4f34bb4c90e70d5d1", + "docs/measurements/transcode/x264-10bit/ab.py": "cf6577b040f3a57cebcde028c29a077ab5a7b231bda78dfed39445d9a5435014", + "docs/measurements/transcode/x264-10bit/ab/ab.jsonl": "af73091a0c903d3eeb2dc9c840cbbbbb9124a34fd7103d672bcaadf2c0e08cb0", + "docs/measurements/transcode/x264-10bit/ab/host.txt": "94c7b124c53d3b8732ee17d25c8d8f072f6ce7410e8183b4187c7b94abaa93bb", + "docs/measurements/transcode/x264-10bit/ab/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/transcode/x264-10bit/ab/progress.txt": "64da55161b42e3d26941b95e53d7beb0d62e5a947f9557ed49fc1e1356d8db43", + "docs/measurements/transcode/x264-10bit/command/files.jsonl": "2391c724a9bc4bbf20afb873bc9f45f1be051273a90db6925d377c2aa1ec7a45", + "docs/measurements/transcode/x264-10bit/command/gate.json": "acbbb9d81a0f1160fbb0489e2b7239181cfd83da1d19158552c73f4ab332125d", + "docs/measurements/transcode/x264-10bit/command/host.json": "ca0ec62935472c0f29871ffce4219976b686eaaeb692bc6951cc2c5b49132319", + "docs/measurements/transcode/x264-10bit/command/host.txt": "17efa72059709e944a778405a07e996b687d0ed1a8588823898aabe0fe248666", + "docs/measurements/transcode/x264-10bit/command/job.sh": "a5af2f7798a85068d6e4818d207e32e403e9f43d903099882f92d695006adc0e", + "docs/measurements/transcode/x264-10bit/command/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/transcode/x264-10bit/command/plan.json": "4c054f4c15abc73cfd3e93d76cbc8ff994441dbf24c6c8bb730730befa716b59", + "docs/measurements/transcode/x264-10bit/command/progress.txt": "6aa269c16ec906fe2f480bc60df48ffbae283349ddd378b28e783ac28538ca63", + "docs/measurements/transcode/x264-10bit/command/speed.log": "e756517ca1838b6b22edf5e3534e5555696a88fedf6e0cb24bf8979dc69bcf50", + "docs/measurements/transcode/x264-10bit/command/summary.json": "3f15e8b2c94ad2336c5e035d0baaf6424fc89cda42f683e4eaf021be886a7f5d", + "docs/measurements/transcode/x264-10bit/diag-job.sh": "16931466eb972463b2f2d7f91929dfd4a1f660a1919bebd7bb016c0cd6d9a998", + "docs/measurements/transcode/x264-10bit/diag.py": "2704f3870e084fee5b5e2d8ce3b7dde5e7d349c2d9b27262af6d8e6928bd4eb9", + "docs/measurements/transcode/x264-10bit/diag/diag.jsonl": "6badc383983e0a5302fdeee977391a31b505192827a0272050511400a357fc5f", + "docs/measurements/transcode/x264-10bit/diag/host.txt": "7317054baa9c5c612aef33c10f97bf66b6221532d71a7d0614311b7085fb7d2a", + "docs/measurements/transcode/x264-10bit/diag/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/transcode/x264-10bit/diag/progress.txt": "9e96bfe6250d91d01eb649e9594d93d11697c52dba116c62edbf2633017bae0f", + "docs/measurements/transcode/x264-10bit/input-depth-16.diff": "be46f4fbbda33a1b8fad04127b2cd68719d0a53afb3e9660f03279cbe8add9c3", + "docs/measurements/transcode/x264-10bit/job.sh": "ab7444ba18fac1e9ed3c15d0cf8f39b134de5947c1f84dd29952410f7824adec", + "docs/measurements/transcode/x264-10bit/profile.py": "a34afb510f9337dd01d50d15fbb1dd4cccdbfade2afc8659407cf32c0bb415b9", + "docs/measurements/transcode/x264-10bit/profile/host.txt": "343859228cbad8d11759516970457570a1eb1dcf3219485633d46ae421e6e50c", + "docs/measurements/transcode/x264-10bit/profile/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/transcode/x264-10bit/profile/perf-hevc-1080-420p8-libx264.txt": "552aa67e989c7ec4b235a9d9950fd3f0c9f26140afa1e494ebe8cde045689db8", + "docs/measurements/transcode/x264-10bit/profile/perf-hevc-1080-420p8-x264.txt": "cd1da070aafe7f304cc2e0b92bad0fe7571ff8054c1cd75787ac70f3251c0b84", + "docs/measurements/transcode/x264-10bit/profile/perf-prores-1080-422p10-libx264.txt": "937c8acf3cc1b0cf5c559297638b8c1e0d6aa7baef7f73b5bbf8f3ad9750cbe9", + "docs/measurements/transcode/x264-10bit/profile/perf-prores-1080-422p10-x264.txt": "598e0a8170ab275c21b4600db65e27de3b24760dbed31533617232dd06b5dfef", + "docs/measurements/transcode/x264-10bit/profile/perf-prores-4k-420p10-libx264.txt": "66281f24eba2846cbd579b6725e6fa0fcefe1a5de342026de17b7916073e32ad", + "docs/measurements/transcode/x264-10bit/profile/perf-prores-4k-420p10-x264-depth16.txt": "3778936d957c9086606627e776bebb3050519d2a171aab2c38e3171a1f5fbd85", + "docs/measurements/transcode/x264-10bit/profile/perf-prores-4k-420p10-x264-thread-input.txt": "6050e5ad3ee22364a64ff4b61d0affc8ed5c2a2d59b67b149f12525cd3ec0574", + "docs/measurements/transcode/x264-10bit/profile/perf-prores-4k-420p10-x264-y4m.txt": "70d1cd3c057d00fc68da2cb64a81051c6f8a7b45e438117ce410b2d32e6ca441", + "docs/measurements/transcode/x264-10bit/profile/perf-prores-4k-420p10-x264.txt": "01518170583530d3350b95ee04af7ca094ab5ac65aab0df49b7c69d9f53e35b3", + "docs/measurements/transcode/x264-10bit/profile/perf-prores-4k-420p8-libx264.txt": "144f029ae2875712be14f0761c435548e043a14f50ef3852152ea36ee438cbd7", + "docs/measurements/transcode/x264-10bit/profile/perf-prores-4k-420p8-x264.txt": "cbcef47d96c2cf7c71d2acc825c3e8d6e9c9642205f694f405bed19d6881cd0e", + "docs/measurements/transcode/x264-10bit/profile/perf-prores-4k-422p10-libx264.txt": "3b5bf96f388d8e5f7fffb247cd273408c8f302897c565e3b7469fe071fefa19c", + "docs/measurements/transcode/x264-10bit/profile/perf-prores-4k-422p10-x264.txt": "a6a1669fe23e2738cfa941adc0e214d9043e4752923ba7cbd21aa1b2772545d9", + "docs/measurements/transcode/x264-10bit/profile/progress.txt": "5539b7edf5ae6337ba93b3d5c2e5ac5551cdcd8316e49458bd9059b287f818b5", + "docs/measurements/transcode/x264-10bit/profile/results.jsonl": "05f0a988df92b8542f80d27b85840a481e0ac1f92d4f9dcd6a798a3d6dbd5807", + "docs/measurements/transcode/x264-10bit/thp-job.sh": "565edc4fa6ee64b4ef51bdace4d9c2f6b642c878b13e376b5702a22b35215208", + "docs/measurements/transcode/x264-10bit/thp.py": "ee0d7386c559fc57e336887f83ea25fdd99a1ac19078ecf1dada57e67083455f", + "docs/measurements/transcode/x264-10bit/thp/host.txt": "c1e25a141dd9e6dac0e626763e40b26c36163b8c3a3cece4c69b02cb6f8bf87f", + "docs/measurements/transcode/x264-10bit/thp/stat/d10-422-pipe-nothp.txt": "3f82720f50d48364a8bd6ffdae09be9752526800327a7b6d85af4db251198ad0", + "docs/measurements/transcode/x264-10bit/thp/stat/d10-422-pipe.txt": "eb76dad7c869a4327c65dda9a3abb1500690bd71fc49867bebff886800700fbf", + "docs/measurements/transcode/x264-10bit/thp/stat/d10-file-nothp.txt": "dc2fe3a85e9a305019d011ce816a6d13b926a91c433569ce74b39d48d6e97bb1", + "docs/measurements/transcode/x264-10bit/thp/stat/d10-pipe-never.txt": "8c4354a453bd693154c7c01e0a8ebb2d72916d7a2c33fa4d3707b3a39b2f8a33", + "docs/measurements/transcode/x264-10bit/thp/stat/d10-pipe-nothp.txt": "c91a8d71fcf50e2f11233ff14621bdd00fe9d1e979aef9e2abfede749e2793b9", + "docs/measurements/transcode/x264-10bit/thp/stat/d10-pipe.txt": "4bab1d91f27643e4443b25f8f7b5698a806a4da5317e1722ed2c1b84bfc6ffab", + "docs/measurements/transcode/x264-10bit/thp/stat/d16-file.txt": "daf4eab97fa57853fbdca7919bfae47375905309844139b5e333bf1c22a8025c", + "docs/measurements/transcode/x264-10bit/thp/stat/d16-pipe-nothp.txt": "996edd2afb904406533b4c0e7d4320dd89d12d0262c82766aade16801fe63fc3", + "docs/measurements/transcode/x264-10bit/thp/stat/d8-pipe-nothp.txt": "301de24db99383099aa189632249a98a642bfccc29acad1a89307d48aa6b56c1", + "docs/measurements/transcode/x264-10bit/thp/stat/d8-pipe.txt": "231ed317c951746d109648b6efffd4fec6d3eaad4f2b092710be2c9175351215", + "docs/measurements/transcode/x264-10bit/thp/thp.jsonl": "893b42952e2d9d744fd78d4fbb93c68462eb8128c7f9922763c8dc751d0e8a46", + "docs/measurements/transcode/x264-10bit/why-job.sh": "9d10ae34bcadc48970ccda9a5dd74cd95ec18f3a3cd616b35ec358484d2be944", + "docs/measurements/transcode/x264-10bit/why.py": "a72f67a12d60c1083d6c589500a7a8d9daa0eef40d6971bc41199adaa9e007b5", + "docs/measurements/transcode/x264-10bit/why/amd/host.txt": "e80169d57add9b5e393aa73eb3f94016368b389f6f083faf90d384ae31f11e96", + "docs/measurements/transcode/x264-10bit/why/amd/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/transcode/x264-10bit/why/amd/perf-list.txt.gz": "5f24a3f42e5be58d1cd4161ca3a42dca3e41a8a16edfb727ba88998bdc36b810", + "docs/measurements/transcode/x264-10bit/why/amd/perf/4k-libx264-file-cpu.txt": "bf033fc629f52de19c0e1d2ef62e5d154daffb1380e2a25dd3e7a1e875c19903", + "docs/measurements/transcode/x264-10bit/why/amd/perf/4k-x264-d10-file-cpu.txt": "2ba5e56e5b732a4376066a2a2f7e6227386243d14292c57cea896a1945073f7b", + "docs/measurements/transcode/x264-10bit/why/amd/perf/4k-x264-d10-pipe-cpu.txt": "a8eea1ff707baf834b9204f65d28d24b39009436c2c2a9982f648d06c6599161", + "docs/measurements/transcode/x264-10bit/why/amd/perf/4k-x264-d16-file-cpu.txt": "7eb3c18adf58e5d059d7ed6a143ec2c5118eaf1b8295f983c21bfdd33ff8ddda", + "docs/measurements/transcode/x264-10bit/why/amd/perf/4k-x264-d16-pipe-cpu.txt": "c3fdb60932775c8ec8a14b2c520bd7d9ad9475d29807d0c5fd40213bc565e0e0", + "docs/measurements/transcode/x264-10bit/why/amd/progress.txt": "459d84252b1dbce09a427adf0f69a2dc71890c29023db29f905121c05605bb89", + "docs/measurements/transcode/x264-10bit/why/amd/why.jsonl": "527a005f54be4a2fac2b426124edb8f09a6888b42d3a3e8d99b18298a6e33509", + "docs/measurements/transcode/x264-10bit/why/annotate/host.txt": "e1be33deeba36bb4ec13405c08a88242016fe4065aa260e4499c18926a3f3114", + "docs/measurements/transcode/x264-10bit/why/annotate/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/debian-d10-file-cycles-sym.txt": "e81972e8aa3928df1a7443d32cd83dc492f14e63483bc2d4c86136272afebaec", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/debian-d10-file-load-bound-sym.txt": "448d421ba141c1bcfbd623bc5b1bddbcca419b02be6a131c81999a39ff68a66b", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/debian-d10-pipe-cycles-sym.txt": "81c51ac397ce54ba8b6145d17f6b2a966556e9e1f087dcb3c69c00a5a7e7cd4b", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/debian-d10-pipe-load-bound-sym.txt": "950600ba6becfdb74f3a9b88215a02e069e8bf8bac8a6a7014a6fb9506483702", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/debian-d16-file-cycles-sym.txt": "ab2e6ea4dbdd7e1d004cbe7ac4912179411f5dca4551962b23bb474f7b1b6d01", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/debian-d16-file-load-bound-sym.txt": "68614e5acf6714eb919ac46801aaa9c2ef08e3cf18fbb5e79983a748ecbe0f01", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/debian-d16-memfd-cycles-sym.txt": "dccba83e3d582121bb0bbed56cecd39a117713a13449cc19bbcf0316ff588a2c", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/debian-d16-memfd-load-bound-sym.txt": "c4ec36832e195b170e0537c6a2971f47681d2104f9aa04a6c7f499c6b37dc725", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/debian-d16-pipe-cycles-sym.txt": "ebb763af72c63d51c45da2fa9849c5538a850e301389b60c248f81630c20e9fa", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/debian-d16-pipe-load-bound-sym.txt": "7052ebed306a66f7e6cdb452727cb60c738ec8b93da8efa6e83e1b7f08116e47", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/pinned-d10-file-cycles-sym.txt": "c00272560490e7aa5fd77707a5334680efd091c90ff2d870cf8726aae3bc61fc", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/pinned-d10-file-load-bound-sym.txt": "3121d7f00970cb511508dc486a10a5a0cca587cb1c909776ad620ff374bea54a", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/pinned-d10-pipe-cycles-sym.txt": "39ae050c50c2d73c6d6ddc7125f1cc2991a064c5cc073bb9d133be6964ee7f8f", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/pinned-d10-pipe-load-bound-sym.txt": "114d50d8c12c9ec6a35b001e075449485536ca490085bb136d6d54056c618886", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/pinned-d16-file-cycles-sym.txt": "062dc636f8bb5ea6c06c190e37b8ef4e3e64e10f2b9131009196fa1486f79a7a", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/pinned-d16-file-load-bound-sym.txt": "b7aacfff12f2a93b259a32a8803495b80355a51d14d06d654fa492b265e6d5d0", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/pinned-d16-memfd-cycles-sym.txt": "eb5c736c0304fdc56206c62c62628dd00d8945c1d9b580abed0e1eefb82b0481", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/pinned-d16-memfd-load-bound-sym.txt": "7fd4d1765cc1f0e3f5400e7e2e70878eb5ad0eaee6ef47fe6b315012af589c68", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/pinned-d16-pipe-cycles-sym.txt": "b6fada8b99fc6e5f30a250dc4ba9ef42acf594d7c26173f062edcc25333c76e0", + "docs/measurements/transcode/x264-10bit/why/annotate/perf/pinned-d16-pipe-load-bound-sym.txt": "110d389166dc126b410bb33756258a3135a56cb5189c07d2034a45fafdc086cc", + "docs/measurements/transcode/x264-10bit/why/annotate/progress.txt": "bf4038c33ca2694fd6dd6a54fa3dbf679d1c580bb805a31d46eba3a715b2c3f3", + "docs/measurements/transcode/x264-10bit/why/annotate/why4.jsonl": "dab558b04ec97417b7cb7c4a0e1636fb1462bea70656285f284d9c0f3fc515b6", + "docs/measurements/transcode/x264-10bit/why/inputs/host.txt": "4073b80ca1830c24708a0821b0858407c00ad76222218854786de8a747ecd1a7", + "docs/measurements/transcode/x264-10bit/why/inputs/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/transcode/x264-10bit/why/inputs/perf/1080p-d10-file-cpu.txt": "93c61f36270f43dffd7b4438d75619c2684170c147e673e398c36f21ef80d00b", + "docs/measurements/transcode/x264-10bit/why/inputs/perf/1080p-d16-file-cpu.txt": "b44b60f785de6b476a6d6d0695ee8d8302877c552ec69edc40565d9dbe3a7ee8", + "docs/measurements/transcode/x264-10bit/why/inputs/perf/1080p-d16-memfd-cpu.txt": "81991c6ca4bec8f5627fa020ead7c431d72611f4105296b7eebd159edcdbcb13", + "docs/measurements/transcode/x264-10bit/why/inputs/perf/1080p-d16-pipe-64k-cpu.txt": "f359345f4c982146b17ed4530b4f3e57233ce0497fbbf76ab6541562a1a07dd9", + "docs/measurements/transcode/x264-10bit/why/inputs/perf/4k-d10-file-cpu.txt": "e71a84082b974ae5ee5fb78b9cb8055f67729053a3003c5f8d3f111ec11720d5", + "docs/measurements/transcode/x264-10bit/why/inputs/perf/4k-d16-disk-file-cpu.txt": "1ba85bd5102f8a68fb7ac1f9cc3034b3906556069335654a62388cdcf1c09114", + "docs/measurements/transcode/x264-10bit/why/inputs/perf/4k-d16-file-cpu.txt": "8dfbfc4f995b29f7a196d5625d87702e35a8fcc2cbc32d95cf01e52fe0f1f7c7", + "docs/measurements/transcode/x264-10bit/why/inputs/perf/4k-d16-memfd-cpu.txt": "dad550a133853a6b31a5a65980b1b0d8f9e585a6fe59d11d2444351fb208c576", + "docs/measurements/transcode/x264-10bit/why/inputs/perf/4k-d16-pipe-1m-cpu.txt": "f4b105d4ed2eac2d990aa10dac5d653d43f1e293cd4b6b047c551a11bdfefdc2", + "docs/measurements/transcode/x264-10bit/why/inputs/perf/4k-d16-pipe-64k-cpu.txt": "b0608fc780d4f0ff1e19caca5def76c42939f2d25909e40bc6dac6e92280a3de", + "docs/measurements/transcode/x264-10bit/why/inputs/perf/4k-d16-y4m-file-cpu.txt": "46146258867afe8dff6d39a42a5f6ba313e17d23aa84d748132abe30579a24d0", + "docs/measurements/transcode/x264-10bit/why/inputs/perf/4k-d16r-file-cpu.txt": "a5cc4e5ed759d72c55455b1e0eadd62541aabf4ec9fb4d8840a98afe6bb7058c", + "docs/measurements/transcode/x264-10bit/why/inputs/progress.txt": "9f49e01dab86794d571cd7d259b41a83bfd19535b12cac157389056c30ab2ed0", + "docs/measurements/transcode/x264-10bit/why/inputs/stat/1080p-d10-file-group.txt": "81d9981a974ff638f3b1b27d1a39223d16f694eeb264a3387ca286303b21be2e", + "docs/measurements/transcode/x264-10bit/why/inputs/stat/1080p-d16-file-group.txt": "403628ebd61b0d79c214a6e33fe484e3f9ef3a7e5484a2ccdc53772a1dd4f47c", + "docs/measurements/transcode/x264-10bit/why/inputs/stat/1080p-d16-memfd-group.txt": "075c0c3dbeb9192d634f79c587e83642aabef80a8221ce37c10dbc5c5b429dbd", + "docs/measurements/transcode/x264-10bit/why/inputs/stat/1080p-d16-pipe-64k-group.txt": "53af5a8891f11e0a0291eb696a552cb0885b9569a8d9ae84120c64658923ece8", + "docs/measurements/transcode/x264-10bit/why/inputs/stat/4k-d10-file-group.txt": "e6436bfcb755e142862937457ad91ad55036d216efc115cd898960b3feb7af71", + "docs/measurements/transcode/x264-10bit/why/inputs/stat/4k-d16-disk-file-group.txt": "59d3813d1dda8c2ccc3838811df884b6382b67aaa65513f405cbd6065921eead", + "docs/measurements/transcode/x264-10bit/why/inputs/stat/4k-d16-file-group.txt": "122d0aedf7174c1294ea67959916ab6473e1f5e7b844c917b25931a9974de553", + "docs/measurements/transcode/x264-10bit/why/inputs/stat/4k-d16-memfd-group.txt": "525449fafc89177fb56945c62a4e4968784b6a1a12b5317f80cacca1dcd1f2b8", + "docs/measurements/transcode/x264-10bit/why/inputs/stat/4k-d16-pipe-1m-group.txt": "8a477123310886f04725bba58f5f9aa8df1a431d0302d44183277ef5b245bb10", + "docs/measurements/transcode/x264-10bit/why/inputs/stat/4k-d16-pipe-64k-group.txt": "daf476bc02be83e976f8833fdc9960b69dd70e43142b5fbd8bdab6cae2271532", + "docs/measurements/transcode/x264-10bit/why/inputs/stat/4k-d16-y4m-file-group.txt": "b8c30cfa202b0b4a9cbe0e5118aef272b25f1f485d778aeaf0cfc779fdb6a454", + "docs/measurements/transcode/x264-10bit/why/inputs/stat/4k-d16r-file-group.txt": "fd7f8c49ee0e6ada3bd32c58853d5fb3bbf00920d823a2c7fbe701700c505d9c", + "docs/measurements/transcode/x264-10bit/why/inputs/why3.jsonl": "52a8adaf9261253ed0ebec491fd39a89e9fdc8cf84f6aee95ce6717d9bb4a2c4", + "docs/measurements/transcode/x264-10bit/why/registers/host.txt": "e58fc65880a50c76d562c11dfead569f751b1a376a1263fa3a4dc45142276749", + "docs/measurements/transcode/x264-10bit/why/registers/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/transcode/x264-10bit/why/registers/progress.txt": "eb858389937d933c297da08ef07daddc7f30cc7a29d5b12f47896b1ef0fc45be", + "docs/measurements/transcode/x264-10bit/why/registers/why5.jsonl": "278331dd4a2062dc3337f2568af1e0e76202d594ee281a1121963101eaa28f0b", + "docs/measurements/transcode/x264-10bit/why/run1/host.txt": "3f7c3c44a90b19165a722de3951b1215aa15c509d6a2ddff47b139bd5e265643", + "docs/measurements/transcode/x264-10bit/why/run1/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/transcode/x264-10bit/why/run1/perf-list.txt.gz": "971baf6f094ccfe2f20530f6f13c97474a7d4fd4d6aae1d48f3bbfb95f4c63c8", + "docs/measurements/transcode/x264-10bit/why/run1/perf/1080p-x264-d10-file-cpu.txt": "b0aa70e1af29be00b83491a832121105bbaef97322b319ce30be5fd948dbd202", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-debian-debian-libx264-file-cpu.txt": "205fcf5efb9d70b395e22155dc6cc4175ca900f5a4189f48de3644743eb03edd", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-debian-debian-x264-d10-file-cpu.txt": "53877199154abfc416c18a7f73cd8917b0fe7d3c6edc07cd268606f37612ccc4", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-libx264-file-cpu.txt": "eb5993a1a20f6ca86111a3b4aa33e78d96b76ec3700eb300b942821acd598223", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-file-align.txt": "ddf39f26f13a570f7032c5f80e486e44151099178ad6c0059c8c80f3028f33e1", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-file-assist.txt": "915fcd768b9c5c6e344dc1de16891ea512d29de32a6c067f20f199b8af73d763", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-file-branch.txt": "17dd0a275105618ba59cc6a7f8dcf6670221d27950d1bdd8e241acfd1ea94636", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-file-cpu.txt": "7cdd23675d37e6ae66e19f6e47844adcf3d3c5cc86ca7f6f080df1d7336921ba", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-file-fp1.txt": "88cc9f1c047dc37abae743228dc7ddacf3e1e8136d8e3067e543cc71c4e5dbce", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-file-fp2.txt": "3a64ee8380e07b4cad96a17829d3324391f719977963da103602ddd4b402b1a3", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-file-int.txt": "7b51427e42985f07fbd9c07290996769c79245b1cf307f5ddf6f78c12074625f", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-file-mem.txt": "f4c1420d56aa6b8f08d05ee15df62aaaeebb2aa404048a795b8938db8ee2b367", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-file-stall.txt": "92f16ce8b07e499ef37f482b7e94ed988ed6190a9805d6367e5051f39cdc089d", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-pipe-align.txt": "5abd001a34f10d21389c61e20687cc6a8c0c610acb0b10c92496e7c680e67d2b", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-pipe-assist.txt": "c06095e2f9e54dacee790f9a5875b5c473df4eaafd40719f6e812a8a1511f2ac", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-pipe-cpu.txt": "f2ac1a0e6da67883f7f069e3f0fa145524170a21ad4dfecb47b784ab04aed203", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-pipe-fp1.txt": "d7ada450f6a2f016f31bcec423966cf63b7f7d108e8b1c73fbcd74f124bf69fb", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-pipe-mem.txt": "ff599b55beae68ad6b31e87aa2d37107d70f8893654d36c66ea3d5510ca57169", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d10-pipe-stall.txt": "980e7a2366e872ede62e76b41a286abf64a4a0c279a2c4704e49b14e7f2f0533", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-file-align.txt": "13bb950c282ca23595db31a87995dd8d75c5064de6730bcfd6b80a2067a08644", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-file-assist.txt": "f9b98f5e07712007747df058035a772addbd9af71dfc0c0010368783739fd67d", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-file-branch.txt": "3e26309340a3434405b31134576bf386a23129cbfe5c47c30748a0a98a83d55d", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-file-cpu.txt": "58900a7d09ea788892852dabb74e3212523583ec3174f65c0efa0e1f2e7d0270", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-file-fp1.txt": "82a3cefc03159628df97c1ab4be3510f7cf1a8d55a6eea130a5a2b64c8475e87", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-file-fp2.txt": "9c02bf0b14b9691427c29e840c4b3fc138d0dad2cf7637a947332d69ab728956", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-file-int.txt": "65ade4d356cbb56387744c5af414b88567f8c1906bdeb70d05e2231e6ff754b5", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-file-mem.txt": "f0d1583a9a75c5c9a1abad28b8b6db495b05baade883457d6d4f49b72242bbb4", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-file-stall.txt": "97086b5eca6aff38a12daa95b797dc276722f3b63a75980a802a8bafdd47647f", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-pipe-align.txt": "dbbd5fc8b724bac4a527adf54b106227cb62264684f85b92078909cb259b5272", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-pipe-assist.txt": "5bb9132a736340ab1a208a90c47c7cf4299d7665460ece9fa3fdda2f07dc1e3b", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-pipe-cpu.txt": "f790264b52c42e8f74017d1cd9bdda75087b4e38cef27c5b0b62fab223c1a456", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-pipe-fp1.txt": "be27b2bac7d03ccdc220448fb2a83b54f04dd153ef02cbe0a07787ba880934c0", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-pipe-mem.txt": "ac0fb83ed27cb73ebe7b9f8f87f3c35454dd8de1d59a15ca83b3bcbe07151299", + "docs/measurements/transcode/x264-10bit/why/run1/perf/4k-x264-d16-pipe-stall.txt": "9cd1c4808eab0d912da95b0b8620b1e71ac48e4fa7770c77768ed80d045e39ca", + "docs/measurements/transcode/x264-10bit/why/run1/perf/720p-x264-d10-file-cpu.txt": "1ea16118aeca7ca778fdaa8803874ecf7a711261e34ebd146b551466cafdcf83", + "docs/measurements/transcode/x264-10bit/why/run1/perf/8k-x264-d10-file-cpu.txt": "c06dbcc7ff7efb6efc9f80d52edcefc460e14ca3214ce2f2e4e0624a2146d790", + "docs/measurements/transcode/x264-10bit/why/run1/progress.txt": "a794740c074a3c94b35433aae3175952b29d3d3eb775714335d58c37a15c074a", + "docs/measurements/transcode/x264-10bit/why/run1/sched/4k-x264-d10-file-main.txt.gz": "0302ba23ed19d88cbb724c98cd5c05c9f9f43d27003bf5da5bc275f7b15da166", + "docs/measurements/transcode/x264-10bit/why/run1/sched/4k-x264-d10-file-strace.txt": "cf85ce1edf3d9e72dce6604246782beaa2c35a509678607c8b1900685da83eb5", + "docs/measurements/transcode/x264-10bit/why/run1/sched/4k-x264-d10-file-summary.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/sched/4k-x264-d10-pipe-main.txt.gz": "bec53ea8202f63ccc895f73fc24a9e63b4a57e90ce7305ce9323f7e1e4b73df4", + "docs/measurements/transcode/x264-10bit/why/run1/sched/4k-x264-d10-pipe-strace.txt": "ea46b1b7b6c47728ec7e797ff0fecacad2e7332c3aa7e6c8cb683f45b78d3b5e", + "docs/measurements/transcode/x264-10bit/why/run1/sched/4k-x264-d10-pipe-summary.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/sched/4k-x264-d16-file-main.txt.gz": "cad9c5999befd3046018ab49711c2bf89963b0bdc82efea2adb336258f8f6ede", + "docs/measurements/transcode/x264-10bit/why/run1/sched/4k-x264-d16-file-strace.txt": "3bdbff88fd96333f17bb72986af00757048a16ceed61e0e25bc60299bf5cb47b", + "docs/measurements/transcode/x264-10bit/why/run1/sched/4k-x264-d16-file-summary.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/sched/4k-x264-d16-pipe-main.txt.gz": "bc87002083c02921afaa44d47e6f2bed55a085602b898c48d568f07445e09498", + "docs/measurements/transcode/x264-10bit/why/run1/sched/4k-x264-d16-pipe-strace.txt": "400a4f8a047f562f5f8eebc364bfd29b6edaed0d7efe22bc69874f19f773bfac", + "docs/measurements/transcode/x264-10bit/why/run1/sched/4k-x264-d16-pipe-summary.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d10-file-basic.txt": "c0d7223f34226161e41377999d5a42d26180b5ce2729b76da918830dd5125d01", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d10-file-basic.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d10-file-topdown-l1.txt": "238bafa5fa51c96fd6dfa8d704f7067af7b4ae2076feb60c0ceffabe3b33291d", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d10-file-topdown-l1.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d10-file-topdown.txt": "57ed0129bb34ffddb4435a883503e0a23fb4563ee4c47544f4dc7e3b7828ebf2", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d10-file-topdown.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d10-pipe-basic.txt": "19cc0ece969d0a7777d0ed38079a062cff397fab1ef4b65c971c90f699cf8918", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d10-pipe-basic.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d10-pipe-topdown-l1.txt": "b86b57fda7768a3ba4f49942a95566f31a79d653dc0352e94bbd5f89dc6f037b", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d10-pipe-topdown-l1.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d10-pipe-topdown.txt": "88e00843f62b9342d2f9feca1f82fef52812a40caf9772674ef468a081ce21e1", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d10-pipe-topdown.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d16-file-basic.txt": "b43cdaf95a7b550ec91b7f5db7d50fe12236fc71cb0f30132f8eea7f46483adb", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d16-file-basic.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d16-file-topdown-l1.txt": "ee8c0db7bdee9ebba6288621eb00c5b7a535c73f7c6bfac995ce033966e7c10b", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d16-file-topdown-l1.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d16-file-topdown.txt": "f18d2017eee3b701d24df0552b1fbfba8e3a84ffd3fd1d7e99d1d2deb4cfa4e5", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d16-file-topdown.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d16-pipe-basic.txt": "c5f13ac3f72ba96c76178491e6bc38623885953092335a6468aacb687cb92a4b", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d16-pipe-basic.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d16-pipe-topdown-l1.txt": "51ce24abeefc1c24ba9a895df5a06f46f0b370e18105f7e997a6300ed47812e3", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d16-pipe-topdown-l1.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d16-pipe-topdown.txt": "d05b9e05c75086300f640b7430334ae4e7b4db86718ee53a6cec0b76a9fe86a0", + "docs/measurements/transcode/x264-10bit/why/run1/stat/4k-x264-d16-pipe-topdown.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run1/why.jsonl": "ff2e15dc8a2d7ce40c9591d3fe0372de991f321e1da9f1a63a34ee66fe949718", + "docs/measurements/transcode/x264-10bit/why/run2/host.txt": "11aad3563353441892eb397c919fbd2685276e711b3c82af2cc8e9af0a64c4af", + "docs/measurements/transcode/x264-10bit/why/run2/job.status": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "docs/measurements/transcode/x264-10bit/why/run2/perf/4k-x264-d10-file-alias.txt": "850c940ce87a5800d0d44fcc557236f2bfc4f5544f4ca6810ce940a1e264c640", + "docs/measurements/transcode/x264-10bit/why/run2/perf/4k-x264-d10-pipe-alias.txt": "fdd6867df0262722d7e91f102eb5e03f14c2d1695f90626d51d19debda6146b6", + "docs/measurements/transcode/x264-10bit/why/run2/perf/4k-x264-d16-file-alias.txt": "364176639adf308664bb6e7a2cd839fb7bfd944ba98576ebae0b4cf3f635004c", + "docs/measurements/transcode/x264-10bit/why/run2/perf/4k-x264-d16-pipe-alias.txt": "32185ef2269967b3fb6fe5479883530e6493fbe7d2bb490b55a209258ebbcd96", + "docs/measurements/transcode/x264-10bit/why/run2/progress.txt": "5937bec015be7abedd6ac47bb2a06cdbac24390f6e9f6b086b1ef2ab9005c161", + "docs/measurements/transcode/x264-10bit/why/run2/sched/4k-x264-d10-file-main.txt.gz": "531e4206cd4ac2e8715bf1be467f12fc6d8ae4e92aa146071bd40f71c86fe347", + "docs/measurements/transcode/x264-10bit/why/run2/sched/4k-x264-d10-file-summary.txt": "ae040de5312b0124555d0bc52c16fd4899d6effcf7836443b0ba7fe20cbe560d", + "docs/measurements/transcode/x264-10bit/why/run2/sched/4k-x264-d10-pipe-main.txt.gz": "08877bbf5725238ea408496555ba206dc9304e5ed923ba9cdec17a8f24be4f7c", + "docs/measurements/transcode/x264-10bit/why/run2/sched/4k-x264-d10-pipe-summary.txt": "863e995ab754e74c824947d53d2ddd0baba56bc37aafeec7ede86b8ddd37a61e", + "docs/measurements/transcode/x264-10bit/why/run2/sched/4k-x264-d16-file-main.txt.gz": "f63061c3bf8921074a3dd03941d01928b934ba82cc9359e3753fd06f439c2f42", + "docs/measurements/transcode/x264-10bit/why/run2/sched/4k-x264-d16-file-summary.txt": "4c29257314d5494d39152e681142878bdc7abcd227bcaf8660478c7f3e60b90a", + "docs/measurements/transcode/x264-10bit/why/run2/sched/4k-x264-d16-pipe-main.txt.gz": "f4a68a23f3b75a73c2f0baa743680eaf2a7190c70f90e2ce2e2c989ae075cbe5", + "docs/measurements/transcode/x264-10bit/why/run2/sched/4k-x264-d16-pipe-summary.txt": "5aadc8f80843c3364a8c52718f82f5b15a9666fc5122b75bae2b438c23bcecd0", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-group-alias.txt": "a04ad83e505f1c37cb3b825a1c7b114501c62ba99a58b322735cc1d9bcc9a4a6", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-group-alias.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-group-bound.txt": "7093dc616f13f20e1c81fd64fb8a7b70ca718ce0d24523136c9bff12f43a6977", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-group-bound.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-group-other.txt": "243f8b3947a9d38051a826d1ebade4a472165f34b0b1c019302719469f97b3e1", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-group-other.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-group-tlb.txt": "a89f7c925da2b179d4571fee78a6bc683a38b8e9319543b3c123a22041b07843", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-group-tlb.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-metric-l1.txt": "e659a35e583dcb7dd22699cfc1fcbf7c2aa2746d16f03d6fabed95561a4d0496", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-metric-l1.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-metric-level3.txt": "897bea89ab28a4e2c8037de3ea6e85a3ec796d0fc75b427020bc5333592196f4", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-metric-level3.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-metric-store.txt": "876917a1a245f9baecca48887d9a39cc33300d536c511e57a65423d05fcfc5eb", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-file-metric-store.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-group-alias.txt": "1169ab46c025fe2c2076cb5d6323803ccbb8c6bf91c7ec23554fdddaaa177504", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-group-alias.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-group-bound.txt": "20cd6f93146e4a08dd24c9f3a7372f31e4c0c507bbb76be9dcfcf42a0ceb950a", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-group-bound.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-group-other.txt": "ef5d86209cf76ab6073e25b71ed5f6efc983e90249c76373995fef6a36b98d50", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-group-other.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-group-tlb.txt": "69a723724ae53e0fe53f89978628f0369fa9a97b2df9702750e98154d73ef19a", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-group-tlb.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-metric-l1.txt": "12c77bc0e68833e4933d4731653fdfe8b81e82ce326cf62c9161744c432e16d1", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-metric-l1.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-metric-level3.txt": "8868ed9f77b242574bace58fca0eaebdca06a9f3b8a0e1fac125dd420a21c06c", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-metric-level3.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-metric-store.txt": "97669984c631e7f260a0150d47e314d8487c3cd827338348900927fe3e6c9a9a", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d10-pipe-metric-store.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-group-alias.txt": "16f79765977a7a9328f88f69d3e53e8faedff03078e22b04c1ed3dbca6e4d67e", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-group-alias.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-group-bound.txt": "b271a4ac88f100d1b492b558c54abcd7f278ca7b34194f0a9bb8be77ac4f73e6", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-group-bound.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-group-other.txt": "5204db61fd623067dae5e39a9df28c253ebcfb9eb3f538ab86977e98786e8bfa", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-group-other.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-group-tlb.txt": "b2756cc182c4b7b6eab7709823b564c9798b9450c69af6f4cc5905e9a31aeac1", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-group-tlb.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-metric-l1.txt": "c2637b73a6ab9efe85335f6f760e61efd3ede24dfab1f1b0ce237a968964471d", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-metric-l1.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-metric-level3.txt": "59b746d2417c976b8eba51835105ab294d61e60a3d45d0db65e0a733ee05ba5a", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-metric-level3.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-metric-store.txt": "3997fe274b83f7de743fea966180f58dddc29f8f32aa4e5790ec03adbdaa1f10", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-file-metric-store.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-group-alias.txt": "1239238e7d244f90cbe61dd0ab31e27a88cbcf7ab5c3ece74c4a67a744ab35b5", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-group-alias.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-group-bound.txt": "34355296ea018ba53567b9de36aa3a3818160e4079adb9cfb4c19ea20b8d67ae", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-group-bound.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-group-other.txt": "e66a099b122bd14f521fc78c484dc0e36e061c8e5f11bd3071064a3295ae9ebf", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-group-other.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-group-tlb.txt": "0b314cbf4945b0837581bb0e9a9164a0214bd3122e9888873204dc4176118efe", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-group-tlb.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-metric-l1.txt": "40f50da64dfd6e824976a59295e5ec76e609f5eba770a6e870ea0f6d8735924a", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-metric-l1.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-metric-level3.txt": "1a7fb2298f5dcf58c99d548c446c1c70db540b1969b5f8a1262d9ff2b7c8484e", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-metric-level3.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-metric-store.txt": "d226d58724c81dbe3f05bd520b5c835d354a57432329ea92307ef17a172a8a3c", + "docs/measurements/transcode/x264-10bit/why/run2/stat/4k-x264-d16-pipe-metric-store.txt.err": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "docs/measurements/transcode/x264-10bit/why/run2/why2.jsonl": "69f4b426c22750d659057dd258572bcad545518087b856719f97e6c1ace0ec0d", + "docs/measurements/transcode/x264-10bit/why2-job.sh": "2ce29402cd8b600d80b4c1ac45163ee0f8645ac31c2cbbfd19e53afabd894bef", + "docs/measurements/transcode/x264-10bit/why2.py": "a7a8b481efbe2975a3398a8b463dbfff1e5e5f5acd3d7ab04d8d357142a17af2", + "docs/measurements/transcode/x264-10bit/why3-job.sh": "c2bd333e36f890da98a1c3f880ae43857733c75f554b286557652b9078934c98", + "docs/measurements/transcode/x264-10bit/why3.py": "331ecaebc5a3c60c5395c9c8e0ee99d1931014b7a0c3e577d81b0eab1eba7846", + "docs/measurements/transcode/x264-10bit/why4-job.sh": "35b2817198fd88cc42cf15a86d89bee573f09075536ba4309b66c611e4809e4f", + "docs/measurements/transcode/x264-10bit/why4.py": "87133964a1b4ff45ef0bd8a64109c2415170db6aec25b31b6cfc945167fd1503", + "docs/measurements/transcode/x264-10bit/why5-job.sh": "90c1d30fc68f63380872a20a07d13da9aa0188282b8a9a33cac5223c93a6c3d0", + "docs/measurements/transcode/x264-10bit/why5.py": "891e9cea5ef3cf1072709a6589fb5d4887302c1730af0d2afc4f81eb11787087", + "docs/measurements/ts-demux.md": "65fc4901bc884c05a349bdd56bcc1a4076681e12ae7eda3367a446775d785ebc", + "docs/measurements/vp9-filter-coverage/plan.json": "fd9198195c0258e4391139949dc5571cb9caba3efafdfc029ec9beccf8ed50e1", + "docs/measurements/vp9-libvpx.md": "3a980d1d106a9075e4fd8b1a63e425f0540b14741d3e55e696e195ade230ed84", + "docs/measurements/vp9-libvpx/attribution/gate.json": "a4649183fec3466854317f0917163c8c44e4a4090a3ad5ac31ad10c6b595a189", + "docs/measurements/vp9-libvpx/attribution/host.txt": "bfefeb4af7c48421e9be1272fb46fc8f0ed5a79bb864dad7734230fbd2200143", + "docs/measurements/vp9-libvpx/attribution/instance.json": "d0992e27c0c19e979d35769f18c63fd137f63a0596ab24df779be88be3058af8", + "docs/measurements/vp9-libvpx/attribution/stages.json": "d30e508a096bdb0788cf6e0b33e45490371c2ff003a2baab9aaafe7a6af86539", + "docs/measurements/vp9-libvpx/attribution/timed.jsonl": "c04edf75db482ad1c80f2e86c8ab76958e00fbf92c053601fbbbad0e393a76d3", + "docs/measurements/vp9-libvpx/release-build/analysis.json": "684eb6e38e7a45aa05efff8d72bf5601652b06468105cce0c9e27ba783220829", + "docs/measurements/vp9-libvpx/release-build/gate.jsonl": "34ff20d280a73189e93da4f5aecd046f0deea39d4a5f255b1edf94bd2d5eb34a", + "docs/measurements/vp9-libvpx/release-build/harness.patch": "981acb41f4ca4675710e67309f2fdf112229286b0d39fa59c25ff4cf1107c85c", + "docs/measurements/vp9-libvpx/release-build/host.txt": "7a9704be490f3c2eb3f37e6eaa9e4e2d7a72d76684b0aa4bfb37f6ddd3a78bc6", + "docs/measurements/vp9-libvpx/release-build/method.json": "5076442edb6b4470ea0425a2a083f5e3b7f3c8f14e62dba80c2eed6249c0de80", + "docs/measurements/vp9-libvpx/release-build/runs.jsonl": "4acc2c0981cf0634e5a91162a6096438ccec103416575ec958d2180c2d5c1791", + "docs/measurements/vp9-libvpx/thumbnails/files.jsonl": "6b330f9a15f7aff91c5d386c539e2ae4ff8d44e292e840113086ba32cb75a8c6", + "docs/measurements/vp9-libvpx/thumbnails/gate.json": "88555275ac408c7160d2d9377a1347692c3a715b6cf5f6de0270b8bf404bb835", + "docs/measurements/vp9-libvpx/thumbnails/hosts.json": "7db4abc0b39be602609343d7eb811bd0cdd4f564423c78850f8249cf16a30c3e", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c0/host.txt": "7cb8f3a65437a7ecd22c3369da0f375c841d9c71ba77a4a06892873f58803a90", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c0/job.sh": "425ce05e4e79f5acfad7d9645fc4f419bb6e06c2a3ffbae45c493ffe40ed5c7b", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c0/oracle.log": "06cb48835f000ffcf567adc96c4b5b28ff38b5bb39842cdae96be25f1775352a", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c0/progress.txt": "f5e3cbe46b1d446bfb074a65310c4a6db51f8d952522616a194a0d34766878dd", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c0/speed.log": "7cbe00c9e0f7ffc0687194ed4e58aebd6fbf9edd6c9570dd75758dfe04d745e6", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c1r/host.txt": "92de8edd9d72b6372b7972a29aa1d5e5ab2bb4bbf4bc749fdc2c399fb769cf10", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c1r/job.sh": "9ca78be718c701b09678b9f497e55d15516395d6079031a3d64f5d272ab22122", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c1r/oracle.log": "d51f4ee06011987c3d5743fc0773150bef84816ef8caaac80b58330958b50075", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c1r/progress.txt": "c860c431ac21f84c231687fe4f6f35674060af6dd722f286d7cb8444d1406d80", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c1r/speed.log": "a1b52ec7ba00de2c515b4393ce878a1f777ed5c9e791210eb3d100183ff02c49", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c2r/host.txt": "1a83d78245b1f729959088cc899501faaee1e45e6c21d9f91ba95b974b409283", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c2r/job.sh": "9ca78be718c701b09678b9f497e55d15516395d6079031a3d64f5d272ab22122", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c2r/oracle.log": "db00986caa5036dcf9bd4dbcaf8d5b801867d846faa204fdb2b24ca24dbbd78a", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c2r/progress.txt": "6b9c84f5be920ae20c7f90fc573e4ee60d6a1adda878f5a7185959ecb5b96231", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c2r/speed.log": "c95efae19cb851c9256fd874ad74ab2174581e85f6162cac521158199018754f", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c3r/host.txt": "83908cfc0688123eec2a549e93cc3873f6b33d85ebcd02930e13b4656116e571", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c3r/job.sh": "9ca78be718c701b09678b9f497e55d15516395d6079031a3d64f5d272ab22122", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c3r/oracle.log": "5066e52a20c39eebc88c7af8d253c87b51eebcf228c3e2dc8e080e7e1dc3bede", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c3r/progress.txt": "c79123464f2f26d08eecee04e2a126d8886c6895f669ca319508e52c6b4293b0", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c3r/speed.log": "53eca7d2c90161076d6f350f5f0a70387defb3f302f272154e650c86d3abd387", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c4/host.txt": "8d3f24dce68725e41fac766c6b5debc4bcb957f3f44dfb0c002e9dcef933a4e3", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c4/job.sh": "9ca78be718c701b09678b9f497e55d15516395d6079031a3d64f5d272ab22122", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c4/oracle.log": "c929fa78a6350991769863911b67cd3e31d9dad0afc0b1eaf52a244310d1027e", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c4/progress.txt": "078d0fec78f4e19ce344ffed32a15eda4ddab9d177c26b199176c9e8730d12ee", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c4/speed.log": "4e908e248dfee877f4b16a50f4af813fcd75e5681cf2d307a6f42aa4489381bb", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c5b/host.txt": "8045317687f3ccaeafe200a8ae2c7de02944ce9b99d9b0f3c4a65db5116657d8", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c5b/job.sh": "9ca78be718c701b09678b9f497e55d15516395d6079031a3d64f5d272ab22122", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c5b/oracle.log": "54bab95955acfa555c02f3d1b2c5cf83816fcfd5bd6047fc923c529663f15333", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c5b/progress.txt": "c345b4ed4053830ddd46d3ac8a353f59a4563ff60a52d22830bf65f62b437f60", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c5b/speed.log": "b20bf61585bb17a92c674b40cddf3c3c2f3a43b83b1eff4b5da1ad6c2010e6ab", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c6b/host.txt": "41288e6a94e7437e832ebdf226913d9ede51a342e865677576869f0b07b1a0d6", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c6b/job.sh": "9ca78be718c701b09678b9f497e55d15516395d6079031a3d64f5d272ab22122", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c6b/oracle.log": "7d40eede9af551ed8ce353e7c19e3400f3eb130877c21d4d08ebfccbfb1c8d00", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c6b/progress.txt": "eae4aebcb14776aaa37d48d31306f622e267a17ebd610b8f0a84be71f0ee15ab", + "docs/measurements/vp9-libvpx/thumbnails/jobs/c6b/speed.log": "91f353bf6926478a025c7ec3117182a1921cbb5ae746b0bf2e5f0dadd4a6f667", + "docs/measurements/vp9-libvpx/thumbnails/oracle.jsonl": "7a4f8b51351ad3705645647fb23323cbc6bf81223a044d7477c9383a68b0d5cc", + "docs/measurements/vp9-libvpx/thumbnails/selection.json": "704d9bf332b4dd28be973757625d14af1e10986c669c3760f859129b3a97efbd", + "docs/measurements/vp9-libvpx/thumbnails/summary.json": "b8eacedfe9a5b114058666b5931c3d56b8280864ed9df178617e8d7cae6a7c60", + "docs/measurements/vp9-libvpx/thumbnails/summary.md": "30346d732ff4b082f52b00b30578c448251898ac12609e2f4e1589911509dbeb", + "docs/measurements/vp9-libvpx/thumbnails/void/c1/files.jsonl": "3be04d5d42f324137040225b4fe87437de25593a80a22afaf4b78d3a7a00a332", + "docs/measurements/vp9-libvpx/thumbnails/void/c1/gate.json": "5c8c5bd7ba9a649859df61473c5fc18586f6319d2e05dee2c3913230dec02d46", + "docs/measurements/vp9-libvpx/thumbnails/void/c1/host.txt": "d00d6b9b4c4fb40d530c0e09e6ea7c54fa9ee9f07835f48ab5aad810b8220a96", + "docs/measurements/vp9-libvpx/thumbnails/void/c1/speed.log": "499521063b997126fff61df9d034f94e6b73df3c94ab4df39b83b600c5e2a94f", + "docs/measurements/vp9-libvpx/thumbnails/void/c1/summary.json": "4f742d7b18541d9f58dbae41e9ca79d425fe4dd87e14e599253fe81f76baf791", + "docs/measurements/vp9-libvpx/thumbnails/void/c2/files.jsonl": "28f9acf5d42482efdb5f03a7ff30873a2b05ece58343f235201237a02760a2e3", + "docs/measurements/vp9-libvpx/thumbnails/void/c2/gate.json": "36dff995ce385d2f2922750fe01fadea710141f2ad269f7d2d8f71071cc32530", + "docs/measurements/vp9-libvpx/thumbnails/void/c2/host.txt": "e69b689c43cf5438b8a5e11a6c0c9b3b40f80335c6e5a0e99deb6da2c5da47a7", + "docs/measurements/vp9-libvpx/thumbnails/void/c2/speed.log": "e9660c782c683260e3dc35e2c28433b9453b4d709130854cdfb1e41d23c6df57", + "docs/measurements/vp9-libvpx/thumbnails/void/c2/summary.json": "2606998782721d89ca24b2ff99df4dfc57f87e14821b85f6a239ab7a40b56f45", + "docs/measurements/vp9-libvpx/thumbnails/void/c3b/files.jsonl": "d2540b22a4c18acf13ba243c9d305d2416ea3bbd03e72a8906441f279f95061c", + "docs/measurements/vp9-libvpx/thumbnails/void/c3b/gate.json": "08376e118d6a3e27873dbcda0e4314f0efb7e513c5ceb15725c355e0e76b559b", + "docs/measurements/vp9-libvpx/thumbnails/void/c3b/host.txt": "71fa2356b808aa10e2a5b7a0e83326299db4087a2b74fd2c0beb2e54f1808c9b", + "docs/measurements/vp9-libvpx/thumbnails/void/c3b/speed.log": "d33de73688700ac27ae7e06664ecc7737285f6daca4e529c636c94cff91f639e", + "docs/measurements/vp9-libvpx/thumbnails/void/c3b/summary.json": "60214a892ddc83bc05e9a91d838efb6e1b950a13c1555749cdefa01e66d1cf38", + "docs/measurements/vp9-libvpx/transcode-b5/files.jsonl": "4e55d0f49e140943cbddd62d2149d7f7c2789fab62676af733239674073f9481", + "docs/measurements/vp9-libvpx/transcode-b5/gate.json": "f79fdb16f6efb6ce79981d0ae41e24a37488b3c34c3a011db24347bb0faa71f6", + "docs/measurements/vp9-libvpx/transcode-b5/host.json": "2a2f592f320ab213628fc5e717be3eb1c78af5263648ab315fa6614fe572ed1e", + "docs/measurements/vp9-libvpx/transcode-b5/host.txt": "18b334f409ad5ad786f6e6c8b44a7f614bcde24b48a3b9b23d3f5df0ea0326c5", + "docs/measurements/vp9-libvpx/transcode-b5/job.sh": "2fe9d39e956cf42e1eda31fe00ceba9ee5483bbf5dcb3e9af3253d17f5fecc76", + "docs/measurements/vp9-libvpx/transcode-b5/progress.txt": "b036633767e07897a9fc31cb22bc4923d93993b975adad44f8f896e3a2544113", + "docs/measurements/vp9-libvpx/transcode-b5/speed.log": "3388e45f6bbf46034489c0010604103163623e63d6d613f6f889f5d0d799d95b", + "docs/measurements/vp9-libvpx/transcode-b5/summary.json": "a0b77b8bcee2e1eb5cbb526072a7b3143bb66a117ed5e1cb8b84e399e0e885e9", + "docs/measurements/vp9-native/file-condition.json": "9962315a974fca7778ecb7da007af4045d3a44e610a212bb119165b5e66720ea", + "docs/measurements/vp9-native/roster.json": "4dd8e412b958d02878380cab303cb8fa516bcba924c30f4e98444b945fa400b9", + "docs/measurements/vp9-pixel-round/build.json": "462aaeb7ad192843e6d2925ba38f6e03c88e24de03dd60932e090d52ded94e03", + "docs/measurements/vp9-pixel-round/plan.json": "0cdd1ae3a3e7598ee1129eea0f46b27a601e43f55bb888899f97f005044ac651", + "docs/measurements/vp9-pixel-round/provenance.json": "b9eb0a5365db4de0c47dc10cb4377ad57e450151758cca5477e525c332cacaa7", + "docs/measurements/vp9-pixel-round/results.md": "4569289333ffe368f59dc4e4e61b56c8bb13da62c238ad47bcffdb7d2677b27f", + "docs/measurements/vp9-pixel-round/summary.json": "175f4cce5c3758a4b65d70827ae07bb0378298d1137406280a40d4dece15125d", + "docs/measurements/vp9-release-cost.md": "53fd37cc8389d0b6d45d6330eed9a6ee09f5e2af8de2335d97d10e0653e3a7b2", + "docs/measurements/vp9-release-cost/attribution-unit-tests.patch": "4991cb6309365e2322172e78b50da118f0e5c3134c91d4349ef54b42efee24ba", + "docs/measurements/vp9-release-cost/attribution/analysis.json": "a4569699e9c6278b6b70eddafbee6da8a33ee9a5dcf0598a2de2f18335482092", + "docs/measurements/vp9-release-cost/attribution/builds.json": "399bc9c4c2b0857fe724434f7a5b562b9ead82397cbef8cb40c98c427214a7db", + "docs/measurements/vp9-release-cost/attribution/calls.jsonl.gz": "18642721b61669c09f116dc0e1cd61ac4cc97f5e7bc1634b888a9f9b698653cf", + "docs/measurements/vp9-release-cost/attribution/chunk.patch": "1a59e597c8c36782d863f60d40779f489b206b5fba36c0cc63d01c482c63f8c2", + "docs/measurements/vp9-release-cost/attribution/completed.json": "976c7ed8b05bda3c5a21a2c7f335de2df4a4fa0bc29c3efb8ca13b99d6892a02", + "docs/measurements/vp9-release-cost/attribution/count.patch": "7b868b8a66ed336e2b33f13cd9d20c771ff5a0442b2c986a58d1dfd13dc0d021", + "docs/measurements/vp9-release-cost/attribution/gate.json": "de795935211e40e3a858f5ba9b02b6539d2341299bf70751ecca7ba342ee8a36", + "docs/measurements/vp9-release-cost/attribution/host-fault/analysis.json": "4d1ef117f3acba6bd3083f27ed0aaa575f076a485f1488440156a5a9a503e39d", + "docs/measurements/vp9-release-cost/attribution/host-fault/builds.json": "399bc9c4c2b0857fe724434f7a5b562b9ead82397cbef8cb40c98c427214a7db", + "docs/measurements/vp9-release-cost/attribution/host-fault/calls.jsonl.gz": "d940f68baad5f191a73aad7555328632953b4e8cb00d05a0517b7342b2a46364", + "docs/measurements/vp9-release-cost/attribution/host-fault/completed.json": "2a825c96aef9315089276d199ce7cd000247d4ccd26f066913f7bebcfea21f09", + "docs/measurements/vp9-release-cost/attribution/host-fault/gate.json": "57e08aac383db924ffdebeb766f3f4bc7dc8629e8b473cd9b2b784a2fbfde240", + "docs/measurements/vp9-release-cost/attribution/host-fault/host.json": "1e3816851365d8c1275148c2bb106dd7d7d08f54f9b729d403d3e3a5a009ada1", + "docs/measurements/vp9-release-cost/attribution/host-fault/maps.json": "ebea9e3dfdf2d8bab54af97b0e179b317db6c35074932c1a4e34cec74910ef92", + "docs/measurements/vp9-release-cost/attribution/host-fault/mimalloc-arena-reserve-kib.txt": "38ea4bbef6fea8d73df79e1cfd9ee0e1e8aa44b963877e0285c6e892018cacda", + "docs/measurements/vp9-release-cost/attribution/host-fault/musl-chunk-t0-r1.profile.txt": "5686fe95dfd2497d27c6f4c1592d49fbf85c54e67ec1cbd04e38fa728c6fa253", + "docs/measurements/vp9-release-cost/attribution/host-fault/musl-count-t0-r1.profile.txt": "13c40a0b80703abba47c23e4cfac16c69d623c68506c20a4681486c5eccfc6d0", + "docs/measurements/vp9-release-cost/attribution/host-fault/musl-count-t1-r1.profile.txt": "65feef20e28eb1ef9886501e6bc9ada86e0c6c56b8ff5b72ba1d574d0445c378", + "docs/measurements/vp9-release-cost/attribution/host-fault/musl-plain-t0-r1.profile.txt": "4b857418947007e24ade257920d49fd08dadf0e9fe53c9e3f108b93614154734", + "docs/measurements/vp9-release-cost/attribution/host-fault/musl-plain-t1-r0.profile.txt": "b94e0a1a6a1104a120be36bf1f564a54ebfd8af2ff4f533c339ed19a5bdde21d", + "docs/measurements/vp9-release-cost/attribution/host-fault/musl-plain-t1-r1.profile.txt": "93eaf92575f0e578817753b1e4f1403715490c76db71f02e0a613f7133a9bb12", + "docs/measurements/vp9-release-cost/attribution/host.json": "d1764be7c6ec2ca4e9d96ebfe92ab7048c2528f23279108d5edd65c9c0cfaabe", + "docs/measurements/vp9-release-cost/attribution/maps.json": "ebea9e3dfdf2d8bab54af97b0e179b317db6c35074932c1a4e34cec74910ef92", + "docs/measurements/vp9-release-cost/attribution/mimalloc-arena-reserve-kib.txt": "38ea4bbef6fea8d73df79e1cfd9ee0e1e8aa44b963877e0285c6e892018cacda", + "docs/measurements/vp9-release-cost/attribution/musl-chunk-t0-r1.profile.txt": "a4b3683e31744486103337cb7b47d203d3492976f6797503337d2419c2b764b2", + "docs/measurements/vp9-release-cost/attribution/musl-count-t0-r1.profile.txt": "994be5591e9c8de372693d82b3e5ce6fe9d855db7e29de215387c8b66d42abde", + "docs/measurements/vp9-release-cost/attribution/musl-count-t1-r1.profile.txt": "fe0ba813fffe0fd8726fe499c9d534c490b7acfa6d4fd4eac5a47c703494caf0", + "docs/measurements/vp9-release-cost/attribution/musl-plain-t0-r1.profile.txt": "eae562cf7257d6d23398e134bd5f59d98c5b9f4dc8e6cc19d02f355de6c535cc", + "docs/measurements/vp9-release-cost/attribution/musl-plain-t1-r0.profile.txt": "1fd59549cbed2d9be47cd7dbe28e5ef4870a3dfda1dd341b5aa392991f061fe3", + "docs/measurements/vp9-release-cost/attribution/musl-plain-t1-r1.profile.txt": "50da68f9e1ea01fdfafe8d66e684f8e456537a4276605b8f26fb6c96217cc052", + "docs/measurements/vp9-release-cost/attribution/plain.patch": "e3d503b0b8dae5259ef908fe6128c7e1bd0e78b0cecfe6d8798ee4c4c0706f10", + "docs/measurements/vp9-release-cost/builds.json": "0340025dc16996b3dd7acc77c6a2aa3ffb6e17dbd388347dff3477a0defcf305", + "docs/measurements/vp9-release-cost/files.json": "06c7e44129ad26e36461cf162ffb071d30f7e42b6980e6cfee677fe833a05f1d", + "docs/measurements/vp9-release-cost/first/584a16b906bb-alloc.profile.txt": "887c897d4b4f74987b1bef3cd278651c59c3e0f8598034798c89b8d619ba5518", + "docs/measurements/vp9-release-cost/first/analysis.json": "8e860b0f8853e40ce78c8bf8194d06036d38918edc0c3cd4a66fdd88018e80f9", + "docs/measurements/vp9-release-cost/first/builds.json": "c9dd9537cc7e99d1707fc2f67fc45135ac61874028421cc042d6044c20deead7", + "docs/measurements/vp9-release-cost/first/calls.jsonl.gz": "1b66d62110d78b92e964189d1e735a009b2866219a13e5e4cf43a9f96aeb5617", + "docs/measurements/vp9-release-cost/first/completed.json": "6b62979a373f2eb4c7f1977162280d01e4704b0b157aab88deaa723d3b3e7cc9", + "docs/measurements/vp9-release-cost/first/ea684713a5be-alloc.profile.txt": "2fbd26315e94cd8ffe6076df43406a06717536d7f3602895d32b42b1de560ada", + "docs/measurements/vp9-release-cost/first/frames.json.gz": "999a97333bd46f6cfd59e373d3ed6285cbdaac40fc476cf3b914d36d45f7de2c", + "docs/measurements/vp9-release-cost/first/gate.json": "ab94400e9ccc63655ca831efc4fecdf5efe9e31b82cfdf4b0f5854ae0ef23685", + "docs/measurements/vp9-release-cost/first/host.json": "b1dd1291161145ccf6a65a13f6e715b5858871b7dee3264b9f5f8d02481fd4d7", + "docs/measurements/vp9-release-cost/first/maps.json": "06c7e44129ad26e36461cf162ffb071d30f7e42b6980e6cfee677fe833a05f1d", + "docs/measurements/vp9-release-cost/first/mimalloc-arena-reserve-kib.txt": "de33640a0eb4eaa5ecd485dccb29eab8e5af8268c84edd0794b4c6a4acae7607", + "docs/measurements/vp9-release-cost/second/584a16b906bb-alloc.profile.txt": "f69320d2150b64b9b54c0a0e21706c2b0ef342798f22871d002c56148e7c2eca", + "docs/measurements/vp9-release-cost/second/analysis.json": "194fbd620aea4fc4364f2d2fe98e3fc09c7b0efa087660ff570ecc07e23405c2", + "docs/measurements/vp9-release-cost/second/builds.json": "0340025dc16996b3dd7acc77c6a2aa3ffb6e17dbd388347dff3477a0defcf305", + "docs/measurements/vp9-release-cost/second/calls.jsonl.gz": "fb7a7c7eef8f1611bc46e858880194e7580c3f3c507471f6bfe2a46db4398299", + "docs/measurements/vp9-release-cost/second/completed.json": "6b62979a373f2eb4c7f1977162280d01e4704b0b157aab88deaa723d3b3e7cc9", + "docs/measurements/vp9-release-cost/second/ea684713a5be-alloc.profile.txt": "f9e7b94d809ce0ae92910791a42612239f09ccbfa1511e121a23e0a4250120f6", + "docs/measurements/vp9-release-cost/second/frames.json.gz": "999a97333bd46f6cfd59e373d3ed6285cbdaac40fc476cf3b914d36d45f7de2c", + "docs/measurements/vp9-release-cost/second/gate.json": "8ea739384971ae43fcd352e6a1672f55c41af08aefff2a99dd265a2eadf9338e", + "docs/measurements/vp9-release-cost/second/host.json": "b1dd1291161145ccf6a65a13f6e715b5858871b7dee3264b9f5f8d02481fd4d7", + "docs/measurements/vp9-release-cost/second/maps.json": "06c7e44129ad26e36461cf162ffb071d30f7e42b6980e6cfee677fe833a05f1d", + "docs/measurements/vp9-release-cost/second/mimalloc-arena-reserve-kib.txt": "38ea4bbef6fea8d73df79e1cfd9ee0e1e8aa44b963877e0285c6e892018cacda", + "docs/measurements/vp9-release-cost/third/584a16b906bb-alloc.profile.txt": "d4b71a3a339cd928b8b36b2b44269ffd526f78900cd58cf51c973ed499b70e20", + "docs/measurements/vp9-release-cost/third/analysis.json": "511ed5d67ada469ff82e222bc8100b5b3fe3f2943821fa52cda28eb447f3f2c0", + "docs/measurements/vp9-release-cost/third/builds.json": "3a8ac443c8dd42a0418d18e646d5e2ea5fc2b07ca7f2f6013fa4ebb4d954b232", + "docs/measurements/vp9-release-cost/third/calls.jsonl.gz": "92d2c489b63f61df3ac11d9de0d6a43ba6dc67acc9e890a46aa32cc50150f482", + "docs/measurements/vp9-release-cost/third/completed.json": "6b62979a373f2eb4c7f1977162280d01e4704b0b157aab88deaa723d3b3e7cc9", + "docs/measurements/vp9-release-cost/third/ea684713a5be-alloc.profile.txt": "79f46c5a0cf023a7a523ddbb56299a3ef542eeb14b1ca5f88b834a5244f5ed30", + "docs/measurements/vp9-release-cost/third/frames.json.gz": "ef2ca72791060ae28864d7247c21200ec88a0ff05cdb2f2b997604e6e842f3a8", + "docs/measurements/vp9-release-cost/third/gate.json": "2df5cba526980e2ce66ecb4cf587d9fbc59b61815a53db7149e349f11450d91e", + "docs/measurements/vp9-release-cost/third/host.json": "64aa9e70b40a10076f980cf0f321a06357169b9a5e0b4acdc2a52f7f2537ae3e", + "docs/measurements/vp9-release-cost/third/maps.json": "06c7e44129ad26e36461cf162ffb071d30f7e42b6980e6cfee677fe833a05f1d", + "docs/measurements/vp9-release-cost/third/mimalloc-arena-reserve-kib.txt": "38ea4bbef6fea8d73df79e1cfd9ee0e1e8aa44b963877e0285c6e892018cacda", + "docs/measurements/vp9-release-cost/third/source.patch": "8efe99f548cc2c19ae6d26203d68999b1c6bdc7aa670b3cfe04f8ed0fc9e2ee3" + } +} From 7b5b8103ef37cf677d19d833ac843c9fb184a583 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 13:40:25 +0000 Subject: [PATCH 08/21] test(audio): fix conversion reference CPU profile Signed-off-by: gunwooterry --- crates/coreav-audio/src/convert/oracle.rs | 4 ++++ docs/agents/codecs.md | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/coreav-audio/src/convert/oracle.rs b/crates/coreav-audio/src/convert/oracle.rs index e9874d8b1..9ff02cbe8 100644 --- a/crates/coreav-audio/src/convert/oracle.rs +++ b/crates/coreav-audio/src/convert/oracle.rs @@ -25,6 +25,9 @@ fn reference( channels: usize, planar: bool, ) -> Vec { + // FFmpeg's arm64 SIMD path rounds half-LSB ties away from even; + // its C path and CoreAV round to even. + const SCALAR_CONVERSION_REFERENCE: [&str; 2] = ["-cpuflags", "0"]; let (input_format, _) = format(source); let (output_format, sample_format) = format(target); let layout = format!( @@ -33,6 +36,7 @@ fn reference( ); let mut child = Command::new(ffmpeg) .args(["-v", "error", "-nostdin"]) + .args(SCALAR_CONVERSION_REFERENCE) .args(include_str!("../../../../scripts/oracle-audio-args.txt").split_whitespace()) .args(["-f", input_format, "-ar", "48000", "-ac"]) .arg(channels.to_string()) diff --git a/docs/agents/codecs.md b/docs/agents/codecs.md index db3b0ad34..5bc04c201 100644 --- a/docs/agents/codecs.md +++ b/docs/agents/codecs.md @@ -17,7 +17,7 @@ H.264, AAC, Opus, VP9, AC-3, MP3 and AudioToolbox behavior; HEVC decoding and pl | Small G1 pictures retain the level's access-unit envelope instead of an unregistered fraction of their raw size | `a_small_textured_picture_uses_the_level_ceiling_not_a_raw_size_fraction` encodes a one-macroblock picture above 192 NAL bytes, while preserving a caller's explicit smaller bound | | The JM downloader supplements a missing intermediate only from the exact pinned certificate and a chain to existing roots; it never disables TLS verification | The bundle consumes a single PEM reconstructed from validated DER, not the downloaded multi-certificate input. `test_jm_bundle_drops_a_trailing_unpinned_certificate` proves an appended synthetic CA stays untrusted; `test_jm_archive_fetch_requires_pinned_and_root_verified_intermediate` refuses hash or root-validation failures before archive fetch | | G1 VUI colour combinations obey the specification, and cached RD summaries are replayed from complete raw metric output | `unspecified_primaries_cannot_signal_derived_colour_matrices` rejects forbidden derived matrices; `test_aggregate_mutation_and_missing_metric_detail_fail` requires 60 finite frame scores, their arithmetic mean, chroma scores, and replayable process records. The conformance harness rejects CoreAV oracle diagnostics even on a zero exit | -| Native packed S24 conversion keeps its single-rounding contract; FFmpeg-exact sample-format tests cover S16, S32 and F32 rather than treating PCM24 packing as an S24 sample format | `float_to_s24_rounds_once_at_the_stored_width` derives native half-LSB and clipping bytes independently; `sample_conversion_is_exact_against_the_pinned_oracle` compares complete S16/S32/F32 output bytes with the verified oracle and requires it in CI. The documentary PCM24 difference adds no acceptance predicate | +| Native packed S24 conversion keeps its single-rounding contract; FFmpeg-exact sample-format tests cover S16, S32 and F32 rather than treating PCM24 packing as an S24 sample format | `float_to_s24_rounds_once_at_the_stored_width` derives native half-LSB and clipping bytes independently; `sample_conversion_is_exact_against_the_pinned_oracle` compares complete S16/S32/F32 output bytes with the verified oracle and requires it in CI. Its local `SCALAR_CONVERSION_REFERENCE` fixes the CPU profile because the arm64 SIMD path differs at half-LSB ties; native ties-to-even, CLI comparisons and measurement profiles stay unchanged. The documentary PCM24 difference adds no acceptance predicate | | AudioToolbox native fixtures append source PCM or begin drain only at `Flow::NeedInput`, pulling pending `Flow::More` output first | The `flow == Flow::NeedInput` append branch and pre-drain assertion in `native_four_cells_drain_and_decode_with_the_independent_rust_decoder` (`coreav-backend-apple/src/audiotoolbox/tests.rs`) enforce the fixture's ordering; it runs in `encoder-backends.yml` on hosted macOS | | H.264 output metadata accepts unspecified Extended_SAR and keeps SEI before, and filler after, the first VCL NAL | `vui` and `AccessUnit::copy_from` own these checks; zero-SAR and auxiliary-NAL ordering regressions in `coreav-backend-apple/tests/h264_output.rs` run on hosted macOS. Types cannot establish external bitstream order | | One-IDR admission uses fresh bounded state and the activated SPS geometry before picture start, refuses empty framed NALs and never releases output after failure | The codec owns header preflight and the geometry callback; its terminal state, strict framing policy and exact-coverage check are exercised by `coreav-backend-h264/tests/one_idr.rs`, including retained streaming scratch, undrained output, empty/truncated framing and the counting-allocator caller veto. The shared length-prefix reader owns both framing policies so normal streaming stays unchanged | From 721ce6df7b4d1b547d76542d25c57416bf632f35 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 14:54:30 +0000 Subject: [PATCH 09/21] test(ffmpeg): discover delegated process calls Signed-off-by: gunwooterry --- .../design}/oracle-historical-records.json | 0 scripts/oracle_invocation_check.py | 129 ++++++++++++++++-- scripts/tests/test_oracle_invocation_check.py | 31 +++++ 3 files changed, 152 insertions(+), 8 deletions(-) rename {test-support => docs/design}/oracle-historical-records.json (100%) diff --git a/test-support/oracle-historical-records.json b/docs/design/oracle-historical-records.json similarity index 100% rename from test-support/oracle-historical-records.json rename to docs/design/oracle-historical-records.json diff --git a/scripts/oracle_invocation_check.py b/scripts/oracle_invocation_check.py index 05040cdd3..dc2392eb0 100644 --- a/scripts/oracle_invocation_check.py +++ b/scripts/oracle_invocation_check.py @@ -12,7 +12,7 @@ ROOT = Path(__file__).resolve().parent.parent HISTORICAL_BOUNDARY = 'docs/measurements' -HISTORICAL_RECORD = 'test-support/oracle-historical-records.json' +HISTORICAL_RECORD = 'docs/design/oracle-historical-records.json' def historical_records(root, record): @@ -103,6 +103,12 @@ def __init__(self, text, path): self.process_modules.add(item.asname or item.name) if item.name == 'test_oracle': self.owners.add((item.asname or item.name) + '.require') + if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): + arguments = [*node.args.posonlyargs, *node.args.args] + for argument, default in zip(arguments[len(arguments) - len(node.args.defaults):], node.args.defaults): + name = ast.unparse(default) + if name in self.process_names or name.split('.', 1)[0] in self.process_modules and name.rsplit('.', 1)[-1] in PROCESS: + self.process_names.add(argument.arg) for _ in range(len(list(ast.walk(self.tree)))): before = len(self.process_names) for node in ast.walk(self.tree): @@ -124,7 +130,7 @@ def value(self, node, state): if isinstance(node, ast.Constant) and isinstance(node.value, str): if 'literal:' + node.value in state: return state['literal:' + node.value] - return 'oracle' if ROLE.search(Path(node.value).name) else 'other' + return 'oracle' if ROLE.search(Path(node.value).name) else 'other' if Path(node.value).name in OTHER else 'unknown' if isinstance(node, (ast.List, ast.Tuple)): if not node.elts: return 'argv:other' @@ -159,7 +165,10 @@ def add(self, node, state, scope, kind): expression = ast.unparse(node) tag = self.value(node, state).removeprefix('argv:') if tag == 'other': - return + if ROLE.search(ast.unparse(node)): + tag = 'oracle' + else: + return key = (node.lineno, scope, expression) self.sites[key] = dict(path=self.path, line=node.lineno, scope=scope, kind=kind, program=expression, status='qualified' if tag == 'verified' else 'unproven', @@ -172,8 +181,13 @@ def expression(self, node, state, scope): process = (name in self.process_names or name.split('.', 1)[0] in self.process_modules and (leaf in PROCESS or leaf.startswith(('exec', 'spawn', 'posix_spawn')) or leaf in ('system', 'popen', 'create_subprocess_exec', 'create_subprocess_shell'))) - if process and node.args: - self.add(node.args[0], state, scope, 'process') + if process: + argument = node.args[0] if node.args else next( + (keyword.value for keyword in node.keywords if keyword.arg in ('args', 'cmd', None)), node.func) + self.add(argument, state, scope, 'process') + for keyword in node.keywords: + if keyword.arg == 'executable': + self.add(keyword.value, state, scope, 'executable-override') if name in ('eval', 'exec', 'compile') and node.args: self.add(node.args[0], {}, scope, 'generated-execution') if isinstance(node.func, ast.Attribute) and node.func.attr == 'update': @@ -249,7 +263,7 @@ def collect(self): for node in ast.walk(self.tree): if not isinstance(node, ast.Constant) or not isinstance(node.value, str) or '\n' not in node.value: continue - if ROLE.search(node.value) and any(token in node.value for token in ('subprocess.', 'Command::new', '#!/bin/sh', '#!/bin/bash')): + if ROLE.search(node.value): self.sites[(node.lineno, 'embedded', '')] = dict(path=self.path, line=node.lineno, scope='embedded', kind='embedded-source', program='', status='unproven', role='opaque') @@ -275,7 +289,9 @@ def shell_sites(text, path, offset=0): first = tokens[0] if first in ('echo', 'printf', 'export'): continue - oracle = bool(ROLE.search(first)) and not first.endswith(('.py', '.sh', '.rs', '.json')) + interpreter = first in ('bash', 'sh', 'python', 'python3', 'ruby', 'node', 'exec', 'eval', 'env', 'sudo', 'taskset') + oracle = (bool(ROLE.search(first)) and not first.endswith(('.py', '.sh', '.rs', '.json')) + or interpreter and bool(ROLE.search(source))) dynamic = first.startswith(('$', '"$')) and '=' not in first if oracle or dynamic: found.append(dict(path=path, line=line, scope='', kind='shell', program=source.strip(), @@ -337,6 +353,92 @@ def workflow_sites(text, path): return sites +def delegated_python_sites(root, paths): + modules = {} + by_name = {} + for path in paths: + tree = ast.parse((root / path).read_text()) + collector = PythonSites((root / path).read_text(), path) + functions = {} + aliases = {} + imports = {} + for node in ast.walk(tree): + if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): + functions.setdefault(node.name, []).append(node) + elif isinstance(node, ast.Assign) and isinstance(node.value, (ast.Name, ast.Attribute)): + for target in node.targets: + if isinstance(target, ast.Name): + aliases[target.id] = node.value + elif isinstance(node, ast.Import): + for item in node.names: + imports[item.asname or item.name.split('.')[0]] = (item.name, None) + elif isinstance(node, ast.ImportFrom) and node.module: + for item in node.names: + imports[item.asname or item.name] = (node.module, item.name) + modules[path] = (tree, collector, functions, aliases, imports) + by_name.setdefault(Path(path).stem, set()).add(path) + + def resolve(path, function, seen): + name = ast.unparse(function) + if name in seen: + return set() + seen = {*seen, name} + _, _, functions, aliases, imports = modules[path] + if isinstance(function, ast.Name): + if function.id in aliases: + return resolve(path, aliases[function.id], seen) + if function.id in functions: + return {(path, function.id)} + imported = imports.get(function.id) + if not imported or imported[1] is None: + return set() + module, symbol = imported + elif isinstance(function, ast.Attribute): + if isinstance(function.value, ast.Name) and function.value.id in ('self', 'cls'): + return {(path, function.attr)} if function.attr in functions else set() + base = name.split('.')[0] + imported = imports.get(base) + if not imported: + return set() + module, _ = imported + symbol = function.attr + else: + return set() + candidates = by_name.get(module.rsplit('.', 1)[-1], set()) + return {(candidate, symbol) for candidate in candidates if symbol in modules[candidate][2]} + + edges = {} + relays = set() + for path, (_, collector, functions, _, _) in modules.items(): + for name, definitions in functions.items(): + identity = (path, name) + edges[identity] = set() + for definition in definitions: + for node in ast.walk(definition): + if not isinstance(node, ast.Call): + continue + call = ast.unparse(node.func) + leaf = call.rsplit('.', 1)[-1] + if call in collector.process_names or call.split('.', 1)[0] in collector.process_modules and ( + leaf in PROCESS or leaf.startswith(('exec', 'spawn', 'posix_spawn')) or + leaf in ('system', 'popen', 'create_subprocess_exec', 'create_subprocess_shell')): + relays.add(identity) + edges[identity].update(resolve(path, node.func, set())) + while True: + reached = {identity for identity, children in edges.items() if children & relays} + if reached <= relays: + break + relays.update(reached) + found = [] + for path, (tree, _, _, _, _) in modules.items(): + for node in ast.walk(tree): + if isinstance(node, ast.Call) and resolve(path, node.func, set()) & relays: + found.append(dict(path=path, line=node.lineno, scope='', kind='delegated', + program=ast.unparse(node.func), status='unclassified', + role='oracle' if ROLE.search(ast.unparse(node)) else 'opaque')) + return found + + def inventory(root): paths = sorted(set(filter(None, subprocess.check_output( ['git', '-C', str(root), 'ls-files', '-z', '--cached', '--others', '--exclude-standard'], text=True).split('\0')))) @@ -355,6 +457,10 @@ def inventory(root): found.extend(shell_sites(file.read_text(), path)) elif file.suffix in ('.yml', '.yaml'): found.extend(workflow_sites(file.read_text(), path)) + python = [path for path in paths if path.endswith('.py') and path not in historical + and path not in BOOTSTRAP and path not in ('scripts/oracle_invocation_check.py', + 'scripts/tests/test_oracle_invocation_check.py')] + found.extend(delegated_python_sites(root, python)) rust = [path for path in paths if path.endswith('.rs') and path not in historical] aliases = {'Command'} for path in rust: @@ -371,10 +477,17 @@ def inventory(root): found.append(dict(path=path, line=source[:source.index('test-support/oracle.rs')].count('\n') + 1, scope='', kind='deployment', program='', status='unproven', role='oracle')) + javascript_aliases = set() + for path in paths: + if path.endswith(('.js', '.mjs', '.cjs', '.ts', '.tsx')) and path not in historical: + source = (root / path).read_text() + javascript_aliases.update(re.findall(r'\b(?:spawnSync|spawn|execFileSync|execFile|execSync|exec)\s+as\s+(\w+)', source)) + javascript_aliases.update(re.findall(r'\b(\w+)\s*=\s*(?:\w+\.)?(?:spawnSync|spawn|execFileSync|execFile|execSync|exec)\b', source)) + javascript_functions = r'(?:^|\.)(?:spawn|spawnSync|execFile|execFileSync|execSync|exec|' + '|'.join(re.escape(name) for name in sorted(javascript_aliases)) + r')$' for language, suffixes in (('JavaScript', ('.js', '.mjs', '.cjs')), ('TypeScript', ('.ts',)), ('Tsx', ('.tsx',))): selected = [path for path in paths if path.endswith(suffixes) and path not in historical] found.extend(structural_sites(root, selected, language, '$FUNCTION($PROGRAM, $$$ARGS)', 'PROGRAM', - lambda item: bool(re.search(r'(?:^|\.)(?:spawn|spawnSync|execFile|execFileSync|execSync)$', + lambda item: bool(re.search(javascript_functions, item['metaVariables']['single']['FUNCTION']['text'])))) for site in found: site['owner_path_hint'] = site['status'] == 'qualified' diff --git a/scripts/tests/test_oracle_invocation_check.py b/scripts/tests/test_oracle_invocation_check.py index 826d83ce0..3a87a6403 100644 --- a/scripts/tests/test_oracle_invocation_check.py +++ b/scripts/tests/test_oracle_invocation_check.py @@ -78,6 +78,12 @@ def test_shell_command_substitutions_are_discovered(self): self.assertEqual(len(sites), 1) self.assertEqual(sites[0]['program'], 'ffmpeg -encoders') + def test_an_oracle_hidden_behind_a_shell_interpreter_is_discovered(self): + sites = check.PythonSites('import subprocess\nsubprocess.run(["bash", "-c", "ffmpeg -version"])\n', + 'consumer.py').collect() + self.assertTrue(sites) + self.assertEqual(sites[0]['role'], 'oracle') + def test_namespaced_rust_constructor_is_discovered(self): with tempfile.TemporaryDirectory() as directory: root = Path(directory) @@ -100,6 +106,31 @@ def test_an_assigned_process_alias_is_discovered(self): self.assertTrue(sites) self.assertEqual(sites[0]['role'], 'opaque') + def test_a_default_process_callable_is_discovered(self): + sites = check.PythonSites('import subprocess\ndef capture(command, launch=subprocess.run):\n launch(command)\n', + 'consumer.py').collect() + self.assertTrue(sites) + self.assertEqual(sites[0]['role'], 'opaque') + + def test_renamed_literal_executable_is_not_assumed_non_oracle(self): + sites = check.PythonSites('import subprocess\nsubprocess.run(["renamed-program", "-version"])\n', + 'consumer.py').collect() + self.assertTrue(sites) + self.assertEqual(sites[0]['role'], 'opaque') + + def test_keyword_argv_and_actual_executable_override_are_discovered(self): + sites = check.PythonSites('import subprocess\nsubprocess.run(args=command, executable=override)\n', + 'consumer.py').collect() + self.assertEqual({site['kind'] for site in sites}, {'process', 'executable-override'}) + + def test_a_delegated_caller_without_a_process_constructor_is_discovered(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + (root / 'helper.py').write_text('import subprocess\ndef capture(command):\n subprocess.run(command)\n') + (root / 'caller.py').write_text('from helper import capture as launch\nlaunch(command)\n') + sites = check.delegated_python_sites(root, ['helper.py', 'caller.py']) + self.assertTrue(any(site['path'] == 'caller.py' and site['program'] == 'launch' for site in sites)) + def test_workflow_environment_fields_are_not_commands(self): source = 'steps:\n - run: |\n ffprobe -version\n env:\n COREAV_FFMPEG: /bin/ffmpeg\n' sites = check.workflow_sites(source, 'workflow.yml') From 50a563c5b457e8f39c005c45857ac46ca04e3fd0 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 14:59:03 +0000 Subject: [PATCH 10/21] test(ffmpeg): reject replaced historical boundaries Signed-off-by: gunwooterry --- scripts/oracle_invocation_check.py | 6 +++++- scripts/tests/test_oracle_invocation_check.py | 12 ++++++++++++ 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/scripts/oracle_invocation_check.py b/scripts/oracle_invocation_check.py index dc2392eb0..fc595c8f7 100644 --- a/scripts/oracle_invocation_check.py +++ b/scripts/oracle_invocation_check.py @@ -21,7 +21,11 @@ def historical_records(root, record): expected = record.get('files') if not isinstance(expected, dict) or not expected or not all(isinstance(key, str) for key in expected): raise ValueError('restore the nonempty historical path and digest record') - boundary = root / HISTORICAL_BOUNDARY + boundary = root + for component in HISTORICAL_BOUNDARY.split('/'): + boundary /= component + if boundary.is_symlink() or not boundary.is_dir(): + raise ValueError('historical boundary must contain only real directories') actual = {path.relative_to(root).as_posix(): path for path in boundary.rglob('*') if path.is_file() or path.is_symlink()} problems = [] diff --git a/scripts/tests/test_oracle_invocation_check.py b/scripts/tests/test_oracle_invocation_check.py index 3a87a6403..6392ad339 100644 --- a/scripts/tests/test_oracle_invocation_check.py +++ b/scripts/tests/test_oracle_invocation_check.py @@ -66,6 +66,18 @@ def test_a_symlink_cannot_substitute_for_recorded_bytes(self): with self.assertRaisesRegex(ValueError, 'symbolic link'): check.historical_records(root, record) + def test_the_boundary_and_its_parents_cannot_be_symbolic_links(self): + for name in ('docs', 'docs/measurements'): + with self.subTest(name=name), tempfile.TemporaryDirectory() as directory: + root = Path(directory) + _, record = self.fixture(root) + boundary = root / name + copy = root / 'retained' + boundary.rename(copy) + boundary.symlink_to(copy, target_is_directory=True) + with self.assertRaisesRegex(ValueError, 'historical boundary'): + check.historical_records(root, record) + class Discovery(unittest.TestCase): def test_shell_commands_are_not_confused_with_copy_operands(self): From eaf046ecfaf86a924f9b57f56ba363b5cffe56fb Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 15:04:50 +0000 Subject: [PATCH 11/21] docs(ffmpeg): record scalar reference scope Signed-off-by: gunwooterry --- docs/design/local-oracle-qualification.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/design/local-oracle-qualification.md b/docs/design/local-oracle-qualification.md index 8e776aa80..ace8c393b 100644 --- a/docs/design/local-oracle-qualification.md +++ b/docs/design/local-oracle-qualification.md @@ -16,6 +16,8 @@ Test a valid pair, a wrong version, a malformed or failed version command, a mis This is oracle qualification only. It does not change runtime fallback, native admission, generated media, command registrations, comparison tolerances or measured coverage. The registered frozen harness and Python driver retain workflow-level verification because their dependency closure is immutable. FROZEN, JUDGING, their registered hashes and all their source files remain unchanged. No media corpus or performance round is needed. +On arm64, FFmpeg 9.0.2's default SIMD F32→S16 path rounds half-LSB ties away from even, so the conversion reference test pins the scalar path to preserve CoreAV's ties-to-even contract; registered measurements run on x86-64. + ## Implemented boundaries Real callers use the common owner before fixture generation or comparison. Literal-only generated fixtures and mocked subprocess tests stay oracle-free; optional fixture and non-FFmpeg backend selection remains separate from oracle availability. The Linux CI job provisions its pair before any real backend test, and Python discovery provisions it before real fixture consumers. Registered macOS arm64 tests provision the existing macOS pair; other platform selections name and exclude their real oracle-dependent tests explicitly instead of treating a missing executable as a passing comparison. From bb5c812b03248bb9b78c316f1e384fb3fdd2a5f0 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 16:14:13 +0000 Subject: [PATCH 12/21] test(ffmpeg): classify oracle invocation evidence Signed-off-by: gunwooterry --- docs/design/local-oracle-qualification.md | 2 + .../oracle-invocation-dispositions.json | 1793 +++++++++++++++++ scripts/oracle_invocation_classify.py | 156 ++ .../tests/test_oracle_invocation_classify.py | 175 ++ 4 files changed, 2126 insertions(+) create mode 100644 docs/design/oracle-invocation-dispositions.json create mode 100644 scripts/oracle_invocation_classify.py create mode 100644 scripts/tests/test_oracle_invocation_classify.py diff --git a/docs/design/local-oracle-qualification.md b/docs/design/local-oracle-qualification.md index ace8c393b..6472b6eb7 100644 --- a/docs/design/local-oracle-qualification.md +++ b/docs/design/local-oracle-qualification.md @@ -35,3 +35,5 @@ Historical measurement records under `docs/measurements/` retain their exact byt Classify each remaining discovery hit as a confirmed bypass, already routed through qualification, or a false positive, with the actual boundary and the evidence for its disposition. Keep unknown hits failing rather than counting them as bypasses or qualified calls. Bind reviewed dispositions to their source and qualification dependencies so a new invocation or changed proof requires review. Cover explicit executable identity, early dispatch, source bundles and relocated production adapters separately from local source-pattern matches. Report the confirmed-bypass count before changing any consumers. If the remaining migration cannot stay coherent with the existing deployment and dispatch repairs, split only after a scope decision. Run only short local source and generated regression checks during discovery; no media corpus, performance or remote infrastructure run is required. + +The classifier matches concrete call patterns against source-bound dispositions rather than inferring qualification from a general-purpose value-flow model. Each disposition identifies its source locations, executable expression, verdict and evidence; the code snapshot and qualification dependencies must still match their recorded digests. A changed helper, added source, shadowed binding or executable override therefore invalidates the prior disposition instead of inheriting it. Unmatched locations remain unknown and fail. Reports count source locations, folding overlapping constructor, completion and delegated rows at the same location; they do not count runtime calls or claim an exhaustive bypass total while unknown locations remain. diff --git a/docs/design/oracle-invocation-dispositions.json b/docs/design/oracle-invocation-dispositions.json new file mode 100644 index 000000000..25e994ad9 --- /dev/null +++ b/docs/design/oracle-invocation-dispositions.json @@ -0,0 +1,1793 @@ +{ + "dependencies": { + "docs/design/oracle-historical-records.json": "85a032c2ae9e89f4368107672886f22ea758e69a96d9ec5f63b03bad9a7fcf52", + "scripts/oracle-ffmpeg-macos.env": "32805c5848146a1a1200a2c401f07f9c09cfb41628f656ef60dadcca956ae4bd", + "scripts/oracle-ffmpeg.env": "95601248eba142d1cbf8d81aaf46d5ebc61c1962fe1edafdc1ee2c1b7bd33f24", + "scripts/oracle_pin.py": "b221378b054a6e6bae92051ae4e4e4fa1add451213f28e888825fa6e43f2f909", + "scripts/oracle_pin_macos.py": "70c0f515b3a58cf6b6d2d11938b537b2e8824f0fafbfe6ab9578669c1d857879", + "scripts/test_oracle.py": "ba9bc428dae34681fa5b9c3f80863479c6fc0c0f45f267ec009d7d97ea004510", + "test-support/oracle.rs": "bda841d4ac18d3cb12d417ff29b1fbc0a5f083a2838e06b1d4b6e92a67c679c2" + }, + "frozen": { + ".github/workflows/compat-0.1.0.yml": "b979061433995d3a504edddac660216fefbdef556080967f7facf76c89eb1a80", + "bench/audio-decode/agreement.py": "32f312ad10962d654568c85b6962041ae8cce82ccd74272dfddb3b0656ac0818", + "bench/audio-decode/capacity.py": "da27491bc077453e0fca6706bddaefdf8098e1d4bb8d1006ada34c6abedd1462", + "bench/audio-decode/oracle.py": "6999bc89af9f0ffb4dade872e30b2b0ba7342648b32e22aaeeca50936316b32a", + "bench/audio-decode/receipts.py": "bec504c954c8750df703116325e37ea21c2844696df68e23856495bf95a18783", + "bench/audio-decode/run.py": "516120decdaf44a5e206c5e57da485ad15d3f9aa010422daa027508bb2ef6112", + "crates/coreav-cli/tests/ffmpeg.rs": "15e49cefc43240d732903b37874a0fda544065777e331200cfe2ad6182eebefc", + "crates/coreav-isobmff/tests/common/fragments.rs": "a9e161349e40328ca2b95ffa593aff35af0e1739648d74fc0767100cda3f0b89", + "crates/coreav-isobmff/tests/common/mod.rs": "fcd4b45894250821d93290d802d8324dfc8cbc1b27c56980a6a6075955744d71", + "crates/coreav-isobmff/tests/common/sound.rs": "7db44a00ee6bc2671517fdf5e8bb8b31b25ac224c856b04948aed5bb1875ef03", + "crates/coreav-isobmff/tests/common/text_movie.rs": "14d531666bb6c356d27ad936e7ee2425a9b63a131a6ea0b013042d947a1f324f", + "docs/design/b4-calibration.md": "3222e7f6001f7f88d4fa380fbe87c525f0363eb3e2ad82ba7f5425ef0e1302a3", + "docs/known-divergences-clip.json": "58fcca78ddd8462ac2f194d4461efe9783f32c062a2699741dd6eba3f232e736", + "docs/known-divergences-decode-audio.json": "9b776384b90f23bad4c50d9613661f95fc2ccfb8da195e3bb76da00ea2d30a18", + "docs/known-divergences-extract.json": "e3cc703458a19150673dd30ccf1ba0a0990fb637e6ed304c8153eff4205d2ab1", + "docs/known-divergences-hls.json": "885310e6e2a2b976c6fd9c38e1de9145edd25eda96ccfca9270195d0ed58b0d5", + "docs/known-divergences-join.json": "aca15deefe581e69197de4998a81a41eec2ec28d4c4b776820daec9a3bf6872a", + "docs/known-divergences-mkv.json": "a7a73ce921ed7ce8f8eaaa7b4418f611feea3779528f9c2ef990261ff712c716", + "docs/known-divergences-remux.json": "2da90e34d112b9793d183755c0a6946a8c593bad17fb5004ff788ab92c388f3f", + "docs/known-divergences-split.json": "263d5365501db4935672c4c5b182768c14cd3a747bb6d11072741e44128d37a0", + "docs/known-divergences-ts.json": "44ef5eec8132cf5e490588dafa7c3c99e33676ea4ab17deb41dcf50f9ca303fc", + "docs/known-divergences.json": "25b7b962df7e72e47a35146418ff232726ed4c1f3cb781ae9d54c747a793203c", + "docs/measurements/compat-0.1.0/judging.json": "4b31ec8809f792c5f57d079782280ad0f34eeaba19389ed3e92992e95e206dc9", + "docs/measurements/compat-ffprobe/round10-plan.md": "027ed41e1d586ff8d62965b1fa8174fa024599c8acab21057544c55b326b5322", + "scripts/clip_check.py": "f448dcf2a98a88546fa988a4b24dbccf95fc3baa517bbbe34021e3df2bb588c4", + "scripts/compat_check.py": "6d5c1322a578632bcf9cb9fe6cd87519e427127589c39b8ba52ba70b51a250cc", + "scripts/compat_sources.py": "6df31864dd84ac9518a4140bcc32a86e8149b9b39377f51882eadcb7606824e5", + "scripts/decode_audio_check.py": "05277f5e3c9d17a352088d003b703705f6738354bf6dbf81be3620802dd448e2", + "scripts/extract_check.py": "d0ca1b1975d08acdb6fad7b9f185badfc1709d1444359037a0d94bb59aa834e7", + "scripts/gcp_vm_job.py": "aaadd972e8e12715d118c12ef569a7813e11024750336f2a73e900550ab23bec", + "scripts/h264_parity_bars.py": "35b87258d5254861a91c94baba6ad6c7a736637fb88b4feced06796894797f5b", + "scripts/h264_pgo_acquire.py": "b9d0942f33baee08d4bd7386318d658deede6190cf8113d5d0f5f80f1d2182e1", + "scripts/h264_pgo_diagnostics.py": "cb2c425e48af13b0b9be3548168fbe645672c5f546d84f26f35f99bbe8ba047c", + "scripts/hls_check.py": "629a7bea8045fbc04d115d784dd6ec033163b045e7fe75c5b1c0bc38351f10d5", + "scripts/install-oracle-ffmpeg.sh": "819e66bbdd3ee43327e5183be216997211299434db239eb4a41a22c41910bfd5", + "scripts/install-oracle-mediainfo.sh": "c8224047da52c9032d339270e51ce5bc9034daeee2c351bbf90cb270de1e4e36", + "scripts/join_check.py": "2af2682134b3bfb08b0be371032fb604ad8579008ecd8b76a354a68b78ae84e2", + "scripts/mkv_remux_check.py": "cf81d3d0b7395219374208f2ae24099c4f155b582190f9988224f77a9066ab9a", + "scripts/opus_identity.py": "c87a89900823e43b09bbf06a2ead35cd9390e9e7cd59b13ff075637b6e1fd987", + "scripts/oracle-audio-args.txt": "52720de7a4d973d387c1c7bffd770f40120b7315dcf307625841d04d5e000586", + "scripts/oracle-ffmpeg.env": "95601248eba142d1cbf8d81aaf46d5ebc61c1962fe1edafdc1ee2c1b7bd33f24", + "scripts/oracle_audio.py": "cc4a68c084aab8f22201a517fb35efbc427f85590b5007e3dfc852e6dc5a98f4", + "scripts/oracle_kd.py": "255f193b6bc6e2f67f32f7fe40bd5f91179ce13c91ce462a6514ecd4b0f50d52", + "scripts/oracle_kd_mkv.py": "f03b407674c5faa955381f2439bac16f412591041f31326bab241b2f81526b27", + "scripts/oracle_kd_ts.py": "a837051ee8900c860973e0e91bacfed14eb21be99b07260938cf1d409d322d31", + "scripts/oracle_pin.py": "b221378b054a6e6bae92051ae4e4e4fa1add451213f28e888825fa6e43f2f909", + "scripts/policy_ref.py": "782e327baef9626f4cd9631bb93e45476fdebd3234ca4b605ce4e9960317d1d1", + "scripts/registered_candidate.py": "93d5733c6e3645c9adc29b9eefcc5bb89e54cf6e96ef8de0d17976032b5f5604", + "scripts/remux_check.py": "8cccb3551736f918660c304d434b3fc3cc9501e98e8ade011ae75d0787c14670", + "scripts/split_check.py": "1cd37d7d66608a3d74230a247369d733deb0a13cb51ab1b9ce32a024107f3c61", + "scripts/track_boxes.py": "97965c1b8f23758c75fedc0eb1d0815fa01f51469ad50c7ae6b5d02fe007a967", + "scripts/vp9_pixel_build.py": "6a899aecd066379adfbd6016eea2dc8a6a708ae157aa931919676d5679fdf34f", + "scripts/vp9_pixel_ceiling.py": "10335257ea5cc07c5fc5e1f8e976c9856b0ea25a0f991621519ba825181711dc", + "scripts/vp9_pixel_job.sh": "db0226d50f4f5c3830a4465caa67146655a2baa8bc30b3f36ea04a9fef26bcde", + "scripts/vp9_pixel_profiles.py": "3f0cbe890a89b35d960ee18435831a409e6aeea6825638d6078ed04b1f9b05b9", + "scripts/vp9_pixel_round.py": "2dd7d856d5570741113489f76da099dfd5b11f5867b7e8334437db7d0f78961f", + "scripts/writer_boxes.py": "2aaa08ab4e82c78c240b9b594a4ace6639eaf478bef2dde99a50dd6b22acfbb9", + "tools/compat-corpus/b4_protocol.py": "16ad6f705c053e283ed7ee1046d2e012b133746c83726c04aafca7b4513966a8", + "tools/compat-corpus/b4_round10.py": "c71b1005b327d4b9d0ff00e671fd18b1dbb0250a0088114229535bb3b0438054", + "tools/compat-corpus/commands-0.1.0/commands.json": "abeae21f954d18b50ab4af5cef972dbfe14396453329c6f8c751034942bdac0f", + "tools/compat-corpus/commands-0.1.0/coverage.json": "077ed478f4693c5612ec3d018c9d3bbe96125a80eb635322ddf3d68dec6894c3", + "tools/compat-corpus/copy_check.py": "e73b39820ded04968f9c5cae7ac7a9157e1207a5b9e7351c24a6e6b007f20a75", + "tools/compat-corpus/ffmpeg9.json": "12204af1619cf806ede5e009dee43edc51edc361b5c9a93c96f0838ef9d0028d", + "tools/compat-corpus/r3.py": "0549a6b9f429e0cadd61d6d10498c971f17b901a7e89143d5d3043fa3b58d913", + "tools/compat-corpus/release_round.py": "b5c959bbfb004b8f4cffc65d25bdaf442d5f8e2920b968b844618c0fdfb6a2fa", + "tools/compat-corpus/round_files.py": "422d539f46c26443ac418a408261f64057c7a2155582146f1c6a9650d14494ce", + "tools/compat-corpus/run.py": "c39fa06827c17e57ba501fa7dde6c4b2fc2f319fc3e7616d62238d070ec056d7", + "tools/compat-corpus/speed.py": "adac065441a90301a2a026b89c4d3f0d609881770697cb8ba5c641794b448e21", + "tools/oracle/writer_corpus.py": "c4bb64463375c6b0fb10c6efe1ed582f6cb075bbbd3fd15666399230aebd830d", + "tools/stage3-report/corpus.py": "86741f53e0ff67df381fef5a875b905ee2037ae6742bcc6eec0e7ea8f4c685f0", + "tools/stage3-report/r2pool.py": "b0990e04927f66434dad4041af92ae41377277c6e26695b559ae5997024030ac" + }, + "rules": [ + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 133 + ], + "path": "crates/coreav-audio/tests/flac_encode.rs", + "pattern": "(?s)\\&program", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 133 + ], + "path": "crates/coreav-audio/tests/flac_encode.rs", + "pattern": "(?s)std::process::Command::new\\(\\&program\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 32, + 47 + ], + "path": "crates/coreav-backend-dav1d/tests/decode.rs", + "pattern": "(?s)Command::new\\(ffmpeg\\(\\)\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 32, + 47 + ], + "path": "crates/coreav-backend-dav1d/tests/decode.rs", + "pattern": "(?s)ffmpeg\\(\\)", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 29, + 40, + 188 + ], + "path": "crates/coreav-backend-ffmpeg/tests/decode.rs", + "pattern": "(?s)Command::new\\(ffmpeg\\(\\)\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 29, + 40, + 188 + ], + "path": "crates/coreav-backend-ffmpeg/tests/decode.rs", + "pattern": "(?s)ffmpeg\\(\\)", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 36, + 48 + ], + "path": "crates/coreav-backend-h264/tests/decode.rs", + "pattern": "(?s)Command::new\\(ffmpeg\\(\\)\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 36, + 48 + ], + "path": "crates/coreav-backend-h264/tests/decode.rs", + "pattern": "(?s)ffmpeg\\(\\)", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 37 + ], + "path": "crates/coreav-backend-h264/tests/memory.rs", + "pattern": "(?s)Command::new\\(ffmpeg\\(\\)\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 37 + ], + "path": "crates/coreav-backend-h264/tests/memory.rs", + "pattern": "(?s)ffmpeg\\(\\)", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 522 + ], + "path": "crates/coreav-backend-h264/tests/one_idr.rs", + "pattern": "(?s)std::process::Command::new\\(test_oracle::require\\(\\)\\.ffmpeg\\(\\)\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 522 + ], + "path": "crates/coreav-backend-h264/tests/one_idr.rs", + "pattern": "(?s)test_oracle::require\\(\\)\\.ffmpeg\\(\\)", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 49, + 95, + 197, + 220 + ], + "path": "crates/coreav-backend-libvpx/tests/decode.rs", + "pattern": "(?s)Command::new\\(ffmpeg\\(\\)\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 49, + 95, + 197, + 220 + ], + "path": "crates/coreav-backend-libvpx/tests/decode.rs", + "pattern": "(?s)ffmpeg\\(\\)", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 24 + ], + "path": "crates/coreav-cli/tests/avi.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 24 + ], + "path": "crates/coreav-cli/tests/avi.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 317 + ], + "path": "crates/coreav-cli/tests/check.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 317 + ], + "path": "crates/coreav-cli/tests/check.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 491, + 499 + ], + "path": "crates/coreav-cli/tests/decode_audio.rs", + "pattern": "(?s)Command::new\\(\\&ffmpeg\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 491, + 499 + ], + "path": "crates/coreav-cli/tests/decode_audio.rs", + "pattern": "(?s)\\&ffmpeg", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 24, + 87 + ], + "path": "crates/coreav-cli/tests/decoder_host.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 62, + 115 + ], + "path": "crates/coreav-cli/tests/decoder_host.rs", + "pattern": "(?s)Command::new\\(\\&ffmpeg\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 62, + 115 + ], + "path": "crates/coreav-cli/tests/decoder_host.rs", + "pattern": "(?s)\\&ffmpeg", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 24 + ], + "path": "crates/coreav-cli/tests/docs_site.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 24 + ], + "path": "crates/coreav-cli/tests/docs_site.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 11, + 25, + 31 + ], + "path": "crates/coreav-cli/tests/exec.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 11, + 25, + 31 + ], + "path": "crates/coreav-cli/tests/exec.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 46 + ], + "path": "crates/coreav-cli/tests/fallback_windows.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "pin() at lines 118-137 verifies the parent directory but returns the originally selected file. A different executable in that valid directory remains selectable.", + "id": "rust-parent-directory-only", + "kinds": [ + "Rust" + ], + "lines": [ + 154, + 298, + 326, + 408, + 497, + 592 + ], + "path": "crates/coreav-cli/tests/ffmpeg_flac.rs", + "pattern": "(?s)Command::new\\(\\&ffmpeg\\).*", + "verdict": "confirmed-bypass" + }, + { + "evidence": "pin() at lines 118-137 verifies the parent directory but returns the originally selected file. A different executable in that valid directory remains selectable.", + "id": "rust-parent-directory-only", + "kinds": [ + "Rust" + ], + "lines": [ + 154, + 298, + 326, + 408, + 497, + 592 + ], + "path": "crates/coreav-cli/tests/ffmpeg_flac.rs", + "pattern": "(?s)\\&ffmpeg", + "verdict": "confirmed-bypass" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 75, + 81 + ], + "path": "crates/coreav-cli/tests/ffmpeg_flac.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 63, + 253, + 295, + 522 + ], + "path": "crates/coreav-cli/tests/ffmpeg_frames.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 63, + 186, + 253, + 295, + 522, + 556 + ], + "path": "crates/coreav-cli/tests/ffmpeg_frames.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 40 + ], + "path": "crates/coreav-cli/tests/ffmpeg_frames.rs", + "pattern": "(?s)\\&oracle", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 76 + ], + "path": "crates/coreav-cli/tests/ffmpeg_matroska.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 76 + ], + "path": "crates/coreav-cli/tests/ffmpeg_matroska.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "oracle() at lines 27-39 reads COREAV_FFMPEG and checks only file presence. The private generator and reference callers pass that unchecked path or its unchecked ffprobe sibling.", + "id": "rust-environment-file-check-only", + "kinds": [ + "Rust" + ], + "lines": [ + 180, + 275, + 347, + 359, + 476 + ], + "path": "crates/coreav-cli/tests/ffmpeg_mkv_aac_copy.rs", + "pattern": "(?s)Command::new\\(\\&ffmpeg\\).*", + "verdict": "confirmed-bypass" + }, + { + "evidence": "oracle() at lines 27-39 reads COREAV_FFMPEG and checks only file presence. The private generator and reference callers pass that unchecked path or its unchecked ffprobe sibling.", + "id": "rust-environment-file-check-only", + "kinds": [ + "Rust" + ], + "lines": [ + 62 + ], + "path": "crates/coreav-cli/tests/ffmpeg_mkv_aac_copy.rs", + "pattern": "(?s)Command::new\\(ffmpeg\\).*", + "verdict": "confirmed-bypass" + }, + { + "evidence": "oracle() at lines 27-39 reads COREAV_FFMPEG and checks only file presence. The private generator and reference callers pass that unchecked path or its unchecked ffprobe sibling.", + "id": "rust-environment-file-check-only", + "kinds": [ + "Rust" + ], + "lines": [ + 79 + ], + "path": "crates/coreav-cli/tests/ffmpeg_mkv_aac_copy.rs", + "pattern": "(?s)Command::new\\(ffprobe\\).*", + "verdict": "confirmed-bypass" + }, + { + "evidence": "oracle() at lines 27-39 reads COREAV_FFMPEG and checks only file presence. The private generator and reference callers pass that unchecked path or its unchecked ffprobe sibling.", + "id": "rust-environment-file-check-only", + "kinds": [ + "Rust" + ], + "lines": [ + 180, + 275, + 347, + 359, + 476 + ], + "path": "crates/coreav-cli/tests/ffmpeg_mkv_aac_copy.rs", + "pattern": "(?s)\\&ffmpeg", + "verdict": "confirmed-bypass" + }, + { + "evidence": "oracle() at lines 27-39 reads COREAV_FFMPEG and checks only file presence. The private generator and reference callers pass that unchecked path or its unchecked ffprobe sibling.", + "id": "rust-environment-file-check-only", + "kinds": [ + "Rust" + ], + "lines": [ + 62 + ], + "path": "crates/coreav-cli/tests/ffmpeg_mkv_aac_copy.rs", + "pattern": "(?s)ffmpeg", + "verdict": "confirmed-bypass" + }, + { + "evidence": "oracle() at lines 27-39 reads COREAV_FFMPEG and checks only file presence. The private generator and reference callers pass that unchecked path or its unchecked ffprobe sibling.", + "id": "rust-environment-file-check-only", + "kinds": [ + "Rust" + ], + "lines": [ + 79 + ], + "path": "crates/coreav-cli/tests/ffmpeg_mkv_aac_copy.rs", + "pattern": "(?s)ffprobe", + "verdict": "confirmed-bypass" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 195, + 217, + 238, + 305, + 319, + 333, + 371, + 491, + 509 + ], + "path": "crates/coreav-cli/tests/ffmpeg_mkv_aac_copy.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 195, + 217, + 238, + 305, + 319, + 333, + 371, + 491, + 509 + ], + "path": "crates/coreav-cli/tests/ffmpeg_mkv_aac_copy.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 19, + 118, + 139, + 186, + 215, + 226, + 274, + 316, + 350, + 405, + 455, + 497, + 546, + 588, + 622, + 942, + 985, + 1008 + ], + "path": "crates/coreav-cli/tests/ffmpeg_pcm.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 19, + 118, + 139, + 186, + 215, + 226, + 274, + 316, + 350, + 405, + 455, + 497, + 546, + 588, + 622, + 942, + 985, + 1008 + ], + "path": "crates/coreav-cli/tests/ffmpeg_pcm.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 51, + 94 + ], + "path": "crates/coreav-cli/tests/ffmpeg_pcm.rs", + "pattern": "(?s)Command::new\\(\\&ffmpeg\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 51, + 94 + ], + "path": "crates/coreav-cli/tests/ffmpeg_pcm.rs", + "pattern": "(?s)\\&ffmpeg", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 15 + ], + "path": "crates/coreav-cli/tests/ffmpeg_raw.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 15 + ], + "path": "crates/coreav-cli/tests/ffmpeg_raw.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 443, + 654 + ], + "path": "crates/coreav-cli/tests/ffmpeg_wav.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 41, + 180, + 238, + 443, + 654 + ], + "path": "crates/coreav-cli/tests/ffmpeg_wav.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 109, + 143, + 431 + ], + "path": "crates/coreav-cli/tests/ffmpeg_wav.rs", + "pattern": "(?s)Command::new\\(\\&ffmpeg\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 109, + 143, + 187, + 245, + 431 + ], + "path": "crates/coreav-cli/tests/ffmpeg_wav.rs", + "pattern": "(?s)\\&ffmpeg", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 50 + ], + "path": "crates/coreav-cli/tests/ffprobe_ancillary_bit_rate.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 50 + ], + "path": "crates/coreav-cli/tests/ffprobe_ancillary_bit_rate.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 61 + ], + "path": "crates/coreav-cli/tests/ffprobe_aspect_ratio.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 61 + ], + "path": "crates/coreav-cli/tests/ffprobe_aspect_ratio.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 75, + 179, + 215, + 259, + 287, + 354, + 404, + 416, + 442, + 485 + ], + "path": "crates/coreav-cli/tests/ffprobe_clean_aperture.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 75, + 179, + 215, + 259, + 287, + 354, + 404, + 416, + 442, + 485 + ], + "path": "crates/coreav-cli/tests/ffprobe_clean_aperture.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 51, + 167, + 193, + 224 + ], + "path": "crates/coreav-cli/tests/ffprobe_format_span.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 51, + 167, + 193, + 224 + ], + "path": "crates/coreav-cli/tests/ffprobe_format_span.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 209 + ], + "path": "crates/coreav-cli/tests/ffprobe_format_span.rs", + "pattern": "(?s)Command::new\\(\\&pin\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 288 + ], + "path": "crates/coreav-cli/tests/ffprobe_format_span.rs", + "pattern": "(?s)Command::new\\(oracle\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 209 + ], + "path": "crates/coreav-cli/tests/ffprobe_format_span.rs", + "pattern": "(?s)\\&pin", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 288 + ], + "path": "crates/coreav-cli/tests/ffprobe_format_span.rs", + "pattern": "(?s)oracle", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 102 + ], + "path": "crates/coreav-cli/tests/ffprobe_fragment_bit_rate.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 102 + ], + "path": "crates/coreav-cli/tests/ffprobe_fragment_bit_rate.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 113 + ], + "path": "crates/coreav-cli/tests/ffprobe_pixel_range.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 113 + ], + "path": "crates/coreav-cli/tests/ffprobe_pixel_range.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 54, + 190, + 234, + 262, + 274, + 296 + ], + "path": "crates/coreav-cli/tests/ffprobe_stream_groups.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 54, + 190, + 234, + 262, + 274, + 296 + ], + "path": "crates/coreav-cli/tests/ffprobe_stream_groups.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 84 + ], + "path": "crates/coreav-cli/tests/ffprobe_track_names.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 52, + 86, + 115, + 132, + 169, + 180, + 207, + 219 + ], + "path": "crates/coreav-cli/tests/ffprobe_ts_private.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 52, + 86, + 115, + 132, + 169, + 180, + 207, + 219 + ], + "path": "crates/coreav-cli/tests/ffprobe_ts_private.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 84 + ], + "path": "crates/coreav-cli/tests/ffprobe_ts_tail.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 84 + ], + "path": "crates/coreav-cli/tests/ffprobe_ts_tail.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The standalone entry point executes the recorded PATH or environment selection without qualifying that executable.", + "id": "rust-environment-selection", + "kinds": [ + "Rust" + ], + "lines": [ + 37 + ], + "path": "crates/coreav-cli/tests/frame_handoff.rs", + "pattern": "(?s)\\&ffmpeg", + "verdict": "confirmed-bypass" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 75 + ], + "path": "crates/coreav-cli/tests/frame_handoff.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 72 + ], + "path": "crates/coreav-cli/tests/legacy_encoders.rs", + "pattern": "(?s)test_oracle::require\\(\\)\\.ffmpeg\\(\\)", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 61, + 103 + ], + "path": "crates/coreav-cli/tests/probe_tuning.rs", + "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", + "verdict": "excluded" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 61, + 103 + ], + "path": "crates/coreav-cli/tests/probe_tuning.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 95 + ], + "path": "crates/coreav-cli/tests/strict_safe.rs", + "pattern": "(?s)Command::new\\(\\&ffmpeg\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 95 + ], + "path": "crates/coreav-cli/tests/strict_safe.rs", + "pattern": "(?s)\\&ffmpeg", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 16 + ], + "path": "crates/coreav-cli/tests/strict_safe_limit.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 80, + 89 + ], + "path": "crates/coreav-cli/tests/thumbnail.rs", + "pattern": "(?s)Command::new\\(test_oracle::require\\(\\)\\.ffmpeg\\(\\)\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 80, + 89 + ], + "path": "crates/coreav-cli/tests/thumbnail.rs", + "pattern": "(?s)test_oracle::require\\(\\)\\.ffmpeg\\(\\)", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", + "id": "rust-compiled-target", + "kinds": [ + "Rust" + ], + "lines": [ + 27, + 612 + ], + "path": "crates/coreav-cli/tests/transcode_selection.rs", + "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", + "verdict": "excluded" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 1287 + ], + "path": "crates/coreav-isobmff-write/tests/replace.rs", + "pattern": "(?s)Command::new\\(test_oracle::require\\(\\)\\.ffmpeg\\(\\)\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 1122 + ], + "path": "crates/coreav-isobmff-write/tests/replace.rs", + "pattern": "(?s)Command::new\\(test_oracle::require\\(\\)\\.ffprobe\\(\\)\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 1287 + ], + "path": "crates/coreav-isobmff-write/tests/replace.rs", + "pattern": "(?s)test_oracle::require\\(\\)\\.ffmpeg\\(\\)", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 1122 + ], + "path": "crates/coreav-isobmff-write/tests/replace.rs", + "pattern": "(?s)test_oracle::require\\(\\)\\.ffprobe\\(\\)", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 29, + 129, + 175, + 267, + 370, + 478 + ], + "path": "crates/coreav-worker/tests/ffmpeg.rs", + "pattern": "(?s)Command::new\\(ffmpeg\\(\\)\\).*", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "rust-owner-return", + "kinds": [ + "Rust" + ], + "lines": [ + 29, + 129, + 175, + 267, + 370, + 478 + ], + "path": "crates/coreav-worker/tests/ffmpeg.rs", + "pattern": "(?s)ffmpeg\\(\\)", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The standalone entry point executes the recorded PATH or environment selection without qualifying that executable.", + "id": "shell-unqualified-array", + "kinds": [ + "shell" + ], + "lines": [ + 21, + 22, + 23, + 24, + 25, + 28 + ], + "path": "packages/cli/test/release-clips.sh", + "pattern": "(?s)\"\\$\\{ff\\[@\\]\\}\"(?:\\s.*)?", + "verdict": "confirmed-bypass" + }, + { + "evidence": "The standalone entry point executes the recorded PATH or environment selection without qualifying that executable.", + "id": "shell-unqualified-command-word", + "kinds": [ + "shell" + ], + "lines": [ + 13 + ], + "path": "packages/cli/test/release-clips.sh", + "pattern": "(?s)ffmpeg(?:\\s.*)?", + "verdict": "confirmed-bypass" + }, + { + "evidence": "main() at lines 89-94 verifies opts.ffmpeg.parent, then passes the originally selected executable into the direct runner and video_equal. Neither basename nor selected-file identity is checked.", + "id": "python-parent-directory-only", + "kinds": [ + "command" + ], + "lines": [ + 79 + ], + "path": "scripts/avi_fixture_check.py", + "pattern": "(?s)ffmpeg", + "verdict": "confirmed-bypass" + }, + { + "evidence": "main() at lines 89-94 verifies opts.ffmpeg.parent, then passes the originally selected executable into the direct runner and video_equal. Neither basename nor selected-file identity is checked.", + "id": "python-parent-directory-only", + "kinds": [ + "command" + ], + "lines": [ + 102, + 107, + 129, + 132 + ], + "path": "scripts/avi_fixture_check.py", + "pattern": "(?s)opts\\.ffmpeg", + "verdict": "confirmed-bypass" + }, + { + "evidence": "main() at lines 89-94 verifies opts.ffmpeg.parent, then passes the originally selected executable into the direct runner and video_equal. Neither basename nor selected-file identity is checked.", + "id": "python-parent-directory-only", + "kinds": [ + "delegated" + ], + "lines": [ + 79, + 102, + 107, + 129, + 132 + ], + "path": "scripts/avi_fixture_check.py", + "pattern": "(?s)run", + "verdict": "confirmed-bypass" + }, + { + "evidence": "main() at lines 25-31 verifies a directory and parent equality, not the requested files. Lines 42-65 forward those unchecked selections to the unchanged evaluator.", + "id": "python-parent-directory-forwarding", + "kinds": [ + "delegated" + ], + "lines": [ + 65 + ], + "path": "scripts/avi_v2_check.py", + "pattern": "(?s)v2\\.evaluate", + "verdict": "confirmed-bypass" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "python-owner-return", + "kinds": [ + "command" + ], + "lines": [ + 336 + ], + "path": "scripts/bench_guard.py", + "pattern": "(?s)pin", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "python-owner-return", + "kinds": [ + "command" + ], + "lines": [ + 399, + 428 + ], + "path": "scripts/bench_guard.py", + "pattern": "(?s)str\\(test_oracle\\.require\\(\\)\\.ffmpeg\\)", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The standalone entry point executes the recorded PATH or environment selection without qualifying that executable.", + "id": "shell-unqualified-array", + "kinds": [ + "shell" + ], + "lines": [ + 42, + 83, + 143, + 144, + 166, + 167, + 169 + ], + "path": "scripts/gen-fixtures-mkv.sh", + "pattern": "(?s)\"\\$\\{FF\\[@\\]\\}\"(?:\\s.*)?", + "verdict": "confirmed-bypass" + }, + { + "evidence": "The standalone entry point executes the recorded PATH or environment selection without qualifying that executable.", + "id": "shell-unqualified-command-word", + "kinds": [ + "shell" + ], + "lines": [ + 26 + ], + "path": "scripts/gen-fixtures-mkv.sh", + "pattern": "(?s)ffmpeg(?:\\s.*)?", + "verdict": "confirmed-bypass" + }, + { + "evidence": "The standalone entry point executes the recorded PATH or environment selection without qualifying that executable.", + "id": "shell-unqualified-array", + "kinds": [ + "shell" + ], + "lines": [ + 41 + ], + "path": "scripts/gen-fixtures-ts.sh", + "pattern": "(?s)\"\\$\\{FF\\[@\\]\\}\"(?:\\s.*)?", + "verdict": "confirmed-bypass" + }, + { + "evidence": "The standalone entry point executes the recorded PATH or environment selection without qualifying that executable.", + "id": "shell-unqualified-array", + "kinds": [ + "shell" + ], + "lines": [ + 50, + 60, + 68, + 69, + 70, + 73, + 74, + 289, + 290, + 293, + 296, + 619, + 670, + 671 + ], + "path": "scripts/gen-fixtures.sh", + "pattern": "(?s)\"\\$\\{FF\\[@\\]\\}\"(?:\\s.*)?", + "verdict": "confirmed-bypass" + }, + { + "evidence": "The standalone entry point executes the recorded PATH or environment selection without qualifying that executable.", + "id": "shell-unqualified-command-word", + "kinds": [ + "shell" + ], + "lines": [ + 27 + ], + "path": "scripts/gen-fixtures.sh", + "pattern": "(?s)ffmpeg(?:\\s.*)?", + "verdict": "confirmed-bypass" + }, + { + "evidence": "The standalone entry point executes the recorded PATH or environment selection without qualifying that executable.", + "id": "shell-environment-default", + "kinds": [ + "shell" + ], + "lines": [ + 80 + ], + "path": "scripts/oracle-ffprobe.sh", + "pattern": "(?s)\"\\$FFMPEG\"(?:\\s.*)?", + "verdict": "confirmed-bypass" + }, + { + "evidence": "The standalone entry point executes the recorded PATH or environment selection without qualifying that executable.", + "id": "shell-environment-default", + "kinds": [ + "shell" + ], + "lines": [ + 36, + 43, + 51 + ], + "path": "scripts/oracle-ffprobe.sh", + "pattern": "(?s)\"\\$FFPROBE\"(?:\\s.*)?", + "verdict": "confirmed-bypass" + }, + { + "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", + "id": "python-owner-return", + "kinds": [ + "command" + ], + "lines": [ + 199 + ], + "path": "scripts/stsd_craft.py", + "pattern": "(?s)ffmpeg", + "verdict": "qualified-via-owner" + }, + { + "evidence": "The select branch returns at lines 441-444 before require() at 452. select() forwards the unqualified selectors through child_env and make_prober at 84-86.", + "id": "python-prequalification-dispatch", + "kinds": [ + "delegated" + ], + "lines": [ + 444 + ], + "path": "scripts/transcode_speed.py", + "pattern": "(?s)select", + "verdict": "confirmed-bypass" + } + ], + "schema": 1, + "source_snapshot_sha256": "ad321073828929b008210135d37712f959a1ed985c450cf5bf0136dcc02e10db", + "sources": { + "crates/coreav-audio/tests/flac_encode.rs": "6b63b16444965850c74da0651859128602a9093fe487a15865f8a82093bf6880", + "crates/coreav-backend-dav1d/tests/decode.rs": "9094fa0b3a4957d348e9b92420c658fda930329cac3b9c2da17e5c3248e0e791", + "crates/coreav-backend-ffmpeg/tests/decode.rs": "3c7a77d92030a5f888aefa172809b0cb39871232a6b5bfafe3368baaf80c9854", + "crates/coreav-backend-h264/tests/decode.rs": "50e43655c3d95a5d20e5dd87c19015da109739c849e7ee78a54ee3d5a78fe806", + "crates/coreav-backend-h264/tests/memory.rs": "2c57b9ee0d6da9feaa15f165ee9e9680b84ecd8c1dad20df31e061f63bd0d3db", + "crates/coreav-backend-h264/tests/one_idr.rs": "b7fc2c4c44d990aac2022a62f2ab35df23b3010e9baf4595509b51742052136d", + "crates/coreav-backend-libvpx/tests/decode.rs": "408ab605d61c7883127c2373415288226814177c4e1b513044f9ad902c258515", + "crates/coreav-cli/tests/avi.rs": "5ea0bdc1146f1695f555d7666315e35642305c5ce287cd8265245be2b8b5c3b4", + "crates/coreav-cli/tests/check.rs": "d9b98d866436bf4cde837943a2aac7bd574c808657510997d0c721e4fb70f7e7", + "crates/coreav-cli/tests/decode_audio.rs": "117c3bc34dc63615335f9e78542f7b49e73661f2c43c8bc974601dcdd728b387", + "crates/coreav-cli/tests/decoder_host.rs": "e71be94fcc770e16d7f36e2b985eb6fec2fdb5e314c21739789c14dd8d014dc0", + "crates/coreav-cli/tests/docs_site.rs": "bd3979d63545179b8066a2132a1d31e25b72af558a3c60cb34d144c280471db1", + "crates/coreav-cli/tests/exec.rs": "8105821de01ac99e0096a40b0266de02411dd21f593d7b029d13d7c344209abe", + "crates/coreav-cli/tests/fallback_windows.rs": "5c97b42c1b3d351c564ccf266d51f3ab36a604080f7c78d18ed0d21ee22ffb92", + "crates/coreav-cli/tests/ffmpeg_flac.rs": "bdd12fd98b9dda64c059ff142b8c73e550b5341438542f6db926985319237613", + "crates/coreav-cli/tests/ffmpeg_frames.rs": "c14f50e8876d869a711b6b232c61f07412979dcb65ce3f458dfb7a3ec26aecab", + "crates/coreav-cli/tests/ffmpeg_matroska.rs": "9cba9336b1f21b9199ac4c2167f7f4e8ee2172f7e7acf302445a6283e7b2cb4b", + "crates/coreav-cli/tests/ffmpeg_mkv_aac_copy.rs": "2d72e6aed47edfdf3dc1a53a79b6489a7ecaee75e72e96d7cf5a33b78eceff60", + "crates/coreav-cli/tests/ffmpeg_pcm.rs": "c700046642796bb6ab27f09b7d7991059088f175cbae71c4541113a6ed25dd22", + "crates/coreav-cli/tests/ffmpeg_raw.rs": "e695c08e045f8dd07d2296fd1e4054c1e95a49493922973768b14c0785d7ad0f", + "crates/coreav-cli/tests/ffmpeg_wav.rs": "5b7ee1855630fec70c1190411a64f535980afc56e7bd0a123891f27080cde383", + "crates/coreav-cli/tests/ffprobe_ancillary_bit_rate.rs": "948d83c773436cce55aa0328544f61405b84b243efd926762e7cd23ca0772da3", + "crates/coreav-cli/tests/ffprobe_aspect_ratio.rs": "b8a9a4dba8d8ffa75457f929bd87805261663ee93777c5eadcf76be921bc636c", + "crates/coreav-cli/tests/ffprobe_clean_aperture.rs": "a0d0e45785bfcbf64e1de08823df4ba253eccc3859b60a876b2c67b5f22fe056", + "crates/coreav-cli/tests/ffprobe_format_span.rs": "8bbb34aa88990971917e869a8f5bf8dd4a43ebd483247bd22c93a145992d50cb", + "crates/coreav-cli/tests/ffprobe_fragment_bit_rate.rs": "73cd5dbf534ec2fa3a4b94f42ee303bf1a8cb260b805ace842928bdcd87a74ff", + "crates/coreav-cli/tests/ffprobe_pixel_range.rs": "57b580c255692bfdf2b2b5ebb7d40b3d4ca40cf99627903294325a636a6e3d3c", + "crates/coreav-cli/tests/ffprobe_stream_groups.rs": "1b8ea3c79cba429bd34b8a19c9b483a94726e0964af4ff88f1a455ca9499443e", + "crates/coreav-cli/tests/ffprobe_track_names.rs": "dbefa40cfdadb2a5c9933ce218e99f50e5d87db073def67a3d6076a7da6c0b34", + "crates/coreav-cli/tests/ffprobe_ts_private.rs": "dd405f3bc581cad8f67003f58ff0950e9b9ef841332a3451b614b8d6d20c4754", + "crates/coreav-cli/tests/ffprobe_ts_tail.rs": "46005c1efd657ea93d8515a475a907cfd2783e6b74f62f9ef564f8a7ced2b4f3", + "crates/coreav-cli/tests/frame_handoff.rs": "b78aa02ac5a202b16aea232c967b03a4564253c095f7f628e8ae1c9f71382dd2", + "crates/coreav-cli/tests/legacy_encoders.rs": "0b2f40a8462ec08b23538ca97d509f44af2c15c9958f36f90992f4d40311ef9f", + "crates/coreav-cli/tests/probe_tuning.rs": "dcf0bf0331730dea3114297310f82e59c00d5a37596ea9a0ec887fef51888f78", + "crates/coreav-cli/tests/strict_safe.rs": "a75f3d5c6a22eee49b44cefd43931f1199515218603f7126d62198a232db7699", + "crates/coreav-cli/tests/strict_safe_limit.rs": "0b11d217aea687a5d7e81a9d85cb8703fd0d8092c6d660c29ece8559e5cfc895", + "crates/coreav-cli/tests/thumbnail.rs": "3740eda708acee2bdb0f3ea4a0ac5819c80927c4bc361e3210d5acbe7d85279e", + "crates/coreav-cli/tests/transcode_selection.rs": "ee9deecabf5a4a2715ea8ece168ff89af163ecb3a31fc2598bc7a6ae1de294c6", + "crates/coreav-isobmff-write/tests/replace.rs": "c704b6600421661b444eed3c4ad88efcbda2d41636d10fedcac15b0be5268991", + "crates/coreav-worker/tests/ffmpeg.rs": "48ca0fb6ab070e47c3a8ea3f4d9f626b2c9696ef031b5225cef87010ba250d92", + "packages/cli/test/release-clips.sh": "870efad502950d8dbb9a3f88c8672a2c10d610dcada7fb8dfe5dbc12e29c37c1", + "scripts/avi_fixture_check.py": "0d87de769e2678e9f1299a1b8667a785ed0a9943443c2f5ee4f9a4fec8fcf97e", + "scripts/avi_v2_check.py": "731fb170c38f8694cbbefc9914f9f40836b3558651a45dda85bcc8ef9f2f74e1", + "scripts/bench_guard.py": "9906ca0e4d376bc5fde262d17297d699b5802212a293ff6676d588bdd4e03250", + "scripts/gen-fixtures-mkv.sh": "2edfdf356a214c97fc24c9e445892beaf9bd9e339d9fd519f100a800b1f05010", + "scripts/gen-fixtures-ts.sh": "d7f797724e4521b1a4840ce41953cfb5f1fd8e4b79a0266feacbf325bf4d5551", + "scripts/gen-fixtures.sh": "baa6378c62602ce2332f2d1138766965eaa979737864a29737cd4d92b16ab6cb", + "scripts/oracle-ffprobe.sh": "8ffb1e92747b2f7e5d668e9f70074b90ca99347fbfdbb2723aead2a536970ac5", + "scripts/stsd_craft.py": "4d683dd4fd8048ac1140d13cfafdfb18f57ebf314fe1a10b8a81770e8184402b", + "scripts/transcode_speed.py": "3084a9ba86a8834ef693c38843384b4b3e32b32fb017c709d3aed07990c425bc" + } +} diff --git a/scripts/oracle_invocation_classify.py b/scripts/oracle_invocation_classify.py new file mode 100644 index 000000000..6136f11ee --- /dev/null +++ b/scripts/oracle_invocation_classify.py @@ -0,0 +1,156 @@ +"""Classify source-bound invocation patterns; unmatched evidence remains failed.""" +import argparse +import ast +from collections import Counter, defaultdict +import hashlib +import json +from pathlib import Path +import re +import subprocess +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import oracle_invocation_check as discovery + +RECORD = 'docs/design/oracle-invocation-dispositions.json' +SOURCE_SUFFIXES = {'.py', '.rs', '.sh', '.bash', '.js', '.mjs', '.cjs', '.ts', '.tsx', + '.yml', '.yaml', '.toml', '.c', '.h', '.cpp', '.cc', '.mm', '.swift'} +DEPENDENCIES = ('scripts/test_oracle.py', 'test-support/oracle.rs', + 'scripts/oracle_pin.py', 'scripts/oracle_pin_macos.py', + 'scripts/oracle-ffmpeg.env', 'scripts/oracle-ffmpeg-macos.env', + discovery.HISTORICAL_RECORD) +VERDICTS = ('confirmed-bypass', 'unknown', 'qualified-via-owner', 'excluded') + + +def digest(path): + if path.is_symlink(): + raise ValueError('invocation proof source must not be a symbolic link: ' + str(path)) + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def source_snapshot(root): + if (root / '.git').exists(): + paths = subprocess.check_output(['git', '-C', str(root), 'ls-files', '-z', '--cached', + '--others', '--exclude-standard'], text=True).split('\0') + else: + paths = [path.relative_to(root).as_posix() for path in root.rglob('*') if path.is_file()] + selected = {path for path in paths if path and not path.startswith(discovery.HISTORICAL_BOUNDARY + '/') + and (Path(path).suffix in SOURCE_SUFFIXES or path in DEPENDENCIES or Path(path).name == 'package.json')} + hashes = {path: digest(root / path) for path in sorted(selected)} + return hashlib.sha256(json.dumps(hashes, sort_keys=True, separators=(',', ':')).encode()).hexdigest() + + +def validate_record(record): + if record.get('schema') != 1 or not re.fullmatch('[0-9a-f]{64}', record.get('source_snapshot_sha256', '')): + raise ValueError('restore the invocation disposition schema and source snapshot') + for field in ('sources', 'dependencies', 'frozen'): + values = record.get(field) + if not isinstance(values, dict): + raise ValueError('restore invocation ' + field) + for path, value in values.items(): + if Path(path).is_absolute() or '..' in Path(path).parts or not re.fullmatch('[0-9a-f]{64}', value): + raise ValueError('invalid invocation proof path or digest: ' + path) + for rule in record.get('rules', []): + if rule.get('verdict') not in ('confirmed-bypass', 'qualified-via-owner', 'excluded'): + raise ValueError('restore a closed invocation verdict') + if rule.get('path') not in record['sources'] or not rule.get('evidence'): + raise ValueError('bind every invocation rule to source bytes and an explanation') + if not rule.get('lines') or not all(isinstance(line, int) and line > 0 for line in rule['lines']): + raise ValueError('bind every invocation rule to concrete source locations') + if not rule.get('kinds') or not isinstance(rule.get('pattern'), str): + raise ValueError('bind every invocation rule to its call pattern') + re.compile(rule['pattern']) + + +def classify(root, sites, record=None): + if record is None: + path = root / RECORD + record = json.loads(path.read_text()) if path.is_file() else None + if record is not None: + validate_record(record) + source_hashes = {} + def current(path): + if path not in source_hashes: + source_hashes[path] = digest(root / path) + return source_hashes[path] + trusted = bool(record) and source_snapshot(root) == record['source_snapshot_sha256'] + if trusted: + trusted = all(current(path) == value for path, value in record['dependencies'].items()) + rules = defaultdict(list) + if record: + for rule in record['rules']: + rules[rule['path']].append(rule) + docstrings = {} + groups = {} + for row, site in enumerate(sites): + path, line = site['path'], site['line'] + verdict, pattern, evidence = 'unknown', 'unmatched-call-pattern', 'no source-bound disposition' + folded_line = line + if site['status'] == 'frozen' and record and record['frozen'].get(path) == current(path): + verdict, pattern, evidence = 'excluded', 'registered-source', 'unchanged registered source bytes' + elif site['status'] in ('bootstrap', 'runtime-boundary') and trusted: + verdict, pattern, evidence = 'excluded', site['status'], 'explicit non-reference execution boundary' + elif site['kind'] == 'embedded-source' and path.endswith('.py'): + if path not in docstrings: + tree = ast.parse((root / path).read_text()) + docstrings[path] = {node.body[0].value.lineno for node in ast.walk(tree) + if isinstance(node, (ast.Module, ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)) + and node.body and isinstance(node.body[0], ast.Expr) + and isinstance(node.body[0].value, ast.Constant) + and isinstance(node.body[0].value.value, str)} + if line in docstrings[path]: + verdict, pattern, evidence = 'excluded', 'python-docstring', 'AST docstring data, not a process launch' + if verdict == 'unknown' and trusted and record['sources'].get(path) == current(path): + matches = [rule for rule in rules[path] if line in rule['lines'] and site['kind'] in rule['kinds'] + and re.fullmatch(rule['pattern'], site['program'])] + if matches and len({rule['verdict'] for rule in matches}) == 1: + verdict = matches[0]['verdict'] + pattern = matches[0]['id'] + evidence = matches[0]['evidence'] + folded_line = matches[0].get('fold_to', {}).get(str(line), line) + key = (path, folded_line) + if key not in groups: + groups[key] = dict(path=path, line=folded_line, verdict=verdict, rule=pattern, + evidence=evidence, rows=[], patterns=set()) + group = groups[key] + group['rows'].append(row) + group['patterns'].add(pattern) + if VERDICTS.index(verdict) < VERDICTS.index(group['verdict']): + group.update(verdict=verdict, rule=pattern, evidence=evidence) + locations = [] + for value in groups.values(): + value['patterns'] = sorted(value['patterns']) + locations.append(value) + counts = {} + for verdict in VERDICTS: + selected = [item for item in locations if item['verdict'] == verdict] + counts[verdict] = dict(locations=len(selected), files=len({item['path'] for item in selected}), + rows=sum(len(item['rows']) for item in selected)) + patterns = Counter(item['rule'] for item in locations if item['verdict'] == 'confirmed-bypass') + row_ids = sorted(row for item in locations for row in item['rows']) + return dict(schema=1, source_snapshot_valid=trusted, counts=counts, + top_patterns=[dict(rule=rule, locations=count, + files=len({item['path'] for item in locations if item['rule'] == rule})) + for rule, count in patterns.most_common()], + locations=locations, + reconciliation=dict(input_rows=len(sites), mapped_rows=len(row_ids), + exact=row_ids == list(range(len(sites)))), + proof='source-bound patterns only; unknown and bypass fail; the bypass count is a lower bound while unknown remains') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--root', type=Path, default=discovery.ROOT) + parser.add_argument('--json', type=Path, required=True) + args = parser.parse_args() + root = args.root.resolve() + report = classify(root, discovery.inventory(root)) + args.json.write_text(json.dumps(report, indent=2) + '\n') + print(json.dumps({key: report[key] for key in ('source_snapshot_valid', 'counts', 'top_patterns', 'reconciliation')}, sort_keys=True)) + if not report['reconciliation']['exact']: + return 2 + return int(bool(report['counts']['confirmed-bypass']['rows'] or report['counts']['unknown']['rows'])) + + +if __name__ == '__main__': + raise SystemExit(main()) diff --git a/scripts/tests/test_oracle_invocation_classify.py b/scripts/tests/test_oracle_invocation_classify.py new file mode 100644 index 000000000..0db6b0d62 --- /dev/null +++ b/scripts/tests/test_oracle_invocation_classify.py @@ -0,0 +1,175 @@ +from pathlib import Path +import re +import sys +import tempfile +import unittest + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +import oracle_invocation_check as discovery +import oracle_invocation_classify as classifier + + +class Classification(unittest.TestCase): + def setUp(self): + self.directory = tempfile.TemporaryDirectory() + self.root = Path(self.directory.name) + (self.root / 'scripts').mkdir() + self.path = 'scripts/consumer.py' + self.file = self.root / self.path + + def tearDown(self): + self.directory.cleanup() + + def sites(self, source): + self.file.write_text(source) + sites = discovery.PythonSites(source, self.path).collect() + for site in sites: + site['status'] = 'unclassified' + return sites + + def record(self, sites, verdict, fold=None): + return dict(schema=1, source_snapshot_sha256=classifier.source_snapshot(self.root), + sources={self.path: classifier.digest(self.file)}, dependencies={}, frozen={}, + rules=[dict(id='fixture-call-pattern', verdict=verdict, path=self.path, + lines=[site['line']], kinds=[site['kind']], + pattern=re.escape(site['program']), fold_to=fold or {}, + evidence='generated fixture with a concrete call-pattern proof') + for site in sites]) + + def test_import_alone_does_not_qualify_a_literal(self): + sites = self.sites('import test_oracle, subprocess\nsubprocess.run(["ffmpeg", "-version"])\n') + report = classifier.classify(self.root, sites, self.record(sites, 'confirmed-bypass')) + self.assertEqual(report['counts']['confirmed-bypass']['locations'], 1) + self.assertEqual(report['counts']['qualified-via-owner']['rows'], 0) + + def test_owner_return_value_qualifies(self): + sites = self.sites('import test_oracle, subprocess\ndef main():\n' + ' pair = test_oracle.require()\n' + ' subprocess.run([str(pair.ffmpeg), "-version"])\n') + report = classifier.classify(self.root, sites, self.record(sites, 'qualified-via-owner')) + self.assertEqual(report['counts']['qualified-via-owner']['locations'], 1) + + def test_a_same_named_module_is_not_the_owner(self): + sites = self.sites('import test_oracle, subprocess\npair = test_oracle.require()\nsubprocess.run([pair.ffmpeg])\n') + record = self.record(sites, 'qualified-via-owner') + (self.root / 'scripts/test_oracle.py').write_text('def require(): return None\n') + report = classifier.classify(self.root, sites, record) + self.assertFalse(report['source_snapshot_valid']) + self.assertEqual(report['counts']['qualified-via-owner']['rows'], 0) + + def test_a_parameter_cannot_shadow_the_owner(self): + sites = self.sites('import test_oracle, subprocess\ndef f():\n' + ' pair = test_oracle.require()\n subprocess.run([pair.ffmpeg])\n') + record = self.record(sites, 'qualified-via-owner') + changed = self.sites(self.file.read_text().replace('def f():', 'def f(test_oracle):')) + self.assertEqual(classifier.classify(self.root, changed, record)['counts']['qualified-via-owner']['rows'], 0) + + def test_branch_only_qualification_remains_unknown(self): + sites = self.sites('import test_oracle, subprocess\npair = test_oracle.require()\nsubprocess.run([pair.ffmpeg])\n') + record = self.record(sites, 'qualified-via-owner') + changed = self.sites('import test_oracle, subprocess\nif ready:\n pair = test_oracle.require()\nsubprocess.run([pair.ffmpeg])\n') + report = classifier.classify(self.root, changed, record) + self.assertEqual(report['counts']['qualified-via-owner']['rows'], 0) + self.assertEqual(report['counts']['confirmed-bypass']['rows'], 0) + self.assertGreater(report['counts']['unknown']['rows'], 0) + + def test_ignored_directory_guard_is_not_an_owner_return(self): + sites = self.sites('import test_oracle, subprocess\ntest_oracle.verify_bin(program.parent)\nsubprocess.run([program])\n') + report = classifier.classify(self.root, sites) + self.assertEqual(report['counts']['qualified-via-owner']['rows'], 0) + self.assertGreater(report['counts']['unknown']['rows'], 0) + + def test_docstrings_are_not_executed_programs(self): + sites = self.sites('"""Example ffmpeg\nnot an executed program\n"""\n') + self.assertEqual(classifier.classify(self.root, sites)['counts']['excluded']['locations'], 1) + + def test_an_opaque_executable_stays_failed(self): + sites = self.sites('import subprocess\nsubprocess.run(command)\n') + self.assertEqual(classifier.classify(self.root, sites)['counts']['unknown']['locations'], 1) + + def test_argv_alias_rows_fold_into_one_construction(self): + sites = self.sites('import subprocess\ncommand = ["ffmpeg", "-version"]\nsubprocess.run(command)\n') + report = classifier.classify(self.root, sites, self.record(sites, 'confirmed-bypass', {'3': 2})) + self.assertEqual(report['counts']['confirmed-bypass']['locations'], 1) + self.assertTrue(report['reconciliation']['exact']) + + def test_distinct_argv_constructions_are_not_one_origin(self): + sites = self.sites('import test_oracle, subprocess\npair = test_oracle.require()\n' + 'subprocess.run([pair.ffmpeg, "-version"])\nsubprocess.run([pair.ffmpeg, "-encoders"])\n') + report = classifier.classify(self.root, sites, self.record(sites, 'qualified-via-owner')) + self.assertEqual(report['counts']['qualified-via-owner']['locations'], 2) + + def test_execution_override_is_not_qualified_by_argv(self): + sites = self.sites('import test_oracle, subprocess\npair = test_oracle.require()\nsubprocess.run([pair.ffmpeg])\n') + record = self.record(sites, 'qualified-via-owner') + changed = self.sites('import test_oracle, subprocess\npair = test_oracle.require()\n' + 'subprocess.run(\n [pair.ffmpeg],\n executable=override)\n') + self.assertEqual(classifier.classify(self.root, changed, record)['counts']['qualified-via-owner']['rows'], 0) + + def test_qualified_argv_mutation_invalidates_the_proof(self): + sites = self.sites('import test_oracle, subprocess\npair = test_oracle.require()\n' + 'command = [pair.ffmpeg]\nsubprocess.run(command)\n') + record = self.record(sites, 'qualified-via-owner') + changed = self.sites('import test_oracle, subprocess\npair = test_oracle.require()\n' + 'command = [pair.ffmpeg]\ncommand[0] = override\nsubprocess.run(command)\n') + process = [item for item in classifier.classify(self.root, changed, record)['locations'] if item['line'] == 5] + self.assertTrue(process) + self.assertTrue(all(item['verdict'] == 'unknown' for item in process)) + + def test_rust_native_identity_is_not_a_substring_hint(self): + self.path = 'scripts/consumer.rs' + self.file = self.root / self.path + self.file.write_text('fn f() {\nCommand::new(env!("CARGO_BIN_EXE_coreav"));\nCommand::new(other);\n}\n') + sites = [dict(path=self.path, line=2, kind='Rust', program='env!("CARGO_BIN_EXE_coreav")', status='unclassified'), + dict(path=self.path, line=3, kind='Rust', program='PathBuf::from(env!("CARGO_BIN_EXE_coreav")).with_file_name("ffmpeg")', status='unclassified')] + report = classifier.classify(self.root, sites, self.record(sites[:1], 'excluded')) + self.assertEqual(report['counts']['excluded']['locations'], 1) + self.assertEqual(report['counts']['unknown']['locations'], 1) + + def test_rust_environment_binding_has_a_positive_origin(self): + self.path = 'scripts/consumer.rs' + self.file = self.root / self.path + self.file.write_text('fn f() {\nlet ffmpeg = std::env::var_os("COREAV_FFMPEG");\nCommand::new(&ffmpeg);\n}\n') + sites = [dict(path=self.path, line=3, kind='Rust', program='&ffmpeg', status='unclassified')] + report = classifier.classify(self.root, sites, self.record(sites, 'confirmed-bypass')) + self.assertEqual(report['counts']['confirmed-bypass']['locations'], 1) + + def test_shell_arrays_need_a_concrete_program_assignment(self): + self.path = 'scripts/fixture.sh' + self.file = self.root / self.path + self.file.write_text('FF=(ffmpeg -v error)\n"$' + '{FF[@]}" -version\n') + sites = [dict(path=self.path, line=2, kind='shell', program='"$' + '{FF[@]}" -version', status='unclassified')] + record = self.record(sites, 'confirmed-bypass') + self.assertEqual(classifier.classify(self.root, sites, record)['counts']['confirmed-bypass']['locations'], 1) + self.file.write_text('"$' + '{FF[@]}" -version\n') + self.assertEqual(classifier.classify(self.root, sites, record)['counts']['confirmed-bypass']['locations'], 0) + + def test_dependency_edit_invalidates_unchanged_callers(self): + sites = self.sites('import subprocess\nsubprocess.run(command)\n') + dependency = self.root / 'scripts/helper.py' + dependency.write_text('def command(): pass\n') + record = self.record(sites, 'qualified-via-owner') + record['dependencies']['scripts/helper.py'] = classifier.digest(dependency) + dependency.write_text('def command(): return "ffmpeg"\n') + report = classifier.classify(self.root, sites, record) + self.assertFalse(report['source_snapshot_valid']) + self.assertEqual(report['counts']['qualified-via-owner']['rows'], 0) + + def test_new_sources_do_not_inherit_a_disposition(self): + sites = self.sites('import subprocess\nsubprocess.run(command)\n') + record = self.record(sites, 'qualified-via-owner') + (self.root / 'new.py').write_text('import subprocess\nsubprocess.run(["renamed-program"])\n') + self.assertFalse(classifier.classify(self.root, sites, record)['source_snapshot_valid']) + + def test_unknown_row_wins_over_a_qualified_row_at_the_same_location(self): + sites = self.sites('import subprocess\nsubprocess.run(command)\n') + record = self.record(sites, 'qualified-via-owner') + sites.append(dict(sites[0], program='other')) + report = classifier.classify(self.root, sites, record) + self.assertEqual(report['counts']['qualified-via-owner']['rows'], 0) + self.assertEqual(report['counts']['unknown']['rows'], 2) + self.assertTrue(report['reconciliation']['exact']) + + +if __name__ == '__main__': + unittest.main() From efa6a187bce218c2683f8684aba49a4ed30e8599 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 16:17:24 +0000 Subject: [PATCH 13/21] test(ffmpeg): bind every invocation input file Signed-off-by: gunwooterry --- docs/design/local-oracle-qualification.md | 2 +- .../oracle-invocation-dispositions.json | 2 +- scripts/oracle_invocation_classify.py | 20 ++++++++++++++----- .../tests/test_oracle_invocation_classify.py | 6 ++++++ 4 files changed, 23 insertions(+), 7 deletions(-) diff --git a/docs/design/local-oracle-qualification.md b/docs/design/local-oracle-qualification.md index 6472b6eb7..fbc96f51e 100644 --- a/docs/design/local-oracle-qualification.md +++ b/docs/design/local-oracle-qualification.md @@ -36,4 +36,4 @@ Classify each remaining discovery hit as a confirmed bypass, already routed thro Report the confirmed-bypass count before changing any consumers. If the remaining migration cannot stay coherent with the existing deployment and dispatch repairs, split only after a scope decision. Run only short local source and generated regression checks during discovery; no media corpus, performance or remote infrastructure run is required. -The classifier matches concrete call patterns against source-bound dispositions rather than inferring qualification from a general-purpose value-flow model. Each disposition identifies its source locations, executable expression, verdict and evidence; the code snapshot and qualification dependencies must still match their recorded digests. A changed helper, added source, shadowed binding or executable override therefore invalidates the prior disposition instead of inheriting it. Unmatched locations remain unknown and fail. Reports count source locations, folding overlapping constructor, completion and delegated rows at the same location; they do not count runtime calls or claim an exhaustive bypass total while unknown locations remain. +The classifier matches concrete call patterns against source-bound dispositions rather than inferring qualification from a general-purpose value-flow model. Each disposition identifies its source locations, executable expression, verdict and evidence; the repository input snapshot and qualification dependencies must still match their recorded digests. A changed helper, added file, shadowed binding or executable override therefore invalidates the prior disposition instead of inheriting it. Unmatched locations remain unknown and fail. Reports count source locations, folding overlapping constructor, completion and delegated rows at the same location; they do not count runtime calls or claim an exhaustive bypass total while unknown locations remain. Generated reports stay outside the checkout so they cannot alter the input snapshot. diff --git a/docs/design/oracle-invocation-dispositions.json b/docs/design/oracle-invocation-dispositions.json index 25e994ad9..bb6ed0ba2 100644 --- a/docs/design/oracle-invocation-dispositions.json +++ b/docs/design/oracle-invocation-dispositions.json @@ -1737,7 +1737,7 @@ } ], "schema": 1, - "source_snapshot_sha256": "ad321073828929b008210135d37712f959a1ed985c450cf5bf0136dcc02e10db", + "source_snapshot_sha256": "bb9390211d5e1f4133aa9686eaea7b15ea12f2426c59c140a913f640dc48d49f", "sources": { "crates/coreav-audio/tests/flac_encode.rs": "6b63b16444965850c74da0651859128602a9093fe487a15865f8a82093bf6880", "crates/coreav-backend-dav1d/tests/decode.rs": "9094fa0b3a4957d348e9b92420c658fda930329cac3b9c2da17e5c3248e0e791", diff --git a/scripts/oracle_invocation_classify.py b/scripts/oracle_invocation_classify.py index 6136f11ee..7eebc314f 100644 --- a/scripts/oracle_invocation_classify.py +++ b/scripts/oracle_invocation_classify.py @@ -13,8 +13,6 @@ import oracle_invocation_check as discovery RECORD = 'docs/design/oracle-invocation-dispositions.json' -SOURCE_SUFFIXES = {'.py', '.rs', '.sh', '.bash', '.js', '.mjs', '.cjs', '.ts', '.tsx', - '.yml', '.yaml', '.toml', '.c', '.h', '.cpp', '.cc', '.mm', '.swift'} DEPENDENCIES = ('scripts/test_oracle.py', 'test-support/oracle.rs', 'scripts/oracle_pin.py', 'scripts/oracle_pin_macos.py', 'scripts/oracle-ffmpeg.env', 'scripts/oracle-ffmpeg-macos.env', @@ -34,9 +32,19 @@ def source_snapshot(root): '--others', '--exclude-standard'], text=True).split('\0') else: paths = [path.relative_to(root).as_posix() for path in root.rglob('*') if path.is_file()] - selected = {path for path in paths if path and not path.startswith(discovery.HISTORICAL_BOUNDARY + '/') - and (Path(path).suffix in SOURCE_SUFFIXES or path in DEPENDENCIES or Path(path).name == 'package.json')} - hashes = {path: digest(root / path) for path in sorted(selected)} + selected = {path for path in paths if path and path != RECORD + and not path.startswith(discovery.HISTORICAL_BOUNDARY + '/')} + hashes = {} + for path in sorted(selected): + file = root / path + if file.is_symlink(): + target = file.resolve(strict=True) + if not target.is_relative_to(root) or not target.is_file(): + raise ValueError('invocation input link must name a repository file: ' + path) + value = 'link:' + str(file.readlink()) + ':' + digest(target) + hashes[path] = hashlib.sha256(value.encode()).hexdigest() + else: + hashes[path] = digest(file) return hashlib.sha256(json.dumps(hashes, sort_keys=True, separators=(',', ':')).encode()).hexdigest() @@ -144,6 +152,8 @@ def main(): parser.add_argument('--json', type=Path, required=True) args = parser.parse_args() root = args.root.resolve() + if args.json.resolve().is_relative_to(root): + parser.error('write the report outside the checkout so it cannot change the input snapshot') report = classify(root, discovery.inventory(root)) args.json.write_text(json.dumps(report, indent=2) + '\n') print(json.dumps({key: report[key] for key in ('source_snapshot_valid', 'counts', 'top_patterns', 'reconciliation')}, sort_keys=True)) diff --git a/scripts/tests/test_oracle_invocation_classify.py b/scripts/tests/test_oracle_invocation_classify.py index 0db6b0d62..6824638f6 100644 --- a/scripts/tests/test_oracle_invocation_classify.py +++ b/scripts/tests/test_oracle_invocation_classify.py @@ -161,6 +161,12 @@ def test_new_sources_do_not_inherit_a_disposition(self): (self.root / 'new.py').write_text('import subprocess\nsubprocess.run(["renamed-program"])\n') self.assertFalse(classifier.classify(self.root, sites, record)['source_snapshot_valid']) + def test_a_renamed_executable_cannot_escape_by_losing_its_extension(self): + sites = self.sites('import subprocess\nsubprocess.run(command)\n') + record = self.record(sites, 'qualified-via-owner') + (self.root / 'renamed-reference').write_text('#!/bin/sh\nexec ffmpeg "$@"\n') + self.assertFalse(classifier.classify(self.root, sites, record)['source_snapshot_valid']) + def test_unknown_row_wins_over_a_qualified_row_at_the_same_location(self): sites = self.sites('import subprocess\nsubprocess.run(command)\n') record = self.record(sites, 'qualified-via-owner') From 0b8af37046c6fe7b29041b67a0864627c10de929 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 16:19:19 +0000 Subject: [PATCH 14/21] test(ffmpeg): enforce source-bound classification rules Signed-off-by: gunwooterry --- docs/agents/ffmpeg-cli.md | 1 + docs/design/oracle-invocation-dispositions.json | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/agents/ffmpeg-cli.md b/docs/agents/ffmpeg-cli.md index ab3c376ff..dfac5c9cf 100644 --- a/docs/agents/ffmpeg-cli.md +++ b/docs/agents/ffmpeg-cli.md @@ -49,6 +49,7 @@ CLI and ffprobe behavior, the FFmpeg pin, and fallback names. | Image and raw-video dispatch preserves metadata and encoder-option refusals before selecting a frame job | `ffmpeg::plan` owns both guards before `Job::Frames`; `frame_plans_validate_common_options` covers every encoder setting and all metadata modes, and the strict-safe and fallback metadata regressions require refusal before any output is created (`ci.yml`) | | Windows fallback waits for its program, preserves its full exit code and skips CoreAV copies and hard links on PATH | `fallback_cmd::run` owns inherited and replayed process completion; replay carries its spool owner until the child finishes, then drops handles and the spool before the full-code exit. `fallback_windows.rs` and `replayed_fallback_keeps_full_windows_exit_codes_and_cleans_its_spool` exercise native stand-ins, codes above 255, original stdin and cleanup in `ci.yml`'s existing `check-windows` tests. Stable `ExitCode` cannot carry a full Windows code | | Current comparisons use the shared FFmpeg pin; the historical training extractor stays isolated | `test_oracle.require` owns non-frozen selection and cached success/failure through the unchanged platform verifier; the Rust adapter shares one `OnceLock` per test process. Owner/cache contracts, actual wrong-pin whole-suite failures and pinned passes cover missing, partial, renamed and unverified selections. Frozen consumers retain workflow verification; their immutable closure prevents deleting the old verifier API. `oracle_pin.py --check` keeps historical-extractor references isolated. Types cannot establish an external executable's version | +| Invocation classifications do not treat owner imports, executable names or unbound value-flow hints as qualification proof | `oracle_invocation_classify.py` owns source-bound call-pattern dispositions and fails on unmatched locations or changed inputs. Shadowing, executable overrides, changed dependencies and extensionless additions invalidate the prior snapshot in `test_oracle_invocation_classify.py`. One disposition owner avoids divergent verdicts; cross-language types cannot establish dynamic executable provenance | | Relocated oracle consumers retain the shared owner, its unchanged pins and their local imports | `test_oracle.bundle` copies the transitive Python closure into its normal `scripts` layout with the common support files. The relocated-bundle regression qualifies a fresh process against the copied pin and checks imported helper bytes; remote runner tests cover the complete pair and unchanged launch contracts. A path alone cannot establish a copied file's identity | | Standalone audio parity executes the native command with global strict-safe mode, rather than allowing fallback to satisfy equality | `standalone_audio_probe_check.py` owns the command and strict-safe environment; its command-capture regression requires `--strict-safe` before `ffprobe`, and real generated default/JSON comparisons run in `ci.yml`. A mocked subprocess alone cannot prove the command parses | | The fallback name lists match the pinned FFmpeg listings and CoreAV's printed keys, not boolean match-return values | `scripts/fallback_names.py --check DIR` in `ci.yml`'s `check` job fails on drift and names the regeneration command; `test_boolean_match_values_are_not_printed_keys` rejects stereo and unit values without dropping boolean field names | diff --git a/docs/design/oracle-invocation-dispositions.json b/docs/design/oracle-invocation-dispositions.json index bb6ed0ba2..1a392e399 100644 --- a/docs/design/oracle-invocation-dispositions.json +++ b/docs/design/oracle-invocation-dispositions.json @@ -1737,7 +1737,7 @@ } ], "schema": 1, - "source_snapshot_sha256": "bb9390211d5e1f4133aa9686eaea7b15ea12f2426c59c140a913f640dc48d49f", + "source_snapshot_sha256": "23237aed907a55f36637ccea64304a4c04eb5c2e0c439f7c0b511e337584d3cb", "sources": { "crates/coreav-audio/tests/flac_encode.rs": "6b63b16444965850c74da0651859128602a9093fe487a15865f8a82093bf6880", "crates/coreav-backend-dav1d/tests/decode.rs": "9094fa0b3a4957d348e9b92420c658fda930329cac3b9c2da17e5c3248e0e791", From 86b40dea11c72446d28f45c1fb95e1b11681ec12 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 17:21:23 +0000 Subject: [PATCH 15/21] fix(ffmpeg): preserve qualified oracle handoffs Signed-off-by: gunwooterry --- docs/agents/ffmpeg-cli.md | 4 +- docs/design/local-oracle-qualification.md | 4 +- .../oracle-invocation-dispositions.json | 128 +------------- scripts/audio_copy_check.py | 4 +- scripts/avi_fixture_check.py | 6 +- scripts/avi_v2_check.py | 7 +- scripts/exact_skip_check.py | 4 +- scripts/h264_parity_gcp.py | 5 +- scripts/oracle.py | 4 +- scripts/policy_check.py | 3 +- scripts/seek_check.py | 5 +- scripts/test_oracle.py | 8 +- scripts/tests/test_gcp_vm_job.py | 2 + scripts/tests/test_test_oracle.py | 166 ++++++++++++++++++ scripts/tests/test_ts_speed_pair.py | 117 ++++++++++++ scripts/text_check.py | 4 +- scripts/thumbnail_oracle.py | 4 +- scripts/transcode_speed.py | 2 + scripts/ts_speed.py | 3 +- scripts/ts_speed_gcp.py | 11 +- test-support/oracle-dependent.json | 55 ++++-- test-support/oracle.rs | 109 +++++++++++- tools/compat-corpus/frames.py | 3 +- tools/compat-corpus/tests/test_current_ci.py | 8 +- .../tests/test_decode_breadth.py | 1 + .../tests/test_decode_breadth_fixtures.py | 7 +- .../tests/test_encode_breadth.py | 1 + tools/compat-corpus/tests/test_r4_scan.py | 1 + tools/decode-oracle/src/main.rs | 7 +- tools/mediainfo-oracle/corpus.py | 12 +- tools/mediarecorder/generate.py | 4 +- tools/mkv-adapter/bench.py | 6 +- tools/mkv-adapter/corpus.py | 11 +- tools/mkv-adapter/remux_corpus.py | 23 ++- tools/ts-speed/build-lav.sh | 6 +- 35 files changed, 540 insertions(+), 205 deletions(-) create mode 100644 scripts/tests/test_ts_speed_pair.py diff --git a/docs/agents/ffmpeg-cli.md b/docs/agents/ffmpeg-cli.md index 098b35433..d23264a53 100644 --- a/docs/agents/ffmpeg-cli.md +++ b/docs/agents/ffmpeg-cli.md @@ -50,9 +50,11 @@ CLI and ffprobe behavior, the FFmpeg pin, and fallback names. | Audio-only encoding refuses source offsets, tags and dispositions it cannot preserve, and never treats a concat list as a media file | The shared concat-encoding guard and `audio::plan` own these refusals; `ffmpeg_audio_only_refuses_unpreserved_source_properties` covers positive input origins, delayed audio, custom handlers, forced dispositions and concat in the whole transcode fixture target (`ci.yml`). Types cannot prove source metadata or command semantics | | Image and raw-video dispatch preserves metadata and encoder-option refusals before selecting a frame job | `ffmpeg::plan` owns both guards before `Job::Frames`; `frame_plans_validate_common_options` covers every encoder setting and all metadata modes, and the strict-safe and fallback metadata regressions require refusal before any output is created (`ci.yml`) | | Windows fallback waits for its program, preserves its full exit code and skips CoreAV copies and hard links on PATH | `fallback_cmd::run` owns inherited and replayed process completion; replay carries its spool owner until the child finishes, then drops handles and the spool before the full-code exit. `fallback_windows.rs` and `replayed_fallback_keeps_full_windows_exit_codes_and_cleans_its_spool` exercise native stand-ins, codes above 255, original stdin and cleanup in `ci.yml`'s existing `check-windows` tests. Stable `ExitCode` cannot carry a full Windows code | -| Current comparisons use the shared FFmpeg pin; the historical training extractor stays isolated | `test_oracle.require` owns non-frozen selection and cached success/failure through the unchanged platform verifier; the Rust adapter shares one `OnceLock` per test process. Owner/cache contracts, actual wrong-pin whole-suite failures and pinned passes cover missing, partial, renamed and unverified selections. Frozen consumers retain workflow verification; their immutable closure prevents deleting the old verifier API. `oracle_pin.py --check` keeps historical-extractor references isolated. Types cannot establish an external executable's version | +| Migrated comparisons use the shared FFmpeg pin; the historical training extractor stays isolated | `test_oracle.require` owns migrated selection and cached success/failure through the unchanged platform verifier; the Rust adapter shares one `OnceLock` per test process. Owner/cache contracts, actual wrong-pin whole-suite failures and pinned passes cover missing, partial, renamed and unverified selections. Frozen consumers retain workflow verification; their immutable closure prevents deleting the old verifier API. `oracle_pin.py --check` keeps historical-extractor references isolated. Types cannot establish an external executable's version | | Invocation classifications do not treat owner imports, executable names or unbound value-flow hints as qualification proof | `oracle_invocation_classify.py` owns source-bound call-pattern dispositions and fails on unmatched locations or changed inputs. Shadowing, executable overrides, changed dependencies and extensionless additions invalidate the prior snapshot in `test_oracle_invocation_classify.py`. One disposition owner avoids divergent verdicts; cross-language types cannot establish dynamic executable provenance | | Relocated oracle consumers retain the shared owner, its unchanged pins and their local imports | `test_oracle.bundle` copies the transitive Python closure into its normal `scripts` layout with the common support files. The relocated-bundle regression qualifies a fresh process against the copied pin and checks imported helper bytes; remote runner tests cover the complete pair and unchanged launch contracts. A path alone cannot establish a copied file's identity | +| The relocated decode adapter qualifies without its build checkout and returns a structured qualification error instead of panicking | `try_require` retains the cached result while the embedded support owner stages its complete closure in an exclusive private directory with cleanup. The Rust compiler regression removes the build sources before checking positive, negative, cached and native-only paths. A build-time path type cannot establish runtime file availability | +| Probe-only selectors derive the sibling from the resolved executable, and remux checks execute the retained pair | `test_oracle.executable_path` owns name resolution before sibling selection. The split-PATH regression exercises the policy, frame and TS entry points; the remux subprocess regression runs the unchanged registered checker through a private directory containing only links to the qualified pair. Runtime PATH contents cannot be constrained by a path type | | Standalone audio parity executes the native command with global strict-safe mode, rather than allowing fallback to satisfy equality | `standalone_audio_probe_check.py` owns the command and strict-safe environment; its command-capture regression requires `--strict-safe` before `ffprobe`, and real generated default/JSON comparisons run in `ci.yml`. A mocked subprocess alone cannot prove the command parses | | The fallback name lists match the pinned FFmpeg listings and CoreAV's printed keys, not boolean match-return values | `scripts/fallback_names.py --check DIR` in `ci.yml`'s `check` job fails on drift and names the regeneration command; `test_boolean_match_values_are_not_printed_keys` rejects stereo and unit values without dropping boolean field names | | The unsupported ffprobe format diagnostic names every accepted forced format | `unsupported_format_message_lists_accepted_formats` in `ffprobe::args::tests` checks acceptance and diagnostic coverage together. Rust types cannot prove a user-facing sentence lists the accepted names | diff --git a/docs/design/local-oracle-qualification.md b/docs/design/local-oracle-qualification.md index fbc96f51e..6c568dc55 100644 --- a/docs/design/local-oracle-qualification.md +++ b/docs/design/local-oracle-qualification.md @@ -20,7 +20,7 @@ On arm64, FFmpeg 9.0.2's default SIMD F32→S16 path rounds half-LSB ties away f ## Implemented boundaries -Real callers use the common owner before fixture generation or comparison. Literal-only generated fixtures and mocked subprocess tests stay oracle-free; optional fixture and non-FFmpeg backend selection remains separate from oracle availability. The Linux CI job provisions its pair before any real backend test, and Python discovery provisions it before real fixture consumers. Registered macOS arm64 tests provision the existing macOS pair; other platform selections name and exclude their real oracle-dependent tests explicitly instead of treating a missing executable as a passing comparison. +Migrated callers use the common owner before fixture generation or comparison. Literal-only generated fixtures and mocked subprocess tests stay oracle-free; optional fixture and non-FFmpeg backend selection remains separate from oracle availability. The Linux CI job provisions its pair before any real backend test, and Python discovery provisions it before real fixture consumers. Registered macOS arm64 tests provision the existing macOS pair; other platform selections name and exclude their real oracle-dependent tests explicitly instead of treating a missing executable as a passing comparison. The owner retains both success and failure for the process, rejects a changed selection and delegates all version predicates to the existing platform verifier. The Rust adapter retains that result once per test binary. Remote source bundles retain the normal repository-relative `scripts` layout, both pin files, the common owner and its transitive local imports. Their binary selection and comparison arguments do not change. Bundle checks run with synthetic banner-only programs; no remote media or performance run is required. @@ -37,3 +37,5 @@ Classify each remaining discovery hit as a confirmed bypass, already routed thro Report the confirmed-bypass count before changing any consumers. If the remaining migration cannot stay coherent with the existing deployment and dispatch repairs, split only after a scope decision. Run only short local source and generated regression checks during discovery; no media corpus, performance or remote infrastructure run is required. The classifier matches concrete call patterns against source-bound dispositions rather than inferring qualification from a general-purpose value-flow model. Each disposition identifies its source locations, executable expression, verdict and evidence; the repository input snapshot and qualification dependencies must still match their recorded digests. A changed helper, added file, shadowed binding or executable override therefore invalidates the prior disposition instead of inheriting it. Unmatched locations remain unknown and fail. Reports count source locations, folding overlapping constructor, completion and delegated rows at the same location; they do not count runtime calls or claim an exhaustive bypass total while unknown locations remain. Generated reports stay outside the checkout so they cannot alter the input snapshot. + +This census is report-only, not a required check. Remaining confirmed bypasses and unclassified sites prevent a total qualification claim. The current repair batch covers the AVI selected-pair paths, transcode selection dispatch, the TS command bundle and the relocated decode adapter; the remaining shell and Rust migration and unknown-site review are follow-up work. A required check is deferred until unknown sites have been resolved. diff --git a/docs/design/oracle-invocation-dispositions.json b/docs/design/oracle-invocation-dispositions.json index 1a392e399..ff2158a50 100644 --- a/docs/design/oracle-invocation-dispositions.json +++ b/docs/design/oracle-invocation-dispositions.json @@ -5,8 +5,8 @@ "scripts/oracle-ffmpeg.env": "95601248eba142d1cbf8d81aaf46d5ebc61c1962fe1edafdc1ee2c1b7bd33f24", "scripts/oracle_pin.py": "b221378b054a6e6bae92051ae4e4e4fa1add451213f28e888825fa6e43f2f909", "scripts/oracle_pin_macos.py": "70c0f515b3a58cf6b6d2d11938b537b2e8824f0fafbfe6ab9578669c1d857879", - "scripts/test_oracle.py": "ba9bc428dae34681fa5b9c3f80863479c6fc0c0f45f267ec009d7d97ea004510", - "test-support/oracle.rs": "bda841d4ac18d3cb12d417ff29b1fbc0a5f083a2838e06b1d4b6e92a67c679c2" + "scripts/test_oracle.py": "e16c34d603508ece64cb5e05ae926426080f44cb1031a49089213c663671db99", + "test-support/oracle.rs": "211e259aecbff14c6b0d0246f0157e90935be97fa2a7dd0e0d15c24686530230" }, "frozen": { ".github/workflows/compat-0.1.0.yml": "b979061433995d3a504edddac660216fefbdef556080967f7facf76c89eb1a80", @@ -15,7 +15,7 @@ "bench/audio-decode/oracle.py": "6999bc89af9f0ffb4dade872e30b2b0ba7342648b32e22aaeeca50936316b32a", "bench/audio-decode/receipts.py": "bec504c954c8750df703116325e37ea21c2844696df68e23856495bf95a18783", "bench/audio-decode/run.py": "516120decdaf44a5e206c5e57da485ad15d3f9aa010422daa027508bb2ef6112", - "crates/coreav-cli/tests/ffmpeg.rs": "15e49cefc43240d732903b37874a0fda544065777e331200cfe2ad6182eebefc", + "crates/coreav-cli/tests/ffmpeg.rs": "b241c0478ec19fc8ae6fd67e9443dcfdced286b920c8af1ef2293e95924c19aa", "crates/coreav-isobmff/tests/common/fragments.rs": "a9e161349e40328ca2b95ffa593aff35af0e1739648d74fc0767100cda3f0b89", "crates/coreav-isobmff/tests/common/mod.rs": "fcd4b45894250821d93290d802d8324dfc8cbc1b27c56980a6a6075955744d71", "crates/coreav-isobmff/tests/common/sound.rs": "7db44a00ee6bc2671517fdf5e8bb8b31b25ac224c856b04948aed5bb1875ef03", @@ -1378,20 +1378,6 @@ "pattern": "(?s)test_oracle::require\\(\\)\\.ffmpeg\\(\\)", "verdict": "qualified-via-owner" }, - { - "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", - "id": "rust-compiled-target", - "kinds": [ - "Rust" - ], - "lines": [ - 27, - 612 - ], - "path": "crates/coreav-cli/tests/transcode_selection.rs", - "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", - "verdict": "excluded" - }, { "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", "id": "rust-owner-return", @@ -1511,92 +1497,6 @@ "pattern": "(?s)ffmpeg(?:\\s.*)?", "verdict": "confirmed-bypass" }, - { - "evidence": "main() at lines 89-94 verifies opts.ffmpeg.parent, then passes the originally selected executable into the direct runner and video_equal. Neither basename nor selected-file identity is checked.", - "id": "python-parent-directory-only", - "kinds": [ - "command" - ], - "lines": [ - 79 - ], - "path": "scripts/avi_fixture_check.py", - "pattern": "(?s)ffmpeg", - "verdict": "confirmed-bypass" - }, - { - "evidence": "main() at lines 89-94 verifies opts.ffmpeg.parent, then passes the originally selected executable into the direct runner and video_equal. Neither basename nor selected-file identity is checked.", - "id": "python-parent-directory-only", - "kinds": [ - "command" - ], - "lines": [ - 102, - 107, - 129, - 132 - ], - "path": "scripts/avi_fixture_check.py", - "pattern": "(?s)opts\\.ffmpeg", - "verdict": "confirmed-bypass" - }, - { - "evidence": "main() at lines 89-94 verifies opts.ffmpeg.parent, then passes the originally selected executable into the direct runner and video_equal. Neither basename nor selected-file identity is checked.", - "id": "python-parent-directory-only", - "kinds": [ - "delegated" - ], - "lines": [ - 79, - 102, - 107, - 129, - 132 - ], - "path": "scripts/avi_fixture_check.py", - "pattern": "(?s)run", - "verdict": "confirmed-bypass" - }, - { - "evidence": "main() at lines 25-31 verifies a directory and parent equality, not the requested files. Lines 42-65 forward those unchecked selections to the unchanged evaluator.", - "id": "python-parent-directory-forwarding", - "kinds": [ - "delegated" - ], - "lines": [ - 65 - ], - "path": "scripts/avi_v2_check.py", - "pattern": "(?s)v2\\.evaluate", - "verdict": "confirmed-bypass" - }, - { - "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", - "id": "python-owner-return", - "kinds": [ - "command" - ], - "lines": [ - 336 - ], - "path": "scripts/bench_guard.py", - "pattern": "(?s)pin", - "verdict": "qualified-via-owner" - }, - { - "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", - "id": "python-owner-return", - "kinds": [ - "command" - ], - "lines": [ - 399, - 428 - ], - "path": "scripts/bench_guard.py", - "pattern": "(?s)str\\(test_oracle\\.require\\(\\)\\.ffmpeg\\)", - "verdict": "qualified-via-owner" - }, { "evidence": "The standalone entry point executes the recorded PATH or environment selection without qualifying that executable.", "id": "shell-unqualified-array", @@ -1721,23 +1621,10 @@ "path": "scripts/stsd_craft.py", "pattern": "(?s)ffmpeg", "verdict": "qualified-via-owner" - }, - { - "evidence": "The select branch returns at lines 441-444 before require() at 452. select() forwards the unqualified selectors through child_env and make_prober at 84-86.", - "id": "python-prequalification-dispatch", - "kinds": [ - "delegated" - ], - "lines": [ - 444 - ], - "path": "scripts/transcode_speed.py", - "pattern": "(?s)select", - "verdict": "confirmed-bypass" } ], "schema": 1, - "source_snapshot_sha256": "23237aed907a55f36637ccea64304a4c04eb5c2e0c439f7c0b511e337584d3cb", + "source_snapshot_sha256": "b81605c40a50b3231bc6e688a8503a078f1e2848f64143407d8ad66c5b991c3d", "sources": { "crates/coreav-audio/tests/flac_encode.rs": "6b63b16444965850c74da0651859128602a9093fe487a15865f8a82093bf6880", "crates/coreav-backend-dav1d/tests/decode.rs": "9094fa0b3a4957d348e9b92420c658fda930329cac3b9c2da17e5c3248e0e791", @@ -1776,18 +1663,13 @@ "crates/coreav-cli/tests/strict_safe.rs": "a75f3d5c6a22eee49b44cefd43931f1199515218603f7126d62198a232db7699", "crates/coreav-cli/tests/strict_safe_limit.rs": "0b11d217aea687a5d7e81a9d85cb8703fd0d8092c6d660c29ece8559e5cfc895", "crates/coreav-cli/tests/thumbnail.rs": "3740eda708acee2bdb0f3ea4a0ac5819c80927c4bc361e3210d5acbe7d85279e", - "crates/coreav-cli/tests/transcode_selection.rs": "ee9deecabf5a4a2715ea8ece168ff89af163ecb3a31fc2598bc7a6ae1de294c6", "crates/coreav-isobmff-write/tests/replace.rs": "c704b6600421661b444eed3c4ad88efcbda2d41636d10fedcac15b0be5268991", "crates/coreav-worker/tests/ffmpeg.rs": "48ca0fb6ab070e47c3a8ea3f4d9f626b2c9696ef031b5225cef87010ba250d92", "packages/cli/test/release-clips.sh": "870efad502950d8dbb9a3f88c8672a2c10d610dcada7fb8dfe5dbc12e29c37c1", - "scripts/avi_fixture_check.py": "0d87de769e2678e9f1299a1b8667a785ed0a9943443c2f5ee4f9a4fec8fcf97e", - "scripts/avi_v2_check.py": "731fb170c38f8694cbbefc9914f9f40836b3558651a45dda85bcc8ef9f2f74e1", - "scripts/bench_guard.py": "9906ca0e4d376bc5fde262d17297d699b5802212a293ff6676d588bdd4e03250", "scripts/gen-fixtures-mkv.sh": "2edfdf356a214c97fc24c9e445892beaf9bd9e339d9fd519f100a800b1f05010", "scripts/gen-fixtures-ts.sh": "d7f797724e4521b1a4840ce41953cfb5f1fd8e4b79a0266feacbf325bf4d5551", "scripts/gen-fixtures.sh": "baa6378c62602ce2332f2d1138766965eaa979737864a29737cd4d92b16ab6cb", "scripts/oracle-ffprobe.sh": "8ffb1e92747b2f7e5d668e9f70074b90ca99347fbfdbb2723aead2a536970ac5", - "scripts/stsd_craft.py": "4d683dd4fd8048ac1140d13cfafdfb18f57ebf314fe1a10b8a81770e8184402b", - "scripts/transcode_speed.py": "3084a9ba86a8834ef693c38843384b4b3e32b32fb017c709d3aed07990c425bc" + "scripts/stsd_craft.py": "4d683dd4fd8048ac1140d13cfafdfb18f57ebf314fe1a10b8a81770e8184402b" } } diff --git a/scripts/audio_copy_check.py b/scripts/audio_copy_check.py index 4b6758d80..fa8b5d13e 100755 --- a/scripts/audio_copy_check.py +++ b/scripts/audio_copy_check.py @@ -268,8 +268,8 @@ def cases(source, out): def main(): parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) parser.add_argument("--coreav", required=True) - parser.add_argument("--ffmpeg", default="ffmpeg") - parser.add_argument("--ffprobe", default="ffprobe") + parser.add_argument("--ffmpeg") + parser.add_argument("--ffprobe") parser.add_argument("--work", required=True, type=pathlib.Path) parser.add_argument("--report", type=pathlib.Path) tools = parser.parse_args() diff --git a/scripts/avi_fixture_check.py b/scripts/avi_fixture_check.py index 2810c92b3..9de665540 100644 --- a/scripts/avi_fixture_check.py +++ b/scripts/avi_fixture_check.py @@ -11,7 +11,6 @@ ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT / 'tools/compat-corpus')) import decoded_output -import oracle_pin import test_oracle from oracle_audio import INPUT_ARGS as AUDIO_DECODE_INPUT @@ -87,9 +86,8 @@ def main(): parser.add_argument('--' + name, type=Path, required=True) opts = parser.parse_args() opts.coreav, opts.ffmpeg, opts.ffprobe = (p.resolve() for p in (opts.coreav, opts.ffmpeg, opts.ffprobe)) - problems = list(test_oracle.verify_bin(opts.ffmpeg.parent)) - if problems: - raise RuntimeError('\n'.join(problems)) + qualified = test_oracle.require(opts.ffmpeg, opts.ffprobe) + opts.ffmpeg, opts.ffprobe = qualified.ffmpeg, qualified.ffprobe opts.work.mkdir(parents=True, exist_ok=True) env = {**os.environ, 'COREAV_FFMPEG': str(opts.ffmpeg), 'COREAV_FALLBACK': '/nonexistent/coreav-fallback', 'COREAV_STRICT_SAFE': '0', 'COREAV_FALLBACK_LOG': str(opts.work / 'fallback.jsonl')} diff --git a/scripts/avi_v2_check.py b/scripts/avi_v2_check.py index 5aa421204..c76708b3a 100644 --- a/scripts/avi_v2_check.py +++ b/scripts/avi_v2_check.py @@ -10,7 +10,6 @@ ROOT = Path(__file__).resolve().parents[1] sys.path[:0] = [str(ROOT / 'tools/compat-corpus'), str(ROOT / 'scripts')] import encode_breadth as v2 -import oracle_pin import test_oracle @@ -25,10 +24,8 @@ def main(): opts = parser.parse_args() for name in ('coreav', 'ffmpeg', 'ffprobe', 'x264', 'fixtures', 'work'): setattr(opts, name, getattr(opts, name).resolve()) - problems = list(test_oracle.verify_bin(opts.ffmpeg.parent)) - if problems: - raise RuntimeError('\n'.join(problems)) - assert opts.ffprobe.parent == opts.ffmpeg.parent + qualified = test_oracle.require(opts.ffmpeg, opts.ffprobe) + opts.ffmpeg, opts.ffprobe = qualified.ffmpeg, qualified.ffprobe artifacts = [json.loads(line) for line in opts.build_log.read_text().splitlines() if line.startswith('{')] opts.harness, = [a['executable'] for a in artifacts if a.get('reason') == 'compiler-artifact' and a.get('target', {}).get('name') == 'ffmpeg' and a.get('executable')] diff --git a/scripts/exact_skip_check.py b/scripts/exact_skip_check.py index 07f89e917..f528d7226 100644 --- a/scripts/exact_skip_check.py +++ b/scripts/exact_skip_check.py @@ -97,8 +97,8 @@ def check(decode_oracle, path, ffprobe, times=1): def main(): p = argparse.ArgumentParser(description=__doc__.splitlines()[0]) p.add_argument('--decode-oracle', required=True) - p.add_argument('--ffmpeg', default=shutil.which('ffmpeg')) - p.add_argument('--ffprobe', default=shutil.which('ffprobe')) + p.add_argument('--ffmpeg') + p.add_argument('--ffprobe') p.add_argument('--fixtures', type=pathlib.Path) p.add_argument('--times', type=int, default=1) p.add_argument('--matroska', action='store_true') diff --git a/scripts/h264_parity_gcp.py b/scripts/h264_parity_gcp.py index adfb3a120..d4dff7263 100644 --- a/scripts/h264_parity_gcp.py +++ b/scripts/h264_parity_gcp.py @@ -389,6 +389,9 @@ def main(): missing = [n for n in ('out', 'es_dir', 'decoder', 'ffmpeg', 'gate_stream', 'null_arm') if getattr(args, n) is None] if missing: ap.error('the following arguments are required: ' + ', '.join('--' + n.replace('_', '-') for n in missing)) + selected = test_oracle.executable_path(args.ffmpeg) + oracle = test_oracle.require(selected, selected.with_name('ffprobe')) + args.ffmpeg = str(oracle.ffmpeg) if args.one_thread_class: args.machine, args.usd_per_hour = MACHINE_1T, USD_PER_HOUR_1T if args.threads not in (None, 1): @@ -475,7 +478,7 @@ def main(): for n, path in args.decoders: shutil.copy(path, os.path.join(up, f'decode-{n}')) shutil.copy(args.ffmpeg, os.path.join(up, 'ffmpeg')) - shutil.copy(os.path.join(os.path.dirname(os.path.abspath(args.ffmpeg)), 'ffprobe'), os.path.join(up, 'ffprobe')) + shutil.copy(oracle.ffprobe, os.path.join(up, 'ffprobe')) shutil.copy(args.gate_stream, os.path.join(up, 'gate.h264')) test_oracle.bundle(up, ['h264_parity.py']) if args.one_thread_class: diff --git a/scripts/oracle.py b/scripts/oracle.py index 7c18ac758..3ccf9d530 100755 --- a/scripts/oracle.py +++ b/scripts/oracle.py @@ -225,8 +225,8 @@ def main(): parser.add_argument("command", choices=["capture", "run", "self-check"]) parser.add_argument("fixtures", type=Path) parser.add_argument("output", type=Path, help="new directory; existing outputs are never overwritten") - parser.add_argument("--ffprobe", default="ffprobe") - parser.add_argument("--ffmpeg", default="ffmpeg") + parser.add_argument("--ffprobe") + parser.add_argument("--ffmpeg") parser.add_argument("--timeout", type=float, default=120, help="seconds per subprocess") parser.add_argument("--comparator", type=Path, default=Path("target/debug/coreav-oracle-json")) parser.add_argument("--profile", choices=["fixtures", "real"], default="fixtures") diff --git a/scripts/policy_check.py b/scripts/policy_check.py index 827fcf709..fc74559ce 100644 --- a/scripts/policy_check.py +++ b/scripts/policy_check.py @@ -332,7 +332,8 @@ def main(): parser.add_argument('--report', type=pathlib.Path) args = parser.parse_args() if args.ffprobe: - args.ffprobe = str(test_oracle.require(pathlib.Path(args.ffprobe).with_name('ffmpeg'), args.ffprobe).ffprobe) + probe = test_oracle.executable_path(args.ffprobe) + args.ffprobe = str(test_oracle.require(probe.with_name('ffmpeg'), probe).ffprobe) if args.media: files = sorted(p for p in args.media.iterdir() if p.is_file() and p.name not in ('MANIFEST', 'manifest.json')) diff --git a/scripts/seek_check.py b/scripts/seek_check.py index 955648ebd..2de001989 100644 --- a/scripts/seek_check.py +++ b/scripts/seek_check.py @@ -82,13 +82,14 @@ def check(oracle, path, ffprobe, n): def main(): p = argparse.ArgumentParser(description=__doc__.splitlines()[0]) p.add_argument('--decode-oracle', required=True) - p.add_argument('--ffprobe', default=shutil.which('ffprobe')) + p.add_argument('--ffprobe') p.add_argument('--fixtures') p.add_argument('--times', type=int, default=64) p.add_argument('--report') p.add_argument('files', nargs='*') a = p.parse_args() - a.ffprobe = str(test_oracle.require(pathlib.Path(a.ffprobe).with_name('ffmpeg'), a.ffprobe).ffprobe) + probe = test_oracle.executable_path(a.ffprobe) if a.ffprobe else None + a.ffprobe = str(test_oracle.require(probe.with_name('ffmpeg') if probe else None, probe).ffprobe) paths = [pathlib.Path(f) for f in a.files] if a.fixtures: paths += sorted(q for q in pathlib.Path(a.fixtures).iterdir() if q.suffix.lstrip('.').lower() in EXTS) diff --git a/scripts/test_oracle.py b/scripts/test_oracle.py index 37ab3d2ef..f210af46b 100644 --- a/scripts/test_oracle.py +++ b/scripts/test_oracle.py @@ -28,7 +28,7 @@ class QualificationError(RuntimeError): _lock = threading.Lock() _selection = None _result = None -SUPPORT = ('test_oracle.py', 'oracle_pin.py', 'oracle_pin_macos.py', +SUPPORT = ('test_oracle.py', 'oracle_pin.py', 'oracle_pin_macos.py', 'oracle_audio.py', 'oracle-ffmpeg.env', 'oracle-ffmpeg-macos.env', 'oracle-audio-args.txt') @@ -63,7 +63,7 @@ def bundle(root, entries): shutil.copyfile(source.parent / relative, destination) -def _path(value): +def executable_path(value): value = os.fspath(value) if Path(value).name == value: value = shutil.which(value) or value @@ -75,9 +75,9 @@ def require(ffmpeg=None, ffprobe=None): selected = ffmpeg if ffmpeg is not None else os.environ.get('COREAV_FFMPEG') if selected is None: selected = shutil.which('ffmpeg') or '/opt/coreav-oracle-bin/ffmpeg' - selected = _path(selected) + selected = executable_path(selected) probe = ffprobe if ffprobe is not None else os.environ.get('COREAV_FFPROBE') - probe = _path(probe) if probe is not None else selected.with_name('ffprobe') + probe = executable_path(probe) if probe is not None else selected.with_name('ffprobe') requested = (selected.resolve(), probe.resolve()) with _lock: if _result is not None: diff --git a/scripts/tests/test_gcp_vm_job.py b/scripts/tests/test_gcp_vm_job.py index 300b02957..5a58681f1 100644 --- a/scripts/tests/test_gcp_vm_job.py +++ b/scripts/tests/test_gcp_vm_job.py @@ -271,6 +271,8 @@ def run(cmd, *a, **k): cmds.append(cmd) return subprocess.CompletedProcess(cmd, rc) with mock.patch.object(sys, 'argv', ['h264_parity_gcp.py', *argv]), \ + mock.patch.object(h264_parity_gcp.test_oracle, 'require', return_value= + h264_parity_gcp.test_oracle.Oracle(self.r / 'ff', self.r / 'ffprobe')), \ mock.patch.object(h264_parity_gcp.subprocess, 'run', run): return h264_parity_gcp.main(), cmds diff --git a/scripts/tests/test_test_oracle.py b/scripts/tests/test_test_oracle.py index ece1515ad..6f70d08b7 100644 --- a/scripts/tests/test_test_oracle.py +++ b/scripts/tests/test_test_oracle.py @@ -1,6 +1,8 @@ """Oracle-free Linux owner/cache contracts using banner-only stand-ins.""" import os from pathlib import Path +import re +import shutil import subprocess import sys import tempfile @@ -150,6 +152,166 @@ def test_relocated_bundle_keeps_the_same_pin_and_complete_import_closure(self): self.assertEqual(result.stdout.splitlines(), [str(self.root / 'ffmpeg'), str(self.root / 'ffprobe')]) + def test_rust_adapter_embeds_the_complete_owner_support_set(self): + source = (ROOT / 'test-support/oracle.rs').read_text() + embedded = set(re.findall(r'"/../../scripts/([^\"]+)"', source)) + self.assertEqual(embedded, set(test_oracle.SUPPORT)) + root = self.root / 'embedded' + test_oracle.bundle(root, []) + self.assertEqual({path.name for path in (root / 'scripts').iterdir()}, embedded) + + @unittest.skipUnless(shutil.which('rustc'), 'Rust adapter compiler is not installed') + def test_rust_adapter_qualifies_without_build_sources_and_retains_both_results(self): + build = self.root / 'build' + manifest = build / 'crates/probe' + manifest.mkdir(parents=True) + test_oracle.bundle(build, []) + shutil.copy(ROOT / 'test-support/oracle.rs', manifest / 'oracle.rs') + source = manifest / 'main.rs' + source.write_text('mod oracle;\nfn main() {\n' + 'let mode = std::env::args().nth(1).unwrap();\n' + 'if mode == "native" { return; }\n' + 'for _ in 0..2 {\n' + 'let result = oracle::try_require();\n' + 'assert_eq!(result.is_ok(), mode == "valid");\n' + 'if let Err(error) = result { assert!(error.contains("stage=oracle_qualification")); }\n' + '}\n}\n') + binary = self.root / 'relocated' + made = subprocess.run(['rustc', '--edition=2024', str(source), '-o', str(binary)], + env=dict(os.environ, CARGO_MANIFEST_DIR=str(manifest)), + capture_output=True, text=True, timeout=60) + self.assertEqual(made.returncode, 0, made.stderr) + shutil.rmtree(build) + temporary = self.root / 'support' + temporary.mkdir() + for mode in ('valid', 'invalid', 'native'): + with self.subTest(mode=mode): + self.pair(self.root, version=self.build if mode == 'valid' else '0.0.0') + self.log.unlink(missing_ok=True) + env = dict(os.environ, COREAV_FFMPEG=str(self.root / 'ffmpeg'), + COREAV_FFPROBE=str(self.root / 'ffprobe'), TMPDIR=str(temporary)) + if mode == 'native': + env['PATH'] = '/nonexistent' + done = subprocess.run([str(binary), mode], env=env, capture_output=True, + text=True, timeout=30) + self.assertEqual(done.returncode, 0, done.stderr) + self.assertEqual(list(temporary.iterdir()), []) + if mode == 'native': + self.assertFalse(self.log.exists()) + else: + self.assertCountEqual(self.log.read_text().splitlines(), ['ffmpeg', 'ffprobe']) + + def test_avi_drivers_reject_each_different_selected_file_before_work(self): + marker = self.root / 'unqualified.called' + selected = self.root / 'other' + selected.write_text(f'#!/bin/sh\ntouch "{marker}"\necho wrong\n') + selected.chmod(0o700) + for driver in ('avi_fixture_check.py', 'avi_v2_check.py'): + for role in ('ffmpeg', 'ffprobe'): + with self.subTest(driver=driver, role=role): + command = [sys.executable, '-I', str(ROOT / 'scripts' / driver), '--coreav', 'missing', + '--ffmpeg', str(selected if role == 'ffmpeg' else self.root / 'ffmpeg'), + '--ffprobe', str(selected if role == 'ffprobe' else self.root / 'ffprobe'), + '--work', str(self.root / 'uncreated')] + if driver == 'avi_v2_check.py': + command += ['--x264', 'missing', '--build-log', 'missing', '--fixtures', 'missing'] + result = subprocess.run(command, capture_output=True, text=True, timeout=30) + self.assertNotEqual(result.returncode, 0) + self.assertIn('stage=oracle_qualification', result.stderr) + self.assertFalse(marker.exists()) + self.assertFalse((self.root / 'uncreated').exists()) + + def test_probe_only_entry_points_derive_the_sibling_after_path_resolution(self): + shadow = self.root / 'shadow' + shadow.mkdir() + (shadow / 'ffmpeg').write_text('#!/bin/sh\necho "ffmpeg version 0.0.0"\n') + (shadow / 'ffmpeg').chmod(0o700) + self.child('import importlib.util, os\n' + 'from pathlib import Path\nfrom unittest.mock import patch\n' + 'root = Path(sys.argv[2])\nrepo = Path(sys.argv[1]).parent\n' + 'require = owner.require\n' + 'os.environ["PATH"] = str(root / "shadow") + os.pathsep + str(root) + os.pathsep + os.environ["PATH"]\n' + 'cases = [("scripts/policy_check.py", ["--coreav", "missing", "--policy", "missing"]),\n' + ' ("tools/compat-corpus/frames.py", ["--coreav", "missing", "--media", "missing"]),\n' + ' ("scripts/ts_speed.py", ["--coreav", "missing", "--null", "missing", "--lav", "missing", "--report", "missing", "missing"])]\n' + 'for index, (path, args) in enumerate(cases):\n' + ' spec = importlib.util.spec_from_file_location("driver" + str(index), repo / path)\n' + ' driver = importlib.util.module_from_spec(spec)\n spec.loader.exec_module(driver)\n' + ' def inspect_selected(ffmpeg, ffprobe):\n' + ' pair = require(ffmpeg, ffprobe)\n' + ' assert pair.ffmpeg == root / "ffmpeg"\n' + ' assert pair.ffprobe == root / "ffprobe"\n' + ' raise StopIteration\n' + ' sys.argv = [path, *args, "--ffprobe", "ffprobe"]\n' + ' with patch.object(driver.test_oracle, "require", side_effect=inspect_selected):\n' + ' try: driver.main()\n' + ' except StopIteration: pass\n' + ' else: raise AssertionError("selection boundary was not reached")\n') + + def test_remux_checker_runs_only_the_retained_pair(self): + (self.root / 'ffprobe').write_text('#!/bin/sh\n' + + f'echo ffprobe >> "{self.log}"\n' + + f'if [ "$1" = "-version" ]; then echo "ffprobe version {self.build}"; exit; fi\n' + + 'echo \'{"format":{"format_name":"mp4"},"streams":[]}\'\n') + shadow = self.root / 'shadow' + shadow.mkdir() + (shadow / 'ffprobe').write_text('#!/bin/sh\nexit 99\n') + (shadow / 'ffprobe').chmod(0o700) + self.child('from pathlib import Path\nimport os\n' + 'root = Path(sys.argv[2])\n' + 'sys.path.insert(0, str(Path(sys.argv[1]).parent / "tools/mkv-adapter"))\n' + 'import remux_corpus as driver\n' + 'os.environ["PATH"] = str(root / "shadow") + os.pathsep + os.environ["PATH"]\n' + 'pair = owner.require()\n' + 'output = root / "output.mp4"\n' + 'output.write_bytes(b"".join((8).to_bytes(4, "big") + kind for kind in (b"ftyp", b"moov", b"mdat")))\n' + 'result = driver.check_with_oracle(output, output, {"streams": []}, None, pair)\n' + 'assert result["ok"], result\n') + self.assertCountEqual(self.log.read_text().splitlines(), ['ffmpeg', 'ffprobe', 'ffprobe', 'ffprobe']) + + def test_omitted_cli_selectors_honor_the_configured_pair_over_path(self): + shadow = self.root / 'shadow' + self.pair(shadow, version='0.0.0') + self.child('import importlib.util, os\nfrom pathlib import Path\nfrom unittest.mock import patch\n' + 'root = Path(sys.argv[2])\nrepo = Path(sys.argv[1]).parent\nrequire = owner.require\n' + 'os.environ["PATH"] = str(root / "shadow") + os.pathsep + os.environ["PATH"]\n' + 'cases = [("text_check", ["--coreav", "missing", "--media", "missing"]),\n' + ' ("audio_copy_check", ["--coreav", "missing", "--work", "missing"]),\n' + ' ("oracle", ["capture", "missing", "missing"]),\n' + ' ("thumbnail_oracle", ["--coreav", "missing", "--decode-oracle", "missing"]),\n' + ' ("exact_skip_check", ["--decode-oracle", "missing"]),\n' + ' ("seek_check", ["--decode-oracle", "missing"])]\n' + 'for name, args in cases:\n' + ' spec = importlib.util.spec_from_file_location("driver_" + name, repo / "scripts" / (name + ".py"))\n' + ' driver = importlib.util.module_from_spec(spec)\n spec.loader.exec_module(driver)\n' + ' def inspect_selected(ffmpeg=None, ffprobe=None):\n' + ' pair = require(ffmpeg, ffprobe)\n' + ' assert pair.ffmpeg == root / "ffmpeg"\n' + ' assert pair.ffprobe == root / "ffprobe"\n' + ' raise StopIteration\n' + ' sys.argv = [name, *args]\n' + ' with patch.object(driver.test_oracle, "require", side_effect=inspect_selected):\n' + ' try: driver.main()\n' + ' except StopIteration: pass\n' + ' else: raise AssertionError("selection boundary was not reached")\n') + + def test_transcode_select_qualifies_and_retains_the_pair_before_dispatch(self): + self.child('from pathlib import Path\n' + 'from unittest.mock import patch\n' + 'import transcode_speed\n' + 'root = Path(sys.argv[2])\n' + 'sys.argv = ["transcode_speed.py", "select", "--work", str(root / "work"),\n' + ' "--selection", str(root / "selection"), "--ffmpeg", str(root / "ffmpeg"),\n' + ' "--ffprobe", str(root / "ffprobe")]\n' + 'def inspect_selected(args):\n' + ' assert args.ffmpeg == str(root / "ffmpeg")\n' + ' assert args.ffprobe == str(root / "ffprobe")\n' + ' assert owner.require().ffmpeg == root / "ffmpeg"\n' + ' return 0\n' + 'with patch.object(transcode_speed, "select", side_effect=inspect_selected) as run:\n' + ' assert transcode_speed.main() == 0\n' + ' assert run.call_count == 1\n') + def test_vp9_main_retains_the_qualified_path_pair_despite_cwd_shadowing(self): shadow = self.root / 'shadow' self.pair(shadow, version='0.0.0') @@ -176,6 +338,10 @@ def test_active_entry_points_reject_before_creating_fixture_or_report_output(sel ffmpeg, ffprobe = str(self.root / 'ffmpeg'), str(self.root / 'ffprobe') output = str(self.root / 'uncreated') commands = ( + ('scripts/h264_parity_gcp.py', '--out', output, '--es-dir', 'missing', '--decoder', 'base=missing', + '--ffmpeg', ffmpeg, '--gate-stream', 'missing', '--null-arm', 'base'), + ('scripts/transcode_speed.py', 'select', '--ffmpeg', ffmpeg, '--ffprobe', ffprobe, + '--work', output, '--selection', output + '.json'), ('scripts/h264_agreement.py', '--ffmpeg', ffmpeg, 'missing.h264'), ('scripts/h264_modes_identity.py', '--streams', 'missing', '--generate', ffmpeg), ('scripts/h264_speed.py', '--ffmpeg', ffmpeg, 'missing.h264'), diff --git a/scripts/tests/test_ts_speed_pair.py b/scripts/tests/test_ts_speed_pair.py new file mode 100644 index 000000000..b9f3cd077 --- /dev/null +++ b/scripts/tests/test_ts_speed_pair.py @@ -0,0 +1,117 @@ +import hashlib +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tarfile +import tempfile +import unittest + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT / 'scripts')) +import oracle_pin + + +@unittest.skipUnless(sys.platform == 'linux', 'Linux shared-oracle deployment layout') +class CommandPair(unittest.TestCase): + def setUp(self): + directory = tempfile.TemporaryDirectory() + self.addCleanup(directory.cleanup) + self.root = Path(directory.name) + self.build = oracle_pin.load()['BUILD'] + + def pair(self, directory): + directory.mkdir(parents=True) + for name in ('ffmpeg', 'ffprobe'): + program = directory / name + program.write_text(f'#!/bin/sh\necho "{name} version {self.build}"\n') + program.chmod(0o700) + + def arguments(self): + media = self.root / 'generated.ts' + media.write_bytes(b'\x47' + bytes(187)) + return ['ts_speed_gcp.py', '--out', str(self.root / 'result'), '--coreav', str(media), + '--coreav-cli', str(media), '--lav-dir', str(self.root / 'lav'), '--dry-run', str(media)] + + def test_command_upload_relocates_both_verified_programs(self): + self.pair(self.root / 'lav/bin') + code = ('import shutil,sys\nfrom pathlib import Path\nfrom unittest.mock import patch\n' + 'sys.path.insert(0, sys.argv[1])\nimport ts_speed_gcp as driver\n' + 'saved = Path(sys.argv[2])\noriginal = shutil.rmtree\n' + 'def capture(directory, **kwargs):\n' + ' shutil.copytree(directory, saved)\n original(directory, **kwargs)\n' + 'sys.argv = sys.argv[3:]\n' + 'with patch.object(shutil, "rmtree", side_effect=capture):\n' + ' assert driver.main() == 0\n') + saved = self.root / 'relocated' + result = subprocess.run([sys.executable, '-I', '-c', code, str(ROOT / 'scripts'), str(saved), + *self.arguments()], capture_output=True, text=True, timeout=30) + self.assertEqual(result.returncode, 0, result.stderr) + script = (saved / 'job.sh').read_text() + self.assertIn('lav/bin/ffmpeg lav/bin/ffprobe', script) + resolved = subprocess.run([sys.executable, '-I', str(saved / 'scripts/test_oracle.py'), '--resolve', + '--ffmpeg', str(saved / 'lav/bin/ffmpeg'), + '--ffprobe', str(saved / 'lav/bin/ffprobe')], + capture_output=True, text=True, timeout=30) + self.assertEqual(resolved.returncode, 0, resolved.stderr) + self.assertEqual(resolved.stdout.splitlines(), + [str(saved / 'lav/bin/ffmpeg'), str(saved / 'lav/bin/ffprobe')]) + + def test_probe_only_input_fails_before_an_upload_is_created(self): + self.pair(self.root / 'lav/bin') + (self.root / 'lav/bin/ffmpeg').unlink() + result = subprocess.run([sys.executable, '-I', str(ROOT / 'scripts/ts_speed_gcp.py'), + *self.arguments()[1:]], capture_output=True, text=True, timeout=30) + self.assertNotEqual(result.returncode, 0) + self.assertIn('stage=oracle_qualification', result.stderr) + self.assertFalse((self.root / 'result').exists()) + + def test_lav_builder_keeps_the_pair_from_the_shared_archive(self): + pin = oracle_pin.load() + archive_root = self.root / pin['LAV_ARCHIVE'] + self.pair(archive_root / 'bin') + for directory in ('include', 'lib'): + (archive_root / directory).mkdir() + (archive_root / directory / 'fixture').write_text('generated layout fixture\n') + (archive_root / 'LICENSE.txt').write_text('generated layout fixture\n') + archive = self.root / 'fixture.tar.xz' + with tarfile.open(archive, 'w:xz') as output: + output.add(archive_root, arcname=archive_root.name) + checkout = self.root / 'checkout' + source = checkout / 'tools/ts-speed' + source.mkdir(parents=True) + (checkout / 'scripts').mkdir() + shutil.copy(ROOT / 'tools/ts-speed/build-lav.sh', source) + environment = (ROOT / 'scripts/oracle-ffmpeg.env').read_text() + environment = environment.replace(pin['LAV_SHA256'], hashlib.sha256(archive.read_bytes()).hexdigest()) + (checkout / 'scripts/oracle-ffmpeg.env').write_text(environment) + helpers = self.root / 'helpers' + helpers.mkdir() + curl = helpers / 'curl' + curl.write_text(f'#!{sys.executable}\nimport os,shutil,sys\nfrom pathlib import Path\n' + 'shutil.copyfile(os.environ["FIXTURE_ARCHIVE"], sys.argv[sys.argv.index("-o") + 1])\n' + 'Path(os.environ["FIXTURE_URL"]).write_text(sys.argv[-1])\n') + gcc = helpers / 'gcc' + gcc.write_text(f'#!{sys.executable}\nimport sys\nfrom pathlib import Path\n' + 'output = Path(sys.argv[sys.argv.index("-o") + 1])\n' + 'output.write_text("#!/bin/sh\\necho generated-layout-fixture\\n")\n' + 'output.chmod(0o700)\n') + for program in (curl, gcc): + program.chmod(0o700) + destination = self.root / 'installed' + url = self.root / 'url' + env = dict(os.environ, PATH=str(helpers) + os.pathsep + os.environ['PATH'], + FIXTURE_ARCHIVE=str(archive), FIXTURE_URL=str(url)) + result = subprocess.run(['bash', str(source / 'build-lav.sh'), str(destination)], env=env, + capture_output=True, text=True, timeout=30) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(url.read_text().rsplit('/', 1)[-1], pin['LAV_ARCHIVE'] + '.tar.xz') + self.assertIn('lgpl', pin['LAV_ARCHIVE']) + for name in ('ffmpeg', 'ffprobe'): + self.assertEqual((destination / 'bin' / name).read_bytes(), (archive_root / 'bin' / name).read_bytes()) + self.assertFalse((destination / 'include').exists()) + + +if __name__ == '__main__': + unittest.main() diff --git a/scripts/text_check.py b/scripts/text_check.py index 5e12da922..5677cb02a 100644 --- a/scripts/text_check.py +++ b/scripts/text_check.py @@ -1117,8 +1117,8 @@ def main(): parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) parser.add_argument("--coreav", required=True) parser.add_argument("--media", required=True) - parser.add_argument("--ffprobe", default="ffprobe") - parser.add_argument("--ffmpeg", default="ffmpeg") + parser.add_argument("--ffprobe") + parser.add_argument("--ffmpeg") parser.add_argument("--mediainfo") parser.add_argument("--kd-overlay", help="known-divergences.json from scripts/oracle_kd.py") parser.add_argument("--require-several-edits", action="store_true", diff --git a/scripts/thumbnail_oracle.py b/scripts/thumbnail_oracle.py index 94a67d4ae..ec3994fc3 100644 --- a/scripts/thumbnail_oracle.py +++ b/scripts/thumbnail_oracle.py @@ -434,8 +434,8 @@ def main(): p = argparse.ArgumentParser(description=__doc__.splitlines()[1]) p.add_argument('--coreav', required=True) p.add_argument('--decode-oracle', required=True) - p.add_argument('--ffmpeg', default=shutil.which('ffmpeg')) - p.add_argument('--ffprobe', default=shutil.which('ffprobe')) + p.add_argument('--ffmpeg') + p.add_argument('--ffprobe') p.add_argument('--backend', default='ffmpeg') p.add_argument('--fixtures') p.add_argument('--report') diff --git a/scripts/transcode_speed.py b/scripts/transcode_speed.py index d25b28c5f..b93be55c8 100644 --- a/scripts/transcode_speed.py +++ b/scripts/transcode_speed.py @@ -441,6 +441,8 @@ def main(): if args.command == 'select': if not args.work or not args.selection: p.error('select needs --work and --selection') + qualified = test_oracle.require(args.ffmpeg, args.ffprobe) + args.ffmpeg, args.ffprobe = str(qualified.ffmpeg), str(qualified.ffprobe) return select(args) if args.command == 'summarize': if not args.out: diff --git a/scripts/ts_speed.py b/scripts/ts_speed.py index c1be4cdad..c3c107360 100644 --- a/scripts/ts_speed.py +++ b/scripts/ts_speed.py @@ -102,7 +102,8 @@ def main(): ap.add_argument('files', nargs='+') args = ap.parse_args() if args.ffprobe: - args.ffprobe = str(test_oracle.require(os.path.join(os.path.dirname(args.ffprobe), 'ffmpeg'), args.ffprobe).ffprobe) + probe = test_oracle.executable_path(args.ffprobe) + args.ffprobe = str(test_oracle.require(probe.with_name('ffmpeg'), probe).ffprobe) if (args.coreav_cli is None) != (args.ffprobe is None): ap.error('--coreav-cli and --ffprobe go together') if args.rounds < 1: diff --git a/scripts/ts_speed_gcp.py b/scripts/ts_speed_gcp.py index 566f8e14d..ca4bf9952 100644 --- a/scripts/ts_speed_gcp.py +++ b/scripts/ts_speed_gcp.py @@ -61,10 +61,10 @@ def job_script(run): command += ['--coreav-cli', './coreav', '--ffprobe', './lav/bin/ffprobe'] command += [f'files/{name}' for name in run['files']] return '\n'.join([ - 'set -u', 'mkdir -p out', 'chmod +x ts-speed ts-speed-null lav/lav_ts' + (' coreav lav/bin/ffprobe' if run['commands'] else ''), + 'set -u', 'mkdir -p out', 'chmod +x ts-speed ts-speed-null lav/lav_ts' + (' coreav lav/bin/ffmpeg lav/bin/ffprobe' if run['commands'] else ''), '{ lscpu; nproc; uname -a; echo "smt active: $(cat /sys/devices/system/cpu/smt/active 2>&1)"; python3 --version;' ' lav/lav_ts --identity; sha256sum ts-speed ts-speed-null lav/lav_ts lav/lib/* scripts/*' - + (' coreav lav/bin/ffprobe' if run['commands'] else '') + '; } > out/host.txt 2>&1', + + (' coreav lav/bin/ffmpeg lav/bin/ffprobe' if run['commands'] else '') + '; } > out/host.txt 2>&1', '{ sudo apt-get -q update && sudo DEBIAN_FRONTEND=noninteractive apt-get -q -y install linux-perf' ' && sudo sysctl -q kernel.perf_event_paranoid=1; } > out/perf-install.log 2>&1', 'echo "start $(date -u +%T)" > out/progress.txt', @@ -204,6 +204,8 @@ def main(): names = [os.path.basename(p) for p in args.files] if len(set(names)) != len(names): ap.error('two files have the same name') + oracle = test_oracle.require(os.path.join(args.lav_dir, 'bin', 'ffmpeg'), + os.path.join(args.lav_dir, 'bin', 'ffprobe')) if args.coreav_cli else None run = {'files': names, 'rounds': args.rounds, 'commands': bool(args.coreav_cli)} up = tempfile.mkdtemp(prefix='ts-speed-upload-') try: @@ -212,6 +214,11 @@ def main(): shutil.copytree(args.lav_dir, os.path.join(up, 'lav'), symlinks=True) if args.coreav_cli: shutil.copy(args.coreav_cli, os.path.join(up, 'coreav')) + for program, name in ((oracle.ffmpeg, 'ffmpeg'), (oracle.ffprobe, 'ffprobe')): + destination = os.path.join(up, 'lav', 'bin', name) + if os.path.islink(destination): + os.unlink(destination) + shutil.copy(program, destination) test_oracle.bundle(up, ['ts_speed.py']) os.makedirs(os.path.join(up, 'files')) for path in args.files: diff --git a/test-support/oracle-dependent.json b/test-support/oracle-dependent.json index 22907e231..5db71a45e 100644 --- a/test-support/oracle-dependent.json +++ b/test-support/oracle-dependent.json @@ -45,8 +45,10 @@ "vp9_hosting_preserves_complete_pixels" ], "crates/coreav-cli/tests/ffmpeg.rs": [ + "av1_video_concat_compares_every_exposed_sample_entry_field_and_packet_byte", "concat_audio_gaps_are_refused_with_exact_pinned_fallback", "contributing_inputs_preserve_complete_packet_order_and_decoded_output", + "copied_video_aac_encoding_preserves_destinations_and_exact_fallback", "copied_video_reconstructs_conflicting_declared_media_durations", "copied_video_refuses_a_later_sample_before_its_first_composition", "cover_selections_agree_with_the_pinned_ffmpeg", @@ -58,6 +60,7 @@ "ordinary_copy_refuses_trimmed_simple_edits", "picture_by_picture_selections_agree_with_the_pinned_ffmpeg", "plain_extraction_metadata_agrees_with_the_pinned_ffmpeg", + "primed_aac_concat_refuses_and_preserves_complete_pinned_fallback", "raw_s16_fifo_refuses_and_preserves_exact_pinned_fallback", "raw_s16_linked_outputs_refuse_and_fall_back_through_the_target", "raw_s16_unwritable_targets_preserve_the_pinned_exit_status", @@ -65,11 +68,19 @@ "stripped_metadata_agrees_with_the_pinned_ffmpeg", "the_0_1_0_commands_on_the_fixtures", "unedited_audiovisual_concat_matches_the_pinned_ffmpeg", - "unedited_video_copy_normalizes_its_origin_without_losing_frames" + "unedited_video_copy_normalizes_its_origin_without_losing_frames", + "unqualified_primed_aac_concat_preserves_outputs_and_real_fallback" ], "crates/coreav-cli/tests/ffmpeg_aac_filter.rs": [ "aac_filter_is_an_exact_concat_identity_or_preserved_fallback" ], + "crates/coreav-cli/tests/ffmpeg_flac.rs": [ + "complete_raw_bytes_match_the_pin_for_files_stdout_and_stdin", + "invalid_reconstructed_ranges_refuse_before_any_output", + "pinned_encoded_frames_and_zero_md5_use_complete_exact_output", + "unsupported_sources_refuse_and_replay_the_real_fallback", + "valid_reconstructed_range_boundaries_match_complete_pinned_bytes" + ], "crates/coreav-cli/tests/ffmpeg_frames.rs": [ "dropping_frames_matches_the_oracles_raw_samples", "image_names_limits_seeking_and_update_are_codec_independent", @@ -100,10 +111,30 @@ "matroska_default_video_encoder_matches_the_explicit_selection", "unsupported_webm_codecs_and_trimming_leave_no_output" ], + "crates/coreav-cli/tests/ffmpeg_mkv_aac_copy.rs": [ + "aac_copy_is_exactly_clocked_or_preserved_fallback", + "one_tick_source_changes_refuse_without_changing_fallback", + "unselected_aac_and_iso_copy_keep_their_native_paths" + ], + "crates/coreav-cli/tests/ffmpeg_mpegts.rs": [ + "automatic_and_explicit_avc_copy_keep_every_packet_clock_and_frame", + "short_transport_outputs_keep_the_qualified_three_sample_boundary", + "unqualified_transport_options_and_sources_preserve_destinations_and_fallback" + ], + "crates/coreav-cli/tests/ffmpeg_pcm.rs": [ + "aac_raw_output_refuses_with_exact_pinned_fallback" + ], + "crates/coreav-cli/tests/ffmpeg_wav.rs": [ + "integer_wav_output_matches_complete_pinned_files", + "wave_wav_stdout_refuses_without_literal_files_and_matches_fallback" + ], "crates/coreav-cli/tests/ffprobe_format_span.rs": [ "format_output_counts_all_cover_picture_streams", "output_span_does_not_change_copy_planning_or_trimmed_bytes" ], + "crates/coreav-cli/tests/ffprobe_stdin.rs": [ + "structured_stdin_and_complete_pinned_replay" + ], "crates/coreav-cli/tests/legacy_encoders.rs": [ "legacy_encoder_choices_keep_media_summaries_errors_and_exit_codes" ], @@ -164,6 +195,15 @@ "resolution_change_fixture_matches_ffmpeg_scale", "test_pictures_match_ffmpeg_scale" ], + "crates/coreav-isobmff-write/src/ts_output/tests.rs": [ + "ts_output::tests::preparation_limits_refuse_instead_of_returning_partial_output", + "ts_output::tests::preparation_nal_and_converted_access_unit_limits_include_the_boundary", + "ts_output::tests::preparation_planning_table_metadata_and_work_ceiling_edges_preserve_output", + "ts_output::tests::preparation_refuses_noncanonical_avc_configuration_and_parameter_set_headers", + "ts_output::tests::preparation_refuses_parser_readable_cadence_and_composition_mutations", + "ts_output::tests::preparation_rejects_first_and_late_malformed_samples_before_sealing", + "ts_output::tests::sealed_preparation_owns_bytes_and_propagates_capture_and_sink_failures" + ], "crates/coreav-isobmff-write/tests/replace.rs": [ "fixtures_present_as_the_plain_remux" ], @@ -179,9 +219,6 @@ "the_minimum_gop_length_is_the_one_x264_chooses", "thirty_frames_come_out" ], - "crates/coreav-transcode/tests/sandboxed.rs": [ - "real encoders through the launcher" - ], "crates/coreav-transcode/tests/encoders.rs": [ "ffmpeg_libx264_high10", "ffmpeg_libx264_medium", @@ -198,6 +235,9 @@ "x264_sixteen_b_frames", "x264_ultrafast" ], + "crates/coreav-transcode/tests/sandboxed.rs": [ + "real encoders through the launcher" + ], "crates/coreav-worker/tests/ffmpeg.rs": [ "fallback_through_the_worker_matches_ffmpeg", "frames_come_while_no_packet_does", @@ -208,12 +248,5 @@ "tools/decode-oracle/tests/stream.rs": [ "a_stream_outside_the_decoder_fails_at_open_with_exit_1", "frames_equal_framemd5" - ], - "crates/coreav-cli/tests/ffmpeg_pcm.rs": [ - "aac_raw_output_refuses_with_exact_pinned_fallback" - ], - "crates/coreav-cli/tests/ffmpeg_wav.rs": [ - "integer_wav_output_matches_complete_pinned_files", - "wave_wav_stdout_refuses_without_literal_files_and_matches_fallback" ] } diff --git a/test-support/oracle.rs b/test-support/oracle.rs index e670880b4..eaa4748f1 100644 --- a/test-support/oracle.rs +++ b/test-support/oracle.rs @@ -1,9 +1,18 @@ #![allow(dead_code, clippy::panic)] +use std::io::{Read, Write}; use std::path::{Path, PathBuf}; use std::process::Command; use std::sync::OnceLock; +struct Support(PathBuf); + +impl Drop for Support { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } +} + pub struct Oracle { ffmpeg: PathBuf, ffprobe: PathBuf, @@ -20,11 +29,105 @@ impl Oracle { } pub fn require() -> &'static Oracle { + match try_require() { + Ok(oracle) => oracle, + Err(error) => panic!("{error}"), + } +} + +pub fn try_require() -> Result<&'static Oracle, String> { static ORACLE: OnceLock> = OnceLock::new(); let result = ORACLE.get_or_init(|| { + if !cfg!(any(target_os = "linux", target_os = "macos")) { + return Err("no registered oracle for this platform".into()); + } + let mut nonce = [0u8; 16]; + std::fs::File::open("/dev/urandom") + .and_then(|mut file| file.read_exact(&mut nonce)) + .map_err(|error| format!("cannot create oracle support identity: {error}"))?; + let directory = std::env::temp_dir().join(format!( + "coreav-oracle-{}-{:032x}", + std::process::id(), + u128::from_ne_bytes(nonce) + )); + #[cfg(unix)] + let builder = { + use std::os::unix::fs::DirBuilderExt; + let mut builder = std::fs::DirBuilder::new(); + builder.mode(0o700); + builder + }; + #[cfg(not(unix))] + let builder = std::fs::DirBuilder::new(); + builder + .create(&directory) + .map_err(|error| format!("cannot create oracle support directory: {error}"))?; + let support = Support(directory); + let scripts = support.0.join("scripts"); + std::fs::create_dir(&scripts) + .map_err(|error| format!("cannot create oracle scripts directory: {error}"))?; + for (name, source) in [ + ( + "test_oracle.py", + include_str!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../scripts/test_oracle.py" + )), + ), + ( + "oracle_pin.py", + include_str!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../scripts/oracle_pin.py" + )), + ), + ( + "oracle_pin_macos.py", + include_str!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../scripts/oracle_pin_macos.py" + )), + ), + ( + "oracle_audio.py", + include_str!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../scripts/oracle_audio.py" + )), + ), + ( + "oracle-ffmpeg.env", + include_str!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../scripts/oracle-ffmpeg.env" + )), + ), + ( + "oracle-ffmpeg-macos.env", + include_str!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../scripts/oracle-ffmpeg-macos.env" + )), + ), + ( + "oracle-audio-args.txt", + include_str!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/../../scripts/oracle-audio-args.txt" + )), + ), + ] { + std::fs::OpenOptions::new() + .write(true) + .create_new(true) + .open(scripts.join(name)) + .and_then(|mut file| file.write_all(source.as_bytes())) + .map_err(|error| format!("cannot stage oracle support file {name}: {error}"))?; + } let result = Command::new("python3") .arg("-I") - .arg(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../scripts/test_oracle.py")) + .arg("-B") + .arg(scripts.join("test_oracle.py")) .arg("--resolve") .output() .map_err(|error| format!("cannot start oracle verifier: {error}"))?; @@ -45,7 +148,7 @@ pub fn require() -> &'static Oracle { }) }); match result { - Ok(oracle) => oracle, - Err(error) => panic!("stage=oracle_qualification: {error}"), + Ok(oracle) => Ok(oracle), + Err(error) => Err(format!("stage=oracle_qualification: {error}")), } } diff --git a/tools/compat-corpus/frames.py b/tools/compat-corpus/frames.py index 9d4c16751..dbd4c6471 100644 --- a/tools/compat-corpus/frames.py +++ b/tools/compat-corpus/frames.py @@ -154,7 +154,8 @@ def main(): ap.add_argument('--report') ap.add_argument('--jobs', type=int, default=os.cpu_count() or 4) opts = ap.parse_args() - opts.ffprobe = str(test_oracle.require(pathlib.Path(opts.ffprobe).with_name('ffmpeg'), opts.ffprobe).ffprobe) + probe = test_oracle.executable_path(opts.ffprobe) + opts.ffprobe = str(test_oracle.require(probe.with_name('ffmpeg'), probe).ffprobe) native = NATIVE | ({f'h264 {f}' for f in H264_PIX_FMTS} if opts.native_h264 else set()) files = media_files(opts.media) names = set() diff --git a/tools/compat-corpus/tests/test_current_ci.py b/tools/compat-corpus/tests/test_current_ci.py index 68f73e869..48275ae69 100644 --- a/tools/compat-corpus/tests/test_current_ci.py +++ b/tools/compat-corpus/tests/test_current_ci.py @@ -347,12 +347,8 @@ def reference_command(argv, env, cwd): class PinnedOracle(unittest.TestCase): @classmethod def setUpClass(cls): - cls.ffmpeg, cls.ffprobe = shutil.which('ffmpeg'), shutil.which('ffprobe') - if not cls.ffmpeg or not cls.ffprobe: - raise AssertionError('fixture CI must install the pinned oracle') - problems = list(current_ci.test_oracle.verify_bin(pathlib.Path(cls.ffmpeg).parent)) - if problems: - raise AssertionError(problems) + oracle = current_ci.test_oracle.require() + cls.ffmpeg, cls.ffprobe = str(oracle.ffmpeg), str(oracle.ffprobe) cls.env = {'PATH': os.environ.get('PATH', ''), 'GCONV_PATH': '/nonexistent/gconv'} def wav(self, path, samples, junk=False): diff --git a/tools/compat-corpus/tests/test_decode_breadth.py b/tools/compat-corpus/tests/test_decode_breadth.py index 9c7162bdd..b93ccbf1e 100644 --- a/tools/compat-corpus/tests/test_decode_breadth.py +++ b/tools/compat-corpus/tests/test_decode_breadth.py @@ -79,6 +79,7 @@ def failure(stage, kind, message, sent=3): return {'stage': stage, 'kind': kind, 'message': message, 'packets_sent': sent} +@unittest.skipUnless(sys.platform == 'linux', 'Linux banner-only stand-in qualification') class Harness(unittest.TestCase): def setUp(self): self.dir = pathlib.Path(tempfile.mkdtemp(prefix='decode-breadth-')) diff --git a/tools/compat-corpus/tests/test_decode_breadth_fixtures.py b/tools/compat-corpus/tests/test_decode_breadth_fixtures.py index 677b2a207..5f63eb8bc 100644 --- a/tools/compat-corpus/tests/test_decode_breadth_fixtures.py +++ b/tools/compat-corpus/tests/test_decode_breadth_fixtures.py @@ -134,7 +134,8 @@ class UnconvertedReference(unittest.TestCase): @classmethod def setUpClass(cls): - cls.ffmpeg = str(test_oracle.require(PROGRAMS['ffmpeg'], PROGRAMS['ffprobe']).ffmpeg) + oracle = test_oracle.require(PROGRAMS['ffmpeg'], PROGRAMS['ffprobe']) + cls.ffmpeg, cls.ffprobe = str(oracle.ffmpeg), str(oracle.ffprobe) cls.dir = pathlib.Path(tempfile.mkdtemp(prefix='decode-breadth-unconverted-')) (cls.dir / 'gconv').mkdir() cls.env = {'PATH': os.environ.get('PATH', ''), 'HOME': os.environ.get('HOME', ''), @@ -231,7 +232,7 @@ def test_a_stream_without_a_change_keeps_its_md5s(self): def pix_fmt(self, path): - done = subprocess.run([PROGRAMS['ffprobe'], '-v', 'error', '-select_streams', 'v:0', '-show_entries', + done = subprocess.run([self.ffprobe, '-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=pix_fmt', '-of', 'csv=p=0', str(path)], capture_output=True, text=True, env=self.env) self.assertEqual(done.returncode, 0, done.stderr) @@ -242,8 +243,6 @@ def test_the_alpha_path_never_reaches_a_codec_v1_counts(self): is still converted to the first frame's format without alpha. That path is taken only where ffprobe lists an alpha format: VP9 and VP8 with alpha are listed without it, while an alpha codec where the change is converted, ProRes, is in group other, which misses as codec_not_in_build before any MD5 is compared.""" - if not PROGRAMS['ffprobe']: - self.skipTest('COREAV_FFPROBE is not set') for name, encoder in (('vp9', ['-c:v', 'libvpx-vp9']), ('vp8', ['-c:v', 'libvpx'])): path = self.dir / f'{name}_alpha.webm' self.ff(*self.source(64, 48, 0), '-pix_fmt', 'yuva420p', *encoder, '-auto-alt-ref', '0', str(path)) diff --git a/tools/compat-corpus/tests/test_encode_breadth.py b/tools/compat-corpus/tests/test_encode_breadth.py index 6f8c86234..c1ffb0af3 100644 --- a/tools/compat-corpus/tests/test_encode_breadth.py +++ b/tools/compat-corpus/tests/test_encode_breadth.py @@ -948,6 +948,7 @@ def pinned_stand_ins(self): pathlib.Path(getattr(self.opts, name)).write_text( f'#!{sys.executable}\nprint({name + " version " + build!r})\n') + @unittest.skipUnless(sys.platform == 'linux', 'Linux banner-only stand-in qualification') def test_preflight_records_the_supplied_pinned_executables(self): self.pinned_stand_ins() program = ('import sys, json, types; sys.path.insert(0, sys.argv[1]); ' diff --git a/tools/compat-corpus/tests/test_r4_scan.py b/tools/compat-corpus/tests/test_r4_scan.py index ad3995616..cf7db859a 100644 --- a/tools/compat-corpus/tests/test_r4_scan.py +++ b/tools/compat-corpus/tests/test_r4_scan.py @@ -49,6 +49,7 @@ def refuse(reason): ''' +@unittest.skipUnless(sys.platform == 'linux', 'Linux banner-only stand-in qualification') class Scan(unittest.TestCase): @classmethod def setUpClass(cls): diff --git a/tools/decode-oracle/src/main.rs b/tools/decode-oracle/src/main.rs index 67602c3c4..a031bc8b6 100644 --- a/tools/decode-oracle/src/main.rs +++ b/tools/decode-oracle/src/main.rs @@ -165,7 +165,7 @@ fn run(args: &[String]) -> Result { }); worker.transfer = transfer; if !native && backend == WorkerBackend::Ffmpeg { - worker.ffmpeg = Some(test_oracle::require().ffmpeg().to_path_buf()); + worker.ffmpeg = Some(test_oracle::try_require()?.ffmpeg().to_path_buf()); } // The worker options' cap would otherwise hold the budget below it. if max_memory.is_some() { @@ -191,7 +191,7 @@ fn run(args: &[String]) -> Result { } else if in_process && backend == WorkerBackend::Libvpx { in_process_libvpx(&stream, &options.decode_limits)? } else if in_process { - let program = test_oracle::require().ffmpeg().to_path_buf(); + let program = test_oracle::try_require()?.ffmpeg().to_path_buf(); let options = coreav_backend_ffmpeg::FfmpegOptions { program, threads: None, @@ -334,7 +334,8 @@ fn run_thumbnail(args: &[String]) -> Result { backend, options: WorkerOptions { ffmpeg: (backend == WorkerBackend::Ffmpeg && !in_process) - .then(|| test_oracle::require().ffmpeg().to_path_buf()), + .then(|| test_oracle::try_require().map(|oracle| oracle.ffmpeg().to_path_buf())) + .transpose()?, ..WorkerOptions::new(WorkerCommand { program, args: vec![coreav_worker::WORKER_ARG.into()], diff --git a/tools/mediainfo-oracle/corpus.py b/tools/mediainfo-oracle/corpus.py index 99e851c1e..64c1f8734 100644 --- a/tools/mediainfo-oracle/corpus.py +++ b/tools/mediainfo-oracle/corpus.py @@ -66,9 +66,9 @@ def failed(name): return {'schema': 'coreav-oracle/streams/1', 'file': name, 'probe_ok': False} -def oracle_adapter(command, name): +def oracle_adapter(command, name, env=None): try: - done = subprocess.run(command, capture_output=True, timeout=TIMEOUT, check=False) + done = subprocess.run(command, capture_output=True, timeout=TIMEOUT, check=False, env=env) except subprocess.TimeoutExpired: return failed(name) if done.returncode != 0 or not done.stdout.strip(): @@ -105,7 +105,8 @@ def process(entry, args, env, endpoint): if done.returncode != 0: return 'download-failed' records = { - 'ffprobe': oracle_adapter([str(ROOT / 'scripts' / 'oracle-ffprobe.sh'), 'streams', str(media)], name), + 'ffprobe': oracle_adapter([str(ROOT / 'scripts' / 'oracle-ffprobe.sh'), 'streams', str(media)], name, + env=dict(os.environ, FFMPEG=str(args.oracle.ffmpeg), FFPROBE=str(args.oracle.ffprobe))), 'coreav': oracle_adapter([args.adapter, 'streams', str(media)], name), 'mediainfo': mo.capture_one(args.mediainfo, media, name), } @@ -138,7 +139,7 @@ def provenance(args): """What produced the captures. Binaries and versions must match to reuse captures.""" git = subprocess.run(['git', '-C', str(ROOT), 'describe', '--always', '--dirty', '--abbrev=12'], capture_output=True, text=True, check=False).stdout.strip() or None - ffprobe = os.environ.get('FFPROBE', 'ffprobe') + ffprobe = str(args.oracle.ffprobe) return { 'binaries': { 'mediainfo': first_line([args.mediainfo, '--Version']), @@ -174,8 +175,7 @@ def check_provenance(captures, current): def cmd_run(args): - probe = pathlib.Path(os.environ.get('FFPROBE', 'ffprobe')) - test_oracle.require(probe.with_name('ffmpeg'), probe) + args.oracle = test_oracle.require(os.environ.get('FFMPEG'), os.environ.get('FFPROBE')) entries = select(args.manifest, args.split, args.set.split(',')) if args.limit: entries = entries[:args.limit] diff --git a/tools/mediarecorder/generate.py b/tools/mediarecorder/generate.py index 38f0133c2..b3c97e6db 100644 --- a/tools/mediarecorder/generate.py +++ b/tools/mediarecorder/generate.py @@ -171,7 +171,7 @@ def kill(proc): def ffprobe(path): p = subprocess.run( - [str(test_oracle.require('ffmpeg', 'ffprobe').ffprobe), "-v", "error", "-show_streams", "-show_format", "-of", "json", str(path)], + [str(test_oracle.require().ffprobe), "-v", "error", "-show_streams", "-show_format", "-of", "json", str(path)], capture_output=True, text=True) info = {"exit": p.returncode, "stderr": p.stderr.strip()[:2000], "codecs": []} try: @@ -241,7 +241,7 @@ def main(): ap.add_argument("--chrome", default="google-chrome") ap.add_argument("--only", help="comma-separated config names to run") args = ap.parse_args() - test_oracle.require('ffmpeg', 'ffprobe') + test_oracle.require() args.out.mkdir(parents=True, exist_ok=True) matrix = MATRIX diff --git a/tools/mkv-adapter/bench.py b/tools/mkv-adapter/bench.py index 12a1d5b96..ea34e02cf 100644 --- a/tools/mkv-adapter/bench.py +++ b/tools/mkv-adapter/bench.py @@ -69,17 +69,17 @@ def main(): parser.add_argument('--coreav', default=str(ROOT / 'target' / 'release' / 'coreav')) parser.add_argument('--adapter', default=str(ROOT / 'target' / 'release' / 'mkv-adapter')) args = parser.parse_args() - test_oracle.require('ffmpeg', 'ffprobe') + oracle = test_oracle.require() files = sorted(p for d in args.media for p in pathlib.Path(d).iterdir() if p.suffix in ('.mkv', '.webm')) rows = [] for path in files: rows.append({ 'size': path.stat().st_size, - 'ffprobe_probe': timed(['ffprobe', '-v', 'error', '-of', 'json', '-show_format', '-show_streams', + 'ffprobe_probe': timed([str(oracle.ffprobe), '-v', 'error', '-of', 'json', '-show_format', '-show_streams', str(path)], args.repeat), 'coreav_probe': timed([args.coreav, 'probe', str(path)], args.repeat), - 'ffprobe_demux': timed(['ffprobe', '-v', 'error', '-count_packets', '-show_entries', + 'ffprobe_demux': timed([str(oracle.ffprobe), '-v', 'error', '-count_packets', '-show_entries', 'stream=nb_read_packets', '-of', 'csv=p=0', str(path)], args.repeat), 'coreav_demux': timed([args.adapter, 'count', str(path)], args.repeat), }) diff --git a/tools/mkv-adapter/corpus.py b/tools/mkv-adapter/corpus.py index daff20639..51b70e920 100644 --- a/tools/mkv-adapter/corpus.py +++ b/tools/mkv-adapter/corpus.py @@ -92,11 +92,11 @@ def sha256_file(path): return digest.hexdigest() -def capture(command, name, level, out_path): +def capture(command, name, level, out_path, env=None): """Runs an adapter; writes its document or a failure record; returns the run record.""" started = time.monotonic() try: - done = subprocess.run(command, capture_output=True, timeout=TIMEOUT, check=False) + done = subprocess.run(command, capture_output=True, timeout=TIMEOUT, check=False, env=env) status, stdout, stderr = done.returncode, done.stdout, done.stderr except subprocess.TimeoutExpired: status, stdout, stderr = 'timeout', b'', b'' @@ -140,7 +140,8 @@ def process(entry, args, env, endpoint): for level in LEVELS: record['runs'][f'ffprobe.{level}'] = capture( [str(ROOT / 'scripts' / 'oracle-ffprobe.sh'), level, str(media)], name, level, - out / 'reference' / f'{name}.{level}.json') + out / 'reference' / f'{name}.{level}.json', + env=dict(os.environ, FFMPEG=str(args.oracle.ffmpeg), FFPROBE=str(args.oracle.ffprobe))) mediainfo = mo.capture_one(args.mediainfo, media, name) (out / 'mediainfo' / f'{name}.mediainfo.json').write_text(json.dumps(mediainfo) + '\n') # A new capture makes this file's old comparison stale. @@ -157,8 +158,8 @@ def process(entry, args, env, endpoint): def cmd_run(args): - probe = pathlib.Path(os.environ.get('FFPROBE', 'ffprobe')) - ffprobe = str(test_oracle.require(probe.with_name('ffmpeg'), probe).ffprobe) + args.oracle = test_oracle.require(os.environ.get('FFMPEG'), os.environ.get('FFPROBE')) + ffprobe = str(args.oracle.ffprobe) out = pathlib.Path(args.out) for sub in ('reference', 'candidate', 'mediainfo', 'runs'): (out / sub).mkdir(parents=True, exist_ok=True) diff --git a/tools/mkv-adapter/remux_corpus.py b/tools/mkv-adapter/remux_corpus.py index 4fde435f9..45a4fb331 100644 --- a/tools/mkv-adapter/remux_corpus.py +++ b/tools/mkv-adapter/remux_corpus.py @@ -124,6 +124,23 @@ def run_rusage(command, helper): 'max_rss_kib': int(text) if text else None}, stdout, stderr +def check_with_oracle(source, output, document, mediainfo, oracle): + with tempfile.TemporaryDirectory(prefix='remux-oracle-') as directory: + root = pathlib.Path(directory) + for name, program in (('ffmpeg', oracle.ffmpeg), ('ffprobe', oracle.ffprobe)): + (root / name).symlink_to(program) + summary = root / 'summary.json' + summary.write_text(json.dumps(document)) + command = [sys.executable, '-I', str(checker.__file__), 'check', str(source), str(output), str(summary)] + if mediainfo: + command += ['--mediainfo', mediainfo] + env = dict(os.environ, PATH=str(root) + os.pathsep + os.environ.get('PATH', '')) + done = subprocess.run(command, env=env, capture_output=True, timeout=TIMEOUT, check=False) + if done.returncode not in (0, 1): + raise RuntimeError('remux checker failed: ' + done.stderr.decode('utf-8', 'replace')) + return json.loads(done.stdout) + + def process(entry, args, env, endpoint, disk): out = pathlib.Path(args.out) name = entry['name'] @@ -175,14 +192,14 @@ def process(entry, args, env, endpoint, disk): record['dropped_additions'] = len(document['dropped_boxes']) + document['dropped_boxes_not_listed'] record['truncated'] = document['source'].get('truncated_at') is not None record['output_bytes'] = document['output']['bytes'] - result = checker.check(media, output, document, args.mediainfo) + result = check_with_oracle(media, output, document, args.mediainfo, args.oracle) record['check'] = {'ok': result['ok'], 'packets_ok': result['packets_ok'], 'packets_total': result['packets_total'], 'fields': sorted({p['field'] for p in result['problems']}), 'problems': result['problems'][:5]} output.unlink(missing_ok=True) # The same streams through FFmpeg, for time and memory only. - command = ['ffmpeg', '-nostdin', '-v', 'error', '-y', '-i', str(media)] + command = [str(args.oracle.ffmpeg), '-nostdin', '-v', 'error', '-y', '-i', str(media)] for stream in document['streams']: command += ['-map', f"0:{stream['stream_index']}"] command += ['-c', 'copy', '-movflags', '+faststart', str(reference)] @@ -208,7 +225,7 @@ def process(entry, args, env, endpoint, disk): def cmd_run(args): - test_oracle.require('ffmpeg', os.environ.get('FFPROBE', 'ffprobe')) + args.oracle = test_oracle.require(os.environ.get('FFMPEG'), os.environ.get('FFPROBE')) out = pathlib.Path(args.out) (out / 'runs').mkdir(parents=True, exist_ok=True) pathlib.Path(args.work).mkdir(parents=True, exist_ok=True) diff --git a/tools/ts-speed/build-lav.sh b/tools/ts-speed/build-lav.sh index 64a0bda43..09805109f 100755 --- a/tools/ts-speed/build-lav.sh +++ b/tools/ts-speed/build-lav.sh @@ -6,7 +6,7 @@ # tools/ts-speed/build-lav.sh DEST # # Downloads the archive, checks its SHA-256, keeps only its libraries, its -# license and its ffprobe (DEST/bin/ffprobe, for the command arms of +# license and its ffmpeg/ffprobe pair (DEST/bin/, for the command arms of # scripts/ts_speed.py), and writes DEST/lav_ts, which finds its libraries in # DEST/lib (an rpath relative to the binary, as the build's ffprobe has, so # DEST can be copied to another host as it is). The headers are used for @@ -27,11 +27,11 @@ WORK=$(mktemp -d) trap 'rm -rf "$WORK"' EXIT curl --fail --location --retry 5 --retry-delay 10 --connect-timeout 20 --max-time 600 -o "$WORK/a.tar.xz" "${URL%/*}/$NAME.tar.xz" echo "$LAV_SHA256 $WORK/a.tar.xz" | sha256sum -c - -tar -xJf "$WORK/a.tar.xz" -C "$WORK" "$NAME/include" "$NAME/lib" "$NAME/LICENSE.txt" "$NAME/bin/ffprobe" +tar -xJf "$WORK/a.tar.xz" -C "$WORK" "$NAME/include" "$NAME/lib" "$NAME/LICENSE.txt" "$NAME/bin/ffmpeg" "$NAME/bin/ffprobe" rm -rf "$DEST/lib" "$DEST/include" "$DEST/bin" mkdir "$DEST/bin" mv "$WORK/$NAME/include" "$WORK/$NAME/lib" "$WORK/$NAME/LICENSE.txt" "$DEST/" -mv "$WORK/$NAME/bin/ffprobe" "$DEST/bin/" +mv "$WORK/$NAME/bin/ffmpeg" "$WORK/$NAME/bin/ffprobe" "$DEST/bin/" rm -rf "$DEST/lib/pkgconfig" gcc -O2 -Wall -Werror -DPINNED="\"$BUILD\"" -o "$DEST/lav_ts" "$HERE/lav_ts.c" -I"$DEST/include" -L"$DEST/lib" \ -lavformat -lavcodec -lavutil -Wl,-rpath-link,"$DEST/lib" -Wl,--disable-new-dtags,-rpath,'$ORIGIN/lib' From 30ccef49d9428a2f3c12cc7dbf921b9ff18678ca Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 17:31:01 +0000 Subject: [PATCH 16/21] fix(ffmpeg): use file-relative oracle support Signed-off-by: gunwooterry --- docs/agents/ffmpeg-cli.md | 2 +- .../oracle-invocation-dispositions.json | 4 +- scripts/tests/test_test_oracle.py | 9 ++-- test-support/oracle.rs | 41 ++++--------------- 4 files changed, 15 insertions(+), 41 deletions(-) diff --git a/docs/agents/ffmpeg-cli.md b/docs/agents/ffmpeg-cli.md index d23264a53..ecf270dde 100644 --- a/docs/agents/ffmpeg-cli.md +++ b/docs/agents/ffmpeg-cli.md @@ -53,7 +53,7 @@ CLI and ffprobe behavior, the FFmpeg pin, and fallback names. | Migrated comparisons use the shared FFmpeg pin; the historical training extractor stays isolated | `test_oracle.require` owns migrated selection and cached success/failure through the unchanged platform verifier; the Rust adapter shares one `OnceLock` per test process. Owner/cache contracts, actual wrong-pin whole-suite failures and pinned passes cover missing, partial, renamed and unverified selections. Frozen consumers retain workflow verification; their immutable closure prevents deleting the old verifier API. `oracle_pin.py --check` keeps historical-extractor references isolated. Types cannot establish an external executable's version | | Invocation classifications do not treat owner imports, executable names or unbound value-flow hints as qualification proof | `oracle_invocation_classify.py` owns source-bound call-pattern dispositions and fails on unmatched locations or changed inputs. Shadowing, executable overrides, changed dependencies and extensionless additions invalidate the prior snapshot in `test_oracle_invocation_classify.py`. One disposition owner avoids divergent verdicts; cross-language types cannot establish dynamic executable provenance | | Relocated oracle consumers retain the shared owner, its unchanged pins and their local imports | `test_oracle.bundle` copies the transitive Python closure into its normal `scripts` layout with the common support files. The relocated-bundle regression qualifies a fresh process against the copied pin and checks imported helper bytes; remote runner tests cover the complete pair and unchanged launch contracts. A path alone cannot establish a copied file's identity | -| The relocated decode adapter qualifies without its build checkout and returns a structured qualification error instead of panicking | `try_require` retains the cached result while the embedded support owner stages its complete closure in an exclusive private directory with cleanup. The Rust compiler regression removes the build sources before checking positive, negative, cached and native-only paths. A build-time path type cannot establish runtime file availability | +| The relocated decode adapter qualifies without its build checkout and returns a structured qualification error instead of panicking | `try_require` retains the cached result while the embedded support owner stages its complete closure in an exclusive private directory with cleanup. File-relative literal includes make that closure independent of the consuming crate and readable by the similarity guard; the complete-set regression rejects a nonliteral include. The Rust compiler regression removes the build sources before checking positive, negative, cached and native-only paths. A build-time path type cannot establish runtime file availability | | Probe-only selectors derive the sibling from the resolved executable, and remux checks execute the retained pair | `test_oracle.executable_path` owns name resolution before sibling selection. The split-PATH regression exercises the policy, frame and TS entry points; the remux subprocess regression runs the unchanged registered checker through a private directory containing only links to the qualified pair. Runtime PATH contents cannot be constrained by a path type | | Standalone audio parity executes the native command with global strict-safe mode, rather than allowing fallback to satisfy equality | `standalone_audio_probe_check.py` owns the command and strict-safe environment; its command-capture regression requires `--strict-safe` before `ffprobe`, and real generated default/JSON comparisons run in `ci.yml`. A mocked subprocess alone cannot prove the command parses | | The fallback name lists match the pinned FFmpeg listings and CoreAV's printed keys, not boolean match-return values | `scripts/fallback_names.py --check DIR` in `ci.yml`'s `check` job fails on drift and names the regeneration command; `test_boolean_match_values_are_not_printed_keys` rejects stereo and unit values without dropping boolean field names | diff --git a/docs/design/oracle-invocation-dispositions.json b/docs/design/oracle-invocation-dispositions.json index ff2158a50..09574df65 100644 --- a/docs/design/oracle-invocation-dispositions.json +++ b/docs/design/oracle-invocation-dispositions.json @@ -6,7 +6,7 @@ "scripts/oracle_pin.py": "b221378b054a6e6bae92051ae4e4e4fa1add451213f28e888825fa6e43f2f909", "scripts/oracle_pin_macos.py": "70c0f515b3a58cf6b6d2d11938b537b2e8824f0fafbfe6ab9578669c1d857879", "scripts/test_oracle.py": "e16c34d603508ece64cb5e05ae926426080f44cb1031a49089213c663671db99", - "test-support/oracle.rs": "211e259aecbff14c6b0d0246f0157e90935be97fa2a7dd0e0d15c24686530230" + "test-support/oracle.rs": "3559a8f47cbec57f10bd7e27f254217b226fb5d4b9b4a9e4a5b387660a91ffce" }, "frozen": { ".github/workflows/compat-0.1.0.yml": "b979061433995d3a504edddac660216fefbdef556080967f7facf76c89eb1a80", @@ -1624,7 +1624,7 @@ } ], "schema": 1, - "source_snapshot_sha256": "b81605c40a50b3231bc6e688a8503a078f1e2848f64143407d8ad66c5b991c3d", + "source_snapshot_sha256": "5ba25fa418a30192433eed530ef204d1cc33f38183c9fe5cf6df46de63df11af", "sources": { "crates/coreav-audio/tests/flac_encode.rs": "6b63b16444965850c74da0651859128602a9093fe487a15865f8a82093bf6880", "crates/coreav-backend-dav1d/tests/decode.rs": "9094fa0b3a4957d348e9b92420c658fda930329cac3b9c2da17e5c3248e0e791", diff --git a/scripts/tests/test_test_oracle.py b/scripts/tests/test_test_oracle.py index 6f70d08b7..a3680cb32 100644 --- a/scripts/tests/test_test_oracle.py +++ b/scripts/tests/test_test_oracle.py @@ -154,7 +154,8 @@ def test_relocated_bundle_keeps_the_same_pin_and_complete_import_closure(self): def test_rust_adapter_embeds_the_complete_owner_support_set(self): source = (ROOT / 'test-support/oracle.rs').read_text() - embedded = set(re.findall(r'"/../../scripts/([^\"]+)"', source)) + embedded = set(re.findall(r'"\.\./scripts/([^\"]+)"', source)) + self.assertEqual(len(re.findall(r'\binclude_str!\(', source)), len(embedded)) self.assertEqual(embedded, set(test_oracle.SUPPORT)) root = self.root / 'embedded' test_oracle.bundle(root, []) @@ -166,9 +167,10 @@ def test_rust_adapter_qualifies_without_build_sources_and_retains_both_results(s manifest = build / 'crates/probe' manifest.mkdir(parents=True) test_oracle.bundle(build, []) - shutil.copy(ROOT / 'test-support/oracle.rs', manifest / 'oracle.rs') + (build / 'test-support').mkdir() + shutil.copy(ROOT / 'test-support/oracle.rs', build / 'test-support/oracle.rs') source = manifest / 'main.rs' - source.write_text('mod oracle;\nfn main() {\n' + source.write_text('#[path = "../../test-support/oracle.rs"] mod oracle;\nfn main() {\n' 'let mode = std::env::args().nth(1).unwrap();\n' 'if mode == "native" { return; }\n' 'for _ in 0..2 {\n' @@ -178,7 +180,6 @@ def test_rust_adapter_qualifies_without_build_sources_and_retains_both_results(s '}\n}\n') binary = self.root / 'relocated' made = subprocess.run(['rustc', '--edition=2024', str(source), '-o', str(binary)], - env=dict(os.environ, CARGO_MANIFEST_DIR=str(manifest)), capture_output=True, text=True, timeout=60) self.assertEqual(made.returncode, 0, made.stderr) shutil.rmtree(build) diff --git a/test-support/oracle.rs b/test-support/oracle.rs index eaa4748f1..a7727bd26 100644 --- a/test-support/oracle.rs +++ b/test-support/oracle.rs @@ -67,54 +67,27 @@ pub fn try_require() -> Result<&'static Oracle, String> { std::fs::create_dir(&scripts) .map_err(|error| format!("cannot create oracle scripts directory: {error}"))?; for (name, source) in [ - ( - "test_oracle.py", - include_str!(concat!( - env!("CARGO_MANIFEST_DIR"), - "/../../scripts/test_oracle.py" - )), - ), - ( - "oracle_pin.py", - include_str!(concat!( - env!("CARGO_MANIFEST_DIR"), - "/../../scripts/oracle_pin.py" - )), - ), + ("test_oracle.py", include_str!("../scripts/test_oracle.py")), + ("oracle_pin.py", include_str!("../scripts/oracle_pin.py")), ( "oracle_pin_macos.py", - include_str!(concat!( - env!("CARGO_MANIFEST_DIR"), - "/../../scripts/oracle_pin_macos.py" - )), + include_str!("../scripts/oracle_pin_macos.py"), ), ( "oracle_audio.py", - include_str!(concat!( - env!("CARGO_MANIFEST_DIR"), - "/../../scripts/oracle_audio.py" - )), + include_str!("../scripts/oracle_audio.py"), ), ( "oracle-ffmpeg.env", - include_str!(concat!( - env!("CARGO_MANIFEST_DIR"), - "/../../scripts/oracle-ffmpeg.env" - )), + include_str!("../scripts/oracle-ffmpeg.env"), ), ( "oracle-ffmpeg-macos.env", - include_str!(concat!( - env!("CARGO_MANIFEST_DIR"), - "/../../scripts/oracle-ffmpeg-macos.env" - )), + include_str!("../scripts/oracle-ffmpeg-macos.env"), ), ( "oracle-audio-args.txt", - include_str!(concat!( - env!("CARGO_MANIFEST_DIR"), - "/../../scripts/oracle-audio-args.txt" - )), + include_str!("../scripts/oracle-audio-args.txt"), ), ] { std::fs::OpenOptions::new() From de75b9b92313ac4788b91995bc7c5a373574a9b0 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 17:39:11 +0000 Subject: [PATCH 17/21] fix(ffmpeg): qualify FLAC tests per platform Signed-off-by: gunwooterry --- crates/coreav-cli/tests/ffmpeg_flac.rs | 22 ++------ docs/agents/ffmpeg-cli.md | 1 + docs/design/local-oracle-qualification.md | 2 +- .../oracle-invocation-dispositions.json | 53 +------------------ 4 files changed, 7 insertions(+), 71 deletions(-) diff --git a/crates/coreav-cli/tests/ffmpeg_flac.rs b/crates/coreav-cli/tests/ffmpeg_flac.rs index b3fb3e082..376ea7f9b 100644 --- a/crates/coreav-cli/tests/ffmpeg_flac.rs +++ b/crates/coreav-cli/tests/ffmpeg_flac.rs @@ -9,6 +9,9 @@ use std::process::{Command, Output, Stdio}; #[path = "../../coreav-audio/tests/support/flac_ranges.rs"] mod flac_ranges; +#[path = "../../../test-support/oracle.rs"] +mod test_oracle; + fn scratch(name: &str) -> PathBuf { let tag = std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) @@ -116,24 +119,7 @@ fn success(result: &Output) { } fn pin() -> Option { - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| PathBuf::from("/opt/coreav-oracle-bin/ffmpeg")); - if !ffmpeg.is_file() { - assert!( - std::env::var_os("CI").is_none() && std::env::var_os("COREAV_REQUIRE_FFMPEG").is_none(), - "set COREAV_FFMPEG to the pin" - ); - return None; - } - let verified = Command::new("python3") - .arg(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../scripts/oracle_pin.py")) - .arg("--verify-bin") - .arg(ffmpeg.parent().unwrap()) - .output() - .unwrap(); - assert!(verified.status.success(), "{verified:?}"); - Some(ffmpeg) + Some(test_oracle::require().ffmpeg().to_path_buf()) } #[test] diff --git a/docs/agents/ffmpeg-cli.md b/docs/agents/ffmpeg-cli.md index ecf270dde..ca578ec73 100644 --- a/docs/agents/ffmpeg-cli.md +++ b/docs/agents/ffmpeg-cli.md @@ -55,6 +55,7 @@ CLI and ffprobe behavior, the FFmpeg pin, and fallback names. | Relocated oracle consumers retain the shared owner, its unchanged pins and their local imports | `test_oracle.bundle` copies the transitive Python closure into its normal `scripts` layout with the common support files. The relocated-bundle regression qualifies a fresh process against the copied pin and checks imported helper bytes; remote runner tests cover the complete pair and unchanged launch contracts. A path alone cannot establish a copied file's identity | | The relocated decode adapter qualifies without its build checkout and returns a structured qualification error instead of panicking | `try_require` retains the cached result while the embedded support owner stages its complete closure in an exclusive private directory with cleanup. File-relative literal includes make that closure independent of the consuming crate and readable by the similarity guard; the complete-set regression rejects a nonliteral include. The Rust compiler regression removes the build sources before checking positive, negative, cached and native-only paths. A build-time path type cannot establish runtime file availability | | Probe-only selectors derive the sibling from the resolved executable, and remux checks execute the retained pair | `test_oracle.executable_path` owns name resolution before sibling selection. The split-PATH regression exercises the policy, frame and TS entry points; the remux subprocess regression runs the unchanged registered checker through a private directory containing only links to the qualified pair. Runtime PATH contents cannot be constrained by a path type | +| Standalone FLAC oracle tests use the platform verifier rather than applying the Linux build predicate to a macOS pair | Their single `pin` helper returns the shared owner's selected executable. The existing real-pin FLAC tests run on Linux and macOS, while the system-pair negative control must fail at qualification. A file path alone cannot establish its platform's oracle identity | | Standalone audio parity executes the native command with global strict-safe mode, rather than allowing fallback to satisfy equality | `standalone_audio_probe_check.py` owns the command and strict-safe environment; its command-capture regression requires `--strict-safe` before `ffprobe`, and real generated default/JSON comparisons run in `ci.yml`. A mocked subprocess alone cannot prove the command parses | | The fallback name lists match the pinned FFmpeg listings and CoreAV's printed keys, not boolean match-return values | `scripts/fallback_names.py --check DIR` in `ci.yml`'s `check` job fails on drift and names the regeneration command; `test_boolean_match_values_are_not_printed_keys` rejects stereo and unit values without dropping boolean field names | | The unsupported ffprobe format diagnostic names every accepted forced format | `unsupported_format_message_lists_accepted_formats` in `ffprobe::args::tests` checks acceptance and diagnostic coverage together. Rust types cannot prove a user-facing sentence lists the accepted names | diff --git a/docs/design/local-oracle-qualification.md b/docs/design/local-oracle-qualification.md index 6c568dc55..d42cc9b52 100644 --- a/docs/design/local-oracle-qualification.md +++ b/docs/design/local-oracle-qualification.md @@ -38,4 +38,4 @@ Report the confirmed-bypass count before changing any consumers. If the remainin The classifier matches concrete call patterns against source-bound dispositions rather than inferring qualification from a general-purpose value-flow model. Each disposition identifies its source locations, executable expression, verdict and evidence; the repository input snapshot and qualification dependencies must still match their recorded digests. A changed helper, added file, shadowed binding or executable override therefore invalidates the prior disposition instead of inheriting it. Unmatched locations remain unknown and fail. Reports count source locations, folding overlapping constructor, completion and delegated rows at the same location; they do not count runtime calls or claim an exhaustive bypass total while unknown locations remain. Generated reports stay outside the checkout so they cannot alter the input snapshot. -This census is report-only, not a required check. Remaining confirmed bypasses and unclassified sites prevent a total qualification claim. The current repair batch covers the AVI selected-pair paths, transcode selection dispatch, the TS command bundle and the relocated decode adapter; the remaining shell and Rust migration and unknown-site review are follow-up work. A required check is deferred until unknown sites have been resolved. +This census is report-only, not a required check. Remaining confirmed bypasses and unclassified sites prevent a total qualification claim. The current repair batch covers the AVI selected-pair paths, transcode selection dispatch, the TS command bundle and the relocated decode adapter. It also moves the standalone FLAC test's qualification to the shared platform owner because the merged main's Linux-only verifier rejected the registered macOS pair in CI. The remaining shell and Rust migration and unknown-site review are follow-up work. A required check is deferred until unknown sites have been resolved. diff --git a/docs/design/oracle-invocation-dispositions.json b/docs/design/oracle-invocation-dispositions.json index 09574df65..aaeb0e213 100644 --- a/docs/design/oracle-invocation-dispositions.json +++ b/docs/design/oracle-invocation-dispositions.json @@ -469,56 +469,6 @@ "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", "verdict": "excluded" }, - { - "evidence": "pin() at lines 118-137 verifies the parent directory but returns the originally selected file. A different executable in that valid directory remains selectable.", - "id": "rust-parent-directory-only", - "kinds": [ - "Rust" - ], - "lines": [ - 154, - 298, - 326, - 408, - 497, - 592 - ], - "path": "crates/coreav-cli/tests/ffmpeg_flac.rs", - "pattern": "(?s)Command::new\\(\\&ffmpeg\\).*", - "verdict": "confirmed-bypass" - }, - { - "evidence": "pin() at lines 118-137 verifies the parent directory but returns the originally selected file. A different executable in that valid directory remains selectable.", - "id": "rust-parent-directory-only", - "kinds": [ - "Rust" - ], - "lines": [ - 154, - 298, - 326, - 408, - 497, - 592 - ], - "path": "crates/coreav-cli/tests/ffmpeg_flac.rs", - "pattern": "(?s)\\&ffmpeg", - "verdict": "confirmed-bypass" - }, - { - "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", - "id": "rust-compiled-target", - "kinds": [ - "Rust" - ], - "lines": [ - 75, - 81 - ], - "path": "crates/coreav-cli/tests/ffmpeg_flac.rs", - "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", - "verdict": "excluded" - }, { "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", "id": "rust-compiled-target", @@ -1624,7 +1574,7 @@ } ], "schema": 1, - "source_snapshot_sha256": "5ba25fa418a30192433eed530ef204d1cc33f38183c9fe5cf6df46de63df11af", + "source_snapshot_sha256": "e4a311a9ff9fbc094ad79c710766ef6e7276a544cd82ce74c145d45a7cedef88", "sources": { "crates/coreav-audio/tests/flac_encode.rs": "6b63b16444965850c74da0651859128602a9093fe487a15865f8a82093bf6880", "crates/coreav-backend-dav1d/tests/decode.rs": "9094fa0b3a4957d348e9b92420c658fda930329cac3b9c2da17e5c3248e0e791", @@ -1640,7 +1590,6 @@ "crates/coreav-cli/tests/docs_site.rs": "bd3979d63545179b8066a2132a1d31e25b72af558a3c60cb34d144c280471db1", "crates/coreav-cli/tests/exec.rs": "8105821de01ac99e0096a40b0266de02411dd21f593d7b029d13d7c344209abe", "crates/coreav-cli/tests/fallback_windows.rs": "5c97b42c1b3d351c564ccf266d51f3ab36a604080f7c78d18ed0d21ee22ffb92", - "crates/coreav-cli/tests/ffmpeg_flac.rs": "bdd12fd98b9dda64c059ff142b8c73e550b5341438542f6db926985319237613", "crates/coreav-cli/tests/ffmpeg_frames.rs": "c14f50e8876d869a711b6b232c61f07412979dcb65ce3f458dfb7a3ec26aecab", "crates/coreav-cli/tests/ffmpeg_matroska.rs": "9cba9336b1f21b9199ac4c2167f7f4e8ee2172f7e7acf302445a6283e7b2cb4b", "crates/coreav-cli/tests/ffmpeg_mkv_aac_copy.rs": "2d72e6aed47edfdf3dc1a53a79b6489a7ecaee75e72e96d7cf5a33b78eceff60", From 6aeeea15b7ef48f516d9d302a24be9c1a3ff07f1 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 17:48:25 +0000 Subject: [PATCH 18/21] fix(ffmpeg): qualify transport fixtures per platform Signed-off-by: gunwooterry --- .../src/ts_output/tests.rs | 36 +++---------------- docs/agents/ffmpeg-cli.md | 2 +- docs/design/local-oracle-qualification.md | 2 +- .../oracle-invocation-dispositions.json | 2 +- 4 files changed, 7 insertions(+), 35 deletions(-) diff --git a/crates/coreav-isobmff-write/src/ts_output/tests.rs b/crates/coreav-isobmff-write/src/ts_output/tests.rs index a042e4701..bb37da511 100644 --- a/crates/coreav-isobmff-write/src/ts_output/tests.rs +++ b/crates/coreav-isobmff-write/src/ts_output/tests.rs @@ -552,6 +552,9 @@ fn verifier_work_and_allocation_ceilings_are_inclusive() { } } +#[path = "../../../../test-support/oracle.rs"] +mod test_oracle; + struct Fixture(PathBuf); impl Drop for Fixture { @@ -566,38 +569,7 @@ fn generated(bframes: bool) -> Option<&'static [u8]> { let cache = if bframes { &REORDERED } else { &PLAIN }; cache .get_or_init(|| { - let default = PathBuf::from("/opt/coreav-oracle-bin/ffmpeg"); - let ffmpeg = std::env::var_os("COREAV_FFMPEG") - .map(PathBuf::from) - .unwrap_or_else(|| { - if default.is_file() { - return default.clone(); - } - std::env::var_os("HOME") - .map(PathBuf::from) - .map(|home| home.join(".local/share/coreav-encoders/ffmpeg")) - .filter(|local| local.is_file()) - .unwrap_or(default) - }); - if !ffmpeg.is_file() { - assert!( - std::env::var_os("CI").is_none() - && std::env::var_os("COREAV_REQUIRE_FFMPEG").is_none(), - "the pinned black-box FFmpeg is required" - ); - return None; - } - let pin = include_str!("../../../../scripts/oracle-ffmpeg.env"); - let build = pin - .lines() - .find_map(|line| line.strip_prefix("BUILD=")) - .unwrap(); - let version = Command::new(&ffmpeg).arg("-version").output().unwrap(); - assert!(version.status.success()); - assert!( - String::from_utf8_lossy(&version.stdout) - .starts_with(&format!("ffmpeg version {build}")) - ); + let ffmpeg = test_oracle::require().ffmpeg(); let fixture = Fixture( std::env::temp_dir() .join(format!("coreav-ts-{}-{bframes}.mp4", std::process::id())), diff --git a/docs/agents/ffmpeg-cli.md b/docs/agents/ffmpeg-cli.md index ca578ec73..a302737fe 100644 --- a/docs/agents/ffmpeg-cli.md +++ b/docs/agents/ffmpeg-cli.md @@ -55,7 +55,7 @@ CLI and ffprobe behavior, the FFmpeg pin, and fallback names. | Relocated oracle consumers retain the shared owner, its unchanged pins and their local imports | `test_oracle.bundle` copies the transitive Python closure into its normal `scripts` layout with the common support files. The relocated-bundle regression qualifies a fresh process against the copied pin and checks imported helper bytes; remote runner tests cover the complete pair and unchanged launch contracts. A path alone cannot establish a copied file's identity | | The relocated decode adapter qualifies without its build checkout and returns a structured qualification error instead of panicking | `try_require` retains the cached result while the embedded support owner stages its complete closure in an exclusive private directory with cleanup. File-relative literal includes make that closure independent of the consuming crate and readable by the similarity guard; the complete-set regression rejects a nonliteral include. The Rust compiler regression removes the build sources before checking positive, negative, cached and native-only paths. A build-time path type cannot establish runtime file availability | | Probe-only selectors derive the sibling from the resolved executable, and remux checks execute the retained pair | `test_oracle.executable_path` owns name resolution before sibling selection. The split-PATH regression exercises the policy, frame and TS entry points; the remux subprocess regression runs the unchanged registered checker through a private directory containing only links to the qualified pair. Runtime PATH contents cannot be constrained by a path type | -| Standalone FLAC oracle tests use the platform verifier rather than applying the Linux build predicate to a macOS pair | Their single `pin` helper returns the shared owner's selected executable. The existing real-pin FLAC tests run on Linux and macOS, while the system-pair negative control must fail at qualification. A file path alone cannot establish its platform's oracle identity | +| Standalone FLAC oracle tests and the ISO writer's transport fixture use the platform verifier rather than applying the Linux build predicate to a macOS pair | Their single `pin` and `generated` helpers consume the shared owner's selected executable. Existing real-pin tests run on Linux and macOS, while system-pair negative controls must fail at qualification. A file path alone cannot establish its platform's oracle identity | | Standalone audio parity executes the native command with global strict-safe mode, rather than allowing fallback to satisfy equality | `standalone_audio_probe_check.py` owns the command and strict-safe environment; its command-capture regression requires `--strict-safe` before `ffprobe`, and real generated default/JSON comparisons run in `ci.yml`. A mocked subprocess alone cannot prove the command parses | | The fallback name lists match the pinned FFmpeg listings and CoreAV's printed keys, not boolean match-return values | `scripts/fallback_names.py --check DIR` in `ci.yml`'s `check` job fails on drift and names the regeneration command; `test_boolean_match_values_are_not_printed_keys` rejects stereo and unit values without dropping boolean field names | | The unsupported ffprobe format diagnostic names every accepted forced format | `unsupported_format_message_lists_accepted_formats` in `ffprobe::args::tests` checks acceptance and diagnostic coverage together. Rust types cannot prove a user-facing sentence lists the accepted names | diff --git a/docs/design/local-oracle-qualification.md b/docs/design/local-oracle-qualification.md index d42cc9b52..18af69afe 100644 --- a/docs/design/local-oracle-qualification.md +++ b/docs/design/local-oracle-qualification.md @@ -38,4 +38,4 @@ Report the confirmed-bypass count before changing any consumers. If the remainin The classifier matches concrete call patterns against source-bound dispositions rather than inferring qualification from a general-purpose value-flow model. Each disposition identifies its source locations, executable expression, verdict and evidence; the repository input snapshot and qualification dependencies must still match their recorded digests. A changed helper, added file, shadowed binding or executable override therefore invalidates the prior disposition instead of inheriting it. Unmatched locations remain unknown and fail. Reports count source locations, folding overlapping constructor, completion and delegated rows at the same location; they do not count runtime calls or claim an exhaustive bypass total while unknown locations remain. Generated reports stay outside the checkout so they cannot alter the input snapshot. -This census is report-only, not a required check. Remaining confirmed bypasses and unclassified sites prevent a total qualification claim. The current repair batch covers the AVI selected-pair paths, transcode selection dispatch, the TS command bundle and the relocated decode adapter. It also moves the standalone FLAC test's qualification to the shared platform owner because the merged main's Linux-only verifier rejected the registered macOS pair in CI. The remaining shell and Rust migration and unknown-site review are follow-up work. A required check is deferred until unknown sites have been resolved. +This census is report-only, not a required check. Remaining confirmed bypasses and unclassified sites prevent a total qualification claim. The current repair batch covers the AVI selected-pair paths, transcode selection dispatch, the TS command bundle and the relocated decode adapter. It also moves qualification in the standalone FLAC tests and the ISO writer's transport fixture helper to the shared platform owner because the merged main's Linux-only predicates rejected the registered macOS pair. The remaining shell and Rust migration and unknown-site review are follow-up work. A required check is deferred until unknown sites have been resolved. diff --git a/docs/design/oracle-invocation-dispositions.json b/docs/design/oracle-invocation-dispositions.json index aaeb0e213..3b6bb95f0 100644 --- a/docs/design/oracle-invocation-dispositions.json +++ b/docs/design/oracle-invocation-dispositions.json @@ -1574,7 +1574,7 @@ } ], "schema": 1, - "source_snapshot_sha256": "e4a311a9ff9fbc094ad79c710766ef6e7276a544cd82ce74c145d45a7cedef88", + "source_snapshot_sha256": "7469e1a0f270152a68ba1adb713a23d5f75b638098c1d399b4d83803cd7a1344", "sources": { "crates/coreav-audio/tests/flac_encode.rs": "6b63b16444965850c74da0651859128602a9093fe487a15865f8a82093bf6880", "crates/coreav-backend-dav1d/tests/decode.rs": "9094fa0b3a4957d348e9b92420c658fda930329cac3b9c2da17e5c3248e0e791", From 76a7e9827b18cc935fce500a79fe9f2daf7874f0 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 17:58:33 +0000 Subject: [PATCH 19/21] ci(ffmpeg): provision structural discovery parser Signed-off-by: gunwooterry --- .github/workflows/deny.yml | 10 ++++++++++ docs/agents/ci.md | 1 + docs/design/oracle-invocation-dispositions.json | 2 +- scripts/tests/test_oracle_invocation_check.py | 12 ++++++++++++ 4 files changed, 24 insertions(+), 1 deletion(-) diff --git a/.github/workflows/deny.yml b/.github/workflows/deny.yml index ce42365c4..e47588a3d 100644 --- a/.github/workflows/deny.yml +++ b/.github/workflows/deny.yml @@ -158,6 +158,16 @@ jobs: # added under docs/measurements (docs/design/h264.md, "A round's bars: # one analyzer, complete reports"). It runs here, not in ci.yml, because # that workflow's filter skips a change to docs/measurements alone. + - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 + if: steps.result.outputs.reuse != 'true' + with: + node-version: 24 + - name: Install structural invocation discovery + if: steps.result.outputs.reuse != 'true' + run: | + set -euo pipefail + npm install --prefix "$RUNNER_TEMP/oracle-discovery" --no-audit --no-fund --save-exact @ast-grep/cli@0.50.0 + echo "$RUNNER_TEMP/oracle-discovery/node_modules/.bin" >> "$GITHUB_PATH" - name: Check the measurement analyzers if: steps.result.outputs.reuse != 'true' env: diff --git a/docs/agents/ci.md b/docs/agents/ci.md index 8edda2ff7..f07a8ada4 100644 --- a/docs/agents/ci.md +++ b/docs/agents/ci.md @@ -9,6 +9,7 @@ Workflow required checks, path filters, DCO, pinned actions, merge-group reuse, | AAC qualification keeps its complete JSON report even when the comparison fails | The existing always-run artifact upload owns retention; `test_aac_qualification_report_survives_failure` checks its condition and report path. Rust types cannot govern workflow artifact paths | | Input-summary fixture CI starts for the registered default CLI build inputs and the inherited Cargo manifest and lockfile | `test_default_cli_build_inputs_trigger_summary_checks` pins the fourteen current local dependency crate paths and both root files, and names the filter entries to restore. The input set is checked against `cargo tree -p coreav-cli -e normal,build`; Rust types cannot govern GitHub path filters | | No `unwrap`, `expect`, `panic!`, `todo!`, `unimplemented!` or slice indexing in production code | Workspace lints in `Cargo.toml`, `cargo clippy --workspace --all-targets -- -D warnings` (`ci.yml`) | +| Structural invocation-discovery tests run with their pinned parser installed rather than relying on the runner image | `deny.yml` installs the exact `@ast-grep/cli` package before scripts discovery and exports its binary directory. The dependency-order regression checks the pin and PATH handoff; Rust types cannot provision an external CLI | | Native SVT backend tests use the installed distribution compiler even when the repository selects stable | The explicit Cargo toolchain selector in `svt-av1-native.yml` owns selection; `test_native_backend_uses_the_installed_pin_despite_a_stable_override` executes that step for all four targets with a different pin and checks linker selection and failure propagation. Rust types cannot select the workflow's compiler | | No `unsafe` outside the files `docs/unsafe-sites.md` lists; the change that adds or changes an `unsafe` site adds or updates its row there | `unsafe_code = "forbid"` (`Cargo.toml`); `scripts/unsafe_sites_check.py` (`ci.yml`) fails on a file with `unsafe` and no row. It checks files, not sites: a new site in a listed file passes it, so its row is review judgment | | Every commit a pull request adds carries a `Signed-off-by` with its author's email (`git commit -s`) | `scripts/dco_check.py` (`deny.yml`): the name may differ and the email's case is ignored; commits already on `main` are skipped | diff --git a/docs/design/oracle-invocation-dispositions.json b/docs/design/oracle-invocation-dispositions.json index 3b6bb95f0..1d7e41097 100644 --- a/docs/design/oracle-invocation-dispositions.json +++ b/docs/design/oracle-invocation-dispositions.json @@ -1574,7 +1574,7 @@ } ], "schema": 1, - "source_snapshot_sha256": "7469e1a0f270152a68ba1adb713a23d5f75b638098c1d399b4d83803cd7a1344", + "source_snapshot_sha256": "639e53ce3d68104b16179d5537c5dc5f3d36aa9f53788ea85c12f9ae0551c3b9", "sources": { "crates/coreav-audio/tests/flac_encode.rs": "6b63b16444965850c74da0651859128602a9093fe487a15865f8a82093bf6880", "crates/coreav-backend-dav1d/tests/decode.rs": "9094fa0b3a4957d348e9b92420c658fda930329cac3b9c2da17e5c3248e0e791", diff --git a/scripts/tests/test_oracle_invocation_check.py b/scripts/tests/test_oracle_invocation_check.py index 6392ad339..65a5d12c5 100644 --- a/scripts/tests/test_oracle_invocation_check.py +++ b/scripts/tests/test_oracle_invocation_check.py @@ -8,6 +8,18 @@ import oracle_invocation_check as check +class Provisioning(unittest.TestCase): + def test_ci_installs_the_pinned_structural_parser_before_script_discovery(self): + workflow = (check.ROOT / '.github/workflows/deny.yml').read_text() + install = workflow.index('name: Install structural invocation discovery') + tests = workflow.index('name: Check the measurement analyzers') + self.assertLess(install, tests) + block = workflow[install:tests] + self.assertRegex(block, r'@ast-grep/cli@[0-9]+\.[0-9]+\.[0-9]+(?:\s|$)') + self.assertIn('--save-exact', block) + self.assertIn('"$RUNNER_TEMP/oracle-discovery/node_modules/.bin" >> "$GITHUB_PATH"', block) + + class HistoricalRecords(unittest.TestCase): def fixture(self, root): source = root / 'docs/measurements/past/run.py' From 09c7fedfd2c3a84780012620751899054be00e3a Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 18:11:53 +0000 Subject: [PATCH 20/21] docs(ffmpeg): clarify migrated oracle scope Signed-off-by: gunwooterry --- docs/agents/docs.md | 1 + docs/design/local-oracle-qualification.md | 2 +- docs/design/oracle-invocation-dispositions.json | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/docs/agents/docs.md b/docs/agents/docs.md index 506f406da..a42cfdff3 100644 --- a/docs/agents/docs.md +++ b/docs/agents/docs.md @@ -10,6 +10,7 @@ Documentation-site prose, schema wording, and design-note updates. | Algebraic acceptance examples identify each abstract cost separately from complete emitted data | Not enforced: design review. State successive costs as separate values, not a comma-grouped scalar. Prose cannot establish that an abstract cost is a realizable codec output; complete emitted-data accounting needs its own acceptance check | | The full HEVC census command prepares and consumes its required synthetic references | `test_documented_census_prepares_and_consumes_synthetic_references` parses the published commands and requires fixture verification before census execution with the same output directory. The workflow already owns the executable gate; types cannot establish a documented shell command's arguments | | A design status distinguishes unchanged milestone structure from changed evidence or acceptance rules | `test_design_status_distinguishes_milestones_from_changed_evidence_rules` rejects the former HEVC unchanged-gates claim and requires the explicit evidence/exclusion qualification. Other design notes remain review judgment; types cannot establish the meaning of status prose | +| A partial oracle migration describes migrated callers rather than implying total qualification while unknown sites remain | Not enforced: review of the design note against the report-only census. A source hash can bind the prose to a snapshot but cannot establish the meaning of its scope claim | | Raw-audio documentation limits the platform gate to changed-rate output, not unchanged-rate identity output | `test_raw_audio_documents_platform_gates_only_for_changed_rates` requires both scopes and rejects the former unqualified platform claim (`deny.yml`). The rate owner already separates identity from platform-gated conversions, but types cannot govern documentation prose | | Raw S16 input documentation distinguishes integer-byte copying from F32 packing | `test_raw_audio_distinguishes_integer_copy_from_float_packing` requires both scopes (`deny.yml`); the CLI identity tests separately check their actual bytes. The packing type distinguishes execution but cannot govern prose | | The platform page alone owns version-specific pnpm approval settings and preserves existing approvals; the package README and design note link it | `test_pnpm_approval_documents_both_supported_settings` in `scripts/tests/test_docs_site.py` checks pnpm 10.0–10.4, 10.5–10.x and 11+, list preservation and links from both consumers. A single documentation owner prevents divergent copies; external package-manager versions cannot be enforced by the CLI's types | diff --git a/docs/design/local-oracle-qualification.md b/docs/design/local-oracle-qualification.md index 18af69afe..c8d30f25b 100644 --- a/docs/design/local-oracle-qualification.md +++ b/docs/design/local-oracle-qualification.md @@ -1,6 +1,6 @@ # Local oracle qualification -Every non-frozen Rust and Python oracle consumer must qualify its selected executable before comparing output or generating fixtures. Executable permissions alone do not prove the shared pin. +Migrated Rust and Python oracle consumers qualify their selected executable before comparing output or generating fixtures. Executable permissions alone do not prove the shared pin. ## Plan diff --git a/docs/design/oracle-invocation-dispositions.json b/docs/design/oracle-invocation-dispositions.json index 1d7e41097..f968aa767 100644 --- a/docs/design/oracle-invocation-dispositions.json +++ b/docs/design/oracle-invocation-dispositions.json @@ -1574,7 +1574,7 @@ } ], "schema": 1, - "source_snapshot_sha256": "639e53ce3d68104b16179d5537c5dc5f3d36aa9f53788ea85c12f9ae0551c3b9", + "source_snapshot_sha256": "6a45af9b605a90aaee295d51f92b848fa87f2dabd6f717c32504505857e6c521", "sources": { "crates/coreav-audio/tests/flac_encode.rs": "6b63b16444965850c74da0651859128602a9093fe487a15865f8a82093bf6880", "crates/coreav-backend-dav1d/tests/decode.rs": "9094fa0b3a4957d348e9b92420c658fda930329cac3b9c2da17e5c3248e0e791", From aead179eb30852fd7f2ec3efd1b375faadfe4721 Mon Sep 17 00:00:00 2001 From: gunwooterry Date: Thu, 5 Nov 2026 18:38:17 +0000 Subject: [PATCH 21/21] fix(ffmpeg): retain configured oracle selectors Signed-off-by: gunwooterry --- docs/agents/ffmpeg-cli.md | 1 + .../oracle-invocation-dispositions.json | 70 +------------------ scripts/test_oracle.py | 3 +- scripts/tests/test_test_oracle.py | 31 +++++++- scripts/transcode_speed.py | 4 +- test-support/oracle-dependent.json | 8 ++- tools/compat-corpus/frames.py | 10 ++- 7 files changed, 51 insertions(+), 76 deletions(-) diff --git a/docs/agents/ffmpeg-cli.md b/docs/agents/ffmpeg-cli.md index 58c04d84c..316efc364 100644 --- a/docs/agents/ffmpeg-cli.md +++ b/docs/agents/ffmpeg-cli.md @@ -57,6 +57,7 @@ CLI and ffprobe behavior, the FFmpeg pin, and fallback names. | Relocated oracle consumers retain the shared owner, its unchanged pins and their local imports | `test_oracle.bundle` copies the transitive Python closure into its normal `scripts` layout with the common support files. The relocated-bundle regression qualifies a fresh process against the copied pin and checks imported helper bytes; remote runner tests cover the complete pair and unchanged launch contracts. A path alone cannot establish a copied file's identity | | The relocated decode adapter qualifies without its build checkout and returns a structured qualification error instead of panicking | `try_require` retains the cached result while the embedded support owner stages its complete closure in an exclusive private directory with cleanup. File-relative literal includes make that closure independent of the consuming crate and readable by the similarity guard; the complete-set regression rejects a nonliteral include. The Rust compiler regression removes the build sources before checking positive, negative, cached and native-only paths. A build-time path type cannot establish runtime file availability | | Probe-only selectors derive the sibling from the resolved executable, and remux checks execute the retained pair | `test_oracle.executable_path` owns name resolution before sibling selection. The split-PATH regression exercises the policy, frame and TS entry points; the remux subprocess regression runs the unchanged registered checker through a private directory containing only links to the qualified pair. Runtime PATH contents cannot be constrained by a path type | +| Omitted Python selectors retain the configured pair, while an explicit FFmpeg without a probe selects its resolved sibling before any configured probe | `test_oracle.require` owns the precedence. The omitted-selector regressions cover both transcode commands and frame comparisons with conflicting PATH programs; the explicit-FFmpeg regression uses a second valid installation beside a configured pair. Runtime environment values cannot be constrained by a path type | | Standalone FLAC oracle tests and the ISO writer's transport fixture use the platform verifier rather than applying the Linux build predicate to a macOS pair | Their single `pin` and `generated` helpers consume the shared owner's selected executable. Existing real-pin tests run on Linux and macOS, while system-pair negative controls must fail at qualification. A file path alone cannot establish its platform's oracle identity | | Standalone audio parity executes the native command with global strict-safe mode, rather than allowing fallback to satisfy equality | `standalone_audio_probe_check.py` owns the command and strict-safe environment; its command-capture regression requires `--strict-safe` before `ffprobe`, and real generated default/JSON comparisons run in `ci.yml`. A mocked subprocess alone cannot prove the command parses | | The fallback name lists match the pinned FFmpeg listings and CoreAV's printed keys, not boolean match-return values | `scripts/fallback_names.py --check DIR` in `ci.yml`'s `check` job fails on drift and names the regeneration command; `test_boolean_match_values_are_not_printed_keys` rejects stereo and unit values without dropping boolean field names | diff --git a/docs/design/oracle-invocation-dispositions.json b/docs/design/oracle-invocation-dispositions.json index f968aa767..602715820 100644 --- a/docs/design/oracle-invocation-dispositions.json +++ b/docs/design/oracle-invocation-dispositions.json @@ -5,7 +5,7 @@ "scripts/oracle-ffmpeg.env": "95601248eba142d1cbf8d81aaf46d5ebc61c1962fe1edafdc1ee2c1b7bd33f24", "scripts/oracle_pin.py": "b221378b054a6e6bae92051ae4e4e4fa1add451213f28e888825fa6e43f2f909", "scripts/oracle_pin_macos.py": "70c0f515b3a58cf6b6d2d11938b537b2e8824f0fafbfe6ab9578669c1d857879", - "scripts/test_oracle.py": "e16c34d603508ece64cb5e05ae926426080f44cb1031a49089213c663671db99", + "scripts/test_oracle.py": "af9e07a0f66cc1daca5574333cf129a9d92bc8465de868c6332bb7e4a83a7812", "test-support/oracle.rs": "3559a8f47cbec57f10bd7e27f254217b226fb5d4b9b4a9e4a5b387660a91ffce" }, "frozen": { @@ -15,7 +15,7 @@ "bench/audio-decode/oracle.py": "6999bc89af9f0ffb4dade872e30b2b0ba7342648b32e22aaeeca50936316b32a", "bench/audio-decode/receipts.py": "bec504c954c8750df703116325e37ea21c2844696df68e23856495bf95a18783", "bench/audio-decode/run.py": "516120decdaf44a5e206c5e57da485ad15d3f9aa010422daa027508bb2ef6112", - "crates/coreav-cli/tests/ffmpeg.rs": "b241c0478ec19fc8ae6fd67e9443dcfdced286b920c8af1ef2293e95924c19aa", + "crates/coreav-cli/tests/ffmpeg.rs": "14c7db0ca9a7fdd8d349dc807c2293ee6a84198519b1615a537f544ef59f9d5c", "crates/coreav-isobmff/tests/common/fragments.rs": "a9e161349e40328ca2b95ffa593aff35af0e1739648d74fc0767100cda3f0b89", "crates/coreav-isobmff/tests/common/mod.rs": "fcd4b45894250821d93290d802d8324dfc8cbc1b27c56980a6a6075955744d71", "crates/coreav-isobmff/tests/common/sound.rs": "7db44a00ee6bc2671517fdf5e8bb8b31b25ac224c856b04948aed5bb1875ef03", @@ -784,69 +784,6 @@ "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", "verdict": "excluded" }, - { - "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", - "id": "rust-compiled-target", - "kinds": [ - "Rust" - ], - "lines": [ - 443, - 654 - ], - "path": "crates/coreav-cli/tests/ffmpeg_wav.rs", - "pattern": "(?s)Command::new\\(env!\\(\"CARGO_BIN_EXE_coreav\"\\)\\).*", - "verdict": "excluded" - }, - { - "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", - "id": "rust-compiled-target", - "kinds": [ - "Rust" - ], - "lines": [ - 41, - 180, - 238, - 443, - 654 - ], - "path": "crates/coreav-cli/tests/ffmpeg_wav.rs", - "pattern": "(?s)env!\\(\"CARGO_BIN_EXE_coreav\"\\)", - "verdict": "excluded" - }, - { - "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", - "id": "rust-owner-return", - "kinds": [ - "Rust" - ], - "lines": [ - 109, - 143, - 431 - ], - "path": "crates/coreav-cli/tests/ffmpeg_wav.rs", - "pattern": "(?s)Command::new\\(\\&ffmpeg\\).*", - "verdict": "qualified-via-owner" - }, - { - "evidence": "The selected executable is the shared owner return value, directly or through the recorded same-file helper.", - "id": "rust-owner-return", - "kinds": [ - "Rust" - ], - "lines": [ - 109, - 143, - 187, - 245, - 431 - ], - "path": "crates/coreav-cli/tests/ffmpeg_wav.rs", - "pattern": "(?s)\\&ffmpeg", - "verdict": "qualified-via-owner" - }, { "evidence": "The compile-time Cargo binary identity is the program under test; reference launches are separate boundaries.", "id": "rust-compiled-target", @@ -1574,7 +1511,7 @@ } ], "schema": 1, - "source_snapshot_sha256": "6a45af9b605a90aaee295d51f92b848fa87f2dabd6f717c32504505857e6c521", + "source_snapshot_sha256": "8e19debfcc25d021944c4cef59a4acaaf5610200aef01385b3b4af8b170832d7", "sources": { "crates/coreav-audio/tests/flac_encode.rs": "6b63b16444965850c74da0651859128602a9093fe487a15865f8a82093bf6880", "crates/coreav-backend-dav1d/tests/decode.rs": "9094fa0b3a4957d348e9b92420c658fda930329cac3b9c2da17e5c3248e0e791", @@ -1595,7 +1532,6 @@ "crates/coreav-cli/tests/ffmpeg_mkv_aac_copy.rs": "2d72e6aed47edfdf3dc1a53a79b6489a7ecaee75e72e96d7cf5a33b78eceff60", "crates/coreav-cli/tests/ffmpeg_pcm.rs": "c700046642796bb6ab27f09b7d7991059088f175cbae71c4541113a6ed25dd22", "crates/coreav-cli/tests/ffmpeg_raw.rs": "e695c08e045f8dd07d2296fd1e4054c1e95a49493922973768b14c0785d7ad0f", - "crates/coreav-cli/tests/ffmpeg_wav.rs": "5b7ee1855630fec70c1190411a64f535980afc56e7bd0a123891f27080cde383", "crates/coreav-cli/tests/ffprobe_ancillary_bit_rate.rs": "948d83c773436cce55aa0328544f61405b84b243efd926762e7cd23ca0772da3", "crates/coreav-cli/tests/ffprobe_aspect_ratio.rs": "b8a9a4dba8d8ffa75457f929bd87805261663ee93777c5eadcf76be921bc636c", "crates/coreav-cli/tests/ffprobe_clean_aperture.rs": "a0d0e45785bfcbf64e1de08823df4ba253eccc3859b60a876b2c67b5f22fe056", diff --git a/scripts/test_oracle.py b/scripts/test_oracle.py index f210af46b..134485038 100644 --- a/scripts/test_oracle.py +++ b/scripts/test_oracle.py @@ -76,7 +76,8 @@ def require(ffmpeg=None, ffprobe=None): if selected is None: selected = shutil.which('ffmpeg') or '/opt/coreav-oracle-bin/ffmpeg' selected = executable_path(selected) - probe = ffprobe if ffprobe is not None else os.environ.get('COREAV_FFPROBE') + probe = ffprobe if ffprobe is not None else ( + os.environ.get('COREAV_FFPROBE') if ffmpeg is None else None) probe = executable_path(probe) if probe is not None else selected.with_name('ffprobe') requested = (selected.resolve(), probe.resolve()) with _lock: diff --git a/scripts/tests/test_test_oracle.py b/scripts/tests/test_test_oracle.py index a3680cb32..18273cea4 100644 --- a/scripts/tests/test_test_oracle.py +++ b/scripts/tests/test_test_oracle.py @@ -82,6 +82,15 @@ def test_second_selection_is_rejected_without_running_it(self): ' raise AssertionError("second selection accepted")\n') self.assertEqual(len(self.log.read_text().splitlines()), 2) + def test_explicit_ffmpeg_selects_its_sibling_before_the_configured_probe(self): + self.pair(self.root / 'other') + self.child('from pathlib import Path\n' + 'root = Path(sys.argv[2])\n' + 'pair = owner.require(root / "other/ffmpeg")\n' + 'assert pair.ffmpeg == root / "other/ffmpeg"\n' + 'assert pair.ffprobe == root / "other/ffprobe"\n') + self.assertCountEqual(self.log.read_text().splitlines(), ['ffmpeg', 'ffprobe']) + def test_missing_siblings_and_malformed_or_failed_versions_fail(self): for name in ('ffmpeg', 'ffprobe'): with self.subTest(missing=name): @@ -281,7 +290,9 @@ def test_omitted_cli_selectors_honor_the_configured_pair_over_path(self): ' ("oracle", ["capture", "missing", "missing"]),\n' ' ("thumbnail_oracle", ["--coreav", "missing", "--decode-oracle", "missing"]),\n' ' ("exact_skip_check", ["--decode-oracle", "missing"]),\n' - ' ("seek_check", ["--decode-oracle", "missing"])]\n' + ' ("seek_check", ["--decode-oracle", "missing"]),\n' + ' ("transcode_speed", ["select", "--work", "missing", "--selection", "missing"]),\n' + ' ("transcode_speed", ["run"])]\n' 'for name, args in cases:\n' ' spec = importlib.util.spec_from_file_location("driver_" + name, repo / "scripts" / (name + ".py"))\n' ' driver = importlib.util.module_from_spec(spec)\n spec.loader.exec_module(driver)\n' @@ -296,6 +307,24 @@ def test_omitted_cli_selectors_honor_the_configured_pair_over_path(self): ' except StopIteration: pass\n' ' else: raise AssertionError("selection boundary was not reached")\n') + def test_frame_comparisons_honor_the_configured_pair_over_path(self): + self.pair(self.root / 'shadow', version='0.0.0') + self.child('import importlib.util, os\nfrom pathlib import Path\nfrom unittest.mock import patch\n' + 'root = Path(sys.argv[2])\nrepo = Path(sys.argv[1]).parent\nrequire = owner.require\n' + 'os.environ["PATH"] = str(root / "shadow") + os.pathsep + os.environ["PATH"]\n' + 'spec = importlib.util.spec_from_file_location("frames", repo / "tools/compat-corpus/frames.py")\n' + 'driver = importlib.util.module_from_spec(spec)\nspec.loader.exec_module(driver)\n' + 'def inspect_selected(ffmpeg=None, ffprobe=None):\n' + ' pair = require(ffmpeg, ffprobe)\n' + ' assert pair.ffmpeg == root / "ffmpeg"\n' + ' assert pair.ffprobe == root / "ffprobe"\n' + ' raise StopIteration\n' + 'sys.argv = ["frames.py", "--coreav", "missing", "--media", "missing"]\n' + 'with patch.object(driver.test_oracle, "require", side_effect=inspect_selected):\n' + ' try: driver.main()\n' + ' except StopIteration: pass\n' + ' else: raise AssertionError("selection boundary was not reached")\n') + def test_transcode_select_qualifies_and_retains_the_pair_before_dispatch(self): self.child('from pathlib import Path\n' 'from unittest.mock import patch\n' diff --git a/scripts/transcode_speed.py b/scripts/transcode_speed.py index b93be55c8..6d9a8360a 100644 --- a/scripts/transcode_speed.py +++ b/scripts/transcode_speed.py @@ -424,8 +424,8 @@ def main(): p.add_argument('--files') p.add_argument('--coreav') p.add_argument('--arm', action='append', metavar='NAME=ARGS') - p.add_argument('--ffmpeg', default=shutil.which('ffmpeg')) - p.add_argument('--ffprobe', default=shutil.which('ffprobe')) + p.add_argument('--ffmpeg') + p.add_argument('--ffprobe') p.add_argument('--gate') p.add_argument('--out') p.add_argument('--tmp', default='/dev/shm/transcode-speed') diff --git a/test-support/oracle-dependent.json b/test-support/oracle-dependent.json index 5db71a45e..5a0c5dabc 100644 --- a/test-support/oracle-dependent.json +++ b/test-support/oracle-dependent.json @@ -46,7 +46,6 @@ ], "crates/coreav-cli/tests/ffmpeg.rs": [ "av1_video_concat_compares_every_exposed_sample_entry_field_and_packet_byte", - "concat_audio_gaps_are_refused_with_exact_pinned_fallback", "contributing_inputs_preserve_complete_packet_order_and_decoded_output", "copied_video_aac_encoding_preserves_destinations_and_exact_fallback", "copied_video_reconstructs_conflicting_declared_media_durations", @@ -67,13 +66,17 @@ "stream_metadata_agrees_with_the_pinned_ffmpeg", "stripped_metadata_agrees_with_the_pinned_ffmpeg", "the_0_1_0_commands_on_the_fixtures", - "unedited_audiovisual_concat_matches_the_pinned_ffmpeg", "unedited_video_copy_normalizes_its_origin_without_losing_frames", "unqualified_primed_aac_concat_preserves_outputs_and_real_fallback" ], "crates/coreav-cli/tests/ffmpeg_aac_filter.rs": [ "aac_filter_is_an_exact_concat_identity_or_preserved_fallback" ], + "crates/coreav-cli/tests/ffmpeg_concat.rs": [ + "concat_audio_gaps_are_refused_with_exact_pinned_fallback", + "lossless_audiovisual_concat_preserves_complete_native_output", + "unedited_audiovisual_concat_matches_the_pinned_ffmpeg" + ], "crates/coreav-cli/tests/ffmpeg_flac.rs": [ "complete_raw_bytes_match_the_pin_for_files_stdout_and_stdin", "invalid_reconstructed_ranges_refuse_before_any_output", @@ -125,6 +128,7 @@ "aac_raw_output_refuses_with_exact_pinned_fallback" ], "crates/coreav-cli/tests/ffmpeg_wav.rs": [ + "aac_s16_wav_forms_match_complete_pinned_outputs_and_retain_native_metadata_cases", "integer_wav_output_matches_complete_pinned_files", "wave_wav_stdout_refuses_without_literal_files_and_matches_fallback" ], diff --git a/tools/compat-corpus/frames.py b/tools/compat-corpus/frames.py index dbd4c6471..0e7c66edc 100644 --- a/tools/compat-corpus/frames.py +++ b/tools/compat-corpus/frames.py @@ -145,7 +145,7 @@ def judge(opts, native, args, path): def main(): ap = argparse.ArgumentParser(description=__doc__.split('\n')[0]) ap.add_argument('--coreav', required=True) - ap.add_argument('--ffprobe', default='ffprobe') + ap.add_argument('--ffprobe') ap.add_argument('--media', nargs='+', required=True) ap.add_argument('--native-h264', action='store_true', help='the coreav binary is built with the native-h264 feature') @@ -154,8 +154,12 @@ def main(): ap.add_argument('--report') ap.add_argument('--jobs', type=int, default=os.cpu_count() or 4) opts = ap.parse_args() - probe = test_oracle.executable_path(opts.ffprobe) - opts.ffprobe = str(test_oracle.require(probe.with_name('ffmpeg'), probe).ffprobe) + if opts.ffprobe is None: + pair = test_oracle.require() + else: + probe = test_oracle.executable_path(opts.ffprobe) + pair = test_oracle.require(probe.with_name('ffmpeg'), probe) + opts.ffprobe = str(pair.ffprobe) native = NATIVE | ({f'h264 {f}' for f in H264_PIX_FMTS} if opts.native_h264 else set()) files = media_files(opts.media) names = set()