hevc: optimize residual coding(cherry picked from commit 70692a44708157b4dfa50e402e44...
[ffmpeg.git] / libavcodec / hevc_cabac.c
1 /*
2  * HEVC CABAC decoding
3  *
4  * Copyright (C) 2012 - 2013 Guillaume Martres
5  * Copyright (C) 2012 - 2013 Gildas Cocherel
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 #include "libavutil/attributes.h"
25 #include "libavutil/common.h"
26
27 #include "cabac_functions.h"
28 #include "hevc.h"
29
30 #define CABAC_MAX_BIN 100
31
32 /**
33  * number of bin by SyntaxElement.
34  */
35 static const int8_t num_bins_in_se[] = {
36      1,  // sao_merge_flag
37      1,  // sao_type_idx
38      0,  // sao_eo_class
39      0,  // sao_band_position
40      0,  // sao_offset_abs
41      0,  // sao_offset_sign
42      0,  // end_of_slice_flag
43      3,  // split_coding_unit_flag
44      1,  // cu_transquant_bypass_flag
45      3,  // skip_flag
46      3,  // cu_qp_delta
47      1,  // pred_mode
48      4,  // part_mode
49      0,  // pcm_flag
50      1,  // prev_intra_luma_pred_mode
51      0,  // mpm_idx
52      0,  // rem_intra_luma_pred_mode
53      2,  // intra_chroma_pred_mode
54      1,  // merge_flag
55      1,  // merge_idx
56      5,  // inter_pred_idc
57      2,  // ref_idx_l0
58      2,  // ref_idx_l1
59      2,  // abs_mvd_greater0_flag
60      2,  // abs_mvd_greater1_flag
61      0,  // abs_mvd_minus2
62      0,  // mvd_sign_flag
63      1,  // mvp_lx_flag
64      1,  // no_residual_data_flag
65      3,  // split_transform_flag
66      2,  // cbf_luma
67      4,  // cbf_cb, cbf_cr
68      2,  // transform_skip_flag[][]
69     18,  // last_significant_coeff_x_prefix
70     18,  // last_significant_coeff_y_prefix
71      0,  // last_significant_coeff_x_suffix
72      0,  // last_significant_coeff_y_suffix
73      4,  // significant_coeff_group_flag
74     42,  // significant_coeff_flag
75     24,  // coeff_abs_level_greater1_flag
76      6,  // coeff_abs_level_greater2_flag
77      0,  // coeff_abs_level_remaining
78      0,  // coeff_sign_flag
79 };
80
81 /**
82  * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
83  */
84 static const int elem_offset[sizeof(num_bins_in_se)] = {
85     0,
86     1,
87     2,
88     2,
89     2,
90     2,
91     2,
92     2,
93     5,
94     6,
95     9,
96     12,
97     13,
98     17,
99     17,
100     18,
101     18,
102     18,
103     20,
104     21,
105     22,
106     27,
107     29,
108     31,
109     33,
110     35,
111     35,
112     35,
113     36,
114     37,
115     40,
116     42,
117     46,
118     48,
119     66,
120     84,
121     84,
122     84,
123     88,
124     130,
125     154,
126     160,
127     160,
128 };
129
130 #define CNU 154
131 /**
132  * Indexed by init_type
133  */
134 static const uint8_t init_values[3][HEVC_CONTEXTS] = {
135     {
136         // sao_merge_flag
137         153,
138         // sao_type_idx
139         200,
140         // split_coding_unit_flag
141         139, 141, 157,
142         // cu_transquant_bypass_flag
143         154,
144         // skip_flag
145         CNU, CNU, CNU,
146         // cu_qp_delta
147         154, 154, 154,
148         // pred_mode
149         CNU,
150         // part_mode
151         184, CNU, CNU, CNU,
152         // prev_intra_luma_pred_mode
153         184,
154         // intra_chroma_pred_mode
155         63, 139,
156         // merge_flag
157         CNU,
158         // merge_idx
159         CNU,
160         // inter_pred_idc
161         CNU, CNU, CNU, CNU, CNU,
162         // ref_idx_l0
163         CNU, CNU,
164         // ref_idx_l1
165         CNU, CNU,
166         // abs_mvd_greater1_flag
167         CNU, CNU,
168         // abs_mvd_greater1_flag
169         CNU, CNU,
170         // mvp_lx_flag
171         CNU,
172         // no_residual_data_flag
173         CNU,
174         // split_transform_flag
175         153, 138, 138,
176         // cbf_luma
177         111, 141,
178         // cbf_cb, cbf_cr
179         94, 138, 182, 154,
180         // transform_skip_flag
181         139, 139,
182         // last_significant_coeff_x_prefix
183         110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
184          79, 108, 123,  63,
185         // last_significant_coeff_y_prefix
186         110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
187          79, 108, 123,  63,
188         // significant_coeff_group_flag
189         91, 171, 134, 141,
190         // significant_coeff_flag
191         111, 111, 125, 110, 110,  94, 124, 108, 124, 107, 125, 141, 179, 153,
192         125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
193         139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
194         // coeff_abs_level_greater1_flag
195         140,  92, 137, 138, 140, 152, 138, 139, 153,  74, 149,  92, 139, 107,
196         122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
197         // coeff_abs_level_greater2_flag
198         138, 153, 136, 167, 152, 152,
199     },
200     {
201         // sao_merge_flag
202         153,
203         // sao_type_idx
204         185,
205         // split_coding_unit_flag
206         107, 139, 126,
207         // cu_transquant_bypass_flag
208         154,
209         // skip_flag
210         197, 185, 201,
211         // cu_qp_delta
212         154, 154, 154,
213         // pred_mode
214         149,
215         // part_mode
216         154, 139, 154, 154,
217         // prev_intra_luma_pred_mode
218         154,
219         // intra_chroma_pred_mode
220         152, 139,
221         // merge_flag
222         110,
223         // merge_idx
224         122,
225         // inter_pred_idc
226         95, 79, 63, 31, 31,
227         // ref_idx_l0
228         153, 153,
229         // ref_idx_l1
230         153, 153,
231         // abs_mvd_greater1_flag
232         140, 198,
233         // abs_mvd_greater1_flag
234         140, 198,
235         // mvp_lx_flag
236         168,
237         // no_residual_data_flag
238         79,
239         // split_transform_flag
240         124, 138, 94,
241         // cbf_luma
242         153, 111,
243         // cbf_cb, cbf_cr
244         149, 107, 167, 154,
245         // transform_skip_flag
246         139, 139,
247         // last_significant_coeff_x_prefix
248         125, 110,  94, 110,  95,  79, 125, 111, 110,  78, 110, 111, 111,  95,
249          94, 108, 123, 108,
250         // last_significant_coeff_y_prefix
251         125, 110,  94, 110,  95,  79, 125, 111, 110,  78, 110, 111, 111,  95,
252          94, 108, 123, 108,
253         // significant_coeff_group_flag
254         121, 140, 61, 154,
255         // significant_coeff_flag
256         155, 154, 139, 153, 139, 123, 123,  63, 153, 166, 183, 140, 136, 153,
257         154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
258         153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
259         // coeff_abs_level_greater1_flag
260         154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
261         136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
262         // coeff_abs_level_greater2_flag
263         107, 167, 91, 122, 107, 167,
264     },
265     {
266         // sao_merge_flag
267         153,
268         // sao_type_idx
269         160,
270         // split_coding_unit_flag
271         107, 139, 126,
272         // cu_transquant_bypass_flag
273         154,
274         // skip_flag
275         197, 185, 201,
276         // cu_qp_delta
277         154, 154, 154,
278         // pred_mode
279         134,
280         // part_mode
281         154, 139, 154, 154,
282         // prev_intra_luma_pred_mode
283         183,
284         // intra_chroma_pred_mode
285         152, 139,
286         // merge_flag
287         154,
288         // merge_idx
289         137,
290         // inter_pred_idc
291         95, 79, 63, 31, 31,
292         // ref_idx_l0
293         153, 153,
294         // ref_idx_l1
295         153, 153,
296         // abs_mvd_greater1_flag
297         169, 198,
298         // abs_mvd_greater1_flag
299         169, 198,
300         // mvp_lx_flag
301         168,
302         // no_residual_data_flag
303         79,
304         // split_transform_flag
305         224, 167, 122,
306         // cbf_luma
307         153, 111,
308         // cbf_cb, cbf_cr
309         149, 92, 167, 154,
310         // transform_skip_flag
311         139, 139,
312         // last_significant_coeff_x_prefix
313         125, 110, 124, 110,  95,  94, 125, 111, 111,  79, 125, 126, 111, 111,
314          79, 108, 123,  93,
315         // last_significant_coeff_y_prefix
316         125, 110, 124, 110,  95,  94, 125, 111, 111,  79, 125, 126, 111, 111,
317          79, 108, 123,  93,
318         // significant_coeff_group_flag
319         121, 140, 61, 154,
320         // significant_coeff_flag
321         170, 154, 139, 153, 139, 123, 123,  63, 124, 166, 183, 140, 136, 153,
322         154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
323         153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
324         // coeff_abs_level_greater1_flag
325         154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
326         136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
327         // coeff_abs_level_greater2_flag
328         107, 167, 91, 107, 107, 167,
329     },
330 };
331
332 void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
333 {
334     if (s->pps->entropy_coding_sync_enabled_flag &&
335         ((ctb_addr_ts % s->sps->ctb_width) == 2 ||
336          (s->sps->ctb_width == 2 &&
337           (ctb_addr_ts % s->sps->ctb_width) == 0))) {
338         memcpy(s->cabac_state, s->HEVClc.cabac_state, HEVC_CONTEXTS);
339     }
340 }
341
342 static void load_states(HEVCContext *s)
343 {
344     memcpy(s->HEVClc.cabac_state, s->cabac_state, HEVC_CONTEXTS);
345 }
346
347 static void cabac_reinit(HEVCLocalContext *lc)
348 {
349     skip_bytes(&lc->cc, 0);
350 }
351
352 static void cabac_init_decoder(HEVCContext *s)
353 {
354     GetBitContext *gb = &s->HEVClc.gb;
355     skip_bits(gb, 1);
356     align_get_bits(gb);
357     ff_init_cabac_decoder(&s->HEVClc.cc,
358                           gb->buffer + get_bits_count(gb) / 8,
359                           (get_bits_left(gb) + 7) / 8);
360 }
361
362 static void cabac_init_state(HEVCContext *s)
363 {
364     int init_type = 2 - s->sh.slice_type;
365     int i;
366
367     if (s->sh.cabac_init_flag && s->sh.slice_type != I_SLICE)
368         init_type ^= 3;
369
370     for (i = 0; i < HEVC_CONTEXTS; i++) {
371         int init_value = init_values[init_type][i];
372         int m = (init_value >> 4) * 5 - 45;
373         int n = ((init_value & 15) << 3) - 16;
374         int pre = 2 * (((m * av_clip_c(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
375
376         pre ^= pre >> 31;
377         if (pre > 124)
378             pre = 124 + (pre & 1);
379         s->HEVClc.cabac_state[i] =  pre;
380     }
381 }
382
383 void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
384 {
385     if (ctb_addr_ts == s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
386         cabac_init_decoder(s);
387         if ((s->sh.dependent_slice_segment_flag == 0) ||
388             (s->pps->tiles_enabled_flag &&
389              (s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1])))
390             cabac_init_state(s);
391
392         if (!s->sh.first_slice_in_pic_flag && s->pps->entropy_coding_sync_enabled_flag) {
393             if ((ctb_addr_ts % s->sps->ctb_width) == 0) {
394                 if (s->sps->ctb_width == 1)
395                     cabac_init_state(s);
396                 else if (s->sh.dependent_slice_segment_flag == 1)
397                     load_states(s);
398             }
399         }
400     } else {
401         if (s->pps->tiles_enabled_flag &&
402             (s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1])) {
403             cabac_reinit(&s->HEVClc);
404             cabac_init_state(s);
405         }
406         if (s->pps->entropy_coding_sync_enabled_flag) {
407             if ((ctb_addr_ts % s->sps->ctb_width) == 0) {
408                 get_cabac_terminate(&s->HEVClc.cc);
409                 cabac_reinit(&s->HEVClc);
410
411                 if (s->sps->ctb_width == 1)
412                     cabac_init_state(s);
413                 else
414                     load_states(s);
415             }
416         }
417     }
418 }
419
420 #define GET_CABAC(ctx) get_cabac(&s->HEVClc.cc, &s->HEVClc.cabac_state[ctx])
421
422 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
423 {
424     return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
425 }
426
427 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
428 {
429     if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
430         return 0;
431
432     if (!get_cabac_bypass(&s->HEVClc.cc))
433         return SAO_BAND;
434     return SAO_EDGE;
435 }
436
437 int ff_hevc_sao_band_position_decode(HEVCContext *s)
438 {
439     int i;
440     int value = get_cabac_bypass(&s->HEVClc.cc);
441
442     for (i = 0; i < 4; i++)
443         value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc);
444     return value;
445 }
446
447 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
448 {
449     int i = 0;
450     int length = (1 << (FFMIN(s->sps->bit_depth, 10) - 5)) - 1;
451
452     while (i < length && get_cabac_bypass(&s->HEVClc.cc))
453         i++;
454     return i;
455 }
456
457 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
458 {
459     return get_cabac_bypass(&s->HEVClc.cc);
460 }
461
462 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
463 {
464     int ret = (get_cabac_bypass(&s->HEVClc.cc) << 1);
465     ret    |=  get_cabac_bypass(&s->HEVClc.cc);
466     return ret;
467 }
468
469 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
470 {
471     return get_cabac_terminate(&s->HEVClc.cc);
472 }
473
474 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
475 {
476     return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
477 }
478
479 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
480 {
481     int pic_width_in_ctb = s->sps->width >> s->sps->log2_min_coding_block_size;
482     int inc = 0;
483     int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
484     int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
485
486     if (s->HEVClc.ctb_left_flag || x0b)
487         inc = SAMPLE_CTB(s->skip_flag, x_cb-1, y_cb);
488     if (s->HEVClc.ctb_up_flag || y0b)
489         inc += SAMPLE_CTB(s->skip_flag, x_cb, y_cb-1);
490
491     return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
492 }
493
494 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
495 {
496     int prefix_val = 0;
497     int suffix_val = 0;
498     int inc = 0;
499
500     while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
501         prefix_val++;
502         inc = 1;
503     }
504     if (prefix_val >= 5) {
505         int k = 0;
506         while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc)) {
507             suffix_val += 1 << k;
508             k++;
509         }
510         if (k == CABAC_MAX_BIN)
511             av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
512
513         while (k--)
514             suffix_val += get_cabac_bypass(&s->HEVClc.cc) << k;
515     }
516     return prefix_val + suffix_val;
517 }
518
519 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
520 {
521     return get_cabac_bypass(&s->HEVClc.cc);
522 }
523
524 int ff_hevc_pred_mode_decode(HEVCContext *s)
525 {
526     return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
527 }
528
529 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
530 {
531     int inc = 0, depth_left = 0, depth_top = 0;
532     int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
533     int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
534     int x_cb = x0 >> s->sps->log2_min_coding_block_size;
535     int y_cb = y0 >> s->sps->log2_min_coding_block_size;
536
537     if (s->HEVClc.ctb_left_flag || x0b)
538         depth_left = s->tab_ct_depth[(y_cb)*s->sps->min_cb_width + x_cb-1];
539     if (s->HEVClc.ctb_up_flag || y0b)
540         depth_top = s->tab_ct_depth[(y_cb-1)*s->sps->min_cb_width + x_cb];
541
542     inc += (depth_left > ct_depth);
543     inc += (depth_top > ct_depth);
544     return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
545 }
546
547 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
548 {
549     if (GET_CABAC(elem_offset[PART_MODE])) // 1
550         return PART_2Nx2N;
551     if (log2_cb_size == s->sps->log2_min_coding_block_size) {
552         if (s->HEVClc.cu.pred_mode == MODE_INTRA) // 0
553             return PART_NxN;
554         if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
555             return PART_2NxN;
556         if (log2_cb_size == 3) // 00
557             return PART_Nx2N;
558         if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
559             return PART_Nx2N;
560         return PART_NxN; // 000
561     }
562
563     if (!s->sps->amp_enabled_flag) {
564         if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
565             return PART_2NxN;
566         return PART_Nx2N;
567     }
568
569     if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
570         if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
571             return PART_2NxN;
572         if (get_cabac_bypass(&s->HEVClc.cc)) // 0101
573             return PART_2NxnD;
574         return PART_2NxnU; // 0100
575     }
576
577     if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
578         return PART_Nx2N;
579     if (get_cabac_bypass(&s->HEVClc.cc)) // 0001
580         return PART_nRx2N;
581     return  PART_nLx2N; // 0000
582 }
583
584 int ff_hevc_pcm_flag_decode(HEVCContext *s)
585 {
586     return get_cabac_terminate(&s->HEVClc.cc);
587 }
588
589 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
590 {
591     return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
592 }
593
594 int ff_hevc_mpm_idx_decode(HEVCContext *s)
595 {
596     int i = 0;
597     while (i < 2 && get_cabac_bypass(&s->HEVClc.cc))
598         i++;
599     return i;
600 }
601
602 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
603 {
604     int i;
605     int value = get_cabac_bypass(&s->HEVClc.cc);
606
607     for (i = 0; i < 4; i++)
608         value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc);
609     return value;
610 }
611
612 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
613 {
614     int ret;
615     if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
616         return 4;
617
618     ret  = (get_cabac_bypass(&s->HEVClc.cc) << 1);
619     ret |=  get_cabac_bypass(&s->HEVClc.cc);
620     return ret;
621 }
622
623 int ff_hevc_merge_idx_decode(HEVCContext *s)
624 {
625     int i = GET_CABAC(elem_offset[MERGE_IDX]);
626
627     if (i != 0) {
628         while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc.cc))
629             i++;
630     }
631     return i;
632 }
633
634 int ff_hevc_merge_flag_decode(HEVCContext *s)
635 {
636     return GET_CABAC(elem_offset[MERGE_FLAG]);
637 }
638
639 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
640 {
641     if (nPbW + nPbH == 12)
642         return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
643     if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc.ct.depth))
644         return PRED_BI;
645
646     return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
647 }
648
649 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
650 {
651     int i = 0;
652     int max = num_ref_idx_lx - 1;
653     int max_ctx = FFMIN(max, 2);
654
655     while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
656         i++;
657     if (i == 2) {
658         while (i < max && get_cabac_bypass(&s->HEVClc.cc))
659             i++;
660     }
661
662     return i;
663 }
664
665 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
666 {
667     return GET_CABAC(elem_offset[MVP_LX_FLAG]);
668 }
669
670 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
671 {
672     return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
673 }
674
675 int ff_hevc_abs_mvd_greater0_flag_decode(HEVCContext *s)
676 {
677     return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
678 }
679
680 int ff_hevc_abs_mvd_greater1_flag_decode(HEVCContext *s)
681 {
682     return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
683 }
684
685 int ff_hevc_mvd_decode(HEVCContext *s)
686 {
687     int ret = 2;
688     int k = 1;
689
690     while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc)) {
691         ret += 1 << k;
692         k++;
693     }
694     if (k == CABAC_MAX_BIN)
695         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
696     while (k--)
697         ret += get_cabac_bypass(&s->HEVClc.cc) << k;
698     return get_cabac_bypass_sign(&s->HEVClc.cc, -ret);
699 }
700
701 int ff_hevc_mvd_sign_flag_decode(HEVCContext *s)
702 {
703     return get_cabac_bypass_sign(&s->HEVClc.cc, -1);
704 }
705
706 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
707 {
708     return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
709 }
710
711 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
712 {
713     return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
714 }
715
716 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
717 {
718     return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
719 }
720
721 int ff_hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
722 {
723     return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
724 }
725
726 #define LAST_SIG_COEFF(elem)                                                    \
727     int i = 0;                                                                  \
728     int max = (log2_size << 1) - 1;                                             \
729     int ctx_offset, ctx_shift;                                                  \
730                                                                                 \
731     if (c_idx == 0) {                                                           \
732         ctx_offset = 3 * (log2_size - 2)  + ((log2_size - 1) >> 2);             \
733         ctx_shift = (log2_size + 1) >> 2;                                       \
734     } else {                                                                    \
735         ctx_offset = 15;                                                        \
736         ctx_shift = log2_size - 2;                                              \
737     }                                                                           \
738     while (i < max &&                                                           \
739            GET_CABAC(elem_offset[elem] + (i >> ctx_shift) + ctx_offset))        \
740         i++;                                                                    \
741     return i;
742
743 int ff_hevc_last_significant_coeff_x_prefix_decode(HEVCContext *s, int c_idx,
744                                                    int log2_size)
745 {
746     LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_X_PREFIX)
747 }
748
749 int ff_hevc_last_significant_coeff_y_prefix_decode(HEVCContext *s, int c_idx,
750                                                    int log2_size)
751 {
752     LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_Y_PREFIX)
753 }
754
755 int ff_hevc_last_significant_coeff_suffix_decode(HEVCContext *s,
756                                                  int last_significant_coeff_prefix)
757 {
758     int i;
759     int length = (last_significant_coeff_prefix >> 1) - 1;
760     int value = get_cabac_bypass(&s->HEVClc.cc);
761
762     for (i = 1; i < length; i++)
763         value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc);
764     return value;
765 }
766
767 int ff_hevc_significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
768 {
769     int inc;
770
771     inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
772
773     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
774 }
775
776 int ff_hevc_significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c,
777                                           int log2_trafo_size, int scan_idx, int prev_sig)
778 {
779     static const uint8_t ctx_idx_map[] = {
780         0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8
781     };
782     int x_cg = x_c >> 2;
783     int y_cg = y_c >> 2;
784     int sig_ctx;
785     int inc;
786
787     if (x_c + y_c == 0) {
788         sig_ctx = 0;
789     } else if (log2_trafo_size == 2) {
790         sig_ctx = ctx_idx_map[(y_c << 2) + x_c];
791     } else {
792         switch (prev_sig) {
793         case 0: {
794                 int x_off = x_c & 3;
795                 int y_off = y_c & 3;
796                 sig_ctx   = ((x_off + y_off) == 0) ? 2 : ((x_off + y_off) <= 2) ? 1 : 0;
797             }
798             break;
799         case 1:
800             sig_ctx = 2 - FFMIN(y_c & 3, 2);
801             break;
802         case 2:
803             sig_ctx = 2 - FFMIN(x_c & 3, 2);
804             break;
805         default:
806             sig_ctx = 2;
807         }
808
809         if (c_idx == 0 && (x_cg > 0 || y_cg > 0))
810             sig_ctx += 3;
811
812         if (log2_trafo_size == 3) {
813             sig_ctx += (scan_idx == SCAN_DIAG) ? 9 : 15;
814         } else {
815             sig_ctx += c_idx ? 12 : 21;
816         }
817     }
818
819     if (c_idx == 0) {
820         inc = sig_ctx;
821     } else {
822         inc = sig_ctx + 27;
823     }
824
825     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
826 }
827
828 int ff_hevc_coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
829 {
830
831     if (c_idx > 0)
832         inc += 16;
833
834     return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
835 }
836
837 int ff_hevc_coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
838 {
839     if (c_idx > 0)
840         inc += 4;
841
842     return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
843 }
844
845 int ff_hevc_coeff_abs_level_remaining(HEVCContext *s, int base_level, int rc_rice_param)
846 {
847     int prefix = 0;
848     int suffix = 0;
849     int last_coeff_abs_level_remaining;
850     int i;
851
852     while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc))
853         prefix++;
854     if (prefix == CABAC_MAX_BIN)
855         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
856     if (prefix < 3) {
857         for (i = 0; i < rc_rice_param; i++)
858             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc.cc);
859         last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
860     } else {
861         int prefix_minus3 = prefix - 3;
862         for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
863             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc.cc);
864         last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
865                                               << rc_rice_param) + suffix;
866     }
867     return last_coeff_abs_level_remaining;
868 }
869
870 int ff_hevc_coeff_sign_flag(HEVCContext *s, uint8_t nb)
871 {
872     int i;
873     int ret = 0;
874
875     for (i = 0; i < nb; i++)
876         ret = (ret << 1) | get_cabac_bypass(&s->HEVClc.cc);
877     return ret;
878 }