hevc: separate residu and prediction (needed for Range Extension)
[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 const uint8_t ff_hevc_diag_scan4x4_x[16] = {
431     0, 0, 1, 0,
432     1, 2, 0, 1,
433     2, 3, 1, 2,
434     3, 2, 3, 3,
435 };
436
437 const uint8_t ff_hevc_diag_scan4x4_y[16] = {
438     0, 1, 0, 2,
439     1, 0, 3, 2,
440     1, 0, 3, 2,
441     1, 3, 2, 3,
442 };
443
444 static const uint8_t diag_scan4x4_inv[4][4] = {
445     { 0,  2,  5,  9, },
446     { 1,  4,  8, 12, },
447     { 3,  7, 11, 14, },
448     { 6, 10, 13, 15, },
449 };
450
451 const uint8_t ff_hevc_diag_scan8x8_x[64] = {
452     0, 0, 1, 0,
453     1, 2, 0, 1,
454     2, 3, 0, 1,
455     2, 3, 4, 0,
456     1, 2, 3, 4,
457     5, 0, 1, 2,
458     3, 4, 5, 6,
459     0, 1, 2, 3,
460     4, 5, 6, 7,
461     1, 2, 3, 4,
462     5, 6, 7, 2,
463     3, 4, 5, 6,
464     7, 3, 4, 5,
465     6, 7, 4, 5,
466     6, 7, 5, 6,
467     7, 6, 7, 7,
468 };
469
470 const uint8_t ff_hevc_diag_scan8x8_y[64] = {
471     0, 1, 0, 2,
472     1, 0, 3, 2,
473     1, 0, 4, 3,
474     2, 1, 0, 5,
475     4, 3, 2, 1,
476     0, 6, 5, 4,
477     3, 2, 1, 0,
478     7, 6, 5, 4,
479     3, 2, 1, 0,
480     7, 6, 5, 4,
481     3, 2, 1, 7,
482     6, 5, 4, 3,
483     2, 7, 6, 5,
484     4, 3, 7, 6,
485     5, 4, 7, 6,
486     5, 7, 6, 7,
487 };
488
489 static const uint8_t diag_scan8x8_inv[8][8] = {
490     {  0,  2,  5,  9, 14, 20, 27, 35, },
491     {  1,  4,  8, 13, 19, 26, 34, 42, },
492     {  3,  7, 12, 18, 25, 33, 41, 48, },
493     {  6, 11, 17, 24, 32, 40, 47, 53, },
494     { 10, 16, 23, 31, 39, 46, 52, 57, },
495     { 15, 22, 30, 38, 45, 51, 56, 60, },
496     { 21, 29, 37, 44, 50, 55, 59, 62, },
497     { 28, 36, 43, 49, 54, 58, 61, 63, },
498 };
499
500 void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
501 {
502     if (s->pps->entropy_coding_sync_enabled_flag &&
503         (ctb_addr_ts % s->sps->ctb_width == 2 ||
504          (s->sps->ctb_width == 2 &&
505           ctb_addr_ts % s->sps->ctb_width == 0))) {
506         memcpy(s->cabac_state, s->HEVClc->cabac_state, HEVC_CONTEXTS);
507     }
508 }
509
510 static void load_states(HEVCContext *s)
511 {
512     memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
513 }
514
515 static void cabac_reinit(HEVCLocalContext *lc)
516 {
517     skip_bytes(&lc->cc, 0);
518 }
519
520 static void cabac_init_decoder(HEVCContext *s)
521 {
522     GetBitContext *gb = &s->HEVClc->gb;
523     skip_bits(gb, 1);
524     align_get_bits(gb);
525     ff_init_cabac_decoder(&s->HEVClc->cc,
526                           gb->buffer + get_bits_count(gb) / 8,
527                           (get_bits_left(gb) + 7) / 8);
528 }
529
530 static void cabac_init_state(HEVCContext *s)
531 {
532     int init_type = 2 - s->sh.slice_type;
533     int i;
534
535     if (s->sh.cabac_init_flag && s->sh.slice_type != I_SLICE)
536         init_type ^= 3;
537
538     for (i = 0; i < HEVC_CONTEXTS; i++) {
539         int init_value = init_values[init_type][i];
540         int m = (init_value >> 4) * 5 - 45;
541         int n = ((init_value & 15) << 3) - 16;
542         int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
543
544         pre ^= pre >> 31;
545         if (pre > 124)
546             pre = 124 + (pre & 1);
547         s->HEVClc->cabac_state[i] = pre;
548     }
549 }
550
551 void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
552 {
553     if (ctb_addr_ts == s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
554         cabac_init_decoder(s);
555         if (s->sh.dependent_slice_segment_flag == 0 ||
556             (s->pps->tiles_enabled_flag &&
557              s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]))
558             cabac_init_state(s);
559
560         if (!s->sh.first_slice_in_pic_flag &&
561             s->pps->entropy_coding_sync_enabled_flag) {
562             if (ctb_addr_ts % s->sps->ctb_width == 0) {
563                 if (s->sps->ctb_width == 1)
564                     cabac_init_state(s);
565                 else if (s->sh.dependent_slice_segment_flag == 1)
566                     load_states(s);
567             }
568         }
569     } else {
570         if (s->pps->tiles_enabled_flag &&
571             s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
572             if (s->threads_number == 1)
573                 cabac_reinit(s->HEVClc);
574             else
575                 cabac_init_decoder(s);
576             cabac_init_state(s);
577         }
578         if (s->pps->entropy_coding_sync_enabled_flag) {
579             if (ctb_addr_ts % s->sps->ctb_width == 0) {
580                 get_cabac_terminate(&s->HEVClc->cc);
581                 if (s->threads_number == 1)
582                     cabac_reinit(s->HEVClc);
583                 else
584                     cabac_init_decoder(s);
585
586                 if (s->sps->ctb_width == 1)
587                     cabac_init_state(s);
588                 else
589                     load_states(s);
590             }
591         }
592     }
593 }
594
595 #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
596
597 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
598 {
599     return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
600 }
601
602 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
603 {
604     if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
605         return 0;
606
607     if (!get_cabac_bypass(&s->HEVClc->cc))
608         return SAO_BAND;
609     return SAO_EDGE;
610 }
611
612 int ff_hevc_sao_band_position_decode(HEVCContext *s)
613 {
614     int i;
615     int value = get_cabac_bypass(&s->HEVClc->cc);
616
617     for (i = 0; i < 4; i++)
618         value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
619     return value;
620 }
621
622 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
623 {
624     int i = 0;
625     int length = (1 << (FFMIN(s->sps->bit_depth, 10) - 5)) - 1;
626
627     while (i < length && get_cabac_bypass(&s->HEVClc->cc))
628         i++;
629     return i;
630 }
631
632 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
633 {
634     return get_cabac_bypass(&s->HEVClc->cc);
635 }
636
637 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
638 {
639     int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
640     ret    |= get_cabac_bypass(&s->HEVClc->cc);
641     return ret;
642 }
643
644 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
645 {
646     return get_cabac_terminate(&s->HEVClc->cc);
647 }
648
649 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
650 {
651     return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
652 }
653
654 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
655 {
656     int min_cb_width = s->sps->min_cb_width;
657     int inc = 0;
658     int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
659     int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
660
661     if (s->HEVClc->ctb_left_flag || x0b)
662         inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
663     if (s->HEVClc->ctb_up_flag || y0b)
664         inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
665
666     return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
667 }
668
669 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
670 {
671     int prefix_val = 0;
672     int suffix_val = 0;
673     int inc = 0;
674
675     while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
676         prefix_val++;
677         inc = 1;
678     }
679     if (prefix_val >= 5) {
680         int k = 0;
681         while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
682             suffix_val += 1 << k;
683             k++;
684         }
685         if (k == CABAC_MAX_BIN)
686             av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
687
688         while (k--)
689             suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
690     }
691     return prefix_val + suffix_val;
692 }
693
694 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
695 {
696     return get_cabac_bypass(&s->HEVClc->cc);
697 }
698
699 int ff_hevc_pred_mode_decode(HEVCContext *s)
700 {
701     return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
702 }
703
704 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
705 {
706     int inc = 0, depth_left = 0, depth_top = 0;
707     int x0b  = x0 & ((1 << s->sps->log2_ctb_size) - 1);
708     int y0b  = y0 & ((1 << s->sps->log2_ctb_size) - 1);
709     int x_cb = x0 >> s->sps->log2_min_cb_size;
710     int y_cb = y0 >> s->sps->log2_min_cb_size;
711
712     if (s->HEVClc->ctb_left_flag || x0b)
713         depth_left = s->tab_ct_depth[(y_cb) * s->sps->min_cb_width + x_cb - 1];
714     if (s->HEVClc->ctb_up_flag || y0b)
715         depth_top = s->tab_ct_depth[(y_cb - 1) * s->sps->min_cb_width + x_cb];
716
717     inc += (depth_left > ct_depth);
718     inc += (depth_top  > ct_depth);
719
720     return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
721 }
722
723 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
724 {
725     if (GET_CABAC(elem_offset[PART_MODE])) // 1
726         return PART_2Nx2N;
727     if (log2_cb_size == s->sps->log2_min_cb_size) {
728         if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
729             return PART_NxN;
730         if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
731             return PART_2NxN;
732         if (log2_cb_size == 3) // 00
733             return PART_Nx2N;
734         if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
735             return PART_Nx2N;
736         return PART_NxN; // 000
737     }
738
739     if (!s->sps->amp_enabled_flag) {
740         if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
741             return PART_2NxN;
742         return PART_Nx2N;
743     }
744
745     if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
746         if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
747             return PART_2NxN;
748         if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
749             return PART_2NxnD;
750         return PART_2NxnU; // 0100
751     }
752
753     if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
754         return PART_Nx2N;
755     if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
756         return PART_nRx2N;
757     return PART_nLx2N;  // 0000
758 }
759
760 int ff_hevc_pcm_flag_decode(HEVCContext *s)
761 {
762     return get_cabac_terminate(&s->HEVClc->cc);
763 }
764
765 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
766 {
767     return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
768 }
769
770 int ff_hevc_mpm_idx_decode(HEVCContext *s)
771 {
772     int i = 0;
773     while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
774         i++;
775     return i;
776 }
777
778 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
779 {
780     int i;
781     int value = get_cabac_bypass(&s->HEVClc->cc);
782
783     for (i = 0; i < 4; i++)
784         value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
785     return value;
786 }
787
788 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
789 {
790     int ret;
791     if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
792         return 4;
793
794     ret  = get_cabac_bypass(&s->HEVClc->cc) << 1;
795     ret |= get_cabac_bypass(&s->HEVClc->cc);
796     return ret;
797 }
798
799 int ff_hevc_merge_idx_decode(HEVCContext *s)
800 {
801     int i = GET_CABAC(elem_offset[MERGE_IDX]);
802
803     if (i != 0) {
804         while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
805             i++;
806     }
807     return i;
808 }
809
810 int ff_hevc_merge_flag_decode(HEVCContext *s)
811 {
812     return GET_CABAC(elem_offset[MERGE_FLAG]);
813 }
814
815 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
816 {
817     if (nPbW + nPbH == 12)
818         return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
819     if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct.depth))
820         return PRED_BI;
821
822     return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
823 }
824
825 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
826 {
827     int i = 0;
828     int max = num_ref_idx_lx - 1;
829     int max_ctx = FFMIN(max, 2);
830
831     while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
832         i++;
833     if (i == 2) {
834         while (i < max && get_cabac_bypass(&s->HEVClc->cc))
835             i++;
836     }
837
838     return i;
839 }
840
841 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
842 {
843     return GET_CABAC(elem_offset[MVP_LX_FLAG]);
844 }
845
846 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
847 {
848     return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
849 }
850
851 static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
852 {
853     return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
854 }
855
856 static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
857 {
858     return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
859 }
860
861 static av_always_inline int mvd_decode(HEVCContext *s)
862 {
863     int ret = 2;
864     int k = 1;
865
866     while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
867         ret += 1 << k;
868         k++;
869     }
870     if (k == CABAC_MAX_BIN)
871         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
872     while (k--)
873         ret += get_cabac_bypass(&s->HEVClc->cc) << k;
874     return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
875 }
876
877 static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
878 {
879     return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
880 }
881
882 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
883 {
884     return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
885 }
886
887 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
888 {
889     return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
890 }
891
892 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
893 {
894     return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
895 }
896
897 int ff_hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
898 {
899     return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
900 }
901
902 #define LAST_SIG_COEFF(elem)                                                    \
903     int i = 0;                                                                  \
904     int max = (log2_size << 1) - 1;                                             \
905     int ctx_offset, ctx_shift;                                                  \
906                                                                                 \
907     if (c_idx == 0) {                                                           \
908         ctx_offset = 3 * (log2_size - 2)  + ((log2_size - 1) >> 2);             \
909         ctx_shift = (log2_size + 1) >> 2;                                       \
910     } else {                                                                    \
911         ctx_offset = 15;                                                        \
912         ctx_shift = log2_size - 2;                                              \
913     }                                                                           \
914     while (i < max &&                                                           \
915            GET_CABAC(elem_offset[elem] + (i >> ctx_shift) + ctx_offset))        \
916         i++;                                                                    \
917     return i;
918
919 static av_always_inline int last_significant_coeff_x_prefix_decode(HEVCContext *s, int c_idx,
920                                                    int log2_size)
921 {
922     LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_X_PREFIX)
923 }
924
925 static av_always_inline int last_significant_coeff_y_prefix_decode(HEVCContext *s, int c_idx,
926                                                    int log2_size)
927 {
928     LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_Y_PREFIX)
929 }
930
931 static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
932                                                  int last_significant_coeff_prefix)
933 {
934     int i;
935     int length = (last_significant_coeff_prefix >> 1) - 1;
936     int value = get_cabac_bypass(&s->HEVClc->cc);
937
938     for (i = 1; i < length; i++)
939         value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
940     return value;
941 }
942
943 static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
944 {
945     int inc;
946
947     inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
948
949     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
950 }
951
952 static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c,
953                                           int log2_trafo_size, int scan_idx, int prev_sig)
954 {
955     static const uint8_t ctx_idx_map[] = {
956         0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8
957     };
958     int x_cg = x_c >> 2;
959     int y_cg = y_c >> 2;
960     int sig_ctx;
961     int inc;
962
963     if (x_c + y_c == 0) {
964         sig_ctx = 0;
965     } else if (log2_trafo_size == 2) {
966         sig_ctx = ctx_idx_map[(y_c << 2) + x_c];
967     } else {
968         switch (prev_sig) {
969         case 0: {
970                 int x_off = x_c & 3;
971                 int y_off = y_c & 3;
972                 sig_ctx   = ((x_off + y_off) == 0) ? 2 : ((x_off + y_off) <= 2) ? 1 : 0;
973             }
974             break;
975         case 1:
976             sig_ctx = 2 - FFMIN(y_c & 3, 2);
977             break;
978         case 2:
979             sig_ctx = 2 - FFMIN(x_c & 3, 2);
980             break;
981         default:
982             sig_ctx = 2;
983         }
984
985         if (c_idx == 0 && (x_cg > 0 || y_cg > 0))
986             sig_ctx += 3;
987
988         if (log2_trafo_size == 3) {
989             sig_ctx += (scan_idx == SCAN_DIAG) ? 9 : 15;
990         } else {
991             sig_ctx += c_idx ? 12 : 21;
992         }
993     }
994
995     if (c_idx == 0)
996         inc = sig_ctx;
997     else
998         inc = sig_ctx + 27;
999
1000     return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
1001 }
1002
1003 static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
1004 {
1005
1006     if (c_idx > 0)
1007         inc += 16;
1008
1009     return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
1010 }
1011
1012 static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
1013 {
1014     if (c_idx > 0)
1015         inc += 4;
1016
1017     return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
1018 }
1019
1020 static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int base_level, int rc_rice_param)
1021 {
1022     int prefix = 0;
1023     int suffix = 0;
1024     int last_coeff_abs_level_remaining;
1025     int i;
1026
1027     while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
1028         prefix++;
1029     if (prefix == CABAC_MAX_BIN)
1030         av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
1031     if (prefix < 3) {
1032         for (i = 0; i < rc_rice_param; i++)
1033             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
1034         last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
1035     } else {
1036         int prefix_minus3 = prefix - 3;
1037         for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
1038             suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
1039         last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
1040                                               << rc_rice_param) + suffix;
1041     }
1042     return last_coeff_abs_level_remaining;
1043 }
1044
1045 static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
1046 {
1047     int i;
1048     int ret = 0;
1049
1050     for (i = 0; i < nb; i++)
1051         ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1052     return ret;
1053 }
1054
1055 void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1056                                 int log2_trafo_size, enum ScanType scan_idx,
1057                                 int c_idx)
1058 {
1059 #define GET_COORD(offset, n)                                    \
1060     do {                                                        \
1061         x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n];    \
1062         y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n];    \
1063     } while (0)
1064     HEVCLocalContext *lc = s->HEVClc;
1065     int transform_skip_flag = 0;
1066
1067     int last_significant_coeff_x, last_significant_coeff_y;
1068     int last_scan_pos;
1069     int n_end;
1070     int num_coeff = 0;
1071     int greater1_ctx = 1;
1072
1073     int num_last_subset;
1074     int x_cg_last_sig, y_cg_last_sig;
1075
1076     const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1077
1078     ptrdiff_t stride = s->frame->linesize[c_idx];
1079     int hshift = s->sps->hshift[c_idx];
1080     int vshift = s->sps->vshift[c_idx];
1081     uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1082                                           ((x0 >> hshift) << s->sps->pixel_shift)];
1083     DECLARE_ALIGNED(16, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = {0};
1084     DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = {{0}};
1085
1086     int trafo_size = 1 << log2_trafo_size;
1087     int i;
1088     int qp,shift,add,scale,scale_m;
1089     const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1090     const uint8_t *scale_matrix;
1091     uint8_t dc_scale;
1092
1093     // Derive QP for dequant
1094     if (!lc->cu.cu_transquant_bypass_flag) {
1095         static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1096         static const uint8_t rem6[51 + 2 * 6 + 1] = {
1097             0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1098             3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1099             0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1100         };
1101
1102         static const uint8_t div6[51 + 2 * 6 + 1] = {
1103             0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3,  3,  3,
1104             3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6,  6,  6,
1105             7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1106         };
1107         int qp_y = lc->qp_y;
1108
1109         if (c_idx == 0) {
1110             qp = qp_y + s->sps->qp_bd_offset;
1111         } else {
1112             int qp_i, offset;
1113
1114             if (c_idx == 1)
1115                 offset = s->pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
1116             else
1117                 offset = s->pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
1118
1119             qp_i = av_clip(qp_y + offset, - s->sps->qp_bd_offset, 57);
1120             if (qp_i < 30)
1121                 qp = qp_i;
1122             else if (qp_i > 43)
1123                 qp = qp_i - 6;
1124             else
1125                 qp = qp_c[qp_i - 30];
1126
1127             qp += s->sps->qp_bd_offset;
1128         }
1129
1130         shift    = s->sps->bit_depth + log2_trafo_size - 5;
1131         add      = 1 << (shift-1);
1132         scale    = level_scale[rem6[qp]] << (div6[qp]);
1133         scale_m  = 16; // default when no custom scaling lists.
1134         dc_scale = 16;
1135
1136         if (s->sps->scaling_list_enable_flag) {
1137             const ScalingList *sl = s->pps->scaling_list_data_present_flag ?
1138             &s->pps->scaling_list : &s->sps->scaling_list;
1139             int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1140
1141             if (log2_trafo_size != 5)
1142                 matrix_id = 3 * matrix_id + c_idx;
1143
1144             scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1145             if (log2_trafo_size >= 4)
1146                 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1147         }
1148     }
1149
1150     if (s->pps->transform_skip_enabled_flag && !lc->cu.cu_transquant_bypass_flag &&
1151         log2_trafo_size == 2) {
1152         transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
1153     }
1154
1155     last_significant_coeff_x =
1156         last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
1157     last_significant_coeff_y =
1158         last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
1159
1160     if (last_significant_coeff_x > 3) {
1161         int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1162         last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1163         (2 + (last_significant_coeff_x & 1)) +
1164         suffix;
1165     }
1166
1167     if (last_significant_coeff_y > 3) {
1168         int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1169         last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1170         (2 + (last_significant_coeff_y & 1)) +
1171         suffix;
1172     }
1173
1174     if (scan_idx == SCAN_VERT)
1175         FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1176
1177     x_cg_last_sig = last_significant_coeff_x >> 2;
1178     y_cg_last_sig = last_significant_coeff_y >> 2;
1179
1180     switch (scan_idx) {
1181     case SCAN_DIAG: {
1182         int last_x_c = last_significant_coeff_x & 3;
1183         int last_y_c = last_significant_coeff_y & 3;
1184
1185         scan_x_off = ff_hevc_diag_scan4x4_x;
1186         scan_y_off = ff_hevc_diag_scan4x4_y;
1187         num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1188         if (trafo_size == 4) {
1189             scan_x_cg = scan_1x1;
1190             scan_y_cg = scan_1x1;
1191         } else if (trafo_size == 8) {
1192             num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1193             scan_x_cg = diag_scan2x2_x;
1194             scan_y_cg = diag_scan2x2_y;
1195         } else if (trafo_size == 16) {
1196             num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1197             scan_x_cg = ff_hevc_diag_scan4x4_x;
1198             scan_y_cg = ff_hevc_diag_scan4x4_y;
1199         } else { // trafo_size == 32
1200             num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1201             scan_x_cg = ff_hevc_diag_scan8x8_x;
1202             scan_y_cg = ff_hevc_diag_scan8x8_y;
1203         }
1204         break;
1205     }
1206     case SCAN_HORIZ:
1207         scan_x_cg = horiz_scan2x2_x;
1208         scan_y_cg = horiz_scan2x2_y;
1209         scan_x_off = horiz_scan4x4_x;
1210         scan_y_off = horiz_scan4x4_y;
1211         num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1212         break;
1213     default: //SCAN_VERT
1214         scan_x_cg = horiz_scan2x2_y;
1215         scan_y_cg = horiz_scan2x2_x;
1216         scan_x_off = horiz_scan4x4_y;
1217         scan_y_off = horiz_scan4x4_x;
1218         num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1219         break;
1220     }
1221     num_coeff++;
1222     num_last_subset = (num_coeff - 1) >> 4;
1223
1224     for (i = num_last_subset; i >= 0; i--) {
1225         int n, m;
1226         int x_cg, y_cg, x_c, y_c, pos;
1227         int implicit_non_zero_coeff = 0;
1228         int64_t trans_coeff_level;
1229         int prev_sig = 0;
1230         int offset = i << 4;
1231
1232         uint8_t significant_coeff_flag_idx[16];
1233         uint8_t nb_significant_coeff_flag = 0;
1234
1235         x_cg = scan_x_cg[i];
1236         y_cg = scan_y_cg[i];
1237
1238         if ((i < num_last_subset) && (i > 0)) {
1239             int ctx_cg = 0;
1240             if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1241                 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1242             if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1243                 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1244
1245             significant_coeff_group_flag[x_cg][y_cg] =
1246                 significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1247             implicit_non_zero_coeff = 1;
1248         } else {
1249             significant_coeff_group_flag[x_cg][y_cg] =
1250             ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1251              (x_cg == 0 && y_cg == 0));
1252         }
1253
1254         last_scan_pos = num_coeff - offset - 1;
1255
1256         if (i == num_last_subset) {
1257             n_end = last_scan_pos - 1;
1258             significant_coeff_flag_idx[0] = last_scan_pos;
1259             nb_significant_coeff_flag = 1;
1260         } else {
1261             n_end = 15;
1262         }
1263
1264         if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1265             prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1266         if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1267             prev_sig += (significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1268
1269         for (n = n_end; n >= 0; n--) {
1270             GET_COORD(offset, n);
1271
1272             if (significant_coeff_group_flag[x_cg][y_cg] &&
1273                 (n > 0 || implicit_non_zero_coeff == 0)) {
1274                 if (significant_coeff_flag_decode(s, c_idx, x_c, y_c, log2_trafo_size, scan_idx, prev_sig) == 1) {
1275                     significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1276                     nb_significant_coeff_flag++;
1277                     implicit_non_zero_coeff = 0;
1278                 }
1279             } else {
1280                 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1281                 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1282                     significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1283                     nb_significant_coeff_flag++;
1284                 }
1285             }
1286         }
1287
1288         n_end = nb_significant_coeff_flag;
1289
1290
1291         if (n_end) {
1292             int first_nz_pos_in_cg = 16;
1293             int last_nz_pos_in_cg = -1;
1294             int c_rice_param = 0;
1295             int first_greater1_coeff_idx = -1;
1296             uint8_t coeff_abs_level_greater1_flag[16] = {0};
1297             uint16_t coeff_sign_flag;
1298             int sum_abs = 0;
1299             int sign_hidden = 0;
1300
1301             // initialize first elem of coeff_bas_level_greater1_flag
1302             int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1303
1304             if (!(i == num_last_subset) && greater1_ctx == 0)
1305                 ctx_set++;
1306             greater1_ctx = 1;
1307             last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1308
1309             for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1310                 int n_idx = significant_coeff_flag_idx[m];
1311                 int inc = (ctx_set << 2) + greater1_ctx;
1312                 coeff_abs_level_greater1_flag[n_idx] =
1313                     coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1314                 if (coeff_abs_level_greater1_flag[n_idx]) {
1315                     greater1_ctx = 0;
1316                 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1317                     greater1_ctx++;
1318                 }
1319
1320                 if (coeff_abs_level_greater1_flag[n_idx] &&
1321                     first_greater1_coeff_idx == -1)
1322                     first_greater1_coeff_idx = n_idx;
1323             }
1324             first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1325             sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1326                            !lc->cu.cu_transquant_bypass_flag);
1327
1328             if (first_greater1_coeff_idx != -1) {
1329                 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1330             }
1331             if (!s->pps->sign_data_hiding_flag || !sign_hidden ) {
1332                 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1333             } else {
1334                 coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1335             }
1336
1337             for (m = 0; m < n_end; m++) {
1338                 n = significant_coeff_flag_idx[m];
1339                 GET_COORD(offset, n);
1340                 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1341                 if (trans_coeff_level == ((m < 8) ?
1342                                           ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1343                     int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, trans_coeff_level, c_rice_param);
1344
1345                     trans_coeff_level += last_coeff_abs_level_remaining;
1346                     if (trans_coeff_level > (3 << c_rice_param))
1347                         c_rice_param = FFMIN(c_rice_param + 1, 4);
1348
1349                 }
1350                 if (s->pps->sign_data_hiding_flag && sign_hidden) {
1351                     sum_abs += trans_coeff_level;
1352                     if (n == first_nz_pos_in_cg && (sum_abs&1))
1353                         trans_coeff_level = -trans_coeff_level;
1354                 }
1355                 if (coeff_sign_flag >> 15)
1356                     trans_coeff_level = -trans_coeff_level;
1357                 coeff_sign_flag <<= 1;
1358                 if(!lc->cu.cu_transquant_bypass_flag) {
1359                     if(s->sps->scaling_list_enable_flag) {
1360                         if(y_c || x_c || log2_trafo_size < 4) {
1361                             switch(log2_trafo_size) {
1362                                 case 3: pos = (y_c << 3) + x_c; break;
1363                                 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1364                                 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1365                                 default: pos = (y_c << 2) + x_c;
1366                             }
1367                             scale_m = scale_matrix[pos];
1368                         } else {
1369                             scale_m = dc_scale;
1370                         }
1371                     }
1372                     trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1373                     if(trans_coeff_level < 0) {
1374                         if((~trans_coeff_level) & 0xFffffffffff8000)
1375                             trans_coeff_level = -32768;
1376                     } else {
1377                         if(trans_coeff_level & 0xffffffffffff8000)
1378                             trans_coeff_level = 32767;
1379                     }
1380                 }
1381                 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1382             }
1383         }
1384     }
1385
1386     if (!lc->cu.cu_transquant_bypass_flag) {
1387         if (transform_skip_flag)
1388             s->hevcdsp.transform_skip(coeffs, log2_trafo_size);
1389         else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2)
1390             s->hevcdsp.idct_4x4_luma(coeffs);
1391         else {
1392             int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1393             if (max_xy == 0)
1394                 s->hevcdsp.idct_dc[log2_trafo_size-2](coeffs);
1395             else {
1396                 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1397                 if (max_xy < 4)
1398                     col_limit = FFMIN(4, col_limit);
1399                 else if (max_xy < 8)
1400                     col_limit = FFMIN(8, col_limit);
1401                 else if (max_xy < 12)
1402                     col_limit = FFMIN(24, col_limit);
1403                 s->hevcdsp.idct[log2_trafo_size-2](coeffs, col_limit);
1404             }
1405         }
1406     }
1407     s->hevcdsp.transform_add[log2_trafo_size-2](dst, coeffs, stride);
1408 }
1409
1410 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1411 {
1412     HEVCLocalContext *lc = s->HEVClc;
1413     int x = abs_mvd_greater0_flag_decode(s);
1414     int y = abs_mvd_greater0_flag_decode(s);
1415
1416     if (x)
1417         x += abs_mvd_greater1_flag_decode(s);
1418     if (y)
1419         y += abs_mvd_greater1_flag_decode(s);
1420
1421     switch (x) {
1422     case 2: lc->pu.mvd.x = mvd_decode(s);           break;
1423     case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1424     case 0: lc->pu.mvd.x = 0;                       break;
1425     }
1426
1427     switch (y) {
1428     case 2: lc->pu.mvd.y = mvd_decode(s);           break;
1429     case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1430     case 0: lc->pu.mvd.y = 0;                       break;
1431     }
1432 }
1433