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