use crate::bitstream::BitWriter;
use crate::vp9::bool_coder::BoolEncoder;
use crate::vp9::tables::{
DC_PRED, DEFAULT_SKIP_PROBS, INTRA_MODE_TREE, KF_PARTITION_PROBS, KF_UV_MODE_PROB_DC,
KF_Y_MODE_PROB_DC_DC, PARTITION_NONE, PARTITION_TREE,
};
const FRAME_SYNC_CODE: u32 = 0x0049_8342;
const CS_BT_601: u32 = 1;
pub fn encode_intra_gray(width: u32, height: u32) -> Vec<u8> {
assert!(
width == 64 && height == 64,
"encode_intra_gray currently supports a single 64x64 superblock only"
);
let compressed = compressed_header();
let tile = tile_data();
let mut wb = BitWriter::new();
write_uncompressed_header(&mut wb, width, height, compressed.len() as u32);
let mut frame = wb.finish();
frame.extend_from_slice(&compressed);
frame.extend_from_slice(&tile);
crate::vp9::finalize_frame(frame)
}
fn write_uncompressed_header(w: &mut BitWriter, width: u32, height: u32, header_size: u32) {
w.write_bits(2, 2); w.write_bit(0); w.write_bit(0); w.write_bit(0); w.write_bit(0); w.write_bit(1); w.write_bit(0);
w.write_bits(FRAME_SYNC_CODE, 24);
w.write_bits(CS_BT_601, 3); w.write_bit(0);
w.write_bits(width - 1, 16);
w.write_bits(height - 1, 16);
w.write_bit(0);
w.write_bit(0); w.write_bit(1); w.write_bits(0, 2);
w.write_bits(0, 6); w.write_bits(0, 3); w.write_bit(0);
w.write_bits(128, 8); w.write_bit(0); w.write_bit(0); w.write_bit(0);
w.write_bit(0);
w.write_bit(0);
w.write_bits(header_size, 16); }
fn compressed_header() -> Vec<u8> {
let mut e = BoolEncoder::new();
e.put_literal(0, 2); e.put_bit(false); for _ in 0..3 {
e.put_bool(252, false); }
e.finish()
}
fn tile_data() -> Vec<u8> {
let mut e = BoolEncoder::new();
write_tree(
&mut e,
&PARTITION_TREE,
&KF_PARTITION_PROBS[12],
PARTITION_NONE,
);
e.put_bool(DEFAULT_SKIP_PROBS[0], true); write_tree(&mut e, &INTRA_MODE_TREE, &KF_Y_MODE_PROB_DC_DC, DC_PRED); write_tree(&mut e, &INTRA_MODE_TREE, &KF_UV_MODE_PROB_DC, DC_PRED);
e.finish()
}
fn write_tree(e: &mut BoolEncoder, tree: &[i8], probs: &[u8], token: i8) {
let path = tree_path(tree, 0, token).expect("token not in tree");
for (node, bit) in path {
e.put_bool(probs[node >> 1], bit);
}
}
fn tree_path(tree: &[i8], node: usize, token: i8) -> Option<Vec<(usize, bool)>> {
for bit in 0..2 {
let child = tree[node + bit];
if child <= 0 {
if -child == token {
return Some(vec![(node, bit == 1)]);
}
} else if let Some(mut rest) = tree_path(tree, child as usize, token) {
rest.insert(0, (node, bit == 1));
return Some(rest);
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
use crate::vp9::tables::{TM_PRED, V_PRED};
#[test]
fn tree_paths_are_correct() {
assert_eq!(
tree_path(&INTRA_MODE_TREE, 0, DC_PRED).unwrap(),
vec![(0, false)]
);
assert_eq!(
tree_path(&INTRA_MODE_TREE, 0, TM_PRED).unwrap(),
vec![(0, true), (2, false)]
);
assert_eq!(
tree_path(&INTRA_MODE_TREE, 0, V_PRED).unwrap(),
vec![(0, true), (2, true), (4, false)]
);
assert_eq!(
tree_path(&PARTITION_TREE, 0, PARTITION_NONE).unwrap(),
vec![(0, false)]
);
}
#[test]
fn frame_has_plausible_shape() {
let frame = encode_intra_gray(64, 64);
assert_eq!(frame[0] >> 6, 0b10);
assert!(frame.len() > 12, "frame unexpectedly tiny: {}", frame.len());
}
}