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