1use 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
42pub type CoefArr<T, const N: usize> = [[[[[[T; N]; 6]; 6]; 2]; 2]; 4];
44
45#[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#[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
132pub 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}