use crate::bitstream::{rbsp_trailing_bits, BitWriter};
use crate::h264::nal::{nal_unit_base, push_annexb, NalUnitType};
use crate::h264::params::write_sps;
use crate::h264::avcc::build_avcc;
use crate::h264::encoder::H264Encoder;
use crate::h264::pps::write_pps_deblock_control;
use crate::h264::params::EntropyMode;
use crate::mp4::H264Mp4Params;
use crate::rate::{Quality, Reach, RateControl, PROBE_QP};
use crate::captions::CaptionTrack;
use crate::hevc::encoder::{pad_plane, Yuv420Frame};
use crate::h264::cabac::{self, Cabac};
use crate::h264::cavlc::{self, BlockKind, ZIGZAG4};
use crate::h264::intra;
use crate::h264::params::{H264Config, MB_SIZE};
use crate::h264::transform::{
chroma_dc_forward, chroma_dc_inverse, dequant4, fit_luma_dc_levels, forward4, inverse4,
luma_dc_hadamard, luma_dc_inverse, quant4,
};
const MB_TYPE_I_NXN: u32 = 0;
const BLK_POS: [(usize, usize); 16] = [
(0, 0), (1, 0), (0, 1), (1, 1),
(2, 0), (3, 0), (2, 1), (3, 1),
(0, 2), (1, 2), (0, 3), (1, 3),
(2, 2), (3, 2), (2, 3), (3, 3),
];
fn blk_index(x4: usize, y4: usize) -> usize {
BLK_POS.iter().position(|&p| p == (x4, y4)).expect("in-range")
}
const CBP_INTRA_CODE: [u32; 48] = {
const FROM_CODE: [usize; 48] = [
47, 31, 15, 0, 23, 27, 29, 30, 7, 11, 13, 14, 39, 43, 45, 46, 16, 3, 5, 10, 12, 19,
21, 26, 28, 35, 37, 42, 44, 1, 2, 4, 8, 17, 18, 20, 24, 6, 9, 22, 25, 32, 33, 34, 36,
40, 38, 41,
];
let mut out = [0u32; 48];
let mut i = 0;
while i < 48 {
out[FROM_CODE[i]] = i as u32;
i += 1;
}
out
};
fn chroma_qp(qp: i32) -> i32 {
const T: [i32; 22] = [
29, 30, 31, 32, 32, 33, 34, 34, 35, 35, 36, 36, 37, 37, 37, 38, 38, 38, 39, 39, 39, 39,
];
let qpi = qp.clamp(0, 51);
if qpi < 30 {
qpi
} else {
T[(qpi - 30) as usize]
}
}
pub struct Reconstruction {
pub y: Vec<u8>,
pub u: Vec<u8>,
pub v: Vec<u8>,
pub coded_width: u32,
pub coded_height: u32,
}
struct Ctx {
ry: Vec<u8>,
ru: Vec<u8>,
rv: Vec<u8>,
cw: u32,
ch: u32,
cwc: u32,
chc: u32,
mbw: usize,
nnz_y: Vec<usize>,
nnz_c: [Vec<usize>; 2],
modes: Vec<Option<u8>>,
mb: Vec<MbNeighbor>,
prev_qp_delta_nonzero: bool,
}
impl Ctx {
fn avail_luma(&self, px: i32, py: i32, bx: u32, by: u32) -> bool {
if px < 0 || py < 0 || px >= self.cw as i32 || py >= self.ch as i32 {
return false;
}
self.order_luma(px as u32, py as u32) < self.order_luma(bx, by)
}
fn order_luma(&self, px: u32, py: u32) -> (usize, usize) {
let (mbx, mby) = ((px / MB_SIZE) as usize, (py / MB_SIZE) as usize);
let (x4, y4) = (((px % MB_SIZE) / 4) as usize, ((py % MB_SIZE) / 4) as usize);
(mby * self.mbw + mbx, blk_index(x4, y4))
}
fn avail_chroma(&self, px: i32, py: i32, mbx: usize, mby: usize) -> bool {
if px < 0 || py < 0 || px >= self.cwc as i32 || py >= self.chc as i32 {
return false;
}
let (nx, ny) = ((px as u32 / 8) as usize, (py as u32 / 8) as usize);
ny * self.mbw + nx < mby * self.mbw + mbx
}
}
pub fn compressed_slice_rbsp(
cfg: &H264Config,
y: &[u8],
u: &[u8],
v: &[u8],
qp: i32,
) -> (Vec<u8>, Reconstruction) {
let (cw, ch) = (cfg.coded_width, cfg.coded_height);
let (cwc, chc) = (cw / 2, ch / 2);
let mbw = (cw / MB_SIZE) as usize;
let mbh = (ch / MB_SIZE) as usize;
let mb_qp = adaptive_qp(y, cw, mbw, mbh, qp, cfg.aq_strength);
let mut w = BitWriter::new();
let mut header: Vec<u8> = Vec::new();
w.write_ue(0); w.write_ue(7); w.write_ue(0); w.write_bits(0, 4); w.write_ue(0); w.flag(false); w.flag(false); w.write_se(qp - 26); if cfg.deblock {
w.write_ue(0); w.write_se(0); w.write_se(0); } else {
w.write_ue(1); }
let mut entropy = match cfg.entropy {
EntropyMode::Cavlc => Entropy::Cavlc(w),
EntropyMode::Cabac => {
while !w.is_byte_aligned() {
w.write_bit(1); }
header = w.finish();
Entropy::Cabac(Box::new(Cabac::new(qp)))
}
};
let mut ctx = Ctx {
ry: vec![128; (cw * ch) as usize],
ru: vec![128; (cwc * chc) as usize],
rv: vec![128; (cwc * chc) as usize],
cw,
ch,
cwc,
chc,
mbw,
nnz_y: vec![0; (cw / 4 * (ch / 4)) as usize],
nnz_c: [
vec![0; (cwc / 4 * (chc / 4)) as usize],
vec![0; (cwc / 4 * (chc / 4)) as usize],
],
modes: vec![None; (cw / 4 * (ch / 4)) as usize],
mb: vec![MbNeighbor::default(); mbw * mbh],
prev_qp_delta_nonzero: false,
};
let last = mbw * mbh - 1;
let mut qp_prev = qp;
let mut decoded_qp = vec![qp; mbw * mbh];
for mby in 0..mbh {
for mbx in 0..mbw {
let qp_mb = mb_qp[mby * mbw + mbx];
let sent = encode_macroblock(
&mut entropy,
&mut ctx,
y,
u,
v,
mbx,
mby,
qp_mb,
chroma_qp(qp_mb),
qp_mb - qp_prev,
);
if sent {
qp_prev = qp_mb;
}
decoded_qp[mby * mbw + mbx] = qp_prev;
if let Entropy::Cabac(c) = &mut entropy {
c.terminate(u32::from(mby * mbw + mbx == last));
}
}
}
let rbsp = match entropy {
Entropy::Cavlc(mut w) => {
rbsp_trailing_bits(&mut w);
w.finish()
}
Entropy::Cabac(c) => {
let mut out = header;
out.extend_from_slice(&c.finish());
out
}
};
let (mut ry, mut ru, mut rv) = (ctx.ry, ctx.ru, ctx.rv);
if cfg.deblock {
crate::h264::deblock::deblock(
&mut ry,
&mut ru,
&mut rv,
cw,
ch,
&decoded_qp,
chroma_qp,
);
}
(
rbsp,
Reconstruction {
y: ry,
u: ru,
v: rv,
coded_width: cw,
coded_height: ch,
},
)
}
enum LumaCoding {
NxN(NxNLuma),
I16(I16Luma),
}
struct NxNLuma {
modes: [u8; 16],
levels: [[i32; 16]; 16],
cbp_luma: u32,
}
struct I16Luma {
pred_mode: u8,
dc: [i32; 16],
ac: [[i32; 15]; 16],
cbp_luma: u32,
}
struct ChromaData {
mode: u8,
dc: [[i32; 4]; 2],
ac: [[[i32; 15]; 4]; 2],
cbp: u32,
}
struct Candidate {
coding: LumaCoding,
ssd: u64,
}
struct LumaState {
rec: [u8; 256],
nnz: [usize; 16],
modes: [Option<u8>; 16],
}
#[allow(clippy::too_many_arguments)]
fn encode_macroblock(
w: &mut Entropy,
ctx: &mut Ctx,
y: &[u8],
u: &[u8],
v: &[u8],
mbx: usize,
mby: usize,
qp: i32,
qp_c: i32,
qp_delta: i32,
) -> bool {
let chroma = encode_chroma(ctx, u, v, mbx, mby, qp_c);
let nxn = build_nxn(ctx, y, mbx, mby, qp);
let nxn_state = save_luma(ctx, mbx, mby);
let nxn_cost = rd_cost(nxn.ssd, trial_bits(w, ctx, &nxn.coding, &chroma, mbx, mby, qp_delta), qp);
let i16 = build_i16(ctx, y, mbx, mby, qp);
let i16_cost = rd_cost(i16.ssd, trial_bits(w, ctx, &i16.coding, &chroma, mbx, mby, qp_delta), qp);
let winner = if i16_cost < nxn_cost {
&i16.coding
} else {
restore_luma(ctx, mbx, mby, &nxn_state);
&nxn.coding
};
w.write_mb(ctx, winner, &chroma, mbx, mby, qp_delta);
ctx.mb[mby * ctx.mbw + mbx] = MbNeighbor {
avail: true,
i16: matches!(winner, LumaCoding::I16(_)),
cbp_luma: match winner {
LumaCoding::NxN(l) => l.cbp_luma,
LumaCoding::I16(l) => l.cbp_luma,
},
cbp_chroma: chroma.cbp,
chroma_mode: chroma.mode,
dc_cbf: match winner {
LumaCoding::I16(l) => l.dc.iter().any(|&v| v != 0),
LumaCoding::NxN(_) => false,
},
chroma_dc_cbf: [
chroma.dc[0].iter().any(|&v| v != 0),
chroma.dc[1].iter().any(|&v| v != 0),
],
};
let sent = sends_qp_delta(winner, &chroma);
ctx.prev_qp_delta_nonzero = sent && qp_delta != 0;
sent
}
fn sends_qp_delta(luma: &LumaCoding, chroma: &ChromaData) -> bool {
match luma {
LumaCoding::I16(_) => true,
LumaCoding::NxN(l) => l.cbp_luma != 0 || chroma.cbp != 0,
}
}
fn rd_cost(ssd: u64, bits: usize, qp: i32) -> f64 {
let lambda = 0.85 * (f64::from(qp - 12) / 3.0).exp2();
ssd as f64 + lambda * bits as f64
}
#[allow(clippy::too_many_arguments)]
fn trial_bits(
w: &Entropy,
ctx: &Ctx,
luma: &LumaCoding,
chroma: &ChromaData,
mbx: usize,
mby: usize,
qp_delta: i32,
) -> usize {
let mut t = w.probe();
t.write_mb(ctx, luma, chroma, mbx, mby, qp_delta);
t.bit_len()
}
fn save_luma(ctx: &Ctx, mbx: usize, mby: usize) -> LumaState {
let (ox, oy) = ((mbx * MB_SIZE as usize) as u32, (mby * MB_SIZE as usize) as u32);
let mut rec = [0u8; 256];
for j in 0..16u32 {
let row = ((oy + j) * ctx.cw + ox) as usize;
let dst = (j * 16) as usize;
rec[dst..dst + 16].copy_from_slice(&ctx.ry[row..row + 16]);
}
let mut nnz = [0usize; 16];
let mut modes = [None; 16];
for (blk, &(bx4, by4)) in BLK_POS.iter().enumerate() {
let gi = grid_index(ctx.cw, ox + bx4 as u32 * 4, oy + by4 as u32 * 4);
nnz[blk] = ctx.nnz_y[gi];
modes[blk] = ctx.modes[gi];
}
LumaState { rec, nnz, modes }
}
fn restore_luma(ctx: &mut Ctx, mbx: usize, mby: usize, s: &LumaState) {
let (ox, oy) = ((mbx * MB_SIZE as usize) as u32, (mby * MB_SIZE as usize) as u32);
for j in 0..16u32 {
let row = ((oy + j) * ctx.cw + ox) as usize;
let src = (j * 16) as usize;
ctx.ry[row..row + 16].copy_from_slice(&s.rec[src..src + 16]);
}
for (blk, &(bx4, by4)) in BLK_POS.iter().enumerate() {
let gi = grid_index(ctx.cw, ox + bx4 as u32 * 4, oy + by4 as u32 * 4);
ctx.nnz_y[gi] = s.nnz[blk];
ctx.modes[gi] = s.modes[blk];
}
}
fn build_nxn(ctx: &mut Ctx, y: &[u8], mbx: usize, mby: usize, qp: i32) -> Candidate {
let mut l = NxNLuma {
modes: [intra::DC; 16],
levels: [[0; 16]; 16],
cbp_luma: 0,
};
let mut ssd = 0u64;
for (blk, &(bx4, by4)) in BLK_POS.iter().enumerate() {
let px = (mbx * MB_SIZE as usize + bx4 * 4) as u32;
let py = (mby * MB_SIZE as usize + by4 * 4) as u32;
let n = luma_neighbors(ctx, px, py);
let orig = gather(y, ctx.cw, px, py, 4);
let mode = best_luma_mode(&orig, &n);
let pred = intra::predict4(mode, &n);
let mut resid = [0i32; 16];
for i in 0..16 {
resid[i] = orig[i] - pred[i];
}
let levels = quant4(&forward4(&resid), qp, true);
let res = inverse4(&dequant4(&levels, qp));
let mut rec = [0i32; 16];
for i in 0..16 {
rec[i] = (pred[i] + res[i]).clamp(0, 255);
ssd += ((orig[i] - rec[i]) * (orig[i] - rec[i])) as u64;
}
store(&mut ctx.ry, ctx.cw, px, py, 4, &rec);
let mut scan = [0i32; 16];
for (s, &r) in ZIGZAG4.iter().enumerate() {
scan[s] = levels[r];
}
let nnz = scan.iter().filter(|&&c| c != 0).count();
l.modes[blk] = mode;
l.levels[blk] = scan;
if nnz > 0 {
l.cbp_luma |= 1 << (blk / 4);
}
let gi = grid_index(ctx.cw, px, py);
ctx.nnz_y[gi] = nnz;
ctx.modes[gi] = Some(mode);
}
Candidate {
coding: LumaCoding::NxN(l),
ssd,
}
}
fn build_i16(ctx: &mut Ctx, y: &[u8], mbx: usize, mby: usize, qp: i32) -> Candidate {
let (ox, oy) = ((mbx * MB_SIZE as usize) as u32, (mby * MB_SIZE as usize) as u32);
let n = luma16_neighbors(ctx, mbx, mby);
let orig = gather(y, ctx.cw, ox, oy, 16);
let pred_mode = best_luma16_mode(&orig, &n);
let pred = intra::predict16(pred_mode, &n);
let mut coeff = [[0i32; 16]; 16];
let mut dc = [0i32; 16];
for (blk, &(bx4, by4)) in BLK_POS.iter().enumerate() {
let mut r = [0i32; 16];
for j in 0..4 {
for i in 0..4 {
let k = (by4 * 4 + j) * 16 + bx4 * 4 + i;
r[j * 4 + i] = orig[k] - pred[k];
}
}
coeff[blk] = forward4(&r);
dc[by4 * 4 + bx4] = coeff[blk][0];
}
let hdc = luma_dc_hadamard(&dc);
let mf = quant_mf0((qp % 6) as usize) as i64;
let qbits = 15 + qp / 6 + 2;
let f = (1i64 << qbits) / 3;
let mut dc_levels = [0i32; 16];
for k in 0..16 {
let l = ((hdc[k].abs() as i64) * mf + f) >> qbits;
dc_levels[k] = if hdc[k] < 0 { -(l as i32) } else { l as i32 };
}
fit_luma_dc_levels(&mut dc_levels, qp);
let dc_rec = luma_dc_inverse(&dc_levels, qp);
let mut l = I16Luma {
pred_mode,
dc: [0; 16],
ac: [[0; 15]; 16],
cbp_luma: 0,
};
for (s, &r) in ZIGZAG4.iter().enumerate() {
l.dc[s] = dc_levels[r];
}
let mut ssd = 0u64;
for (blk, &(bx4, by4)) in BLK_POS.iter().enumerate() {
let q = quant4(&coeff[blk], qp, true);
let mut scan = [0i32; 15];
for s in 1..16 {
scan[s - 1] = q[ZIGZAG4[s]];
}
let nnz = scan.iter().filter(|&&c| c != 0).count();
l.ac[blk] = scan;
if nnz > 0 {
l.cbp_luma = 15;
}
let mut deq = dequant4(&q, qp);
deq[0] = dc_rec[by4 * 4 + bx4];
let res = inverse4(&deq);
let mut rec = [0i32; 16];
for j in 0..4 {
for i in 0..4 {
let k = (by4 * 4 + j) * 16 + bx4 * 4 + i;
rec[j * 4 + i] = (pred[k] + res[j * 4 + i]).clamp(0, 255);
let e = orig[k] - rec[j * 4 + i];
ssd += (e * e) as u64;
}
}
let (px, py) = (ox + bx4 as u32 * 4, oy + by4 as u32 * 4);
store(&mut ctx.ry, ctx.cw, px, py, 4, &rec);
let gi = grid_index(ctx.cw, px, py);
ctx.nnz_y[gi] = nnz;
ctx.modes[gi] = None;
}
Candidate {
coding: LumaCoding::I16(l),
ssd,
}
}
fn encode_chroma(
ctx: &mut Ctx,
u: &[u8],
v: &[u8],
mbx: usize,
mby: usize,
qp_c: i32,
) -> ChromaData {
let cnb = chroma_neighbors(ctx, mbx, mby);
let mut d = ChromaData {
mode: best_chroma_mode(ctx, u, v, mbx, mby, &cnb),
dc: [[0; 4]; 2],
ac: [[[0; 15]; 4]; 2],
cbp: 0,
};
for (plane, src) in [(0usize, u), (1usize, v)] {
let cn = chroma_neighbors_plane(ctx, mbx, mby, plane);
let pred = intra::predict_chroma(d.mode, &cn);
let (cx, cy) = ((mbx * 8) as u32, (mby * 8) as u32);
let orig = gather(src, ctx.cwc, cx, cy, 8);
let mut dc = [0i32; 4];
let mut ac_coeff = [[0i32; 16]; 4];
for b in 0..4 {
let (sx, sy) = ((b % 2) * 4, (b / 2) * 4);
let mut r = [0i32; 16];
for j in 0..4 {
for i in 0..4 {
let k = (sy + j) * 8 + sx + i;
r[j * 4 + i] = orig[k] - pred[k];
}
}
let c = forward4(&r);
dc[b] = c[0];
ac_coeff[b] = c;
}
let hdc = chroma_dc_forward(&dc);
let m = (qp_c % 6) as usize;
let qbits = 15 + qp_c / 6 + 1;
let f = (1i64 << qbits) / 3;
let mut dc_levels = [0i32; 4];
for b in 0..4 {
let mf = quant_mf0(m) as i64;
let l = ((hdc[b].abs() as i64) * mf + f) >> qbits;
dc_levels[b] = if hdc[b] < 0 { -(l as i32) } else { l as i32 };
}
crate::h264::transform::fit_chroma_dc_levels(&mut dc_levels, qp_c);
let dc_rec = chroma_dc_inverse(&dc_levels, qp_c);
let mut any_ac = false;
for b in 0..4 {
let q = quant4(&ac_coeff[b], qp_c, true);
let mut scan = [0i32; 15];
for s in 1..16 {
scan[s - 1] = q[ZIGZAG4[s]];
}
let nnz = scan.iter().filter(|&&c| c != 0).count();
d.ac[plane][b] = scan;
any_ac |= nnz > 0;
let mut deq = dequant4(&q, qp_c);
deq[0] = dc_rec[b];
let res = inverse4(&deq);
let (sx, sy) = ((b % 2) * 4, (b / 2) * 4);
let mut rec = [0i32; 16];
for j in 0..4 {
for i in 0..4 {
let k = (sy + j) * 8 + sx + i;
rec[j * 4 + i] = (pred[k] + res[j * 4 + i]).clamp(0, 255);
}
}
let rp = if plane == 0 { &mut ctx.ru } else { &mut ctx.rv };
store(rp, ctx.cwc, cx + sx as u32, cy + sy as u32, 4, &rec);
let gi = grid_index(ctx.cwc, cx + sx as u32, cy + sy as u32);
ctx.nnz_c[plane][gi] = nnz;
}
d.dc[plane] = dc_levels;
if any_ac {
d.cbp = 2;
} else if dc_levels.iter().any(|&c| c != 0) && d.cbp < 1 {
d.cbp = 1;
}
}
d
}
fn adaptive_qp(y: &[u8], cw: u32, mbw: usize, mbh: usize, base: i32, strength: f32) -> Vec<i32> {
if strength == 0.0 {
return vec![base; mbw * mbh];
}
let mut energy = Vec::with_capacity(mbw * mbh);
for mby in 0..mbh {
for mbx in 0..mbw {
let (ox, oy) = ((mbx * MB_SIZE as usize) as u32, (mby * MB_SIZE as usize) as u32);
let (mut sum, mut sq) = (0i64, 0i64);
for j in 0..MB_SIZE {
let row = ((oy + j) * cw + ox) as usize;
for &p in &y[row..row + MB_SIZE as usize] {
sum += i64::from(p);
sq += i64::from(p) * i64::from(p);
}
}
let n = i64::from(MB_SIZE * MB_SIZE);
let var = (sq - sum * sum / n).max(0) as f32 / n as f32;
energy.push((var + 1.0).log2());
}
}
let mean = energy.iter().sum::<f32>() / energy.len() as f32;
energy
.iter()
.map(|e| {
let adj = (strength * (e - mean)).round().clamp(-5.0, 5.0) as i32;
(base + adj).clamp(0, 51)
})
.collect()
}
fn quant_mf0(m: usize) -> i32 {
const MF0: [i32; 6] = [13107, 11916, 10082, 9362, 8192, 7282];
MF0[m]
}
#[allow(clippy::too_many_arguments)]
fn write_macroblock(
w: &mut BitWriter,
ctx: &Ctx,
luma: &LumaCoding,
chroma: &ChromaData,
mbx: usize,
mby: usize,
qp_delta: i32,
) {
match luma {
LumaCoding::NxN(l) => {
w.write_ue(MB_TYPE_I_NXN);
for (blk, &(bx4, by4)) in BLK_POS.iter().enumerate() {
let px = (mbx * MB_SIZE as usize + bx4 * 4) as u32;
let py = (mby * MB_SIZE as usize + by4 * 4) as u32;
let pred = mpm(ctx, px, py);
let mode = l.modes[blk];
if mode == pred {
w.write_bit(1);
} else {
w.write_bit(0);
let rem = if mode > pred { mode - 1 } else { mode };
w.write_bits(rem as u32, 3);
}
}
w.write_ue(chroma.mode as u32);
let cbp = l.cbp_luma | (chroma.cbp << 4);
w.write_ue(CBP_INTRA_CODE[cbp as usize]);
if cbp > 0 {
w.write_se(qp_delta);
}
}
LumaCoding::I16(l) => {
let mb_type = 1
+ u32::from(l.pred_mode)
+ 4 * chroma.cbp
+ 12 * u32::from(l.cbp_luma != 0);
w.write_ue(mb_type);
w.write_ue(chroma.mode as u32);
w.write_se(qp_delta);
}
}
match luma {
LumaCoding::NxN(l) => {
for i8 in 0..4usize {
if l.cbp_luma & (1 << i8) == 0 {
continue;
}
for i4 in 0..4usize {
let blk = i8 * 4 + i4;
let (px, py) = blk_origin(mbx, mby, blk);
let nc = luma_nc(ctx, px, py);
cavlc::encode_block(w, &l.levels[blk], BlockKind::Luma4x4, nc);
}
}
}
LumaCoding::I16(l) => {
let (px0, py0) = blk_origin(mbx, mby, 0);
cavlc::encode_block(w, &l.dc, BlockKind::Luma16x16Dc, luma_nc(ctx, px0, py0));
if l.cbp_luma != 0 {
for blk in 0..16usize {
let (px, py) = blk_origin(mbx, mby, blk);
let nc = luma_nc(ctx, px, py);
cavlc::encode_block(w, &l.ac[blk], BlockKind::Luma16x16Ac, nc);
}
}
}
}
if chroma.cbp & 3 != 0 {
for plane in 0..2 {
cavlc::encode_block(w, &chroma.dc[plane], BlockKind::ChromaDc, -1);
}
}
if chroma.cbp & 2 != 0 {
for plane in 0..2 {
for b in 0..4usize {
let cx = (mbx * 8 + (b % 2) * 4) as u32;
let cy = (mby * 8 + (b / 2) * 4) as u32;
let nc = chroma_nc(ctx, plane, cx, cy);
cavlc::encode_block(w, &chroma.ac[plane][b], BlockKind::ChromaAc, nc);
}
}
}
}
enum Entropy {
Cavlc(BitWriter),
Cabac(Box<Cabac>),
}
impl Entropy {
fn bit_len(&self) -> usize {
match self {
Entropy::Cavlc(w) => w.bit_len(),
Entropy::Cabac(c) => c.bit_len(),
}
}
fn probe(&self) -> Entropy {
match self {
Entropy::Cavlc(_) => Entropy::Cavlc(BitWriter::new()),
Entropy::Cabac(c) => Entropy::Cabac(Box::new(c.probe())),
}
}
#[allow(clippy::too_many_arguments)]
fn write_mb(
&mut self,
ctx: &Ctx,
luma: &LumaCoding,
chroma: &ChromaData,
mbx: usize,
mby: usize,
qp_delta: i32,
) {
match self {
Entropy::Cavlc(w) => write_macroblock(w, ctx, luma, chroma, mbx, mby, qp_delta),
Entropy::Cabac(c) => {
write_macroblock_cabac(c, ctx, luma, chroma, mbx, mby, qp_delta)
}
}
}
}
#[derive(Clone, Copy, Default)]
struct MbNeighbor {
avail: bool,
i16: bool,
cbp_luma: u32,
cbp_chroma: u32,
chroma_mode: u8,
dc_cbf: bool,
chroma_dc_cbf: [bool; 2],
}
impl Ctx {
fn neighbor(&self, mbx: usize, mby: usize, dx: isize, dy: isize) -> MbNeighbor {
let (x, y) = (mbx as isize + dx, mby as isize + dy);
if x < 0 || y < 0 || x >= self.mbw as isize {
return MbNeighbor::default();
}
let i = y as usize * self.mbw + x as usize;
if i >= self.mb.len() {
return MbNeighbor::default();
}
self.mb[i]
}
}
#[allow(clippy::too_many_arguments)]
fn write_macroblock_cabac(
c: &mut Cabac,
ctx: &Ctx,
luma: &LumaCoding,
chroma: &ChromaData,
mbx: usize,
mby: usize,
qp_delta: i32,
) {
let a = ctx.neighbor(mbx, mby, -1, 0);
let b = ctx.neighbor(mbx, mby, 0, -1);
let (a_not_nxn, b_not_nxn) = (a.avail && a.i16, b.avail && b.i16);
let cbp_luma = match luma {
LumaCoding::NxN(l) => l.cbp_luma,
LumaCoding::I16(l) => l.cbp_luma,
};
match luma {
LumaCoding::NxN(l) => {
c.mb_type_nxn(a_not_nxn, b_not_nxn);
for (blk, &(bx4, by4)) in BLK_POS.iter().enumerate() {
let px = (mbx * MB_SIZE as usize + bx4 * 4) as u32;
let py = (mby * MB_SIZE as usize + by4 * 4) as u32;
c.intra4x4_mode(l.modes[blk], mpm(ctx, px, py));
}
}
LumaCoding::I16(l) => {
c.mb_type_i16(
l.pred_mode,
chroma.cbp,
l.cbp_luma != 0,
a_not_nxn,
b_not_nxn,
);
}
}
c.chroma_pred_mode(
chroma.mode,
a.avail && a.chroma_mode != 0,
b.avail && b.chroma_mode != 0,
);
if matches!(luma, LumaCoding::NxN(_)) {
let luma_inc = std::array::from_fn(|b8| cbp_luma_ctx_inc(ctx, mbx, mby, b8, cbp_luma));
let cin0 = usize::from(a.avail && a.cbp_chroma != 0)
+ 2 * usize::from(b.avail && b.cbp_chroma != 0);
let cin1 = usize::from(a.avail && a.cbp_chroma == 2)
+ 2 * usize::from(b.avail && b.cbp_chroma == 2);
c.coded_block_pattern(cbp_luma, chroma.cbp, luma_inc, cin0, cin1);
}
if cbp_luma != 0 || chroma.cbp != 0 || matches!(luma, LumaCoding::I16(_)) {
c.mb_qp_delta(qp_delta, ctx.prev_qp_delta_nonzero);
}
match luma {
LumaCoding::I16(l) => {
let (px0, py0) = blk_origin(mbx, mby, 0);
let dc_cbf = l.dc.iter().any(|&v| v != 0);
let inc = dc_cbf_inc(ctx, mbx, mby);
c.coded_block_flag(cabac::CAT_LUMA_DC, inc, dc_cbf);
if dc_cbf {
c.residual_block(&l.dc, cabac::CAT_LUMA_DC);
}
let _ = (px0, py0);
if l.cbp_luma != 0 {
for blk in 0..16usize {
let (px, py) = blk_origin(mbx, mby, blk);
let cbf = l.ac[blk].iter().any(|&v| v != 0);
let inc = luma_cbf_inc(ctx, px, py);
c.coded_block_flag(cabac::CAT_LUMA_AC, inc, cbf);
if cbf {
c.residual_block(&l.ac[blk], cabac::CAT_LUMA_AC);
}
}
}
}
LumaCoding::NxN(l) => {
for i8 in 0..4usize {
if l.cbp_luma & (1 << i8) == 0 {
continue;
}
for i4 in 0..4usize {
let blk = i8 * 4 + i4;
let (px, py) = blk_origin(mbx, mby, blk);
let cbf = l.levels[blk].iter().any(|&v| v != 0);
let inc = luma_cbf_inc(ctx, px, py);
c.coded_block_flag(cabac::CAT_LUMA_4X4, inc, cbf);
if cbf {
c.residual_block(&l.levels[blk], cabac::CAT_LUMA_4X4);
}
}
}
}
}
if chroma.cbp & 3 != 0 {
for plane in 0..2 {
let cbf = chroma.dc[plane].iter().any(|&v| v != 0);
let inc = chroma_dc_cbf_inc(ctx, mbx, mby, plane);
c.coded_block_flag(cabac::CAT_CHROMA_DC, inc, cbf);
if cbf {
c.residual_block(&chroma.dc[plane], cabac::CAT_CHROMA_DC);
}
}
}
if chroma.cbp & 2 != 0 {
for plane in 0..2 {
for blk in 0..4usize {
let cx = (mbx * 8 + (blk % 2) * 4) as u32;
let cy = (mby * 8 + (blk / 2) * 4) as u32;
let cbf = chroma.ac[plane][blk].iter().any(|&v| v != 0);
let inc = chroma_ac_cbf_inc(ctx, plane, cx, cy, mbx, mby, chroma.cbp);
c.coded_block_flag(cabac::CAT_CHROMA_AC, inc, cbf);
if cbf {
c.residual_block(&chroma.ac[plane][blk], cabac::CAT_CHROMA_AC);
}
}
}
}
}
fn cbp_luma_ctx_inc(ctx: &Ctx, mbx: usize, mby: usize, b8: usize, cbp_here: u32) -> usize {
let left = if b8 % 2 == 1 {
Some((cbp_here, b8 - 1))
} else {
let n = ctx.neighbor(mbx, mby, -1, 0);
n.avail.then_some((n.cbp_luma, b8 + 1))
};
let above = if b8 >= 2 {
Some((cbp_here, b8 - 2))
} else {
let n = ctx.neighbor(mbx, mby, 0, -1);
n.avail.then_some((n.cbp_luma, b8 + 2))
};
let flag = |v: Option<(u32, usize)>| match v {
Some((cbp, idx)) => usize::from((cbp >> idx) & 1 == 0),
None => 0,
};
flag(left) + 2 * flag(above)
}
fn luma_cbf_inc(ctx: &Ctx, px: u32, py: u32) -> usize {
let f = |nx: i32, ny: i32| -> usize {
if !ctx.avail_luma(nx, ny, px, py) {
return 1;
}
usize::from(ctx.nnz_y[grid_index(ctx.cw, nx as u32, ny as u32)] > 0)
};
f(px as i32 - 1, py as i32) + 2 * f(px as i32, py as i32 - 1)
}
fn dc_cbf_inc(ctx: &Ctx, mbx: usize, mby: usize) -> usize {
let f = |n: MbNeighbor| -> usize {
if !n.avail {
return 1;
}
usize::from(n.i16 && n.dc_cbf)
};
f(ctx.neighbor(mbx, mby, -1, 0)) + 2 * f(ctx.neighbor(mbx, mby, 0, -1))
}
fn chroma_dc_cbf_inc(ctx: &Ctx, mbx: usize, mby: usize, plane: usize) -> usize {
let f = |n: MbNeighbor| -> usize {
if !n.avail {
return 1;
}
if n.cbp_chroma == 0 {
return 0; }
usize::from(n.chroma_dc_cbf[plane])
};
f(ctx.neighbor(mbx, mby, -1, 0)) + 2 * f(ctx.neighbor(mbx, mby, 0, -1))
}
fn chroma_ac_cbf_inc(
ctx: &Ctx,
plane: usize,
cx: u32,
cy: u32,
mbx: usize,
mby: usize,
cur_cbp_chroma: u32,
) -> usize {
let f = |nx: i32, ny: i32| -> usize {
if nx < 0 || ny < 0 {
return 1;
}
let (nxu, nyu) = (nx as u32, ny as u32);
if !chroma_block_done(ctx, nxu, nyu, cx, cy) {
return 1;
}
let (mx, my) = ((nxu / 8) as usize, (nyu / 8) as usize);
let cbp = if (mx, my) == (mbx, mby) {
cur_cbp_chroma
} else {
ctx.mb[my * ctx.mbw + mx].cbp_chroma
};
if cbp != 2 {
return 0;
}
usize::from(ctx.nnz_c[plane][grid_index(ctx.cwc, nxu, nyu)] > 0)
};
f(cx as i32 - 1, cy as i32) + 2 * f(cx as i32, cy as i32 - 1)
}
fn blk_origin(mbx: usize, mby: usize, blk: usize) -> (u32, u32) {
let (bx4, by4) = BLK_POS[blk];
(
(mbx * MB_SIZE as usize + bx4 * 4) as u32,
(mby * MB_SIZE as usize + by4 * 4) as u32,
)
}
fn luma16_neighbors(ctx: &Ctx, mbx: usize, mby: usize) -> intra::Neighbors16 {
let s = |x: i32, y: i32| ctx.ry[(y as u32 * ctx.cw + x as u32) as usize] as i32;
let (xi, yi) = ((mbx * MB_SIZE as usize) as i32, (mby * MB_SIZE as usize) as i32);
let (bx, by) = (xi as u32, yi as u32);
let above = (0..16)
.all(|k| ctx.avail_luma(xi + k, yi - 1, bx, by))
.then(|| std::array::from_fn(|k| s(xi + k as i32, yi - 1)));
let left = (0..16)
.all(|k| ctx.avail_luma(xi - 1, yi + k, bx, by))
.then(|| std::array::from_fn(|k| s(xi - 1, yi + k as i32)));
let corner = ctx
.avail_luma(xi - 1, yi - 1, bx, by)
.then(|| s(xi - 1, yi - 1));
intra::Neighbors16 {
above,
left,
corner,
}
}
fn best_luma16_mode(orig: &[i32], n: &intra::Neighbors16) -> u8 {
let mut best = (u64::MAX, intra::I16_DC);
for mode in 0..=3u8 {
if !intra::allowed16(mode, n) {
continue;
}
let p = intra::predict16(mode, n);
let mut satd = 0u64;
for by in 0..4 {
for bx in 0..4 {
let mut blk = [0i32; 16];
for j in 0..4 {
for i in 0..4 {
let k = (by * 4 + j) * 16 + bx * 4 + i;
blk[j * 4 + i] = orig[k] - p[k];
}
}
satd += hadamard_sad(&blk);
}
}
if satd < best.0 {
best = (satd, mode);
}
}
best.1
}
fn hadamard_sad(b: &[i32; 16]) -> u64 {
let t = luma_dc_hadamard(b);
let s: u64 = t.iter().map(|v| v.unsigned_abs() as u64).sum();
s / 4
}
fn mpm(ctx: &Ctx, px: u32, py: u32) -> u8 {
let left = ctx
.avail_luma(px as i32 - 1, py as i32, px, py)
.then(|| ctx.modes[grid_index(ctx.cw, px - 4, py)].unwrap_or(intra::DC));
let above = ctx
.avail_luma(px as i32, py as i32 - 1, px, py)
.then(|| ctx.modes[grid_index(ctx.cw, px, py - 4)].unwrap_or(intra::DC));
match (left, above) {
(Some(a), Some(b)) => a.min(b),
_ => intra::DC,
}
}
fn luma_nc(ctx: &Ctx, px: u32, py: u32) -> i32 {
let left = ctx
.avail_luma(px as i32 - 1, py as i32, px, py)
.then(|| ctx.nnz_y[grid_index(ctx.cw, px - 4, py)]);
let above = ctx
.avail_luma(px as i32, py as i32 - 1, px, py)
.then(|| ctx.nnz_y[grid_index(ctx.cw, px, py - 4)]);
cavlc::derive_nc(left, above)
}
fn chroma_nc(ctx: &Ctx, plane: usize, cx: u32, cy: u32) -> i32 {
let inside = |x: i32, y: i32| x >= 0 && y >= 0;
let left = (inside(cx as i32 - 1, cy as i32)
&& chroma_block_done(ctx, cx - 4, cy, cx, cy))
.then(|| ctx.nnz_c[plane][grid_index(ctx.cwc, cx - 4, cy)]);
let above = (inside(cx as i32, cy as i32 - 1)
&& chroma_block_done(ctx, cx, cy - 4, cx, cy))
.then(|| ctx.nnz_c[plane][grid_index(ctx.cwc, cx, cy - 4)]);
cavlc::derive_nc(left, above)
}
fn chroma_block_done(ctx: &Ctx, nx: u32, ny: u32, cx: u32, cy: u32) -> bool {
let key = |x: u32, y: u32| {
let (mx, my) = ((x / 8) as usize, (y / 8) as usize);
let (bx, by) = (((x % 8) / 4) as usize, ((y % 8) / 4) as usize);
(my * ctx.mbw + mx, by * 2 + bx)
};
key(nx, ny) < key(cx, cy)
}
fn luma_neighbors(ctx: &Ctx, px: u32, py: u32) -> intra::Neighbors4 {
let s = |x: i32, y: i32| ctx.ry[(y as u32 * ctx.cw + x as u32) as usize] as i32;
let (xi, yi) = (px as i32, py as i32);
let above = (0..4)
.all(|k| ctx.avail_luma(xi + k, yi - 1, px, py))
.then(|| [s(xi, yi - 1), s(xi + 1, yi - 1), s(xi + 2, yi - 1), s(xi + 3, yi - 1)]);
let above_right = (0..4)
.all(|k| ctx.avail_luma(xi + 4 + k, yi - 1, px, py))
.then(|| {
[
s(xi + 4, yi - 1),
s(xi + 5, yi - 1),
s(xi + 6, yi - 1),
s(xi + 7, yi - 1),
]
});
let left = (0..4)
.all(|k| ctx.avail_luma(xi - 1, yi + k, px, py))
.then(|| [s(xi - 1, yi), s(xi - 1, yi + 1), s(xi - 1, yi + 2), s(xi - 1, yi + 3)]);
let corner = ctx
.avail_luma(xi - 1, yi - 1, px, py)
.then(|| s(xi - 1, yi - 1));
intra::Neighbors4::new(above, above_right, left, corner)
}
fn chroma_neighbors_plane(ctx: &Ctx, mbx: usize, mby: usize, plane: usize) -> intra::NeighborsC {
let rp: &[u8] = if plane == 0 { &ctx.ru } else { &ctx.rv };
let s = |x: i32, y: i32| rp[(y as u32 * ctx.cwc + x as u32) as usize] as i32;
let (xi, yi) = ((mbx * 8) as i32, (mby * 8) as i32);
let above = (0..8)
.all(|k| ctx.avail_chroma(xi + k, yi - 1, mbx, mby))
.then(|| std::array::from_fn(|k| s(xi + k as i32, yi - 1)));
let left = (0..8)
.all(|k| ctx.avail_chroma(xi - 1, yi + k, mbx, mby))
.then(|| std::array::from_fn(|k| s(xi - 1, yi + k as i32)));
let corner = ctx
.avail_chroma(xi - 1, yi - 1, mbx, mby)
.then(|| s(xi - 1, yi - 1));
intra::NeighborsC {
above,
left,
corner,
}
}
fn chroma_neighbors(ctx: &Ctx, mbx: usize, mby: usize) -> intra::NeighborsC {
chroma_neighbors_plane(ctx, mbx, mby, 0)
}
fn best_luma_mode(orig: &[i32], n: &intra::Neighbors4) -> u8 {
let mut best = (u32::MAX, intra::DC);
for mode in 0..=8u8 {
if !intra::allowed(mode, n) {
continue;
}
let p = intra::predict4(mode, n);
let sad: u32 = orig
.iter()
.zip(&p)
.map(|(&o, &q)| (o - q).unsigned_abs())
.sum();
if sad < best.0 {
best = (sad, mode);
}
}
best.1
}
fn best_chroma_mode(
ctx: &Ctx,
u: &[u8],
v: &[u8],
mbx: usize,
mby: usize,
_hint: &intra::NeighborsC,
) -> u8 {
let (cx, cy) = ((mbx * 8) as u32, (mby * 8) as u32);
let mut best = (u32::MAX, intra::C_DC);
for mode in 0..=3u8 {
let mut sad = 0u32;
let mut ok = true;
for (plane, src) in [(0usize, u), (1usize, v)] {
let n = chroma_neighbors_plane(ctx, mbx, mby, plane);
if !intra::chroma_allowed(mode, &n) {
ok = false;
break;
}
let p = intra::predict_chroma(mode, &n);
let o = gather(src, ctx.cwc, cx, cy, 8);
sad += o
.iter()
.zip(&p)
.map(|(&a, &b)| (a - b).unsigned_abs())
.sum::<u32>();
}
if ok && sad < best.0 {
best = (sad, mode);
}
}
best.1
}
fn grid_index(width: u32, px: u32, py: u32) -> usize {
((py / 4) * (width / 4) + px / 4) as usize
}
fn gather(plane: &[u8], w: u32, x: u32, y: u32, n: u32) -> Vec<i32> {
let mut b = vec![0i32; (n * n) as usize];
for yy in 0..n {
for xx in 0..n {
b[(yy * n + xx) as usize] = plane[((y + yy) * w + x + xx) as usize] as i32;
}
}
b
}
fn store(plane: &mut [u8], w: u32, x: u32, y: u32, n: u32, block: &[i32]) {
for yy in 0..n {
for xx in 0..n {
plane[((y + yy) * w + x + xx) as usize] =
block[(yy * n + xx) as usize].clamp(0, 255) as u8;
}
}
}
impl CompressedEncoder {
pub fn new(width: u32, height: u32, qp: i32) -> Self {
let mut cfg = H264Config::new(width, height);
cfg.qp = qp;
cfg.entropy = EntropyMode::Cabac;
cfg.deblock = true;
cfg.aq_strength = 0.0;
let sps = nal_unit_base(NalUnitType::Sps, &write_sps(&cfg));
let pps = nal_unit_base(
NalUnitType::Pps,
&write_pps_deblock_control(cfg.entropy == EntropyMode::Cabac),
);
Self {
cfg,
qp,
headers_emitted: false,
sps,
pps,
}
}
pub fn deblock(mut self, on: bool) -> Self {
self.cfg.deblock = on;
self
}
pub fn entropy(mut self, mode: EntropyMode) -> Self {
self.cfg.entropy = mode;
self.sps = nal_unit_base(NalUnitType::Sps, &write_sps(&self.cfg));
self.pps = nal_unit_base(
NalUnitType::Pps,
&write_pps_deblock_control(mode == EntropyMode::Cabac),
);
self
}
pub fn aq(mut self, strength: f32) -> Self {
self.cfg.aq_strength = strength;
self
}
pub fn config(&self) -> &H264Config {
&self.cfg
}
pub fn sps(&self) -> &[u8] {
&self.sps
}
pub fn pps(&self) -> &[u8] {
&self.pps
}
pub fn encode_frame(&mut self, frame: &Yuv420Frame) -> (Vec<u8>, Reconstruction) {
assert_eq!(
(frame.width, frame.height),
(self.cfg.width, self.cfg.height),
"frame size differs from encoder size"
);
let (cw, ch) = (self.cfg.coded_width, self.cfg.coded_height);
let y = pad_plane(&frame.y, frame.width, frame.height, cw, ch);
let u = pad_plane(&frame.u, frame.width / 2, frame.height / 2, cw / 2, ch / 2);
let v = pad_plane(&frame.v, frame.width / 2, frame.height / 2, cw / 2, ch / 2);
let (slice, recon) = compressed_slice_rbsp(&self.cfg, &y, &u, &v, self.qp);
let mut au = Vec::new();
if !self.headers_emitted {
push_annexb(&mut au, &self.sps);
push_annexb(&mut au, &self.pps);
self.headers_emitted = true;
}
push_annexb(&mut au, &nal_unit_base(NalUnitType::Idr, &slice));
(au, recon)
}
pub fn encode_slice_au(&self, frame: &Yuv420Frame) -> Vec<u8> {
self.encode_slice_au_at(frame, self.qp)
}
pub fn encode_slice_au_at(&self, frame: &Yuv420Frame, qp: i32) -> Vec<u8> {
let (cw, ch) = (self.cfg.coded_width, self.cfg.coded_height);
let y = pad_plane(&frame.y, frame.width, frame.height, cw, ch);
let u = pad_plane(&frame.u, frame.width / 2, frame.height / 2, cw / 2, ch / 2);
let v = pad_plane(&frame.v, frame.width / 2, frame.height / 2, cw / 2, ch / 2);
let (slice, _recon) = compressed_slice_rbsp(&self.cfg, &y, &u, &v, qp.clamp(0, 51));
let mut au = Vec::new();
push_annexb(&mut au, &nal_unit_base(NalUnitType::Idr, &slice));
au
}
pub fn avcc(&self) -> Vec<u8> {
build_avcc(&self.sps, &self.pps)
}
pub fn encode_sample(&self, frame: &Yuv420Frame) -> Vec<u8> {
self.encode_sample_at(frame, self.qp)
}
pub fn encode_sample_at(&self, frame: &Yuv420Frame, qp: i32) -> Vec<u8> {
H264Encoder::sample_from_au(&self.encode_slice_au_at(frame, qp))
}
}
pub fn encode_mp4(width: u32, height: u32, fps: u32, qp: i32, frames: &[Yuv420Frame]) -> Vec<u8> {
encode_mp4_from_iter(width, height, fps, qp, None, frames.iter().cloned())
}
pub fn encode_mp4_from_iter<I>(
width: u32,
height: u32,
fps: u32,
qp: i32,
captions: Option<&CaptionTrack>,
frames: I,
) -> Vec<u8>
where
I: IntoIterator<Item = Yuv420Frame>,
{
let mut out = Vec::new();
write_mp4_from_iter(&mut out, width, height, fps, qp, captions, frames)
.expect("writing to a Vec cannot fail");
out
}
pub fn write_mp4_from_iter<W, I>(
out: &mut W,
width: u32,
height: u32,
fps: u32,
qp: i32,
captions: Option<&CaptionTrack>,
frames: I,
) -> std::io::Result<()>
where
W: std::io::Write,
I: IntoIterator<Item = Yuv420Frame>,
{
write_mp4_quality(out, width, height, fps, Quality::Qp(qp), captions, frames, None)
}
#[allow(clippy::too_many_arguments)]
pub fn write_mp4_quality<W, I>(
out: &mut W,
width: u32,
height: u32,
fps: u32,
quality: Quality,
captions: Option<&CaptionTrack>,
frames: I,
total: Option<u32>,
) -> std::io::Result<()>
where
W: std::io::Write,
I: IntoIterator<Item = Yuv420Frame>,
{
let fps = fps.max(1);
let timescale = 600u32;
let base_qp = match quality {
Quality::Qp(q) => q,
Quality::Bitrate(_) => PROBE_QP,
};
let enc = CompressedEncoder::new(width, height, base_qp);
let avcc = build_avcc(enc.sps(), enc.pps());
let mut batch = crate::frames_in_flight(width, height);
let mut samples = Vec::new();
let mut frames = frames.into_iter();
let mut rc = match quality {
Quality::Qp(_) => None,
Quality::Bitrate(bps) => Some(RateControl::new(bps, fps, total)),
};
if let Some(r) = rc.as_ref() {
batch = r.group_size(crate::frames_by_memory(width, height));
}
let mut pending: Vec<Yuv420Frame> = Vec::with_capacity(batch);
if let Some(r) = rc.as_mut() {
if let Some(first) = frames.next() {
let probe = enc.encode_slice_au_at(&first, PROBE_QP);
r.seed(PROBE_QP, probe.len());
if let Some(q2) = r.probe_again() {
let again = enc.encode_slice_au_at(&first, q2);
r.seed_pair(q2, again.len());
}
pending.push(first);
}
}
loop {
while pending.len() < batch {
match frames.next() {
Some(f) => pending.push(f),
None => break,
}
}
if pending.is_empty() {
break;
}
let qp = rc.as_ref().map_or(base_qp, |r| r.next_qp());
let aus = crate::map_frames(&pending, |f| enc.encode_slice_au_at(f, qp));
pending.clear();
for au in &aus {
if let Some(r) = rc.as_mut() {
r.observe(qp, au.len());
}
samples.push(H264Encoder::sample_from_au(au));
}
}
match rc.as_ref().and_then(|r| r.outcome()) {
Some(Reach::TooComplex { times }) => eprintln!(
"threers: this content will not fit that bitrate — even at the coarsest \
quantizer it is about {times:.1}x larger. The file is as small as the \
encoder can make it."
),
Some(Reach::TooSimple { times }) => eprintln!(
"threers: this content cannot fill that bitrate — even losslessly quantized \
it is about {times:.1}x smaller, so the file is smaller than asked for. \
That is the content, not a failure."
),
None => {}
}
let params = H264Mp4Params {
width,
height,
timescale,
frame_duration: timescale / fps,
avcc_payload: &avcc,
samples: &samples,
};
crate::mp4::write_h264(out, ¶ms, captions.filter(|t| !t.is_empty()))
}
pub struct CompressedEncoder {
cfg: H264Config,
qp: i32,
headers_emitted: bool,
sps: Vec<u8>,
pps: Vec<u8>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn encode_sample_is_the_length_prefixed_slice() {
let frame = Yuv420Frame::from_rgba(32, 16, &vec![90u8; 32 * 16 * 4]);
let enc = CompressedEncoder::new(32, 16, 30);
assert_eq!(enc.encode_sample(&frame), H264Encoder::sample_from_au(&enc.encode_slice_au(&frame)));
assert_eq!(enc.avcc(), build_avcc(enc.sps(), enc.pps()));
}
#[test]
fn cbp_table_is_a_permutation() {
let mut seen = [false; 48];
for &c in CBP_INTRA_CODE.iter() {
assert!(c < 48, "code number {c} out of range");
assert!(!seen[c as usize], "code number {c} used twice");
seen[c as usize] = true;
}
assert!(seen.iter().all(|&s| s), "some code number is unused");
}
#[test]
fn block_positions_are_a_permutation() {
let mut seen = [[false; 4]; 4];
for &(x, y) in BLK_POS.iter() {
assert!(!seen[y][x], "block position ({x},{y}) repeats");
seen[y][x] = true;
}
assert!(seen.iter().flatten().all(|&s| s));
assert_eq!(BLK_POS[3], (1, 1));
assert_eq!(BLK_POS[4], (2, 0));
assert_eq!(blk_index(2, 0), 4);
}
#[test]
fn chroma_qp_follows_table_8_15() {
assert_eq!(chroma_qp(0), 0);
assert_eq!(chroma_qp(29), 29);
assert_eq!(chroma_qp(30), 29);
assert_eq!(chroma_qp(39), 35);
assert_eq!(chroma_qp(51), 39);
for q in 0..=51 {
assert!(chroma_qp(q) <= q.max(0));
if q > 0 {
assert!(chroma_qp(q) >= chroma_qp(q - 1));
}
}
}
}