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