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