Merge commit '150c896a9e46b23b97debb0a5f66fbaeaa32f153'
[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_data.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      2, // explicit_rdpcm_flag[][]
71      2, // explicit_rdpcm_dir_flag[][]
72     18, // last_significant_coeff_x_prefix
73     18, // last_significant_coeff_y_prefix
74      0, // last_significant_coeff_x_suffix
75      0, // last_significant_coeff_y_suffix
76      4, // significant_coeff_group_flag
77     44, // significant_coeff_flag
78     24, // coeff_abs_level_greater1_flag
79      6, // coeff_abs_level_greater2_flag
80      0, // coeff_abs_level_remaining
81      0, // coeff_sign_flag
82      8, // log2_res_scale_abs
83      2, // res_scale_sign_flag
84      1, // cu_chroma_qp_offset_flag
85      1, // cu_chroma_qp_offset_idx
86 };
87
88 /**
89  * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
90  */
91 static const int elem_offset[sizeof(num_bins_in_se)] = {
92     0, // sao_merge_flag
93     1, // sao_type_idx
94     2, // sao_eo_class
95     2, // sao_band_position
96     2, // sao_offset_abs
97     2, // sao_offset_sign
98     2, // end_of_slice_flag
99     2, // split_coding_unit_flag
100     5, // cu_transquant_bypass_flag
101     6, // skip_flag
102     9, // cu_qp_delta
103     12, // pred_mode
104     13, // part_mode
105     17, // pcm_flag
106     17, // prev_intra_luma_pred_mode
107     18, // mpm_idx
108     18, // rem_intra_luma_pred_mode
109     18, // intra_chroma_pred_mode
110     20, // merge_flag
111     21, // merge_idx
112     22, // inter_pred_idc
113     27, // ref_idx_l0
114     29, // ref_idx_l1
115     31, // abs_mvd_greater0_flag
116     33, // abs_mvd_greater1_flag
117     35, // abs_mvd_minus2
118     35, // mvd_sign_flag
119     35, // mvp_lx_flag
120     36, // no_residual_data_flag
121     37, // split_transform_flag
122     40, // cbf_luma
123     42, // cbf_cb, cbf_cr
124     46, // transform_skip_flag[][]
125     48, // explicit_rdpcm_flag[][]
126     50, // explicit_rdpcm_dir_flag[][]
127     52, // last_significant_coeff_x_prefix
128     70, // last_significant_coeff_y_prefix
129     88, // last_significant_coeff_x_suffix
130     88, // last_significant_coeff_y_suffix
131     88, // significant_coeff_group_flag
132     92, // significant_coeff_flag
133     136, // coeff_abs_level_greater1_flag
134     160, // coeff_abs_level_greater2_flag
135     166, // coeff_abs_level_remaining
136     166, // coeff_sign_flag
137     166, // log2_res_scale_abs
138     174, // res_scale_sign_flag
139     176, // cu_chroma_qp_offset_flag
140     177, // cu_chroma_qp_offset_idx
141 };
142
143 #define CNU 154
144 /**
145  * Indexed by init_type
146  */
147 static const uint8_t init_values[3][HEVC_CONTEXTS] = {
148     { // sao_merge_flag
149       153,
150       // sao_type_idx
151       200,
152       // split_coding_unit_flag
153       139, 141, 157,
154       // cu_transquant_bypass_flag
155       154,
156       // skip_flag
157       CNU, CNU, CNU,
158       // cu_qp_delta
159       154, 154, 154,
160       // pred_mode
161       CNU,
162       // part_mode
163       184, CNU, CNU, CNU,
164       // prev_intra_luma_pred_mode
165       184,
166       // intra_chroma_pred_mode
167       63, 139,
168       // merge_flag
169       CNU,
170       // merge_idx
171       CNU,
172       // inter_pred_idc
173       CNU, CNU, CNU, CNU, CNU,
174       // ref_idx_l0
175       CNU, CNU,
176       // ref_idx_l1
177       CNU, CNU,
178       // abs_mvd_greater1_flag
179       CNU, CNU,
180       // abs_mvd_greater1_flag
181       CNU, CNU,
182       // mvp_lx_flag
183       CNU,
184       // no_residual_data_flag
185       CNU,
186       // split_transform_flag
187       153, 138, 138,
188       // cbf_luma
189       111, 141,
190       // cbf_cb, cbf_cr
191       94, 138, 182, 154,
192       // transform_skip_flag
193       139, 139,
194       // explicit_rdpcm_flag
195       139, 139,
196       // explicit_rdpcm_dir_flag
197       139, 139,
198       // last_significant_coeff_x_prefix
199       110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
200        79, 108, 123,  63,
201       // last_significant_coeff_y_prefix
202       110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
203        79, 108, 123,  63,
204       // significant_coeff_group_flag
205       91, 171, 134, 141,
206       // significant_coeff_flag
207       111, 111, 125, 110, 110,  94, 124, 108, 124, 107, 125, 141, 179, 153,
208       125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
209       139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
210       141, 111,
211       // coeff_abs_level_greater1_flag
212       140,  92, 137, 138, 140, 152, 138, 139, 153,  74, 149,  92, 139, 107,
213       122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
214       // coeff_abs_level_greater2_flag
215       138, 153, 136, 167, 152, 152,
216       // log2_res_scale_abs
217       154, 154, 154, 154, 154, 154, 154, 154,
218       // res_scale_sign_flag
219       154, 154,
220       // cu_chroma_qp_offset_flag
221       154,
222       // cu_chroma_qp_offset_idx
223       154,
224     },
225     { // sao_merge_flag
226       153,
227       // sao_type_idx
228       185,
229       // split_coding_unit_flag
230       107, 139, 126,
231       // cu_transquant_bypass_flag
232       154,
233       // skip_flag
234       197, 185, 201,
235       // cu_qp_delta
236       154, 154, 154,
237       // pred_mode
238       149,
239       // part_mode
240       154, 139, 154, 154,
241       // prev_intra_luma_pred_mode
242       154,
243       // intra_chroma_pred_mode
244       152, 139,
245       // merge_flag
246       110,
247       // merge_idx
248       122,
249       // inter_pred_idc
250       95, 79, 63, 31, 31,
251       // ref_idx_l0
252       153, 153,
253       // ref_idx_l1
254       153, 153,
255       // abs_mvd_greater1_flag
256       140, 198,
257       // abs_mvd_greater1_flag
258       140, 198,
259       // mvp_lx_flag
260       168,
261       // no_residual_data_flag
262       79,
263       // split_transform_flag
264       124, 138, 94,
265       // cbf_luma
266       153, 111,
267       // cbf_cb, cbf_cr
268       149, 107, 167, 154,
269       // transform_skip_flag
270       139, 139,
271       // explicit_rdpcm_flag
272       139, 139,
273       // explicit_rdpcm_dir_flag
274       139, 139,
275       // last_significant_coeff_x_prefix
276       125, 110,  94, 110,  95,  79, 125, 111, 110,  78, 110, 111, 111,  95,
277        94, 108, 123, 108,
278       // last_significant_coeff_y_prefix
279       125, 110,  94, 110,  95,  79, 125, 111, 110,  78, 110, 111, 111,  95,
280        94, 108, 123, 108,
281       // significant_coeff_group_flag
282       121, 140, 61, 154,
283       // significant_coeff_flag
284       155, 154, 139, 153, 139, 123, 123,  63, 153, 166, 183, 140, 136, 153,
285       154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
286       153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
287       140, 140,
288       // coeff_abs_level_greater1_flag
289       154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
290       136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
291       // coeff_abs_level_greater2_flag
292       107, 167, 91, 122, 107, 167,
293       // log2_res_scale_abs
294       154, 154, 154, 154, 154, 154, 154, 154,
295       // res_scale_sign_flag
296       154, 154,
297       // cu_chroma_qp_offset_flag
298       154,
299       // cu_chroma_qp_offset_idx
300       154,
301     },
302     { // sao_merge_flag
303       153,
304       // sao_type_idx
305       160,
306       // split_coding_unit_flag
307       107, 139, 126,
308       // cu_transquant_bypass_flag
309       154,
310       // skip_flag
311       197, 185, 201,
312       // cu_qp_delta
313       154, 154, 154,
314       // pred_mode
315       134,
316       // part_mode
317       154, 139, 154, 154,
318       // prev_intra_luma_pred_mode
319       183,
320       // intra_chroma_pred_mode
321       152, 139,
322       // merge_flag
323       154,
324       // merge_idx
325       137,
326       // inter_pred_idc
327       95, 79, 63, 31, 31,
328       // ref_idx_l0
329       153, 153,
330       // ref_idx_l1
331       153, 153,
332       // abs_mvd_greater1_flag
333       169, 198,
334       // abs_mvd_greater1_flag
335       169, 198,
336       // mvp_lx_flag
337       168,
338       // no_residual_data_flag
339       79,
340       // split_transform_flag
341       224, 167, 122,
342       // cbf_luma
343       153, 111,
344       // cbf_cb, cbf_cr
345       149, 92, 167, 154,
346       // transform_skip_flag
347       139, 139,
348       // explicit_rdpcm_flag
349       139, 139,
350       // explicit_rdpcm_dir_flag
351       139, 139,
352       // last_significant_coeff_x_prefix
353       125, 110, 124, 110,  95,  94, 125, 111, 111,  79, 125, 126, 111, 111,
354        79, 108, 123,  93,
355       // last_significant_coeff_y_prefix
356       125, 110, 124, 110,  95,  94, 125, 111, 111,  79, 125, 126, 111, 111,
357        79, 108, 123,  93,
358       // significant_coeff_group_flag
359       121, 140, 61, 154,
360       // significant_coeff_flag
361       170, 154, 139, 153, 139, 123, 123,  63, 124, 166, 183, 140, 136, 153,
362       154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
363       153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
364       140, 140,
365       // coeff_abs_level_greater1_flag
366       154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
367       136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
368       // coeff_abs_level_greater2_flag
369       107, 167, 91, 107, 107, 167,
370       // log2_res_scale_abs
371       154, 154, 154, 154, 154, 154, 154, 154,
372       // res_scale_sign_flag
373       154, 154,
374       // cu_chroma_qp_offset_flag
375       154,
376       // cu_chroma_qp_offset_idx
377       154,
378     },
379 };
380
381 static const uint8_t scan_1x1[1] = {
382     0,
383 };
384
385 static const uint8_t horiz_scan2x2_x[4] = {
386     0, 1, 0, 1,
387 };
388
389 static const uint8_t horiz_scan2x2_y[4] = {
390     0, 0, 1, 1
391 };
392
393 static const uint8_t horiz_scan4x4_x[16] = {
394     0, 1, 2, 3,
395     0, 1, 2, 3,
396     0, 1, 2, 3,
397     0, 1, 2, 3,
398 };
399
400 static const uint8_t horiz_scan4x4_y[16] = {
401     0, 0, 0, 0,
402     1, 1, 1, 1,
403     2, 2, 2, 2,
404     3, 3, 3, 3,
405 };
406
407 static const uint8_t horiz_scan8x8_inv[8][8] = {
408     {  0,  1,  2,  3, 16, 17, 18, 19, },
409     {  4,  5,  6,  7, 20, 21, 22, 23, },
410     {  8,  9, 10, 11, 24, 25, 26, 27, },
411     { 12, 13, 14, 15, 28, 29, 30, 31, },
412     { 32, 33, 34, 35, 48, 49, 50, 51, },
413     { 36, 37, 38, 39, 52, 53, 54, 55, },
414     { 40, 41, 42, 43, 56, 57, 58, 59, },
415     { 44, 45, 46, 47, 60, 61, 62, 63, },
416 };
417
418 static const uint8_t diag_scan2x2_x[4] = {
419     0, 0, 1, 1,
420 };
421
422 static const uint8_t diag_scan2x2_y[4] = {
423     0, 1, 0, 1,
424 };
425
426 static const uint8_t diag_scan2x2_inv[2][2] = {
427     { 0, 2, },
428     { 1, 3, },
429 };
430
431 static const uint8_t diag_scan4x4_inv[4][4] = {
432     { 0,  2,  5,  9, },
433     { 1,  4,  8, 12, },
434     { 3,  7, 11, 14, },
435     { 6, 10, 13, 15, },
436 };
437
438 static const uint8_t diag_scan8x8_inv[8][8] = {
439     {  0,  2,  5,  9, 14, 20, 27, 35, },
440     {  1,  4,  8, 13, 19, 26, 34, 42, },
441     {  3,  7, 12, 18, 25, 33, 41, 48, },
442     {  6, 11, 17, 24, 32, 40, 47, 53, },
443     { 10, 16, 23, 31, 39, 46, 52, 57, },
444     { 15, 22, 30, 38, 45, 51, 56, 60, },
445     { 21, 29, 37, 44, 50, 55, 59, 62, },
446     { 28, 36, 43, 49, 54, 58, 61, 63, },
447 };
448
449 void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
450 {
451     if (s->ps.pps->entropy_coding_sync_enabled_flag &&
452         (ctb_addr_ts % s->ps.sps->ctb_width == 2 ||
453          (s->ps.sps->ctb_width == 2 &&
454           ctb_addr_ts % s->ps.sps->ctb_width == 0))) {
455         memcpy(s->cabac_state, s->HEVClc->cabac_state, HEVC_CONTEXTS);
456     }
457 }
458
459 static void load_states(HEVCContext *s)
460 {
461     memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
462 }
463
464 static void cabac_reinit(HEVCLocalContext *lc)
465 {
466     skip_bytes(&lc->cc, 0);
467 }
468
469 static void cabac_init_decoder(HEVCContext *s)
470 {
471     GetBitContext *gb = &s->HEVClc->gb;
472     skip_bits(gb, 1);
473     align_get_bits(gb);
474     ff_init_cabac_decoder(&s->HEVClc->cc,
475                           gb->buffer + get_bits_count(gb) / 8,
476                           (get_bits_left(gb) + 7) / 8);
477 }
478
479 static void cabac_init_state(HEVCContext *s)
480 {
481     int init_type = 2 - s->sh.slice_type;
482     int i;
483
484     if (s->sh.cabac_init_flag && s->sh.slice_type != I_SLICE)
485         init_type ^= 3;
486
487     for (i = 0; i < HEVC_CONTEXTS; i++) {
488         int init_value = init_values[init_type][i];
489         int m = (init_value >> 4) * 5 - 45;
490         int n = ((init_value & 15) << 3) - 16;
491         int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
492
493         pre ^= pre >> 31;
494         if (pre > 124)
495             pre = 124 + (pre & 1);
496         s->HEVClc->cabac_state[i] = pre;
497     }
498
499     for (i = 0; i < 4; i++)
500         s->HEVClc->stat_coeff[i] = 0;
501 }
502
503 void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
504 {
505     if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
506         cabac_init_decoder(s);
507         if (s->sh.dependent_slice_segment_flag == 0 ||
508             (s->ps.pps->tiles_enabled_flag &&
509              s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
510             cabac_init_state(s);
511
512         if (!s->sh.first_slice_in_pic_flag &&
513             s->ps.pps->entropy_coding_sync_enabled_flag) {
514             if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
515                 if (s->ps.sps->ctb_width == 1)
516                     cabac_init_state(s);
517                 else if (s->sh.dependent_slice_segment_flag == 1)
518                     load_states(s);
519             }
520         }
521     } else {
522         if (s->ps.pps->tiles_enabled_flag &&
523             s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
524             if (s->threads_number == 1)
525                 cabac_reinit(s->HEVClc);
526             else
527                 cabac_init_decoder(s);
528             cabac_init_state(s);
529         }
530         if (s->ps.pps->entropy_coding_sync_enabled_flag) {
531             if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
532                 get_cabac_terminate(&s->HEVClc->cc);
533                 if (s->threads_number == 1)
534                     cabac_reinit(s->HEVClc);
535                 else
536                     cabac_init_decoder(s);
537
538                 if (s->ps.sps->ctb_width == 1)
539                     cabac_init_state(s);
540                 else
541                     load_states(s);
542             }
543         }
544     }
545 }
546
547 #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
548
549 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
550 {
551     return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
552 }
553
554 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
555 {
556     if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
557         return 0;
558
559     if (!get_cabac_bypass(&s->HEVClc->cc))
560         return SAO_BAND;
561     return SAO_EDGE;
562 }
563
564 int ff_hevc_sao_band_position_decode(HEVCContext *s)
565 {
566     int i;
567     int value = get_cabac_bypass(&s->HEVClc->cc);
568
569     for (i = 0; i < 4; i++)
570         value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
571     return value;
572 }
573
574 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
575 {
576     int i = 0;
577     int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
578
579     while (i < length && get_cabac_bypass(&s->HEVClc->cc))
580         i++;
581     return i;
582 }
583
584 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
585 {
586     return get_cabac_bypass(&s->HEVClc->cc);
587 }
588
589 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
590 {
591     int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
592     ret    |= get_cabac_bypass(&s->HEVClc->cc);
593     return ret;
594 }
595
596 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
597 {
598     return get_cabac_terminate(&s->HEVClc->cc);
599 }
600
601 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
602 {
603     return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
604 }
605
606 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
607 {
608     int min_cb_width = s->ps.sps->min_cb_width;
609     int inc = 0;
610     int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
611     int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
612
613     if (s->HEVClc->ctb_left_flag || x0b)
614         inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
615     if (s->HEVClc->ctb_up_flag || y0b)
616         inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
617
618     return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
619 }
620
621 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
622 {
623     int prefix_val = 0;
624     int suffix_val = 0;
625     int inc = 0;
626
627     while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
628         prefix_val++;
629         inc = 1;
630     }
631     if (prefix_val >= 5) {
632         int k = 0;
633         while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
634             suffix_val += 1 << k;
635             k++;
636         }
637         if (k == CABAC_MAX_BIN)
638             av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
639
640         while (k--)
641             suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
642     }
643     return prefix_val + suffix_val;
644 }
645
646 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
647 {
648     return get_cabac_bypass(&s->HEVClc->cc);
649 }
650
651 int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
652 {
653     return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]);
654 }
655
656 int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
657 {
658     int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
659     int i = 0;
660
661     while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
662         i++;
663
664     return i;
665 }
666
667 int ff_hevc_pred_mode_decode(HEVCContext *s)
668 {
669     return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
670 }
671
672 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
673 {
674     int inc = 0, depth_left = 0, depth_top = 0;
675     int x0b  = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
676     int y0b  = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
677     int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
678     int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
679
680     if (s->HEVClc->ctb_left_flag || x0b)
681         depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
682     if (s->HEVClc->ctb_up_flag || y0b)
683         depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
684
685     inc += (depth_left > ct_depth);
686     inc += (depth_top  > ct_depth);
687
688     return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
689 }
690
691 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
692 {
693     if (GET_CABAC(elem_offset[PART_MODE])) // 1
694         return PART_2Nx2N;
695     if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
696         if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
697             return PART_NxN;
698         if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
699             return PART_2NxN;
700         if (log2_cb_size == 3) // 00
701             return PART_Nx2N;
702         if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
703             return PART_Nx2N;
704         return PART_NxN; // 000
705     }
706
707     if (!s->ps.sps->amp_enabled_flag) {
708         if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
709             return PART_2NxN;
710         return PART_Nx2N;
711     }
712
713     if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
714         if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
715             return PART_2NxN;
716         if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
717             return PART_2NxnD;
718         return PART_2NxnU; // 0100
719     }
720
721     if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
722         return PART_Nx2N;
723     if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
724         return PART_nRx2N;
725     return PART_nLx2N;  // 0000
726 }
727
728 int ff_hevc_pcm_flag_decode(HEVCContext *s)
729 {
730     return get_cabac_terminate(&s->HEVClc->cc);
731 }
732
733 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
734 {
735     return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
736 }
737
738 int ff_hevc_mpm_idx_decode(HEVCContext *s)
739 {
740     int i = 0;
741     while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
742         i++;
743     return i;
744 }
745
746 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
747 {
748     int i;
749     int value = get_cabac_bypass(&s->HEVClc->cc);
750
751     for (i = 0; i < 4; i++)
752         value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
753     return value;
754 }
755
756 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
757 {
758     int ret;
759     if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
760         return 4;
761
762     ret  = get_cabac_bypass(&s->HEVClc->cc) << 1;
763     ret |= get_cabac_bypass(&s->HEVClc->cc);
764     return ret;
765 }
766
767 int ff_hevc_merge_idx_decode(HEVCContext *s)
768 {
769     int i = GET_CABAC(elem_offset[MERGE_IDX]);
770
771     if (i != 0) {
772         while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
773             i++;
774     }
775     return i;
776 }
777
778 int ff_hevc_merge_flag_decode(HEVCContext *s)
779 {
780     return GET_CABAC(elem_offset[MERGE_FLAG]);
781 }
782
783 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
784 {
785     if (nPbW + nPbH == 12)
786         return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
787     if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct_depth))
788         return PRED_BI;
789
790     return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
791 }
792
793 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
794 {
795     int i = 0;
796     int max = num_ref_idx_lx - 1;
797     int max_ctx = FFMIN(max, 2);
798
799     while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
800         i++;
801     if (i == 2) {
802         while (i < max && get_cabac_bypass(&s->HEVClc->cc))
803             i++;
804     }
805
806     return i;
807 }
808
809 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
810 {
811     return GET_CABAC(elem_offset[MVP_LX_FLAG]);
812 }
813
814 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
815 {
816     return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
817 }
818
819 static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
820 {
821     return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
822 }
823
824 static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
825 {
826     return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
827 }
828
829 static av_always_inline int mvd_decode(HEVCContext *s)
830 {
831     int ret = 2;
832     int k = 1;
833
834     while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
835         ret += 1U << k;
836         k++;
837     }
838     if (k == CABAC_MAX_BIN) {
839         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
840         return 0;
841     }
842     while (k--)
843         ret += get_cabac_bypass(&s->HEVClc->cc) << k;
844     return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
845 }
846
847 static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
848 {
849     return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
850 }
851
852 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
853 {
854     return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
855 }
856
857 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
858 {
859     return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
860 }
861
862 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
863 {
864     return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
865 }
866
867 static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
868 {
869     return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
870 }
871
872 static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
873 {
874     return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
875 }
876
877 static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
878 {
879     return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
880 }
881
882 int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
883     int i =0;
884
885     while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
886         i++;
887
888     return i;
889 }
890
891 int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
892     return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
893 }
894
895 static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
896                                                    int log2_size, int *last_scx_prefix, int *last_scy_prefix)
897 {
898     int i = 0;
899     int max = (log2_size << 1) - 1;
900     int ctx_offset, ctx_shift;
901
902     if (!c_idx) {
903         ctx_offset = 3 * (log2_size - 2)  + ((log2_size - 1) >> 2);
904         ctx_shift = (log2_size + 1) >> 2;
905     } else {
906         ctx_offset = 15;
907         ctx_shift = log2_size - 2;
908     }
909     while (i < max &&
910            GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
911         i++;
912     *last_scx_prefix = i;
913
914     i = 0;
915     while (i < max &&
916            GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
917         i++;
918     *last_scy_prefix = i;
919 }
920
921 static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
922                                                  int last_significant_coeff_prefix)
923 {
924     int i;
925     int length = (last_significant_coeff_prefix >> 1) - 1;
926     int value = get_cabac_bypass(&s->HEVClc->cc);
927
928     for (i = 1; i < length; i++)
929         value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
930     return value;
931 }
932
933 static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
934 {
935     int inc;
936
937     inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
938
939     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
940 }
941 static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
942                                            int offset, const uint8_t *ctx_idx_map)
943 {
944     int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
945     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
946 }
947
948 static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
949 {
950     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
951 }
952
953 static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
954 {
955
956     if (c_idx > 0)
957         inc += 16;
958
959     return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
960 }
961
962 static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
963 {
964     if (c_idx > 0)
965         inc += 4;
966
967     return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
968 }
969
970 static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
971 {
972     int prefix = 0;
973     int suffix = 0;
974     int last_coeff_abs_level_remaining;
975     int i;
976
977     while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
978         prefix++;
979     if (prefix == CABAC_MAX_BIN) {
980         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
981         return 0;
982     }
983     if (prefix < 3) {
984         for (i = 0; i < rc_rice_param; i++)
985             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
986         last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
987     } else {
988         int prefix_minus3 = prefix - 3;
989         for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
990             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
991         last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
992                                               << rc_rice_param) + suffix;
993     }
994     return last_coeff_abs_level_remaining;
995 }
996
997 static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
998 {
999     int i;
1000     int ret = 0;
1001
1002     for (i = 0; i < nb; i++)
1003         ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1004     return ret;
1005 }
1006
1007 void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1008                                 int log2_trafo_size, enum ScanType scan_idx,
1009                                 int c_idx)
1010 {
1011 #define GET_COORD(offset, n)                                    \
1012     do {                                                        \
1013         x_c = (x_cg << 2) + scan_x_off[n];                      \
1014         y_c = (y_cg << 2) + scan_y_off[n];                      \
1015     } while (0)
1016     HEVCLocalContext *lc = s->HEVClc;
1017     int transform_skip_flag = 0;
1018
1019     int last_significant_coeff_x, last_significant_coeff_y;
1020     int last_scan_pos;
1021     int n_end;
1022     int num_coeff = 0;
1023     int greater1_ctx = 1;
1024
1025     int num_last_subset;
1026     int x_cg_last_sig, y_cg_last_sig;
1027
1028     const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1029
1030     ptrdiff_t stride = s->frame->linesize[c_idx];
1031     int hshift = s->ps.sps->hshift[c_idx];
1032     int vshift = s->ps.sps->vshift[c_idx];
1033     uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1034                                           ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1035     int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1036     uint8_t significant_coeff_group_flag[8][8] = {{0}};
1037     int explicit_rdpcm_flag = 0;
1038     int explicit_rdpcm_dir_flag;
1039
1040     int trafo_size = 1 << log2_trafo_size;
1041     int i;
1042     int qp,shift,add,scale,scale_m;
1043     static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1044     const uint8_t *scale_matrix = NULL;
1045     uint8_t dc_scale;
1046     int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1047                                          lc->tu.intra_pred_mode_c;
1048
1049     memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1050
1051     // Derive QP for dequant
1052     if (!lc->cu.cu_transquant_bypass_flag) {
1053         static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1054         static const uint8_t rem6[51 + 4 * 6 + 1] = {
1055             0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1056             3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1057             0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1058             4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1059         };
1060
1061         static const uint8_t div6[51 + 4 * 6 + 1] = {
1062             0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3,  3,  3,
1063             3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6,  6,  6,
1064             7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1065             10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1066         };
1067         int qp_y = lc->qp_y;
1068
1069         if (s->ps.pps->transform_skip_enabled_flag &&
1070             log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1071             transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1072         }
1073
1074         if (c_idx == 0) {
1075             qp = qp_y + s->ps.sps->qp_bd_offset;
1076         } else {
1077             int qp_i, offset;
1078
1079             if (c_idx == 1)
1080                 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1081                          lc->tu.cu_qp_offset_cb;
1082             else
1083                 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1084                          lc->tu.cu_qp_offset_cr;
1085
1086             qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1087             if (s->ps.sps->chroma_format_idc == 1) {
1088                 if (qp_i < 30)
1089                     qp = qp_i;
1090                 else if (qp_i > 43)
1091                     qp = qp_i - 6;
1092                 else
1093                     qp = qp_c[qp_i - 30];
1094             } else {
1095                 if (qp_i > 51)
1096                     qp = 51;
1097                 else
1098                     qp = qp_i;
1099             }
1100
1101             qp += s->ps.sps->qp_bd_offset;
1102         }
1103
1104         shift    = s->ps.sps->bit_depth + log2_trafo_size - 5;
1105         add      = 1 << (shift-1);
1106         scale    = level_scale[rem6[qp]] << (div6[qp]);
1107         scale_m  = 16; // default when no custom scaling lists.
1108         dc_scale = 16;
1109
1110         if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1111             const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1112             &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1113             int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1114
1115             matrix_id = 3 * matrix_id + c_idx;
1116
1117             scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1118             if (log2_trafo_size >= 4)
1119                 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1120         }
1121     } else {
1122         shift        = 0;
1123         add          = 0;
1124         scale        = 0;
1125         dc_scale     = 0;
1126     }
1127
1128     if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
1129         (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1130         explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1131         if (explicit_rdpcm_flag) {
1132             explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1133         }
1134     }
1135
1136     last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1137                                            &last_significant_coeff_x, &last_significant_coeff_y);
1138
1139     if (last_significant_coeff_x > 3) {
1140         int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1141         last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1142         (2 + (last_significant_coeff_x & 1)) +
1143         suffix;
1144     }
1145
1146     if (last_significant_coeff_y > 3) {
1147         int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1148         last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1149         (2 + (last_significant_coeff_y & 1)) +
1150         suffix;
1151     }
1152
1153     if (scan_idx == SCAN_VERT)
1154         FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1155
1156     x_cg_last_sig = last_significant_coeff_x >> 2;
1157     y_cg_last_sig = last_significant_coeff_y >> 2;
1158
1159     switch (scan_idx) {
1160     case SCAN_DIAG: {
1161         int last_x_c = last_significant_coeff_x & 3;
1162         int last_y_c = last_significant_coeff_y & 3;
1163
1164         scan_x_off = ff_hevc_diag_scan4x4_x;
1165         scan_y_off = ff_hevc_diag_scan4x4_y;
1166         num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1167         if (trafo_size == 4) {
1168             scan_x_cg = scan_1x1;
1169             scan_y_cg = scan_1x1;
1170         } else if (trafo_size == 8) {
1171             num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1172             scan_x_cg = diag_scan2x2_x;
1173             scan_y_cg = diag_scan2x2_y;
1174         } else if (trafo_size == 16) {
1175             num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1176             scan_x_cg = ff_hevc_diag_scan4x4_x;
1177             scan_y_cg = ff_hevc_diag_scan4x4_y;
1178         } else { // trafo_size == 32
1179             num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1180             scan_x_cg = ff_hevc_diag_scan8x8_x;
1181             scan_y_cg = ff_hevc_diag_scan8x8_y;
1182         }
1183         break;
1184     }
1185     case SCAN_HORIZ:
1186         scan_x_cg = horiz_scan2x2_x;
1187         scan_y_cg = horiz_scan2x2_y;
1188         scan_x_off = horiz_scan4x4_x;
1189         scan_y_off = horiz_scan4x4_y;
1190         num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1191         break;
1192     default: //SCAN_VERT
1193         scan_x_cg = horiz_scan2x2_y;
1194         scan_y_cg = horiz_scan2x2_x;
1195         scan_x_off = horiz_scan4x4_y;
1196         scan_y_off = horiz_scan4x4_x;
1197         num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1198         break;
1199     }
1200     num_coeff++;
1201     num_last_subset = (num_coeff - 1) >> 4;
1202
1203     for (i = num_last_subset; i >= 0; i--) {
1204         int n, m;
1205         int x_cg, y_cg, x_c, y_c, pos;
1206         int implicit_non_zero_coeff = 0;
1207         int64_t trans_coeff_level;
1208         int prev_sig = 0;
1209         int offset = i << 4;
1210         int rice_init = 0;
1211
1212         uint8_t significant_coeff_flag_idx[16];
1213         uint8_t nb_significant_coeff_flag = 0;
1214
1215         x_cg = scan_x_cg[i];
1216         y_cg = scan_y_cg[i];
1217
1218         if ((i < num_last_subset) && (i > 0)) {
1219             int ctx_cg = 0;
1220             if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1221                 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1222             if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1223                 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1224
1225             significant_coeff_group_flag[x_cg][y_cg] =
1226                 significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1227             implicit_non_zero_coeff = 1;
1228         } else {
1229             significant_coeff_group_flag[x_cg][y_cg] =
1230             ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1231              (x_cg == 0 && y_cg == 0));
1232         }
1233
1234         last_scan_pos = num_coeff - offset - 1;
1235
1236         if (i == num_last_subset) {
1237             n_end = last_scan_pos - 1;
1238             significant_coeff_flag_idx[0] = last_scan_pos;
1239             nb_significant_coeff_flag = 1;
1240         } else {
1241             n_end = 15;
1242         }
1243
1244         if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1245             prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1246         if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1247             prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1248
1249         if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1250             static const uint8_t ctx_idx_map[] = {
1251                 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1252                 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1253                 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1254                 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1255                 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2  // default
1256             };
1257             const uint8_t *ctx_idx_map_p;
1258             int scf_offset = 0;
1259             if (s->ps.sps->transform_skip_context_enabled_flag &&
1260                 (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1261                 ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1262                 if (c_idx == 0) {
1263                     scf_offset = 40;
1264                 } else {
1265                     scf_offset = 14 + 27;
1266                 }
1267             } else {
1268                 if (c_idx != 0)
1269                     scf_offset = 27;
1270                 if (log2_trafo_size == 2) {
1271                     ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1272                 } else {
1273                     ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1274                     if (c_idx == 0) {
1275                         if ((x_cg > 0 || y_cg > 0))
1276                             scf_offset += 3;
1277                         if (log2_trafo_size == 3) {
1278                             scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1279                         } else {
1280                             scf_offset += 21;
1281                         }
1282                     } else {
1283                         if (log2_trafo_size == 3)
1284                             scf_offset += 9;
1285                         else
1286                             scf_offset += 12;
1287                     }
1288                 }
1289             }
1290             for (n = n_end; n > 0; n--) {
1291                 x_c = scan_x_off[n];
1292                 y_c = scan_y_off[n];
1293                 if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1294                     significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1295                     nb_significant_coeff_flag++;
1296                     implicit_non_zero_coeff = 0;
1297                 }
1298             }
1299             if (implicit_non_zero_coeff == 0) {
1300                 if (s->ps.sps->transform_skip_context_enabled_flag &&
1301                     (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1302                     if (c_idx == 0) {
1303                         scf_offset = 42;
1304                     } else {
1305                         scf_offset = 16 + 27;
1306                     }
1307                 } else {
1308                     if (i == 0) {
1309                         if (c_idx == 0)
1310                             scf_offset = 0;
1311                         else
1312                             scf_offset = 27;
1313                     } else {
1314                         scf_offset = 2 + scf_offset;
1315                     }
1316                 }
1317                 if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1318                     significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1319                     nb_significant_coeff_flag++;
1320                 }
1321             } else {
1322                 significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1323                 nb_significant_coeff_flag++;
1324             }
1325         }
1326
1327         n_end = nb_significant_coeff_flag;
1328
1329
1330         if (n_end) {
1331             int first_nz_pos_in_cg;
1332             int last_nz_pos_in_cg;
1333             int c_rice_param = 0;
1334             int first_greater1_coeff_idx = -1;
1335             uint8_t coeff_abs_level_greater1_flag[8];
1336             uint16_t coeff_sign_flag;
1337             int sum_abs = 0;
1338             int sign_hidden;
1339             int sb_type;
1340
1341
1342             // initialize first elem of coeff_bas_level_greater1_flag
1343             int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1344
1345             if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
1346                 if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1347                     sb_type = 2 * (c_idx == 0 ? 1 : 0);
1348                 else
1349                     sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1350                 c_rice_param = lc->stat_coeff[sb_type] / 4;
1351             }
1352
1353             if (!(i == num_last_subset) && greater1_ctx == 0)
1354                 ctx_set++;
1355             greater1_ctx = 1;
1356             last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1357
1358             for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1359                 int inc = (ctx_set << 2) + greater1_ctx;
1360                 coeff_abs_level_greater1_flag[m] =
1361                     coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1362                 if (coeff_abs_level_greater1_flag[m]) {
1363                     greater1_ctx = 0;
1364                     if (first_greater1_coeff_idx == -1)
1365                         first_greater1_coeff_idx = m;
1366                 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1367                     greater1_ctx++;
1368                 }
1369             }
1370             first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1371
1372             if (lc->cu.cu_transquant_bypass_flag ||
1373                 (lc->cu.pred_mode ==  MODE_INTRA  &&
1374                  s->ps.sps->implicit_rdpcm_enabled_flag  &&  transform_skip_flag  &&
1375                  (pred_mode_intra == 10 || pred_mode_intra  ==  26 )) ||
1376                  explicit_rdpcm_flag)
1377                 sign_hidden = 0;
1378             else
1379                 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1380
1381             if (first_greater1_coeff_idx != -1) {
1382                 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1383             }
1384             if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1385                 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1386             } else {
1387                 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1388             }
1389
1390             for (m = 0; m < n_end; m++) {
1391                 n = significant_coeff_flag_idx[m];
1392                 GET_COORD(offset, n);
1393                 if (m < 8) {
1394                     trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1395                     if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1396                         int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1397
1398                         trans_coeff_level += last_coeff_abs_level_remaining;
1399                         if (trans_coeff_level > (3 << c_rice_param))
1400                             c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1401                         if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1402                             int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1403                             if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1404                                 lc->stat_coeff[sb_type]++;
1405                             else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1406                                 if (lc->stat_coeff[sb_type] > 0)
1407                                     lc->stat_coeff[sb_type]--;
1408                             rice_init = 1;
1409                         }
1410                     }
1411                 } else {
1412                     int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1413
1414                     trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1415                     if (trans_coeff_level > (3 << c_rice_param))
1416                         c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1417                     if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1418                         int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1419                         if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1420                             lc->stat_coeff[sb_type]++;
1421                         else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1422                             if (lc->stat_coeff[sb_type] > 0)
1423                                 lc->stat_coeff[sb_type]--;
1424                         rice_init = 1;
1425                     }
1426                 }
1427                 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1428                     sum_abs += trans_coeff_level;
1429                     if (n == first_nz_pos_in_cg && (sum_abs&1))
1430                         trans_coeff_level = -trans_coeff_level;
1431                 }
1432                 if (coeff_sign_flag >> 15)
1433                     trans_coeff_level = -trans_coeff_level;
1434                 coeff_sign_flag <<= 1;
1435                 if(!lc->cu.cu_transquant_bypass_flag) {
1436                     if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1437                         if(y_c || x_c || log2_trafo_size < 4) {
1438                             switch(log2_trafo_size) {
1439                                 case 3: pos = (y_c << 3) + x_c; break;
1440                                 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1441                                 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1442                                 default: pos = (y_c << 2) + x_c; break;
1443                             }
1444                             scale_m = scale_matrix[pos];
1445                         } else {
1446                             scale_m = dc_scale;
1447                         }
1448                     }
1449                     trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1450                     if(trans_coeff_level < 0) {
1451                         if((~trans_coeff_level) & 0xFffffffffff8000)
1452                             trans_coeff_level = -32768;
1453                     } else {
1454                         if(trans_coeff_level & 0xffffffffffff8000)
1455                             trans_coeff_level = 32767;
1456                     }
1457                 }
1458                 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1459             }
1460         }
1461     }
1462
1463     if (lc->cu.cu_transquant_bypass_flag) {
1464         if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1465                                     (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1466             int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1467
1468             s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1469         }
1470     } else {
1471         if (transform_skip_flag) {
1472             int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
1473                       log2_trafo_size == 2 &&
1474                       lc->cu.pred_mode == MODE_INTRA;
1475             if (rot) {
1476                 for (i = 0; i < 8; i++)
1477                     FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1478             }
1479
1480             s->hevcdsp.dequant(coeffs, log2_trafo_size);
1481
1482             if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1483                                         lc->cu.pred_mode == MODE_INTRA &&
1484                                         (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1485                 int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1486
1487                 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1488             }
1489         } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1490             s->hevcdsp.transform_4x4_luma(coeffs);
1491         } else {
1492             int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1493             if (max_xy == 0)
1494                 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1495             else {
1496                 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1497                 if (max_xy < 4)
1498                     col_limit = FFMIN(4, col_limit);
1499                 else if (max_xy < 8)
1500                     col_limit = FFMIN(8, col_limit);
1501                 else if (max_xy < 12)
1502                     col_limit = FFMIN(24, col_limit);
1503                 s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1504             }
1505         }
1506     }
1507     if (lc->tu.cross_pf) {
1508         int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1509
1510         for (i = 0; i < (trafo_size * trafo_size); i++) {
1511             coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1512         }
1513     }
1514     s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1515 }
1516
1517 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1518 {
1519     HEVCLocalContext *lc = s->HEVClc;
1520     int x = abs_mvd_greater0_flag_decode(s);
1521     int y = abs_mvd_greater0_flag_decode(s);
1522
1523     if (x)
1524         x += abs_mvd_greater1_flag_decode(s);
1525     if (y)
1526         y += abs_mvd_greater1_flag_decode(s);
1527
1528     switch (x) {
1529     case 2: lc->pu.mvd.x = mvd_decode(s);           break;
1530     case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1531     case 0: lc->pu.mvd.x = 0;                       break;
1532     }
1533
1534     switch (y) {
1535     case 2: lc->pu.mvd.y = mvd_decode(s);           break;
1536     case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1537     case 0: lc->pu.mvd.y = 0;                       break;
1538     }
1539 }
1540