1use super::params::SliceType;
5use super::parse_cavlc::classify;
6use super::slice::{Result, SliceDec};
7use super::tables::{BLK_XY, FIELD4, FIELD8, LAST8, SIG8, SIG8_FIELD, ZIGZAG4, ZIGZAG8};
8use super::types::*;
9use crate::decode::bits::BitReader;
10use crate::decode::cabac::Cabac;
11
12const CBF_OFF: [usize; 5] = [0, 4, 8, 12, 16];
13const SIG_OFF: [usize; 5] = [0, 15, 29, 44, 47];
14const ABS_OFF: [usize; 5] = [0, 10, 20, 30, 39];
15
16impl SliceDec<'_> {
17 #[inline(always)]
18 fn bin(&mut self, c: &mut Cabac, idx: usize) -> u32 {
19 c.decision(&mut self.ctx[idx])
20 }
21
22 pub fn cabac_field_flag(&mut self, c: &mut Cabac) -> bool {
26 let w = self.pic.w_mbs;
27 let mut inc = (self.mb_field && self.mb_x > 0) as usize;
28 if self.mb_y >= 2 {
29 let m = &self.pic.mbs[self.addr - 2 * w];
30 inc += (m.slice == self.slice_num && m.field) as usize;
31 }
32 self.bin(c, 70 + inc) == 1
33 }
34
35 pub fn cabac_skip_flag(&mut self, c: &mut Cabac) -> bool {
36 let cond = |s: &Self, dx, dy| {
37 s.mb_nb(dx, dy)
38 .map_or(0, |a| !s.pic.mbs[a].kind.is_skip() as usize)
39 };
40 let inc = cond(self, -1, 0) + cond(self, 0, -1);
41 let base = if self.hdr.slice_type == SliceType::P {
42 11
43 } else {
44 24
45 };
46 self.bin(c, base + inc) == 1
47 }
48
49 fn mb_type_i(&mut self, c: &mut Cabac, base: usize) -> u32 {
52 let in_i = base == 3;
53 let b0 = if in_i {
54 let cond = |s: &Self, dx, dy| {
55 s.mb_nb(dx, dy)
56 .map_or(0, |a| !s.pic.mbs[a].kind.is_nxn() as usize)
57 };
58 let inc = cond(self, -1, 0) + cond(self, 0, -1);
59 self.bin(c, 3 + inc)
60 } else {
61 self.bin(c, base)
62 };
63 if b0 == 0 {
64 return 0;
65 }
66 if c.terminate() == 1 {
67 return 25;
68 }
69 let (luma, chroma, pred);
70 if in_i {
71 luma = self.bin(c, 3 + 3);
72 chroma = if self.bin(c, 3 + 4) == 1 {
73 1 + self.bin(c, 3 + 5)
74 } else {
75 0
76 };
77 pred = (self.bin(c, 3 + 6) << 1) | self.bin(c, 3 + 7);
78 } else {
79 luma = self.bin(c, base + 1);
80 chroma = if self.bin(c, base + 2) == 1 {
81 1 + self.bin(c, base + 2)
82 } else {
83 0
84 };
85 pred = (self.bin(c, base + 3) << 1) | self.bin(c, base + 3);
86 }
87 1 + pred + 4 * chroma + 12 * luma
88 }
89
90 fn mb_type_p(&mut self, c: &mut Cabac) -> u32 {
91 if self.bin(c, 14) == 1 {
92 return 5 + self.mb_type_i(c, 17);
93 }
94 if self.bin(c, 15) == 0 {
95 if self.bin(c, 16) == 0 {
96 0
97 } else {
98 3
99 }
100 } else if self.bin(c, 17) == 1 {
101 1
102 } else {
103 2
104 }
105 }
106
107 fn mb_type_b(&mut self, c: &mut Cabac) -> u32 {
108 let cond = |s: &Self, dx, dy| {
109 s.mb_nb(dx, dy)
110 .map_or(0, |a| !s.pic.mbs[a].b_direct16 as usize)
111 };
112 let inc = cond(self, -1, 0) + cond(self, 0, -1);
113 if self.bin(c, 27 + inc) == 0 {
114 return 0;
115 }
116 if self.bin(c, 27 + 3) == 0 {
117 return 1 + self.bin(c, 27 + 5);
118 }
119 let mut bits = self.bin(c, 27 + 4) << 3;
120 bits |= self.bin(c, 27 + 5) << 2;
121 bits |= self.bin(c, 27 + 5) << 1;
122 bits |= self.bin(c, 27 + 5);
123 match bits {
124 0..=7 => bits + 3,
125 13 => 23 + self.mb_type_i(c, 32),
126 14 => 11,
127 15 => 22,
128 _ => ((bits << 1) | self.bin(c, 27 + 5)) - 4,
129 }
130 }
131
132 fn sub_mb_type_p(&mut self, c: &mut Cabac) -> u8 {
133 if self.bin(c, 21) == 1 {
134 0
135 } else if self.bin(c, 22) == 0 {
136 1
137 } else if self.bin(c, 23) == 1 {
138 2
139 } else {
140 3
141 }
142 }
143
144 fn sub_mb_type_b(&mut self, c: &mut Cabac) -> u8 {
145 if self.bin(c, 36) == 0 {
146 return 0;
147 }
148 if self.bin(c, 37) == 0 {
149 return 1 + self.bin(c, 39) as u8;
150 }
151 let mut t = 3u8;
152 if self.bin(c, 38) == 1 {
153 if self.bin(c, 39) == 1 {
154 return 11 + self.bin(c, 39) as u8;
155 }
156 t += 4;
157 }
158 t += 2 * self.bin(c, 39) as u8;
159 t += self.bin(c, 39) as u8;
160 t
161 }
162
163 fn ref_cond(&self, l: usize, x: isize, y: isize) -> usize {
166 let Some((a, k)) = self.blk_nb(x, y) else {
167 return 0;
168 };
169 let m = &self.pic.mbs[a];
170 if m.kind.is_skip() || m.kind.is_intra() {
171 return 0;
172 }
173 let k8 = (k / 8) * 2 + (k % 4) / 2;
174 if m.direct8 & (1 << k8) != 0 {
175 return 0;
176 }
177 let r = m.ref_idx[l][k8];
178 let r = if self.mbaff && !self.mb_field && m.field {
180 r >> 1
181 } else {
182 r
183 };
184 (r > 0) as usize
185 }
186
187 fn ref_idx_cabac(&mut self, c: &mut Cabac, l: usize, x: usize, y: usize) -> Result<i8> {
188 let inc = self.ref_cond(l, x as isize - 1, y as isize)
189 + 2 * self.ref_cond(l, x as isize, y as isize - 1);
190 let mut v = 0u32;
191 if self.bin(c, 54 + inc) == 1 {
192 v = 1;
193 if self.bin(c, 54 + 4) == 1 {
194 v = 2;
195 while self.bin(c, 54 + 5) == 1 {
196 v += 1;
197 if v > 32 {
198 return Err("ref_idx too large".into());
199 }
200 }
201 }
202 }
203 if v >= self.num_ref(l) {
204 return Err(format!("ref_idx_l{l} {v} out of range"));
205 }
206 Ok(v as i8)
207 }
208
209 fn mvd_abs_nb(&self, l: usize, comp: usize, x: isize, y: isize) -> u32 {
210 let Some((a, k)) = self.blk_nb(x, y) else {
211 return 0;
212 };
213 let m = &self.pic.mbs[a];
214 let v = m.mvd[l][k][comp] as u32;
215 if comp == 1
218 && self.mbaff
219 && m.field != self.mb_field
220 && m.ref_idx[l][(k / 8) * 2 + (k % 4) / 2] >= 0
221 {
222 return if self.mb_field { v >> 1 } else { v << 1 };
223 }
224 v
225 }
226
227 fn mvd_cabac(
228 &mut self,
229 c: &mut Cabac,
230 l: usize,
231 comp: usize,
232 x: usize,
233 y: usize,
234 ) -> Result<i32> {
235 let sum = self.mvd_abs_nb(l, comp, x as isize - 1, y as isize)
236 + self.mvd_abs_nb(l, comp, x as isize, y as isize - 1);
237 let inc = if sum < 3 {
238 0
239 } else if sum <= 32 {
240 1
241 } else {
242 2
243 };
244 let base = if comp == 0 { 40 } else { 47 };
245 if self.bin(c, base + inc) == 0 {
246 return Ok(0);
247 }
248 const INC: [usize; 8] = [3, 4, 5, 6, 6, 6, 6, 6];
249 let mut abs = 1i32;
250 while abs < 9 && self.bin(c, base + INC[abs as usize - 1]) == 1 {
251 abs += 1;
252 }
253 if abs >= 9 {
254 let mut k = 3;
255 while c.bypass() == 1 {
256 abs += 1 << k;
257 k += 1;
258 if k > 24 {
259 return Err("mvd suffix too long".into());
260 }
261 }
262 abs += c.bypass_bits(k) as i32;
263 }
264 Ok(if c.bypass() == 1 { -abs } else { abs })
265 }
266
267 fn parse_mvd_pair(
268 &mut self,
269 c: &mut Cabac,
270 l: usize,
271 x: usize,
272 y: usize,
273 w: usize,
274 h: usize,
275 ) -> Result<()> {
276 let dx = self.mvd_cabac(c, l, 0, x, y)?;
277 let dy = self.mvd_cabac(c, l, 1, x, y)?;
278 self.fill_mvd(l, x, y, w, h, [dx, dy]);
279 Ok(())
280 }
281
282 fn note_ref(&mut self, l: usize, x: usize, y: usize, w: usize, h: usize, r: i8) {
285 let m = &mut self.pic.mbs[self.addr];
286 for yy in (y..y + h).step_by(2) {
287 for xx in (x..x + w).step_by(2) {
288 m.ref_idx[l][(yy / 2) * 2 + xx / 2] = r;
289 }
290 }
291 }
292
293 pub fn parse_mb_cabac(&mut self, c: &mut Cabac) -> Result<()> {
294 let st = self.hdr.slice_type;
295 let raw = match st {
296 SliceType::I => self.mb_type_i(c, 3),
297 SliceType::P => self.mb_type_p(c),
298 SliceType::B => self.mb_type_b(c),
299 };
300 let (kind, t) = classify(st, raw)?;
301 self.syn.kind = kind;
302 self.syn.mb_type = t;
303 if kind == MbKind::IPcm {
304 let start = c.aligned_byte_pos();
305 let data = c.data();
306 let mut r = BitReader::new(data);
307 r.set_pos(start * 8);
308 self.read_pcm(&mut r);
309 c.restart(r.byte_pos());
310 return Ok(());
311 }
312 let mut no_sub_lt8x8 = true;
313 let is_8x8 = (kind == MbKind::P && t >= 3) || (kind == MbKind::B && t == 22);
314 let b_direct16 = kind == MbKind::B && t == 0;
315 if b_direct16 {
316 self.pic.mbs[self.addr].b_direct16 = true;
317 self.pic.mbs[self.addr].direct8 = 0xF;
318 }
319 match kind {
320 MbKind::I4x4 => {
321 if self.pps.transform_8x8_mode && self.t8x8_flag(c) {
322 self.syn.t8x8 = true;
323 self.syn.kind = MbKind::I8x8;
324 }
325 let n = if self.syn.t8x8 { 4 } else { 16 };
326 for i in 0..n {
327 self.syn.prev_flag[i] = self.bin(c, 68) == 1;
328 if !self.syn.prev_flag[i] {
329 let b0 = self.bin(c, 69);
330 let b1 = self.bin(c, 69);
331 let b2 = self.bin(c, 69);
332 self.syn.rem[i] = (b0 | (b1 << 1) | (b2 << 2)) as u8;
333 }
334 }
335 if self.chroma {
336 self.syn.chroma_mode = self.chroma_mode_cabac(c);
337 }
338 }
339 MbKind::I16x16 => {
340 self.set_i16(t);
341 if self.chroma {
342 self.syn.chroma_mode = self.chroma_mode_cabac(c);
343 }
344 }
345 _ if b_direct16 => {}
346 _ if is_8x8 => {
347 for s in 0..4 {
348 self.syn.sub[s] = if kind == MbKind::B {
349 self.sub_mb_type_b(c)
350 } else {
351 self.sub_mb_type_p(c)
352 };
353 }
354 let subs: [(PredFlags, usize, usize); 4] = std::array::from_fn(|s| {
355 if kind == MbKind::B {
356 b_sub_layout(self.syn.sub[s])
357 } else {
358 p_sub_layout(self.syn.sub[s])
359 }
360 });
361 let mut direct = 0u8;
362 for (s, &(pred, w, h)) in subs.iter().enumerate() {
363 if pred == 0 {
364 direct |= 1 << s;
365 if !self.sps.direct_8x8_inference {
366 no_sub_lt8x8 = false;
367 }
368 } else if w * h < 4 {
369 no_sub_lt8x8 = false;
370 }
371 }
372 self.pic.mbs[self.addr].direct8 = direct;
373 let ref0 = kind == MbKind::P && t == 4;
374 for l in 0..2 {
375 for s in 0..4 {
376 let (sx, sy) = ((s % 2) * 2, (s / 2) * 2);
377 if subs[s].0 & (1 << l) != 0 {
378 let r = if ref0 || self.num_ref(l) <= 1 {
379 0
380 } else {
381 self.ref_idx_cabac(c, l, sx, sy)?
382 };
383 self.syn.ref_idx[l][s] = r;
384 self.note_ref(l, sx, sy, 2, 2, r);
385 }
386 }
387 }
388 for l in 0..2 {
389 for s in 0..4 {
390 let (pred, w, h) = subs[s];
391 if pred & (1 << l) == 0 {
392 continue;
393 }
394 let (sx, sy) = ((s % 2) * 2, (s / 2) * 2);
395 for py in (0..2).step_by(h) {
396 for px in (0..2).step_by(w) {
397 self.parse_mvd_pair(c, l, sx + px, sy + py, w, h)?;
398 }
399 }
400 }
401 }
402 }
403 _ => {
404 let (shape, preds) = if kind == MbKind::B {
405 b_mb_layout(t)
406 } else {
407 p_mb_layout(t)
408 };
409 let parts = shape.parts();
410 for l in 0..2 {
411 for (i, &(x, y, w, h)) in parts.iter().enumerate() {
412 if preds[i] & (1 << l) != 0 {
413 let r = if self.num_ref(l) <= 1 {
414 0
415 } else {
416 self.ref_idx_cabac(c, l, x, y)?
417 };
418 self.syn.ref_idx[l][i] = r;
419 self.note_ref(l, x, y, w, h, r);
420 }
421 }
422 }
423 for l in 0..2 {
424 for (i, &(x, y, w, h)) in parts.iter().enumerate() {
425 if preds[i] & (1 << l) != 0 {
426 self.parse_mvd_pair(c, l, x, y, w, h)?;
427 }
428 }
429 }
430 }
431 }
432 if self.syn.kind != MbKind::I16x16 {
433 self.syn.cbp = self.cbp_cabac(c);
434 if self.syn.cbp & 15 != 0
435 && self.pps.transform_8x8_mode
436 && !self.syn.kind.is_intra()
437 && no_sub_lt8x8
438 && (!b_direct16 || self.sps.direct_8x8_inference)
439 {
440 self.syn.t8x8 = self.t8x8_flag(c);
441 }
442 }
443 self.pic.mbs[self.addr].cbp = self.syn.cbp;
445 self.pic.mbs[self.addr].t8x8 = self.syn.t8x8;
446 self.pic.mbs[self.addr].kind = self.syn.kind;
447 if self.syn.cbp != 0 || self.syn.kind == MbKind::I16x16 {
448 self.syn.qp_delta = self.qp_delta_cabac(c)?;
449 self.residual_cabac(c)?;
450 }
451 Ok(())
452 }
453
454 fn t8x8_flag(&mut self, c: &mut Cabac) -> bool {
455 let cond = |s: &Self, dx, dy| s.mb_nb(dx, dy).map_or(0, |a| s.pic.mbs[a].t8x8 as usize);
456 let inc = cond(self, -1, 0) + cond(self, 0, -1);
457 self.bin(c, 399 + inc) == 1
458 }
459
460 fn chroma_mode_cabac(&mut self, c: &mut Cabac) -> u8 {
461 let cond = |s: &Self, dx, dy| {
462 s.mb_nb(dx, dy).map_or(0, |a| {
463 let m = &s.pic.mbs[a];
464 (m.kind.is_intra() && m.kind != MbKind::IPcm && m.chroma_mode != 0) as usize
465 })
466 };
467 let inc = cond(self, -1, 0) + cond(self, 0, -1);
468 if self.bin(c, 64 + inc) == 0 {
469 0
470 } else if self.bin(c, 64 + 3) == 0 {
471 1
472 } else if self.bin(c, 64 + 3) == 0 {
473 2
474 } else {
475 3
476 }
477 }
478
479 fn cbp_cabac(&mut self, c: &mut Cabac) -> u8 {
480 let nb8 = |s: &Self, x: isize, y: isize| {
484 s.blk_nb(x, y)
485 .map(|(a, k)| (s.pic.mbs[a].cbp >> ((k / 8) * 2 + (k % 4) / 2)) & 1)
486 };
487 let mut cbp = 0u8;
488 for b8 in 0..4usize {
489 let a = if b8 % 2 == 1 {
491 (cbp >> (b8 - 1)) & 1 == 0
492 } else {
493 nb8(self, -1, 2 * (b8 / 2) as isize) == Some(0)
494 };
495 let b = if b8 >= 2 {
496 (cbp >> (b8 - 2)) & 1 == 0
497 } else {
498 nb8(self, 2 * (b8 % 2) as isize, -1) == Some(0)
499 };
500 let inc = a as usize + 2 * b as usize;
501 cbp |= (self.bin(c, 73 + inc) as u8) << b8;
502 }
503 if self.chroma {
504 let left = self.mb_nb(-1, 0).map(|a| self.pic.mbs[a].cbp);
505 let top = self.mb_nb(0, -1).map(|a| self.pic.mbs[a].cbp);
506 let ca = left.map_or(0, |l| l >> 4);
507 let cb = top.map_or(0, |t| t >> 4);
508 let inc = (ca > 0) as usize + 2 * (cb > 0) as usize;
509 if self.bin(c, 77 + inc) == 1 {
510 let inc = (ca == 2) as usize + 2 * (cb == 2) as usize;
511 let v = 1 + self.bin(c, 77 + 4 + inc) as u8;
512 cbp |= v << 4;
513 }
514 }
515 cbp
516 }
517
518 fn qp_delta_cabac(&mut self, c: &mut Cabac) -> Result<i32> {
519 let inc = self.prev_qp_nz as usize;
520 if self.bin(c, 60 + inc) == 0 {
521 return Ok(0);
522 }
523 let mut k = 1i32;
524 if self.bin(c, 60 + 2) == 1 {
525 k = 2;
526 while self.bin(c, 60 + 3) == 1 {
527 k += 1;
528 if k > 200 {
529 return Err("mb_qp_delta too long".into());
530 }
531 }
532 }
533 Ok(if k & 1 == 1 { (k + 1) / 2 } else { -(k / 2) })
534 }
535
536 fn cbf_term(&self, v: Option<bool>) -> usize {
539 match v {
540 Some(b) => b as usize,
541 None => self.syn.kind.is_intra() as usize,
542 }
543 }
544
545 fn cbf_luma4(&self, x: isize, y: isize) -> Option<bool> {
546 let (a, k) = self.blk_nb(x, y)?;
547 Some(self.pic.mbs[a].nnz[k] != 0)
548 }
549
550 fn cbf_chroma_ac(&self, comp: usize, x: isize, y: isize) -> Option<bool> {
551 let (a, k) = self.cblk_nb(x, y)?;
552 Some(self.pic.mbs[a].nnz_c[comp][k] != 0)
553 }
554
555 fn cbf_dc(&self, bit: u8, dx: isize, dy: isize) -> Option<bool> {
556 let a = self.mb_nb(dx, dy)?;
557 Some(self.pic.mbs[a].cbf_dc & (1 << bit) != 0)
558 }
559
560 fn block_cabac(
564 &mut self,
565 c: &mut Cabac,
566 cat: usize,
567 max: usize,
568 cbf_inc: Option<usize>,
569 out: &mut [i32],
570 ) -> Result<usize> {
571 if let Some(inc) = cbf_inc
572 && self.bin(c, 85 + CBF_OFF[cat] + inc) == 0
573 {
574 return Ok(0);
575 }
576 let field = self.field_coded();
577 let (sig_base, last_base, abs_base) = match (cat == 5, field) {
578 (true, false) => (402, 417, 426),
579 (true, true) => (436, 451, 426),
580 (false, false) => (105 + SIG_OFF[cat], 166 + SIG_OFF[cat], 227 + ABS_OFF[cat]),
581 (false, true) => (277 + SIG_OFF[cat], 338 + SIG_OFF[cat], 227 + ABS_OFF[cat]),
582 };
583 let sig8 = if field { &SIG8_FIELD } else { &SIG8 };
584 let mut sig = [0u8; 64];
585 let mut n = 0usize;
586 let mut last = max - 1;
587 for i in 0..max - 1 {
588 let (si, li) = match cat {
589 3 => ((i / (max / 4)).min(2), (i / (max / 4)).min(2)),
591 5 => (sig8[i] as usize, LAST8[i] as usize),
592 _ => (i, i),
593 };
594 if self.bin(c, sig_base + si) == 1 {
595 sig[n] = i as u8;
596 n += 1;
597 if self.bin(c, last_base + li) == 1 {
598 last = i;
599 break;
600 }
601 }
602 }
603 if last == max - 1 && (n == 0 || sig[n - 1] as usize != max - 1) {
604 sig[n] = (max - 1) as u8;
605 n += 1;
606 }
607 let mut gt1 = 0usize;
608 let mut eq1 = 0usize;
609 let gt1_cap = if cat == 3 { 3 } else { 4 };
610 for j in (0..n).rev() {
611 let inc0 = if gt1 != 0 { 0 } else { (1 + eq1).min(4) };
612 let mut v = 0i32;
613 if self.bin(c, abs_base + inc0) == 1 {
614 v = 1;
615 let inc = 5 + gt1.min(gt1_cap);
616 while v < 14 && self.bin(c, abs_base + inc) == 1 {
617 v += 1;
618 }
619 if v == 14 {
620 let mut k = 0;
621 while c.bypass() == 1 {
622 v += 1 << k;
623 k += 1;
624 if k > 24 {
625 return Err("coeff_abs_level suffix too long".into());
626 }
627 }
628 v += c.bypass_bits(k) as i32;
629 }
630 }
631 let abs = v + 1;
632 if abs == 1 {
633 eq1 += 1;
634 } else {
635 gt1 += 1;
636 }
637 out[sig[j] as usize] = if c.bypass() == 1 { -abs } else { abs };
638 }
639 Ok(n)
640 }
641
642 fn residual_cabac(&mut self, c: &mut Cabac) -> Result<()> {
643 let (z4, z8) = if self.field_coded() {
644 (&FIELD4, &FIELD8)
645 } else {
646 (&ZIGZAG4, &ZIGZAG8)
647 };
648 let cbp_l = self.syn.cbp & 15;
649 let cbp_c = self.syn.cbp >> 4;
650 let i16 = self.syn.kind == MbKind::I16x16;
651 let t8 = self.syn.t8x8;
652 let mut tmp = [0i32; 64];
653 if i16 {
654 let inc =
655 self.cbf_term(self.cbf_dc(0, -1, 0)) + 2 * self.cbf_term(self.cbf_dc(0, 0, -1));
656 tmp[..16].fill(0);
657 let n = self.block_cabac(c, 0, 16, Some(inc), &mut tmp)?;
658 for k in 0..16 {
659 self.syn.dc_luma[z4[k]] = tmp[k];
660 }
661 if n > 0 {
662 self.pic.mbs[self.addr].cbf_dc |= 1;
663 }
664 }
665 for b8 in 0..4 {
666 if cbp_l & (1 << b8) == 0 {
667 continue;
668 }
669 if t8 {
670 tmp.fill(0);
671 let n = self.block_cabac(c, 5, 64, None, &mut tmp)?;
672 for k in 0..64 {
673 self.syn.coef8[b8][z8[k]] = tmp[k];
674 }
675 if n > 0 {
676 self.syn.coded8 |= 1 << b8;
677 }
678 let (bx, by) = ((b8 % 2) * 2, (b8 / 2) * 2);
679 for d in [0, 1, 4, 5] {
680 self.pic.mbs[self.addr].nnz[by * 4 + bx + d] = n as u8;
681 }
682 continue;
683 }
684 for b4 in 0..4 {
685 let blk = b8 * 4 + b4;
686 let (bx, by) = BLK_XY[blk];
687 let inc = self.cbf_term(self.cbf_luma4(bx as isize - 1, by as isize))
688 + 2 * self.cbf_term(self.cbf_luma4(bx as isize, by as isize - 1));
689 tmp[..16].fill(0);
690 let n = if i16 {
691 let n = self.block_cabac(c, 1, 15, Some(inc), &mut tmp)?;
692 for k in 0..15 {
693 self.syn.coef[blk][z4[k + 1]] = tmp[k];
694 }
695 n
696 } else {
697 let n = self.block_cabac(c, 2, 16, Some(inc), &mut tmp)?;
698 for k in 0..16 {
699 self.syn.coef[blk][z4[k]] = tmp[k];
700 }
701 n
702 };
703 if n > 0 {
704 self.syn.coded |= 1 << blk;
705 }
706 self.pic.mbs[self.addr].nnz[by * 4 + bx] = n as u8;
707 }
708 }
709 if self.chroma && cbp_c != 0 {
710 for comp in 0..2 {
711 let bit = 1 + comp as u8;
712 let inc = self.cbf_term(self.cbf_dc(bit, -1, 0))
713 + 2 * self.cbf_term(self.cbf_dc(bit, 0, -1));
714 let nmax = if self.c422 { 8 } else { 4 };
715 tmp[..nmax].fill(0);
716 let n = self.block_cabac(c, 3, nmax, Some(inc), &mut tmp)?;
717 self.syn.dc_c[comp][..nmax].copy_from_slice(&tmp[..nmax]);
718 if n > 0 {
719 self.pic.mbs[self.addr].cbf_dc |= 1 << bit;
720 }
721 }
722 if cbp_c & 2 != 0 {
723 for comp in 0..2 {
724 for blk in 0..if self.c422 { 8 } else { 4 } {
725 let (bx, by) = ((blk % 2) as isize, (blk / 2) as isize);
726 let inc = self.cbf_term(self.cbf_chroma_ac(comp, bx - 1, by))
727 + 2 * self.cbf_term(self.cbf_chroma_ac(comp, bx, by - 1));
728 tmp[..16].fill(0);
729 let n = self.block_cabac(c, 4, 15, Some(inc), &mut tmp)?;
730 for k in 0..15 {
731 self.syn.ac_c[comp][blk][z4[k + 1]] = tmp[k];
732 }
733 if n > 0 {
734 self.syn.coded_c[comp] |= 1 << blk;
735 }
736 self.pic.mbs[self.addr].nnz_c[comp][blk] = n as u8;
737 }
738 }
739 }
740 }
741 Ok(())
742 }
743}