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