Skip to main content

threers_codec/decode/vp9/
probs.rs

1//! VP9 probability contexts, symbol counts, and backward adaptation
2//! (ffmpeg `vp9dec.h` ProbContext / counts, `vp9prob.c`).
3
4use super::data::DEFAULT_COEF_PROBS;
5use super::{
6    CompPred, FilterMode, Header, DC_PRED, DIAG_DOWN_LEFT_PRED, DIAG_DOWN_RIGHT_PRED,
7    HOR_DOWN_PRED, HOR_PRED, HOR_UP_PRED, TM_VP8_PRED, TX_SWITCHABLE, VERT_LEFT_PRED, VERT_PRED,
8    VERT_RIGHT_PRED,
9};
10
11#[derive(Clone, Copy, Debug)]
12pub struct MvCompProbs {
13    pub sign: u8,
14    pub classes: [u8; 10],
15    pub class0: u8,
16    pub bits: [u8; 10],
17    pub class0_fp: [[u8; 3]; 2],
18    pub fp: [u8; 3],
19    pub class0_hp: u8,
20    pub hp: u8,
21}
22
23#[derive(Clone, Copy, Debug)]
24pub struct ProbContext {
25    pub y_mode: [[u8; 9]; 4],
26    pub uv_mode: [[u8; 9]; 10],
27    pub filter: [[u8; 2]; 4],
28    pub mv_mode: [[u8; 3]; 7],
29    pub intra: [u8; 4],
30    pub comp: [u8; 5],
31    pub single_ref: [[u8; 2]; 5],
32    pub comp_ref: [u8; 5],
33    pub tx32p: [[u8; 3]; 2],
34    pub tx16p: [[u8; 2]; 2],
35    pub tx8p: [u8; 2],
36    pub skip: [u8; 3],
37    pub mv_joint: [u8; 3],
38    pub mv_comp: [MvCompProbs; 2],
39    pub partition: [[[u8; 3]; 4]; 4],
40}
41
42/// `[tx][plane][inter][band][ctx][n]` coefficient probabilities or counts.
43pub type CoefArr<T, const N: usize> = [[[[[[T; N]; 6]; 6]; 2]; 2]; 4];
44
45/// A saved frame context: modes and the 3 coded coefficient probabilities.
46#[derive(Clone)]
47pub struct SavedCtx {
48    pub p: ProbContext,
49    pub coef: CoefArr<u8, 3>,
50}
51
52impl SavedCtx {
53    pub fn default_ctx() -> Self {
54        SavedCtx {
55            p: super::data::DEFAULT_PROBS,
56            coef: DEFAULT_COEF_PROBS,
57        }
58    }
59}
60
61#[derive(Clone, Copy, Default)]
62pub struct MvCompCounts {
63    pub sign: [u32; 2],
64    pub classes: [u32; 11],
65    pub class0: [u32; 2],
66    pub bits: [[u32; 2]; 10],
67    pub class0_fp: [[u32; 4]; 2],
68    pub fp: [u32; 4],
69    pub class0_hp: [u32; 2],
70    pub hp: [u32; 2],
71}
72
73#[derive(Clone)]
74pub struct Counts {
75    pub y_mode: [[u32; 10]; 4],
76    pub uv_mode: [[u32; 10]; 10],
77    pub filter: [[u32; 3]; 4],
78    pub mv_mode: [[u32; 4]; 7],
79    pub intra: [[u32; 2]; 4],
80    pub comp: [[u32; 2]; 5],
81    pub single_ref: [[[u32; 2]; 2]; 5],
82    pub comp_ref: [[u32; 2]; 5],
83    pub tx32p: [[u32; 4]; 2],
84    pub tx16p: [[u32; 3]; 2],
85    pub tx8p: [[u32; 2]; 2],
86    pub skip: [[u32; 2]; 3],
87    pub mv_joint: [u32; 4],
88    pub mv_comp: [MvCompCounts; 2],
89    pub partition: [[[u32; 4]; 4]; 4],
90    pub coef: CoefArr<u32, 3>,
91    pub eob: CoefArr<u32, 2>,
92}
93
94impl Counts {
95    pub fn new() -> Box<Self> {
96        Box::new(Counts {
97            y_mode: [[0; 10]; 4],
98            uv_mode: [[0; 10]; 10],
99            filter: [[0; 3]; 4],
100            mv_mode: [[0; 4]; 7],
101            intra: [[0; 2]; 4],
102            comp: [[0; 2]; 5],
103            single_ref: [[[0; 2]; 2]; 5],
104            comp_ref: [[0; 2]; 5],
105            tx32p: [[0; 4]; 2],
106            tx16p: [[0; 3]; 2],
107            tx8p: [[0; 2]; 2],
108            skip: [[0; 2]; 3],
109            mv_joint: [0; 4],
110            mv_comp: [MvCompCounts::default(); 2],
111            partition: [[[0; 4]; 4]; 4],
112            coef: [[[[[[0; 3]; 6]; 6]; 2]; 2]; 4],
113            eob: [[[[[[0; 2]; 6]; 6]; 2]; 2]; 4],
114        })
115    }
116}
117
118/// `adapt_prob`.
119#[inline]
120fn adapt(p: &mut u8, ct0: u32, ct1: u32, max_count: u32, update_factor: u32) {
121    let ct = ct0 + ct1;
122    if ct == 0 {
123        return;
124    }
125    let uf = (update_factor * ct.min(max_count) / max_count) as i64;
126    let p1 = *p as i64;
127    let p2 = (((ct0 as i64) << 8) + (ct as i64 >> 1)) / ct as i64;
128    let p2 = p2.clamp(1, 255);
129    *p = (p1 + (((p2 - p1) * uf + 128) >> 8)) as u8;
130}
131
132/// `ff_vp9_adapt_probs`: fold this frame's counts into the saved context
133/// `ctx` (the frame's `framectxid`). `cur` is the probability set the frame
134/// was decoded with; `last_keyframe` whether the previous frame was a key.
135pub fn adapt_probs(
136    ctx: &mut SavedCtx,
137    cur: &ProbContext,
138    counts: &Counts,
139    h: &Header,
140    last_keyframe: bool,
141) {
142    let uf = if h.keyframe || h.intraonly || !last_keyframe {
143        112
144    } else {
145        128
146    };
147    for i in 0..4 {
148        for j in 0..2 {
149            for k in 0..2 {
150                for l in 0..6 {
151                    for m in 0..6 {
152                        if l == 0 && m >= 3 {
153                            break;
154                        }
155                        let pp = &mut ctx.coef[i][j][k][l][m];
156                        let e = &counts.eob[i][j][k][l][m];
157                        let c = &counts.coef[i][j][k][l][m];
158                        adapt(&mut pp[0], e[0], e[1], 24, uf);
159                        adapt(&mut pp[1], c[0], c[1] + c[2], 24, uf);
160                        adapt(&mut pp[2], c[1], c[2], 24, uf);
161                    }
162                }
163            }
164        }
165    }
166    let p = &mut ctx.p;
167    if h.keyframe || h.intraonly {
168        p.skip = cur.skip;
169        p.tx32p = cur.tx32p;
170        p.tx16p = cur.tx16p;
171        p.tx8p = cur.tx8p;
172        return;
173    }
174    for i in 0..3 {
175        adapt(
176            &mut p.skip[i],
177            counts.skip[i][0],
178            counts.skip[i][1],
179            20,
180            128,
181        );
182    }
183    for i in 0..4 {
184        adapt(
185            &mut p.intra[i],
186            counts.intra[i][0],
187            counts.intra[i][1],
188            20,
189            128,
190        );
191    }
192    if h.comppredmode == CompPred::Switchable {
193        for i in 0..5 {
194            adapt(
195                &mut p.comp[i],
196                counts.comp[i][0],
197                counts.comp[i][1],
198                20,
199                128,
200            );
201        }
202    }
203    if h.comppredmode != CompPred::Single {
204        for i in 0..5 {
205            adapt(
206                &mut p.comp_ref[i],
207                counts.comp_ref[i][0],
208                counts.comp_ref[i][1],
209                20,
210                128,
211            );
212        }
213    }
214    if h.comppredmode != CompPred::Comp {
215        for i in 0..5 {
216            let c = &counts.single_ref[i];
217            adapt(&mut p.single_ref[i][0], c[0][0], c[0][1], 20, 128);
218            adapt(&mut p.single_ref[i][1], c[1][0], c[1][1], 20, 128);
219        }
220    }
221    for i in 0..4 {
222        for j in 0..4 {
223            let c = &counts.partition[i][j];
224            let pp = &mut p.partition[i][j];
225            adapt(&mut pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
226            adapt(&mut pp[1], c[1], c[2] + c[3], 20, 128);
227            adapt(&mut pp[2], c[2], c[3], 20, 128);
228        }
229    }
230    if h.txfmmode == TX_SWITCHABLE {
231        for i in 0..2 {
232            let (c16, c32) = (&counts.tx16p[i], &counts.tx32p[i]);
233            adapt(
234                &mut p.tx8p[i],
235                counts.tx8p[i][0],
236                counts.tx8p[i][1],
237                20,
238                128,
239            );
240            adapt(&mut p.tx16p[i][0], c16[0], c16[1] + c16[2], 20, 128);
241            adapt(&mut p.tx16p[i][1], c16[1], c16[2], 20, 128);
242            adapt(
243                &mut p.tx32p[i][0],
244                c32[0],
245                c32[1] + c32[2] + c32[3],
246                20,
247                128,
248            );
249            adapt(&mut p.tx32p[i][1], c32[1], c32[2] + c32[3], 20, 128);
250            adapt(&mut p.tx32p[i][2], c32[2], c32[3], 20, 128);
251        }
252    }
253    if h.filtermode == FilterMode::Switchable {
254        for i in 0..4 {
255            let c = &counts.filter[i];
256            adapt(&mut p.filter[i][0], c[0], c[1] + c[2], 20, 128);
257            adapt(&mut p.filter[i][1], c[1], c[2], 20, 128);
258        }
259    }
260    for i in 0..7 {
261        let c = &counts.mv_mode[i];
262        let pp = &mut p.mv_mode[i];
263        adapt(&mut pp[0], c[2], c[1] + c[0] + c[3], 20, 128);
264        adapt(&mut pp[1], c[0], c[1] + c[3], 20, 128);
265        adapt(&mut pp[2], c[1], c[3], 20, 128);
266    }
267    {
268        let c = &counts.mv_joint;
269        adapt(&mut p.mv_joint[0], c[0], c[1] + c[2] + c[3], 20, 128);
270        adapt(&mut p.mv_joint[1], c[1], c[2] + c[3], 20, 128);
271        adapt(&mut p.mv_joint[2], c[2], c[3], 20, 128);
272    }
273    for i in 0..2 {
274        let cc = &counts.mv_comp[i];
275        let pc = &mut p.mv_comp[i];
276        adapt(&mut pc.sign, cc.sign[0], cc.sign[1], 20, 128);
277        let c = &cc.classes;
278        let pp = &mut pc.classes;
279        let mut sum = c[1] + c[2] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9] + c[10];
280        adapt(&mut pp[0], c[0], sum, 20, 128);
281        sum -= c[1];
282        adapt(&mut pp[1], c[1], sum, 20, 128);
283        sum -= c[2] + c[3];
284        adapt(&mut pp[2], c[2] + c[3], sum, 20, 128);
285        adapt(&mut pp[3], c[2], c[3], 20, 128);
286        sum -= c[4] + c[5];
287        adapt(&mut pp[4], c[4] + c[5], sum, 20, 128);
288        adapt(&mut pp[5], c[4], c[5], 20, 128);
289        sum -= c[6];
290        adapt(&mut pp[6], c[6], sum, 20, 128);
291        adapt(&mut pp[7], c[7] + c[8], c[9] + c[10], 20, 128);
292        adapt(&mut pp[8], c[7], c[8], 20, 128);
293        adapt(&mut pp[9], c[9], c[10], 20, 128);
294        adapt(&mut pc.class0, cc.class0[0], cc.class0[1], 20, 128);
295        for j in 0..10 {
296            adapt(&mut pc.bits[j], cc.bits[j][0], cc.bits[j][1], 20, 128);
297        }
298        for j in 0..2 {
299            let c = &cc.class0_fp[j];
300            let pp = &mut pc.class0_fp[j];
301            adapt(&mut pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
302            adapt(&mut pp[1], c[1], c[2] + c[3], 20, 128);
303            adapt(&mut pp[2], c[2], c[3], 20, 128);
304        }
305        let c = &cc.fp;
306        adapt(&mut pc.fp[0], c[0], c[1] + c[2] + c[3], 20, 128);
307        adapt(&mut pc.fp[1], c[1], c[2] + c[3], 20, 128);
308        adapt(&mut pc.fp[2], c[2], c[3], 20, 128);
309        if h.highprecisionmvs {
310            adapt(&mut pc.class0_hp, cc.class0_hp[0], cc.class0_hp[1], 20, 128);
311            adapt(&mut pc.hp, cc.hp[0], cc.hp[1], 20, 128);
312        }
313    }
314    let modes = |pp: &mut [u8; 9], c: &[u32; 10]| {
315        let mut sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
316        adapt(&mut pp[0], c[DC_PRED], sum, 20, 128);
317        sum -= c[TM_VP8_PRED];
318        adapt(&mut pp[1], c[TM_VP8_PRED], sum, 20, 128);
319        sum -= c[VERT_PRED];
320        adapt(&mut pp[2], c[VERT_PRED], sum, 20, 128);
321        let mut s2 = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
322        sum -= s2;
323        adapt(&mut pp[3], s2, sum, 20, 128);
324        s2 -= c[HOR_PRED];
325        adapt(&mut pp[4], c[HOR_PRED], s2, 20, 128);
326        adapt(
327            &mut pp[5],
328            c[DIAG_DOWN_RIGHT_PRED],
329            c[VERT_RIGHT_PRED],
330            20,
331            128,
332        );
333        sum -= c[DIAG_DOWN_LEFT_PRED];
334        adapt(&mut pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
335        sum -= c[VERT_LEFT_PRED];
336        adapt(&mut pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
337        adapt(&mut pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
338    };
339    for i in 0..4 {
340        modes(&mut p.y_mode[i], &counts.y_mode[i]);
341    }
342    for i in 0..10 {
343        modes(&mut p.uv_mode[i], &counts.uv_mode[i]);
344    }
345}