]>
Commit | Line | Data |
---|---|---|
1 | //use nihav_core::codecs::{DecoderResult, DecoderError}; | |
2 | ||
3 | use super::*; | |
4 | use super::cabac_coder::*; | |
5 | use super::dsp::{CHROMA_DC_SCAN, ZIGZAG, ZIGZAG1, ZIGZAG8X8}; | |
6 | use super::slice::SliceHeader; | |
7 | ||
8 | pub fn cabac_decode_mbskip(cabac: &mut CABAC, sstate: &SliceState, slice_hdr: &SliceHeader) -> bool { | |
9 | let skip_idx = if slice_hdr.slice_type.is_p() { 11 } else { 24 }; | |
10 | let mut mb_skip_ctx = 0; | |
11 | let left_mbt = sstate.get_left_mb().mb_type; | |
12 | let top_mbt = sstate.get_top_mb().mb_type; | |
13 | if left_mbt != CompactMBType::None && !left_mbt.is_skip() { | |
14 | mb_skip_ctx += 1; | |
15 | } | |
16 | if top_mbt != CompactMBType::None && !top_mbt.is_skip() { | |
17 | mb_skip_ctx += 1; | |
18 | } | |
19 | if !slice_hdr.slice_type.is_intra() { | |
20 | cabac.decode_bit(skip_idx + mb_skip_ctx) | |
21 | } else { | |
22 | false | |
23 | } | |
24 | } | |
25 | ||
26 | fn decode_i_type(cabac: &mut CABAC, start: usize, ctx: usize) -> MBType { | |
27 | if !cabac.decode_bit(start + ctx) { | |
28 | MBType::Intra4x4 | |
29 | } else if !cabac.decode_terminate() { | |
30 | let cbpy = if cabac.decode_bit(start + 3) { 0xF } else { 0x0 }; | |
31 | let cbpc = cabac.decode_012(start + 4); | |
32 | let ipred = cabac.decode_bits(start + 6, start + 7, 2); | |
33 | ||
34 | MBType::Intra16x16(ipred, cbpy, cbpc) | |
35 | } else { | |
36 | MBType::PCM | |
37 | } | |
38 | } | |
39 | ||
40 | fn decode_i_type_inter(cabac: &mut CABAC, start: usize) -> MBType { | |
41 | if !cabac.decode_bit(start) { | |
42 | MBType::Intra4x4 | |
43 | } else if !cabac.decode_terminate() { | |
44 | let cbpy = if cabac.decode_bit(start + 1) { 0xF } else { 0x0 }; | |
45 | let cbpc = if !cabac.decode_bit(start + 2) { | |
46 | 0 | |
47 | } else if !cabac.decode_bit(start + 2) { | |
48 | 1 | |
49 | } else { | |
50 | 2 | |
51 | }; | |
52 | let ipred = cabac.decode_bits(start + 3, start + 3, 2); | |
53 | ||
54 | MBType::Intra16x16(ipred, cbpy, cbpc) | |
55 | } else { | |
56 | MBType::PCM | |
57 | } | |
58 | } | |
59 | ||
60 | fn remap_si_mbtype(mbtype: MBType) -> MBType { | |
61 | match mbtype { | |
62 | MBType::Intra16x16(0, 0, 0) => MBType::Intra4x4, | |
63 | MBType::Intra16x16(imode, cbpy, cbpc) => { | |
64 | let idx = imode + if cbpy != 0 { 12 } else { 0 } + cbpc * 4 - 1; | |
65 | let nimode = idx & 3; | |
66 | let (ncbpy, ncbpc) = if (idx >> 2) >= 3 { | |
67 | (0xF, (idx >> 2) - 3) | |
68 | } else { | |
69 | (0x0, idx >> 2) | |
70 | }; | |
71 | MBType::Intra16x16(nimode, ncbpy, ncbpc) | |
72 | }, | |
73 | MBType::PCM => MBType::Intra16x16(3, 1, 2), | |
74 | _ => mbtype, | |
75 | } | |
76 | } | |
77 | ||
78 | pub fn cabac_decode_mb_type(cabac: &mut CABAC, slice_hdr: &SliceHeader, sstate: &SliceState) -> MBType { | |
79 | match slice_hdr.slice_type { | |
80 | SliceType::I | SliceType::SI => { | |
81 | let mut ctx = 0; | |
82 | if sstate.get_left_mb().mb_type.is_intra16orpcm() { | |
83 | ctx += 1; | |
84 | } | |
85 | if sstate.get_top_mb().mb_type.is_intra16orpcm() { | |
86 | ctx += 1; | |
87 | } | |
88 | let mbtype = decode_i_type(cabac, 3, ctx); | |
89 | if slice_hdr.slice_type == SliceType::I { | |
90 | mbtype | |
91 | } else { | |
92 | remap_si_mbtype(mbtype) | |
93 | } | |
94 | }, | |
95 | SliceType::P | SliceType::SP => { | |
96 | if cabac.decode_bit(14) { | |
97 | decode_i_type_inter(cabac, 17) | |
98 | } else if !cabac.decode_bit(15) { | |
99 | if !cabac.decode_bit(16) { | |
100 | MBType::P16x16 | |
101 | } else { | |
102 | MBType::P8x8 | |
103 | } | |
104 | } else { | |
105 | if !cabac.decode_bit(17) { | |
106 | MBType::P8x16 | |
107 | } else { | |
108 | MBType::P16x8 | |
109 | } | |
110 | } | |
111 | }, | |
112 | SliceType::B => { | |
113 | let mut ctx = 0; | |
114 | if !sstate.get_left_mb().mb_type.is_direct() { | |
115 | ctx += 1; | |
116 | } | |
117 | if !sstate.get_top_mb().mb_type.is_direct() { | |
118 | ctx += 1; | |
119 | } | |
120 | if !cabac.decode_bit(27 + ctx) { | |
121 | MBType::Direct | |
122 | } else if !cabac.decode_bit(30) { | |
123 | if !cabac.decode_bit(32) { | |
124 | MBType::B16x16(BMode::L0) | |
125 | } else { | |
126 | MBType::B16x16(BMode::L1) | |
127 | } | |
128 | } else { | |
129 | let idx = cabac.decode_bits(31, 32, 4); | |
130 | match idx { | |
131 | 0x0 => MBType::B16x16(BMode::Bi), | |
132 | 0x1 => MBType::B16x8(BMode::L0, BMode::L0), | |
133 | 0x2 => MBType::B8x16(BMode::L0, BMode::L0), | |
134 | 0x3 => MBType::B16x8(BMode::L1, BMode::L1), | |
135 | 0x4 => MBType::B8x16(BMode::L1, BMode::L1), | |
136 | 0x5 => MBType::B16x8(BMode::L0, BMode::L1), | |
137 | 0x6 => MBType::B8x16(BMode::L0, BMode::L1), | |
138 | 0x7 => MBType::B16x8(BMode::L1, BMode::L0), | |
139 | 0xE => MBType::B8x16(BMode::L1, BMode::L0), | |
140 | 0xF => MBType::B8x8, | |
141 | 0xD => decode_i_type_inter(cabac, 32), | |
142 | _ => { | |
143 | let idx = (idx - 8) * 2 + (cabac.decode_bit(32) as u8); | |
144 | match idx { | |
145 | 0 => MBType::B16x8(BMode::L0, BMode::Bi), | |
146 | 1 => MBType::B8x16(BMode::L0, BMode::Bi), | |
147 | 2 => MBType::B16x8(BMode::L1, BMode::Bi), | |
148 | 3 => MBType::B8x16(BMode::L1, BMode::Bi), | |
149 | 4 => MBType::B16x8(BMode::Bi, BMode::L0), | |
150 | 5 => MBType::B8x16(BMode::Bi, BMode::L0), | |
151 | 6 => MBType::B16x8(BMode::Bi, BMode::L1), | |
152 | 7 => MBType::B8x16(BMode::Bi, BMode::L1), | |
153 | 8 => MBType::B16x8(BMode::Bi, BMode::Bi), | |
154 | _ => MBType::B8x16(BMode::Bi, BMode::Bi), | |
155 | } | |
156 | }, | |
157 | } | |
158 | } | |
159 | }, | |
160 | } | |
161 | } | |
162 | ||
163 | fn decode_sub_mb_type_cabac(cabac: &mut CABAC, slice_hdr: &SliceHeader) -> SubMBType { | |
164 | match slice_hdr.slice_type { | |
165 | SliceType::P | SliceType::SP => { | |
166 | if cabac.decode_bit(21) { | |
167 | SubMBType::P8x8 | |
168 | } else if !cabac.decode_bit(22) { | |
169 | SubMBType::P8x4 | |
170 | } else if cabac.decode_bit(23) { | |
171 | SubMBType::P4x8 | |
172 | } else { | |
173 | SubMBType::P4x4 | |
174 | } | |
175 | }, | |
176 | SliceType::B => { | |
177 | if !cabac.decode_bit(36) { | |
178 | SubMBType::Direct8x8 | |
179 | } else if !cabac.decode_bit(37) { | |
180 | if !cabac.decode_bit(39) { | |
181 | SubMBType::B8x8(BMode::L0) | |
182 | } else { | |
183 | SubMBType::B8x8(BMode::L1) | |
184 | } | |
185 | } else { | |
186 | let idx = cabac.decode_bits(38, 39, 3); | |
187 | match idx { | |
188 | 0 => SubMBType::B8x8(BMode::Bi), | |
189 | 1 => SubMBType::B8x4(BMode::L0), | |
190 | 2 => SubMBType::B4x8(BMode::L0), | |
191 | 3 => SubMBType::B8x4(BMode::L1), | |
192 | 6 => SubMBType::B4x4(BMode::L1), | |
193 | 7 => SubMBType::B4x4(BMode::Bi), | |
194 | _ => { | |
195 | let idx = (idx - 4) * 2 + (cabac.decode_bit(39) as u8); | |
196 | match idx { | |
197 | 0 => SubMBType::B4x8(BMode::L1), | |
198 | 1 => SubMBType::B8x4(BMode::Bi), | |
199 | 2 => SubMBType::B4x8(BMode::Bi), | |
200 | _ => SubMBType::B4x4(BMode::L0), | |
201 | } | |
202 | }, | |
203 | } | |
204 | } | |
205 | }, | |
206 | _ => unreachable!(), | |
207 | } | |
208 | } | |
209 | ||
210 | fn decode_ref_idx(cabac: &mut CABAC, num_refs: usize, ctx: usize) -> PicRef { | |
211 | if num_refs == 1 { | |
212 | return ZERO_REF; | |
213 | } | |
214 | if !cabac.decode_bit(54 + ctx) { | |
215 | ZERO_REF | |
216 | } else if !cabac.decode_bit(54 + 4) { | |
217 | PicRef::new(1) | |
218 | } else { | |
219 | let mut idx = 2; | |
220 | while cabac.decode_bit(54 + 5) && idx < 32 { | |
221 | idx += 1; | |
222 | } | |
223 | if idx < num_refs { | |
224 | PicRef::new(idx as u8) | |
225 | } else { | |
226 | INVALID_REF | |
227 | } | |
228 | } | |
229 | } | |
230 | ||
231 | fn decode_mv_component(cabac: &mut CABAC, base: usize, ctx: usize) -> i16 { | |
232 | if !cabac.decode_bit(base + ctx) { | |
233 | 0 | |
234 | } else { | |
235 | let mut val = 1; | |
236 | while val < 9 && cabac.decode_bit(base + (2 + val).min(6)) { | |
237 | val += 1; | |
238 | } | |
239 | if val >= 9 { | |
240 | let mut pfx = 3; | |
241 | while pfx < 16 && cabac.decode_bypass() { | |
242 | val += 1 << pfx; | |
243 | pfx += 1; | |
244 | } | |
245 | val += cabac.decode_bypass_bits(pfx) as usize; | |
246 | } | |
247 | if val == 0 || !cabac.decode_bypass() { | |
248 | val as i16 | |
249 | } else { | |
250 | -(val as i16) | |
251 | } | |
252 | } | |
253 | } | |
254 | ||
255 | fn decode_mv(cabac: &mut CABAC, ctx0: usize, ctx1: usize) -> MV { | |
256 | let x = decode_mv_component(cabac, 40, ctx0); | |
257 | let y = decode_mv_component(cabac, 47, ctx1); | |
258 | MV{ x, y } | |
259 | } | |
260 | ||
261 | pub fn decode_mb_pred_cabac(cabac: &mut CABAC, slice_hdr: &SliceHeader, mb_type: MBType, sstate: &mut SliceState, mb_info: &mut CurrentMBInfo) { | |
262 | mb_info.mb_type = mb_type; | |
263 | let num_l0 = slice_hdr.num_ref_idx_l0_active; | |
264 | let num_l1 = slice_hdr.num_ref_idx_l1_active; | |
265 | sstate.reset_mb_mv(); | |
266 | match mb_type { | |
267 | MBType::Intra4x4 => { | |
268 | for &(x, y) in I4X4_SCAN.iter() { | |
269 | let x = x as usize; | |
270 | let y = y as usize; | |
271 | let top_pred = sstate.get_top_blk4(x + y * 4).ipred; | |
272 | let left_pred = sstate.get_left_blk4(x + y * 4).ipred; | |
273 | ||
274 | let top_idx = top_pred.into_pred_idx(); | |
275 | let left_idx = left_pred.into_pred_idx(); | |
276 | let pred_mode = top_idx.min(left_idx); | |
277 | let mut pred_mode = if pred_mode != -1 { pred_mode as u8 } else { 2 }; | |
278 | ||
279 | if !cabac.decode_bit(68) { | |
280 | let m0 = cabac.decode_bit(69) as u8; | |
281 | let m1 = cabac.decode_bit(69) as u8; | |
282 | let m2 = cabac.decode_bit(69) as u8; | |
283 | let new_mode = (m2 << 2) | (m1 << 1) | m0; | |
284 | pred_mode = if new_mode >= pred_mode { | |
285 | new_mode + 1 | |
286 | } else { new_mode }; | |
287 | } | |
288 | mb_info.ipred[x + y * 4] = pred_mode.into(); | |
289 | sstate.get_cur_blk4(x + y * 4).ipred = (pred_mode as u8).into(); | |
290 | } | |
291 | let mut ctx = 0; | |
292 | if sstate.get_left_mb().cmode != 0 { | |
293 | ctx += 1; | |
294 | } | |
295 | if sstate.get_top_mb().cmode != 0 { | |
296 | ctx += 1; | |
297 | } | |
298 | mb_info.chroma_ipred = if !cabac.decode_bit(64 + ctx) { | |
299 | 0 | |
300 | } else if !cabac.decode_bit(67) { | |
301 | 1 | |
302 | } else if !cabac.decode_bit(67) { | |
303 | 2 | |
304 | } else { | |
305 | 3 | |
306 | }; | |
307 | }, | |
308 | MBType::Intra8x8 => { | |
309 | for part in 0..4 { | |
310 | let blk4 = (part & 1) * 2 + (part & 2) * 4; | |
311 | let top_pred = sstate.get_top_blk4(blk4).ipred; | |
312 | let left_pred = sstate.get_left_blk4(blk4).ipred; | |
313 | ||
314 | let top_idx = top_pred.into_pred_idx(); | |
315 | let left_idx = left_pred.into_pred_idx(); | |
316 | let pred_mode = top_idx.min(left_idx); | |
317 | let mut pred_mode = if pred_mode != -1 { pred_mode as u8 } else { 2 }; | |
318 | if !cabac.decode_bit(68) { | |
319 | let m0 = cabac.decode_bit(69) as u8; | |
320 | let m1 = cabac.decode_bit(69) as u8; | |
321 | let m2 = cabac.decode_bit(69) as u8; | |
322 | let new_mode = (m2 << 2) | (m1 << 1) | m0; | |
323 | pred_mode = if new_mode >= pred_mode { | |
324 | new_mode + 1 | |
325 | } else { new_mode }; | |
326 | } | |
327 | mb_info.ipred[blk4] = pred_mode.into(); | |
328 | mb_info.ipred[blk4 + 1] = pred_mode.into(); | |
329 | mb_info.ipred[blk4 + 4] = pred_mode.into(); | |
330 | mb_info.ipred[blk4 + 5] = pred_mode.into(); | |
331 | sstate.get_cur_blk4(blk4).ipred = (pred_mode as u8).into(); | |
332 | sstate.get_cur_blk4(blk4 + 1).ipred = (pred_mode as u8).into(); | |
333 | sstate.get_cur_blk4(blk4 + 4).ipred = (pred_mode as u8).into(); | |
334 | sstate.get_cur_blk4(blk4 + 5).ipred = (pred_mode as u8).into(); | |
335 | } | |
336 | let mut ctx = 0; | |
337 | if sstate.get_left_mb().cmode != 0 { | |
338 | ctx += 1; | |
339 | } | |
340 | if sstate.get_top_mb().cmode != 0 { | |
341 | ctx += 1; | |
342 | } | |
343 | mb_info.chroma_ipred = if !cabac.decode_bit(64 + ctx) { | |
344 | 0 | |
345 | } else if !cabac.decode_bit(67) { | |
346 | 1 | |
347 | } else if !cabac.decode_bit(67) { | |
348 | 2 | |
349 | } else { | |
350 | 3 | |
351 | }; | |
352 | }, | |
353 | MBType::Intra16x16(_ipred, _, _) => { | |
354 | let mut ctx = 0; | |
355 | if sstate.get_left_mb().cmode != 0 { | |
356 | ctx += 1; | |
357 | } | |
358 | if sstate.get_top_mb().cmode != 0 { | |
359 | ctx += 1; | |
360 | } | |
361 | mb_info.chroma_ipred = if !cabac.decode_bit(64 + ctx) { | |
362 | 0 | |
363 | } else if !cabac.decode_bit(67) { | |
364 | 1 | |
365 | } else if !cabac.decode_bit(67) { | |
366 | 2 | |
367 | } else { | |
368 | 3 | |
369 | }; | |
370 | }, | |
371 | MBType::P16x16 | MBType::P16x8 | MBType::P8x16 => { | |
372 | let num_subparts = mb_type.num_parts(); | |
373 | let (pw, ph) = mb_type.size(); | |
374 | let mut xoff = 0; | |
375 | let mut yoff = 0; | |
376 | for i in 0..num_subparts { | |
377 | let ctx = sstate.get_mv_ref_ctx(xoff, yoff, 0); | |
378 | let ref_idx = decode_ref_idx(cabac, num_l0, ctx); | |
379 | mb_info.ref_l0[i] = ref_idx; | |
380 | sstate.fill_ref(xoff, yoff, pw, ph, 0, ref_idx); | |
381 | xoff += pw; | |
382 | if xoff == 16 { | |
383 | xoff = 0; | |
384 | yoff += ph; | |
385 | } | |
386 | } | |
387 | let mut xoff = 0; | |
388 | let mut yoff = 0; | |
389 | for i in 0..num_subparts { | |
390 | let (ctx0, ctx1) = sstate.get_mv_ctx(xoff, yoff, 0); | |
391 | let mv = decode_mv(cabac, ctx0, ctx1); | |
392 | mb_info.mv_l0[i] = mv; | |
393 | sstate.fill_mvd(xoff, yoff, pw, ph, 0, mv); | |
394 | xoff += pw; | |
395 | if xoff == 16 { | |
396 | xoff = 0; | |
397 | yoff += ph; | |
398 | } | |
399 | } | |
400 | }, | |
401 | MBType::B16x16(mode) => { | |
402 | if mode != BMode::L1 { | |
403 | let ctx = sstate.get_mv_ref_ctx(0, 0, 0); | |
404 | let ref_idx = decode_ref_idx(cabac, num_l0, ctx); | |
405 | mb_info.ref_l0[0] = ref_idx; | |
406 | sstate.fill_ref(0, 0, 16, 16, 0, ref_idx); | |
407 | } | |
408 | if mode != BMode::L0 { | |
409 | let ctx = sstate.get_mv_ref_ctx(0, 0, 1); | |
410 | let ref_idx = decode_ref_idx(cabac, num_l1, ctx); | |
411 | mb_info.ref_l1[0] = ref_idx; | |
412 | sstate.fill_ref(0, 0, 16, 16, 1, ref_idx); | |
413 | } | |
414 | if mode != BMode::L1 { | |
415 | let (ctx0, ctx1) = sstate.get_mv_ctx(0, 0, 0); | |
416 | let mv = decode_mv(cabac, ctx0, ctx1); | |
417 | mb_info.mv_l0[0] = mv; | |
418 | sstate.fill_mvd(0, 0, 16, 16, 0, mv); | |
419 | } | |
420 | if mode != BMode::L0 { | |
421 | let (ctx0, ctx1) = sstate.get_mv_ctx(0, 0, 1); | |
422 | let mv = decode_mv(cabac, ctx0, ctx1); | |
423 | mb_info.mv_l1[0] = mv; | |
424 | sstate.fill_mvd(0, 0, 16, 16, 1, mv); | |
425 | } | |
426 | }, | |
427 | MBType::B16x8(mode0, mode1) | MBType::B8x16(mode0, mode1) => { | |
428 | let (pw, ph) = mb_info.mb_type.size(); | |
429 | let (px, py) = (pw & 8, ph & 8); | |
430 | if mode0 != BMode::L1 { | |
431 | let ctx = sstate.get_mv_ref_ctx(0, 0, 0); | |
432 | let ref_idx = decode_ref_idx(cabac, num_l0, ctx); | |
433 | mb_info.ref_l0[0] = ref_idx; | |
434 | sstate.fill_ref(0, 0, pw, ph, 0, ref_idx); | |
435 | } | |
436 | if mode1 != BMode::L1 { | |
437 | let ctx = sstate.get_mv_ref_ctx(pw & 8, ph & 8, 0); | |
438 | let ref_idx = decode_ref_idx(cabac, num_l0, ctx); | |
439 | mb_info.ref_l0[1] = ref_idx; | |
440 | sstate.fill_ref(px, py, pw, ph, 0, ref_idx); | |
441 | } | |
442 | if mode0 != BMode::L0 { | |
443 | let ctx = sstate.get_mv_ref_ctx(0, 0, 1); | |
444 | let ref_idx = decode_ref_idx(cabac, num_l1, ctx); | |
445 | mb_info.ref_l1[0] = ref_idx; | |
446 | sstate.fill_ref(0, 0, pw, ph, 1, ref_idx); | |
447 | } | |
448 | if mode1 != BMode::L0 { | |
449 | let ctx = sstate.get_mv_ref_ctx(pw & 8, ph & 8, 1); | |
450 | let ref_idx = decode_ref_idx(cabac, num_l1, ctx); | |
451 | mb_info.ref_l1[1] = ref_idx; | |
452 | sstate.fill_ref(px, py, pw, ph, 1, ref_idx); | |
453 | } | |
454 | if mode0 != BMode::L1 { | |
455 | let (ctx0, ctx1) = sstate.get_mv_ctx(0, 0, 0); | |
456 | let mv = decode_mv(cabac, ctx0, ctx1); | |
457 | mb_info.mv_l0[0] = mv; | |
458 | sstate.fill_mvd(0, 0, pw, ph, 0, mv); | |
459 | } | |
460 | if mode1 != BMode::L1 { | |
461 | let (ctx0, ctx1) = sstate.get_mv_ctx(pw & 8, ph & 8, 0); | |
462 | let mv = decode_mv(cabac, ctx0, ctx1); | |
463 | mb_info.mv_l0[1] = mv; | |
464 | sstate.fill_mvd(px, py, pw, ph, 0, mv); | |
465 | } | |
466 | if mode0 != BMode::L0 { | |
467 | let (ctx0, ctx1) = sstate.get_mv_ctx(0, 0, 1); | |
468 | let mv = decode_mv(cabac, ctx0, ctx1); | |
469 | mb_info.mv_l1[0] = mv; | |
470 | sstate.fill_mvd(0, 0, pw, ph, 1, mv); | |
471 | } | |
472 | if mode1 != BMode::L0 { | |
473 | let (ctx0, ctx1) = sstate.get_mv_ctx(pw & 8, ph & 8, 1); | |
474 | let mv = decode_mv(cabac, ctx0, ctx1); | |
475 | mb_info.mv_l1[1] = mv; | |
476 | sstate.fill_mvd(px, py, pw, ph, 1, mv); | |
477 | } | |
478 | }, | |
479 | MBType::P8x8 | MBType::B8x8 => { | |
480 | for sub_type in mb_info.sub_mb_type.iter_mut() { | |
481 | *sub_type = decode_sub_mb_type_cabac(cabac, slice_hdr); | |
482 | } | |
483 | let num_l = [num_l0, num_l1]; | |
484 | let dst_ref = [&mut mb_info.ref_l0, &mut mb_info.ref_l1]; | |
485 | for ref_l in 0..2 { | |
486 | for spart in 0..4 { | |
487 | let stype = mb_info.sub_mb_type[spart]; | |
488 | if stype != SubMBType::Direct8x8 && ((ref_l == 0 && !stype.is_l1()) || (ref_l == 1 && !stype.is_l0())) { | |
489 | let ctx = sstate.get_mv_ref_ctx((spart & 1) * 8, (spart & 2) * 4, ref_l); | |
490 | let ref_idx = decode_ref_idx(cabac, num_l[ref_l], ctx); | |
491 | dst_ref[ref_l][spart] = ref_idx; | |
492 | sstate.get_cur_blk8(spart).ref_idx[ref_l] = ref_idx; | |
493 | } | |
494 | } | |
495 | } | |
496 | let dst_mv = [&mut mb_info.mv_l0, &mut mb_info.mv_l1]; | |
497 | for ref_l in 0..2 { | |
498 | for spart in 0..4 { | |
499 | let stype = mb_info.sub_mb_type[spart]; | |
500 | if stype == SubMBType::Direct8x8 || (ref_l == 0 && stype.is_l1()) || (ref_l == 1 && stype.is_l0()) { | |
501 | continue; | |
502 | } | |
503 | let (pw, ph) = stype.size(); | |
504 | let mut xoff = (spart & 1) * 8; | |
505 | let mut yoff = (spart & 2) * 4; | |
506 | let num_sub = stype.num_parts(); | |
507 | let orig_x = xoff; | |
508 | for i in 0..num_sub { | |
509 | let (ctx0, ctx1) = sstate.get_mv_ctx(xoff, yoff, ref_l); | |
510 | let mv = decode_mv(cabac, ctx0, ctx1); | |
511 | dst_mv[ref_l][spart * 4 + i] = mv; | |
512 | sstate.fill_mvd(xoff, yoff, pw, ph, ref_l, mv); | |
513 | xoff += pw; | |
514 | if xoff == orig_x + 8 { | |
515 | xoff -= 8; | |
516 | yoff += ph; | |
517 | } | |
518 | } | |
519 | } | |
520 | } | |
521 | }, | |
522 | _ => {}, | |
523 | }; | |
524 | } | |
525 | ||
526 | pub fn decode_cbp_cabac(cabac: &mut CABAC, sstate: &SliceState) -> (u8, u8) { | |
527 | let mbt_a = sstate.get_left_mb().mb_type; | |
528 | let mbt_b = sstate.get_top_mb().mb_type; | |
529 | let left = if mbt_a == CompactMBType::None || mbt_a == CompactMBType::PCM { | |
530 | 0x3F | |
531 | } else if !mbt_a.is_skip() { | |
532 | sstate.get_left_mb().cbp | |
533 | } else { | |
534 | 0 | |
535 | }; | |
536 | let top = if mbt_b == CompactMBType::None || mbt_b == CompactMBType::PCM { | |
537 | 0x3F | |
538 | } else if !mbt_b.is_skip() { | |
539 | sstate.get_top_mb().cbp | |
540 | } else { | |
541 | 0 | |
542 | }; | |
543 | ||
544 | let cbp_ctx = if (left & 2) != 0 { 0 } else { 1 } + if (top & 4) != 0 { 0 } else { 2 }; | |
545 | let mut cbpy = cabac.decode_bit(73 + cbp_ctx) as u8; | |
546 | let cbp_ctx = if cbpy != 0 { 0 } else { 1 } + if (top & 8) != 0 { 0 } else { 2 }; | |
547 | cbpy |= (cabac.decode_bit(73 + cbp_ctx) as u8) << 1; | |
548 | let cbp_ctx = if (left & 8) != 0 { 0 } else { 1 } + if (cbpy & 1) != 0 { 0 } else { 2 }; | |
549 | cbpy |= (cabac.decode_bit(73 + cbp_ctx) as u8) << 2; | |
550 | let cbp_ctx = if (cbpy & 4) != 0 { 0 } else { 1 } + if (cbpy & 2) != 0 { 0 } else { 2 }; | |
551 | cbpy |= (cabac.decode_bit(73 + cbp_ctx) as u8) << 3; | |
552 | ||
553 | let left = if mbt_a == CompactMBType::PCM { | |
554 | 0x2F | |
555 | } else if mbt_a == CompactMBType::None || !mbt_a.is_skip() { | |
556 | sstate.get_left_mb().cbp | |
557 | } else { | |
558 | 0 | |
559 | }; | |
560 | let top = if mbt_b == CompactMBType::PCM { | |
561 | 0x2F | |
562 | } else if mbt_b == CompactMBType::None || !mbt_b.is_skip() { | |
563 | sstate.get_top_mb().cbp | |
564 | } else { | |
565 | 0 | |
566 | }; | |
567 | let cleft = left >> 4; | |
568 | let ctop = top >> 4; | |
569 | let cbp_ctx0 = if cleft != 0 { 1 } else { 0 } + if ctop != 0 { 2 } else { 0 }; | |
570 | let cbp_ctx1 = if cleft == 2 { 1 } else { 0 } + if ctop == 2 { 2 } else { 0 }; | |
571 | let cbpc = if !cabac.decode_bit(77 + cbp_ctx0) { | |
572 | 0 | |
573 | } else { | |
574 | cabac.decode_bit(81 + cbp_ctx1) as u8 + 1 | |
575 | }; | |
576 | ||
577 | (cbpy, cbpc) | |
578 | } | |
579 | ||
580 | pub fn decode_mb_qp_delta_cabac(cabac: &mut CABAC, ctx: usize) -> i32 { | |
581 | if !cabac.decode_bit(60 + ctx) { | |
582 | 0 | |
583 | } else if !cabac.decode_bit(62) { | |
584 | 1 | |
585 | } else { | |
586 | let mut val = 0; | |
587 | while val < 128 && cabac.decode_bit(63) { | |
588 | val += 1; | |
589 | } | |
590 | if (val & 1) != 0 { | |
591 | ((val >> 1) as i32) + 2 | |
592 | } else { | |
593 | -((val >> 1) as i32) - 1 | |
594 | } | |
595 | } | |
596 | } | |
597 | ||
598 | fn decode_block(cabac: &mut CABAC, coeffs: &mut [i16], cat: usize, ctx_off: usize) -> bool { | |
599 | const CTX_BASE: [(usize, usize); 5] = [ | |
600 | (0, 0), (15, 10), (29, 20), (44, 30), (47, 39) | |
601 | ]; | |
602 | let (flag_off, coef_off) = CTX_BASE[cat]; | |
603 | let scan: &[usize] = match coeffs.len() { | |
604 | 4 => &CHROMA_DC_SCAN, | |
605 | 15 => &ZIGZAG1, | |
606 | 16 => &ZIGZAG, | |
607 | _ => unreachable!(), | |
608 | }; | |
609 | ||
610 | let coded_block_flag = cabac.decode_bit(85 + ctx_off); | |
611 | let mut coded = [false; 16]; | |
612 | if coded_block_flag { | |
613 | let mut last_idx = coeffs.len() - 1; | |
614 | for i in 0..coeffs.len() - 1 { | |
615 | coded[i] = cabac.decode_bit(105 + flag_off + i); // or 277 for interlaced | |
616 | if coded[i] { | |
617 | let last = cabac.decode_bit(166 + flag_off + i); // or 338 for interlaced | |
618 | if last { | |
619 | last_idx = i; | |
620 | break; | |
621 | } | |
622 | } | |
623 | } | |
624 | coded[last_idx] = true; | |
625 | let mut coef_ctx = 0; | |
626 | for i in (0..=last_idx).rev() { | |
627 | if coded[i] { | |
628 | let zero_ctx = if coef_ctx < 4 { coef_ctx + 1 } else { 0 }; | |
629 | coeffs[scan[i]] = if !cabac.decode_bit(227 + coef_off + zero_ctx) { | |
630 | if coef_ctx < 3 { | |
631 | coef_ctx += 1; | |
632 | } | |
633 | 1 | |
634 | } else { | |
635 | let cur_ctx = 227 + coef_off + (coef_ctx + 2).max(5); | |
636 | coef_ctx = (coef_ctx + 1).max(4).min(7); | |
637 | ||
638 | let mut coef = 2; | |
639 | while coef < 15 && cabac.decode_bit(cur_ctx) { | |
640 | coef += 1; | |
641 | } | |
642 | if coef == 15 { | |
643 | let mut pfx = 0; | |
644 | while pfx < 15 && cabac.decode_bypass() { | |
645 | pfx += 1; | |
646 | } | |
647 | let mut tail = 1; | |
648 | for _ in 0..pfx { | |
649 | tail = (tail << 1) + (cabac.decode_bypass() as i16); | |
650 | } | |
651 | coef + tail - 1 | |
652 | } else { | |
653 | coef | |
654 | } | |
655 | }; | |
656 | if cabac.decode_bypass() { | |
657 | coeffs[scan[i]] = -coeffs[scan[i]]; | |
658 | } | |
659 | } | |
660 | } | |
661 | } | |
662 | coded_block_flag | |
663 | } | |
664 | ||
665 | fn decode_block8x8(cabac: &mut CABAC, coeffs: &mut [i16; 64], _cat: usize) { | |
666 | const SIG_FLAG_MAP: [usize; 63] = [ | |
667 | 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, | |
668 | 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9, 10, 9, 8, 7, | |
669 | 7, 6, 11, 12, 13, 11, 6, 7, 8, 9, 14, 10, 9, 8, 6, 11, | |
670 | 12, 13, 11, 6, 9, 14, 10, 9, 11, 12, 13, 11, 14, 10, 12 | |
671 | ]; | |
672 | const LAST_SIG_FLAG_MAP: [usize; 63] = [ | |
673 | 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
674 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
675 | 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
676 | 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
677 | ]; | |
678 | let (flag_off, coef_off) = (0, 0); | |
679 | let scan = &ZIGZAG8X8; | |
680 | ||
681 | let mut coded = [false; 64]; | |
682 | let mut last_idx = coeffs.len() - 1; | |
683 | for i in 0..coeffs.len() - 1 { | |
684 | coded[i] = cabac.decode_bit(402 + flag_off + SIG_FLAG_MAP[i]); | |
685 | if coded[i] { | |
686 | let last = cabac.decode_bit(417 + flag_off + LAST_SIG_FLAG_MAP[i]); | |
687 | if last { | |
688 | last_idx = i; | |
689 | break; | |
690 | } | |
691 | } | |
692 | } | |
693 | coded[last_idx] = true; | |
694 | let mut coef_ctx = 0; | |
695 | for i in (0..=last_idx).rev() { | |
696 | if coded[i] { | |
697 | let zero_ctx = if coef_ctx < 4 { coef_ctx + 1 } else { 0 }; | |
698 | coeffs[scan[i]] = if !cabac.decode_bit(426 + coef_off + zero_ctx) { | |
699 | if coef_ctx < 3 { | |
700 | coef_ctx += 1; | |
701 | } | |
702 | 1 | |
703 | } else { | |
704 | let cur_ctx = 426 + coef_off + (coef_ctx + 2).max(5); | |
705 | coef_ctx = (coef_ctx + 1).max(4).min(7); | |
706 | ||
707 | let mut coef = 2; | |
708 | while coef < 15 && cabac.decode_bit(cur_ctx) { | |
709 | coef += 1; | |
710 | } | |
711 | if coef == 15 { | |
712 | let mut pfx = 0; | |
713 | while pfx < 15 && cabac.decode_bypass() { | |
714 | pfx += 1; | |
715 | } | |
716 | let mut tail = 1; | |
717 | for _ in 0..pfx { | |
718 | tail = (tail << 1) + (cabac.decode_bypass() as i16); | |
719 | } | |
720 | coef + tail - 1 | |
721 | } else { | |
722 | coef | |
723 | } | |
724 | }; | |
725 | if cabac.decode_bypass() { | |
726 | coeffs[scan[i]] = -coeffs[scan[i]]; | |
727 | } | |
728 | } | |
729 | } | |
730 | } | |
731 | ||
732 | fn derive_ctx_off(sstate: &mut SliceState, cat: usize, blk_no: usize) -> usize { | |
733 | let mbt = sstate.get_cur_mb().mb_type; | |
734 | let mut mbt_a = sstate.get_left_mb().mb_type; | |
735 | let mut mbt_b = sstate.get_top_mb().mb_type; | |
736 | let (trans_a, trans_b, mut cond_term_a, mut cond_term_b) = match cat { | |
737 | 0 => { | |
738 | (mbt_a == CompactMBType::Intra16x16, | |
739 | mbt_b == CompactMBType::Intra16x16, | |
740 | (sstate.get_left_mb().coded_flags & 1) as usize, | |
741 | (sstate.get_top_mb().coded_flags & 1) as usize) | |
742 | }, | |
743 | 1 | 2 => { | |
744 | if (blk_no & 3) != 0 { | |
745 | mbt_a = mbt; | |
746 | } | |
747 | if blk_no >= 4 { | |
748 | mbt_b = mbt; | |
749 | } | |
750 | let nc_left = sstate.get_left_blk4(blk_no).ncoded; | |
751 | let nc_top = sstate.get_top_blk4(blk_no).ncoded; | |
752 | (nc_left != 0, | |
753 | nc_top != 0, | |
754 | (nc_left != 0) as usize, | |
755 | (nc_top != 0) as usize) | |
756 | }, | |
757 | 3 => { | |
758 | ((sstate.get_left_mb().cbp & 0x30) != 0, | |
759 | (sstate.get_top_mb().cbp & 0x30) != 0, | |
760 | ((sstate.get_left_mb().coded_flags & (1 << (blk_no + 1 + 16))) != 0) as usize, | |
761 | ((sstate.get_top_mb().coded_flags & (1 << (blk_no + 1 + 16))) != 0) as usize) | |
762 | }, | |
763 | 4 => { | |
764 | let chroma = blk_no >> 2; | |
765 | if (blk_no & 1) != 0 { | |
766 | mbt_a = mbt; | |
767 | } | |
768 | if (blk_no & 2) != 0 { | |
769 | mbt_b = mbt; | |
770 | } | |
771 | ((blk_no & 1) != 0 || (sstate.get_left_mb().cbp & 0x20) != 0, | |
772 | (blk_no & 2) != 0 || (sstate.get_top_mb().cbp & 0x20) != 0, | |
773 | (sstate.get_left_blk8(blk_no & 3).ncoded_c[chroma] != 0) as usize, | |
774 | (sstate.get_top_blk8(blk_no & 3).ncoded_c[chroma] != 0) as usize) | |
775 | }, | |
776 | _ => unreachable!(), | |
777 | }; | |
778 | /*let coded_no = match cat { | |
779 | 0 => 0, | |
780 | 1 | 2 => blk_no + 1, | |
781 | 3 => 1 + 16 + blk_no, | |
782 | 4 => 1 + 16 + 2 + blk_no, | |
783 | _ => unreachable!(), | |
784 | };*/ | |
785 | ||
786 | if mbt_a == CompactMBType::None && mbt.is_inter() { | |
787 | cond_term_a = 0; | |
788 | } | |
789 | if !trans_a && mbt_a != CompactMBType::PCM { | |
790 | cond_term_a = 0; | |
791 | } | |
792 | /*if mbt.is_intra() && pps.constrained_intra_pred && mbt_a.is_inter() && slice_partitioning { | |
793 | cond_term_a = 0; | |
794 | }*/ | |
795 | if (mbt_a == CompactMBType::PCM) || (mbt_a == CompactMBType::None && mbt.is_intra()) { | |
796 | cond_term_a = 1; | |
797 | } | |
798 | ||
799 | if mbt_b == CompactMBType::None && mbt.is_inter() { | |
800 | cond_term_b = 0; | |
801 | } | |
802 | if !trans_b && mbt_b != CompactMBType::PCM { | |
803 | cond_term_b = 0; | |
804 | } | |
805 | /*if mbt.is_intra() && pps.constrained_intra_pred && mbt_b.is_inter() && slice_partitioning { | |
806 | cond_term_b = 0; | |
807 | }*/ | |
808 | if (mbt_b == CompactMBType::PCM) || (mbt_b == CompactMBType::None && mbt.is_intra()) { | |
809 | cond_term_b = 1; | |
810 | } | |
811 | ||
812 | cat * 4 + cond_term_b * 2 + cond_term_a | |
813 | } | |
814 | ||
815 | pub fn decode_residual_cabac(cabac: &mut CABAC, sstate: &mut SliceState, mb_info: &mut CurrentMBInfo) { | |
816 | sstate.get_cur_mb().mb_type = mb_info.mb_type.into(); | |
817 | let mut coded_flags = 0; | |
818 | if mb_info.mb_type.is_intra16x16() { | |
819 | let off = derive_ctx_off(sstate, 0, 0); | |
820 | let coded = decode_block(cabac, &mut mb_info.coeffs[24], 0, off); | |
821 | mb_info.coded[24] = coded; | |
822 | if coded { | |
823 | coded_flags |= 1; | |
824 | } | |
825 | } | |
826 | if !mb_info.transform_size_8x8 { | |
827 | for blk8 in 0..4 { | |
828 | if (mb_info.cbpy & (1 << blk8)) != 0 { | |
829 | for blk4 in 0..4 { | |
830 | let blk_no = (blk8 & 1) * 2 + (blk8 & 2) * 4 + (blk4 & 1) + (blk4 & 2) * 2; | |
831 | let coded = if mb_info.mb_type.is_intra16x16() { | |
832 | let off = derive_ctx_off(sstate, 1, blk_no); | |
833 | decode_block(cabac, &mut mb_info.coeffs[blk_no][1..], 1, off) | |
834 | } else { | |
835 | let off = derive_ctx_off(sstate, 2, blk_no); | |
836 | decode_block(cabac, &mut mb_info.coeffs[blk_no], 2, off) | |
837 | }; | |
838 | sstate.get_cur_blk4(blk_no).ncoded = coded as u8; | |
839 | mb_info.coded[blk_no] = coded; | |
840 | if coded { | |
841 | coded_flags |= 1 << (1 + blk_no); | |
842 | } | |
843 | } | |
844 | } | |
845 | } | |
846 | } else { | |
847 | for blk8 in 0..4 { | |
848 | if (mb_info.cbpy & (1 << blk8)) != 0 { | |
849 | let blk4 = (blk8 & 1) * 2 + (blk8 & 2) * 4; | |
850 | decode_block8x8(cabac, &mut mb_info.coeffs8x8[blk8].coeffs, 5); | |
851 | coded_flags |= 0x33 << blk4; | |
852 | mb_info.coded[blk4] = true; | |
853 | mb_info.coded[blk4 + 1] = true; | |
854 | mb_info.coded[blk4 + 4] = true; | |
855 | mb_info.coded[blk4 + 5] = true; | |
856 | sstate.get_cur_blk4(blk4).ncoded = 1; | |
857 | sstate.get_cur_blk4(blk4 + 1).ncoded = 1; | |
858 | sstate.get_cur_blk4(blk4 + 4).ncoded = 1; | |
859 | sstate.get_cur_blk4(blk4 + 5).ncoded = 1; | |
860 | } | |
861 | } | |
862 | } | |
863 | for chroma in 0..2 { | |
864 | if (mb_info.cbpc & 3) != 0 { | |
865 | let off = derive_ctx_off(sstate, 3, chroma); | |
866 | let coded = decode_block(cabac, &mut mb_info.chroma_dc[chroma], 3, off); | |
867 | if coded { | |
868 | coded_flags |= 1 << (16 + 1 + chroma); | |
869 | } | |
870 | } | |
871 | } | |
872 | for chroma in 0..2 { | |
873 | if (mb_info.cbpc & 2) != 0 { | |
874 | for blk4 in 0..4 { | |
875 | let blk_no = 16 + chroma * 4 + blk4; | |
876 | let off = derive_ctx_off(sstate, 4, blk_no - 16); | |
877 | let coded = decode_block(cabac, &mut mb_info.coeffs[blk_no][1..], 4, off); | |
878 | sstate.get_cur_blk8(blk4).ncoded_c[chroma] = coded as u8; | |
879 | mb_info.coded[blk_no] = coded; | |
880 | if coded { | |
881 | coded_flags |= 1 << (1 + 2 + blk_no); | |
882 | } | |
883 | } | |
884 | } | |
885 | } | |
886 | sstate.get_cur_mb().coded_flags = coded_flags; | |
887 | } |