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