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