GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/hevc_cabac.c Lines: 641 662 96.8 %
Date: 2019-11-22 03:34:36 Branches: 485 519 93.4 %

Line Branch Exec Source
1
/*
2
 * HEVC CABAC decoding
3
 *
4
 * Copyright (C) 2012 - 2013 Guillaume Martres
5
 * Copyright (C) 2012 - 2013 Gildas Cocherel
6
 *
7
 * This file is part of FFmpeg.
8
 *
9
 * FFmpeg is free software; you can redistribute it and/or
10
 * modify it under the terms of the GNU Lesser General Public
11
 * License as published by the Free Software Foundation; either
12
 * version 2.1 of the License, or (at your option) any later version.
13
 *
14
 * FFmpeg is distributed in the hope that it will be useful,
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17
 * Lesser General Public License for more details.
18
 *
19
 * You should have received a copy of the GNU Lesser General Public
20
 * License along with FFmpeg; if not, write to the Free Software
21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22
 */
23
24
#include "libavutil/attributes.h"
25
#include "libavutil/common.h"
26
27
#include "cabac_functions.h"
28
#include "hevc_data.h"
29
#include "hevc.h"
30
#include "hevcdec.h"
31
32
#define CABAC_MAX_BIN 31
33
34
/**
35
 * number of bin by SyntaxElement.
36
 */
37
static const int8_t num_bins_in_se[] = {
38
     1, // sao_merge_flag
39
     1, // sao_type_idx
40
     0, // sao_eo_class
41
     0, // sao_band_position
42
     0, // sao_offset_abs
43
     0, // sao_offset_sign
44
     0, // end_of_slice_flag
45
     3, // split_coding_unit_flag
46
     1, // cu_transquant_bypass_flag
47
     3, // skip_flag
48
     3, // cu_qp_delta
49
     1, // pred_mode
50
     4, // part_mode
51
     0, // pcm_flag
52
     1, // prev_intra_luma_pred_mode
53
     0, // mpm_idx
54
     0, // rem_intra_luma_pred_mode
55
     2, // intra_chroma_pred_mode
56
     1, // merge_flag
57
     1, // merge_idx
58
     5, // inter_pred_idc
59
     2, // ref_idx_l0
60
     2, // ref_idx_l1
61
     2, // abs_mvd_greater0_flag
62
     2, // abs_mvd_greater1_flag
63
     0, // abs_mvd_minus2
64
     0, // mvd_sign_flag
65
     1, // mvp_lx_flag
66
     1, // no_residual_data_flag
67
     3, // split_transform_flag
68
     2, // cbf_luma
69
     4, // cbf_cb, cbf_cr
70
     2, // transform_skip_flag[][]
71
     2, // explicit_rdpcm_flag[][]
72
     2, // explicit_rdpcm_dir_flag[][]
73
    18, // last_significant_coeff_x_prefix
74
    18, // last_significant_coeff_y_prefix
75
     0, // last_significant_coeff_x_suffix
76
     0, // last_significant_coeff_y_suffix
77
     4, // significant_coeff_group_flag
78
    44, // significant_coeff_flag
79
    24, // coeff_abs_level_greater1_flag
80
     6, // coeff_abs_level_greater2_flag
81
     0, // coeff_abs_level_remaining
82
     0, // coeff_sign_flag
83
     8, // log2_res_scale_abs
84
     2, // res_scale_sign_flag
85
     1, // cu_chroma_qp_offset_flag
86
     1, // cu_chroma_qp_offset_idx
87
};
88
89
/**
90
 * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
91
 */
92
static const int elem_offset[sizeof(num_bins_in_se)] = {
93
    0, // sao_merge_flag
94
    1, // sao_type_idx
95
    2, // sao_eo_class
96
    2, // sao_band_position
97
    2, // sao_offset_abs
98
    2, // sao_offset_sign
99
    2, // end_of_slice_flag
100
    2, // split_coding_unit_flag
101
    5, // cu_transquant_bypass_flag
102
    6, // skip_flag
103
    9, // cu_qp_delta
104
    12, // pred_mode
105
    13, // part_mode
106
    17, // pcm_flag
107
    17, // prev_intra_luma_pred_mode
108
    18, // mpm_idx
109
    18, // rem_intra_luma_pred_mode
110
    18, // intra_chroma_pred_mode
111
    20, // merge_flag
112
    21, // merge_idx
113
    22, // inter_pred_idc
114
    27, // ref_idx_l0
115
    29, // ref_idx_l1
116
    31, // abs_mvd_greater0_flag
117
    33, // abs_mvd_greater1_flag
118
    35, // abs_mvd_minus2
119
    35, // mvd_sign_flag
120
    35, // mvp_lx_flag
121
    36, // no_residual_data_flag
122
    37, // split_transform_flag
123
    40, // cbf_luma
124
    42, // cbf_cb, cbf_cr
125
    46, // transform_skip_flag[][]
126
    48, // explicit_rdpcm_flag[][]
127
    50, // explicit_rdpcm_dir_flag[][]
128
    52, // last_significant_coeff_x_prefix
129
    70, // last_significant_coeff_y_prefix
130
    88, // last_significant_coeff_x_suffix
131
    88, // last_significant_coeff_y_suffix
132
    88, // significant_coeff_group_flag
133
    92, // significant_coeff_flag
134
    136, // coeff_abs_level_greater1_flag
135
    160, // coeff_abs_level_greater2_flag
136
    166, // coeff_abs_level_remaining
137
    166, // coeff_sign_flag
138
    166, // log2_res_scale_abs
139
    174, // res_scale_sign_flag
140
    176, // cu_chroma_qp_offset_flag
141
    177, // cu_chroma_qp_offset_idx
142
};
143
144
#define CNU 154
145
/**
146
 * Indexed by init_type
147
 */
148
static const uint8_t init_values[3][HEVC_CONTEXTS] = {
149
    { // sao_merge_flag
150
      153,
151
      // sao_type_idx
152
      200,
153
      // split_coding_unit_flag
154
      139, 141, 157,
155
      // cu_transquant_bypass_flag
156
      154,
157
      // skip_flag
158
      CNU, CNU, CNU,
159
      // cu_qp_delta
160
      154, 154, 154,
161
      // pred_mode
162
      CNU,
163
      // part_mode
164
      184, CNU, CNU, CNU,
165
      // prev_intra_luma_pred_mode
166
      184,
167
      // intra_chroma_pred_mode
168
      63, 139,
169
      // merge_flag
170
      CNU,
171
      // merge_idx
172
      CNU,
173
      // inter_pred_idc
174
      CNU, CNU, CNU, CNU, CNU,
175
      // ref_idx_l0
176
      CNU, CNU,
177
      // ref_idx_l1
178
      CNU, CNU,
179
      // abs_mvd_greater1_flag
180
      CNU, CNU,
181
      // abs_mvd_greater1_flag
182
      CNU, CNU,
183
      // mvp_lx_flag
184
      CNU,
185
      // no_residual_data_flag
186
      CNU,
187
      // split_transform_flag
188
      153, 138, 138,
189
      // cbf_luma
190
      111, 141,
191
      // cbf_cb, cbf_cr
192
      94, 138, 182, 154,
193
      // transform_skip_flag
194
      139, 139,
195
      // explicit_rdpcm_flag
196
      139, 139,
197
      // explicit_rdpcm_dir_flag
198
      139, 139,
199
      // last_significant_coeff_x_prefix
200
      110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
201
       79, 108, 123,  63,
202
      // last_significant_coeff_y_prefix
203
      110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
204
       79, 108, 123,  63,
205
      // significant_coeff_group_flag
206
      91, 171, 134, 141,
207
      // significant_coeff_flag
208
      111, 111, 125, 110, 110,  94, 124, 108, 124, 107, 125, 141, 179, 153,
209
      125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
210
      139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
211
      141, 111,
212
      // coeff_abs_level_greater1_flag
213
      140,  92, 137, 138, 140, 152, 138, 139, 153,  74, 149,  92, 139, 107,
214
      122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
215
      // coeff_abs_level_greater2_flag
216
      138, 153, 136, 167, 152, 152,
217
      // log2_res_scale_abs
218
      154, 154, 154, 154, 154, 154, 154, 154,
219
      // res_scale_sign_flag
220
      154, 154,
221
      // cu_chroma_qp_offset_flag
222
      154,
223
      // cu_chroma_qp_offset_idx
224
      154,
225
    },
226
    { // sao_merge_flag
227
      153,
228
      // sao_type_idx
229
      185,
230
      // split_coding_unit_flag
231
      107, 139, 126,
232
      // cu_transquant_bypass_flag
233
      154,
234
      // skip_flag
235
      197, 185, 201,
236
      // cu_qp_delta
237
      154, 154, 154,
238
      // pred_mode
239
      149,
240
      // part_mode
241
      154, 139, 154, 154,
242
      // prev_intra_luma_pred_mode
243
      154,
244
      // intra_chroma_pred_mode
245
      152, 139,
246
      // merge_flag
247
      110,
248
      // merge_idx
249
      122,
250
      // inter_pred_idc
251
      95, 79, 63, 31, 31,
252
      // ref_idx_l0
253
      153, 153,
254
      // ref_idx_l1
255
      153, 153,
256
      // abs_mvd_greater1_flag
257
      140, 198,
258
      // abs_mvd_greater1_flag
259
      140, 198,
260
      // mvp_lx_flag
261
      168,
262
      // no_residual_data_flag
263
      79,
264
      // split_transform_flag
265
      124, 138, 94,
266
      // cbf_luma
267
      153, 111,
268
      // cbf_cb, cbf_cr
269
      149, 107, 167, 154,
270
      // transform_skip_flag
271
      139, 139,
272
      // explicit_rdpcm_flag
273
      139, 139,
274
      // explicit_rdpcm_dir_flag
275
      139, 139,
276
      // last_significant_coeff_x_prefix
277
      125, 110,  94, 110,  95,  79, 125, 111, 110,  78, 110, 111, 111,  95,
278
       94, 108, 123, 108,
279
      // last_significant_coeff_y_prefix
280
      125, 110,  94, 110,  95,  79, 125, 111, 110,  78, 110, 111, 111,  95,
281
       94, 108, 123, 108,
282
      // significant_coeff_group_flag
283
      121, 140, 61, 154,
284
      // significant_coeff_flag
285
      155, 154, 139, 153, 139, 123, 123,  63, 153, 166, 183, 140, 136, 153,
286
      154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
287
      153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
288
      140, 140,
289
      // coeff_abs_level_greater1_flag
290
      154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
291
      136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
292
      // coeff_abs_level_greater2_flag
293
      107, 167, 91, 122, 107, 167,
294
      // log2_res_scale_abs
295
      154, 154, 154, 154, 154, 154, 154, 154,
296
      // res_scale_sign_flag
297
      154, 154,
298
      // cu_chroma_qp_offset_flag
299
      154,
300
      // cu_chroma_qp_offset_idx
301
      154,
302
    },
303
    { // sao_merge_flag
304
      153,
305
      // sao_type_idx
306
      160,
307
      // split_coding_unit_flag
308
      107, 139, 126,
309
      // cu_transquant_bypass_flag
310
      154,
311
      // skip_flag
312
      197, 185, 201,
313
      // cu_qp_delta
314
      154, 154, 154,
315
      // pred_mode
316
      134,
317
      // part_mode
318
      154, 139, 154, 154,
319
      // prev_intra_luma_pred_mode
320
      183,
321
      // intra_chroma_pred_mode
322
      152, 139,
323
      // merge_flag
324
      154,
325
      // merge_idx
326
      137,
327
      // inter_pred_idc
328
      95, 79, 63, 31, 31,
329
      // ref_idx_l0
330
      153, 153,
331
      // ref_idx_l1
332
      153, 153,
333
      // abs_mvd_greater1_flag
334
      169, 198,
335
      // abs_mvd_greater1_flag
336
      169, 198,
337
      // mvp_lx_flag
338
      168,
339
      // no_residual_data_flag
340
      79,
341
      // split_transform_flag
342
      224, 167, 122,
343
      // cbf_luma
344
      153, 111,
345
      // cbf_cb, cbf_cr
346
      149, 92, 167, 154,
347
      // transform_skip_flag
348
      139, 139,
349
      // explicit_rdpcm_flag
350
      139, 139,
351
      // explicit_rdpcm_dir_flag
352
      139, 139,
353
      // last_significant_coeff_x_prefix
354
      125, 110, 124, 110,  95,  94, 125, 111, 111,  79, 125, 126, 111, 111,
355
       79, 108, 123,  93,
356
      // last_significant_coeff_y_prefix
357
      125, 110, 124, 110,  95,  94, 125, 111, 111,  79, 125, 126, 111, 111,
358
       79, 108, 123,  93,
359
      // significant_coeff_group_flag
360
      121, 140, 61, 154,
361
      // significant_coeff_flag
362
      170, 154, 139, 153, 139, 123, 123,  63, 124, 166, 183, 140, 136, 153,
363
      154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
364
      153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
365
      140, 140,
366
      // coeff_abs_level_greater1_flag
367
      154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
368
      136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
369
      // coeff_abs_level_greater2_flag
370
      107, 167, 91, 107, 107, 167,
371
      // log2_res_scale_abs
372
      154, 154, 154, 154, 154, 154, 154, 154,
373
      // res_scale_sign_flag
374
      154, 154,
375
      // cu_chroma_qp_offset_flag
376
      154,
377
      // cu_chroma_qp_offset_idx
378
      154,
379
    },
380
};
381
382
static const uint8_t scan_1x1[1] = {
383
    0,
384
};
385
386
static const uint8_t horiz_scan2x2_x[4] = {
387
    0, 1, 0, 1,
388
};
389
390
static const uint8_t horiz_scan2x2_y[4] = {
391
    0, 0, 1, 1
392
};
393
394
static const uint8_t horiz_scan4x4_x[16] = {
395
    0, 1, 2, 3,
396
    0, 1, 2, 3,
397
    0, 1, 2, 3,
398
    0, 1, 2, 3,
399
};
400
401
static const uint8_t horiz_scan4x4_y[16] = {
402
    0, 0, 0, 0,
403
    1, 1, 1, 1,
404
    2, 2, 2, 2,
405
    3, 3, 3, 3,
406
};
407
408
static const uint8_t horiz_scan8x8_inv[8][8] = {
409
    {  0,  1,  2,  3, 16, 17, 18, 19, },
410
    {  4,  5,  6,  7, 20, 21, 22, 23, },
411
    {  8,  9, 10, 11, 24, 25, 26, 27, },
412
    { 12, 13, 14, 15, 28, 29, 30, 31, },
413
    { 32, 33, 34, 35, 48, 49, 50, 51, },
414
    { 36, 37, 38, 39, 52, 53, 54, 55, },
415
    { 40, 41, 42, 43, 56, 57, 58, 59, },
416
    { 44, 45, 46, 47, 60, 61, 62, 63, },
417
};
418
419
static const uint8_t diag_scan2x2_x[4] = {
420
    0, 0, 1, 1,
421
};
422
423
static const uint8_t diag_scan2x2_y[4] = {
424
    0, 1, 0, 1,
425
};
426
427
static const uint8_t diag_scan2x2_inv[2][2] = {
428
    { 0, 2, },
429
    { 1, 3, },
430
};
431
432
static const uint8_t diag_scan4x4_inv[4][4] = {
433
    { 0,  2,  5,  9, },
434
    { 1,  4,  8, 12, },
435
    { 3,  7, 11, 14, },
436
    { 6, 10, 13, 15, },
437
};
438
439
static const uint8_t diag_scan8x8_inv[8][8] = {
440
    {  0,  2,  5,  9, 14, 20, 27, 35, },
441
    {  1,  4,  8, 13, 19, 26, 34, 42, },
442
    {  3,  7, 12, 18, 25, 33, 41, 48, },
443
    {  6, 11, 17, 24, 32, 40, 47, 53, },
444
    { 10, 16, 23, 31, 39, 46, 52, 57, },
445
    { 15, 22, 30, 38, 45, 51, 56, 60, },
446
    { 21, 29, 37, 44, 50, 55, 59, 62, },
447
    { 28, 36, 43, 49, 54, 58, 61, 63, },
448
};
449
450
1377403
void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
451
{
452
1377403
    if (s->ps.pps->entropy_coding_sync_enabled_flag &&
453
93384
        (ctb_addr_ts % s->ps.sps->ctb_width == 2 ||
454
88834
         (s->ps.sps->ctb_width == 2 &&
455
784
          ctb_addr_ts % s->ps.sps->ctb_width == 0))) {
456
4942
        memcpy(s->cabac_state, s->HEVClc->cabac_state, HEVC_CONTEXTS);
457
    }
458
1377403
}
459
460
3939
static void load_states(HEVCContext *s)
461
{
462
3939
    memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
463
3939
}
464
465
7580
static int cabac_reinit(HEVCLocalContext *lc)
466
{
467
7580
    return skip_bytes(&lc->cc, 0) == NULL ? AVERROR_INVALIDDATA : 0;
468
}
469
470
27459
static int cabac_init_decoder(HEVCContext *s)
471
{
472
27459
    GetBitContext *gb = &s->HEVClc->gb;
473
27459
    skip_bits(gb, 1);
474
27459
    align_get_bits(gb);
475
82377
    return ff_init_cabac_decoder(&s->HEVClc->cc,
476
27459
                          gb->buffer + get_bits_count(gb) / 8,
477
27459
                          (get_bits_left(gb) + 7) / 8);
478
}
479
480
24716
static void cabac_init_state(HEVCContext *s)
481
{
482
24716
    int init_type = 2 - s->sh.slice_type;
483
    int i;
484
485

24716
    if (s->sh.cabac_init_flag && s->sh.slice_type != HEVC_SLICE_I)
486
6345
        init_type ^= 3;
487
488
4943200
    for (i = 0; i < HEVC_CONTEXTS; i++) {
489
4918484
        int init_value = init_values[init_type][i];
490
4918484
        int m = (init_value >> 4) * 5 - 45;
491
4918484
        int n = ((init_value & 15) << 3) - 16;
492
4918484
        int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
493
494
4918484
        pre ^= pre >> 31;
495
4918484
        if (pre > 124)
496
529676
            pre = 124 + (pre & 1);
497
4918484
        s->HEVClc->cabac_state[i] = pre;
498
    }
499
500
123580
    for (i = 0; i < 4; i++)
501
98864
        s->HEVClc->stat_coeff[i] = 0;
502
24716
}
503
504
1377404
int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
505
{
506
1377404
    if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
507
27459
        int ret = cabac_init_decoder(s);
508
27459
        if (ret < 0)
509
            return ret;
510
27459
        if (s->sh.dependent_slice_segment_flag == 0 ||
511
7947
            (s->ps.pps->tiles_enabled_flag &&
512
876
             s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
513
19821
            cabac_init_state(s);
514
515
27459
        if (!s->sh.first_slice_in_pic_flag &&
516
17981
            s->ps.pps->entropy_coding_sync_enabled_flag) {
517
3853
            if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
518
1636
                if (s->ps.sps->ctb_width == 1)
519
92
                    cabac_init_state(s);
520
1544
                else if (s->sh.dependent_slice_segment_flag == 1)
521
1162
                    load_states(s);
522
            }
523
        }
524
    } else {
525
1349945
        if (s->ps.pps->tiles_enabled_flag &&
526
269051
            s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
527
            int ret;
528
4601
            if (s->threads_number == 1)
529
4601
                ret = cabac_reinit(s->HEVClc);
530
            else {
531
                ret = cabac_init_decoder(s);
532
            }
533
4601
            if (ret < 0)
534
                return ret;
535
4601
            cabac_init_state(s);
536
        }
537
1349945
        if (s->ps.pps->entropy_coding_sync_enabled_flag) {
538
88812
            if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
539
                int ret;
540
2979
                get_cabac_terminate(&s->HEVClc->cc);
541
2979
                if (s->threads_number == 1)
542
2979
                    ret = cabac_reinit(s->HEVClc);
543
                else {
544
                    ret = cabac_init_decoder(s);
545
                }
546
2979
                if (ret < 0)
547
                    return ret;
548
549
2979
                if (s->ps.sps->ctb_width == 1)
550
202
                    cabac_init_state(s);
551
                else
552
2777
                    load_states(s);
553
            }
554
        }
555
    }
556
1377404
    return 0;
557
}
558
559
#define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
560
561
785420
int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
562
{
563
785420
    return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
564
}
565
566
353971
int ff_hevc_sao_type_idx_decode(HEVCContext *s)
567
{
568
353971
    if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
569
192530
        return 0;
570
571
161441
    if (!get_cabac_bypass(&s->HEVClc->cc))
572
53676
        return SAO_BAND;
573
107765
    return SAO_EDGE;
574
}
575
576
77567
int ff_hevc_sao_band_position_decode(HEVCContext *s)
577
{
578
    int i;
579
77567
    int value = get_cabac_bypass(&s->HEVClc->cc);
580
581
387835
    for (i = 0; i < 4; i++)
582
310268
        value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
583
77567
    return value;
584
}
585
586
864132
int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
587
{
588
864132
    int i = 0;
589
864132
    int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
590
591

2574667
    while (i < length && get_cabac_bypass(&s->HEVClc->cc))
592
1710535
        i++;
593
864132
    return i;
594
}
595
596
242354
int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
597
{
598
242354
    return get_cabac_bypass(&s->HEVClc->cc);
599
}
600
601
107765
int ff_hevc_sao_eo_class_decode(HEVCContext *s)
602
{
603
107765
    int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
604
107765
    ret    |= get_cabac_bypass(&s->HEVClc->cc);
605
107765
    return ret;
606
}
607
608
1377403
int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
609
{
610
1377403
    return get_cabac_terminate(&s->HEVClc->cc);
611
}
612
613
200139
int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
614
{
615
200139
    return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
616
}
617
618
8054524
int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
619
{
620
8054524
    int min_cb_width = s->ps.sps->min_cb_width;
621
8054524
    int inc = 0;
622
8054524
    int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
623
8054524
    int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
624
625

8054524
    if (s->HEVClc->ctb_left_flag || x0b)
626
7850314
        inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
627

8054524
    if (s->HEVClc->ctb_up_flag || y0b)
628
7598229
        inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
629
630
8054524
    return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
631
}
632
633
543293
int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
634
{
635
543293
    int prefix_val = 0;
636
543293
    int suffix_val = 0;
637
543293
    int inc = 0;
638
639

1492342
    while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
640
949049
        prefix_val++;
641
949049
        inc = 1;
642
    }
643
543293
    if (prefix_val >= 5) {
644
104855
        int k = 0;
645

357628
        while (k < 7 && get_cabac_bypass(&s->HEVClc->cc)) {
646
252773
            suffix_val += 1 << k;
647
252773
            k++;
648
        }
649
104855
        if (k == 7) {
650
            av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
651
            return AVERROR_INVALIDDATA;
652
        }
653
654
357628
        while (k--)
655
252773
            suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
656
    }
657
543293
    return prefix_val + suffix_val;
658
}
659
660
353071
int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
661
{
662
353071
    return get_cabac_bypass(&s->HEVClc->cc);
663
}
664
665
266275
int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
666
{
667
266275
    return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]);
668
}
669
670
int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
671
{
672
    int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
673
    int i = 0;
674
675
    while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
676
        i++;
677
678
    return i;
679
}
680
681
4182338
int ff_hevc_pred_mode_decode(HEVCContext *s)
682
{
683
4182338
    return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
684
}
685
686
7385929
int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
687
{
688
7385929
    int inc = 0, depth_left = 0, depth_top = 0;
689
7385929
    int x0b  = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
690
7385929
    int y0b  = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
691
7385929
    int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
692
7385929
    int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
693
694

7385929
    if (s->HEVClc->ctb_left_flag || x0b)
695
7089716
        depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
696

7385929
    if (s->HEVClc->ctb_up_flag || y0b)
697
6737229
        depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
698
699
7385929
    inc += (depth_left > ct_depth);
700
7385929
    inc += (depth_top  > ct_depth);
701
702
7385929
    return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
703
}
704
705
6093281
int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
706
{
707
6093281
    if (GET_CABAC(elem_offset[PART_MODE])) // 1
708
3541785
        return PART_2Nx2N;
709
2551496
    if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
710
1921908
        if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
711
1172993
            return PART_NxN;
712
748915
        if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
713
307999
            return PART_2NxN;
714
440916
        if (log2_cb_size == 3) // 00
715
222875
            return PART_Nx2N;
716
218041
        if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
717
112405
            return PART_Nx2N;
718
105636
        return PART_NxN; // 000
719
    }
720
721
629588
    if (!s->ps.sps->amp_enabled_flag) {
722
64639
        if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
723
29372
            return PART_2NxN;
724
35267
        return PART_Nx2N;
725
    }
726
727
564949
    if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
728
227260
        if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
729
108355
            return PART_2NxN;
730
118905
        if (get_cabac_bypass(&s->HEVClc->cc)) // 0101
731
55171
            return PART_2NxnD;
732
63734
        return PART_2NxnU; // 0100
733
    }
734
735
337689
    if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
736
164471
        return PART_Nx2N;
737
173218
    if (get_cabac_bypass(&s->HEVClc->cc)) // 0001
738
80051
        return PART_nRx2N;
739
93167
    return PART_nLx2N;  // 0000
740
}
741
742
153183
int ff_hevc_pcm_flag_decode(HEVCContext *s)
743
{
744
153183
    return get_cabac_terminate(&s->HEVClc->cc);
745
}
746
747
7367714
int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
748
{
749
7367714
    return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
750
}
751
752
4388604
int ff_hevc_mpm_idx_decode(HEVCContext *s)
753
{
754
4388604
    int i = 0;
755

7468906
    while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
756
3080302
        i++;
757
4388604
    return i;
758
}
759
760
2979110
int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
761
{
762
    int i;
763
2979110
    int value = get_cabac_bypass(&s->HEVClc->cc);
764
765
14895550
    for (i = 0; i < 4; i++)
766
11916440
        value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
767
2979110
    return value;
768
}
769
770
3950096
int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
771
{
772
    int ret;
773
3950096
    if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
774
2925494
        return 4;
775
776
1024602
    ret  = get_cabac_bypass(&s->HEVClc->cc) << 1;
777
1024602
    ret |= get_cabac_bypass(&s->HEVClc->cc);
778
1024602
    return ret;
779
}
780
781
6124714
int ff_hevc_merge_idx_decode(HEVCContext *s)
782
{
783
6124714
    int i = GET_CABAC(elem_offset[MERGE_IDX]);
784
785
6124714
    if (i != 0) {
786

4154204
        while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc->cc))
787
1649855
            i++;
788
    }
789
6124714
    return i;
790
}
791
792
4706854
int ff_hevc_merge_flag_decode(HEVCContext *s)
793
{
794
4706854
    return GET_CABAC(elem_offset[MERGE_FLAG]);
795
}
796
797
1811353
int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
798
{
799
1811353
    if (nPbW + nPbH == 12)
800
239847
        return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
801
1571506
    if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc->ct_depth))
802
404002
        return PRED_BI;
803
804
1167504
    return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
805
}
806
807
2781475
int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
808
{
809
2781475
    int i = 0;
810
2781475
    int max = num_ref_idx_lx - 1;
811
2781475
    int max_ctx = FFMIN(max, 2);
812
813

3723508
    while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
814
942033
        i++;
815
2781475
    if (i == 2) {
816

281277
        while (i < max && get_cabac_bypass(&s->HEVClc->cc))
817
85409
            i++;
818
    }
819
820
2781475
    return i;
821
}
822
823
2781475
int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
824
{
825
2781475
    return GET_CABAC(elem_offset[MVP_LX_FLAG]);
826
}
827
828
2346082
int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
829
{
830
2346082
    return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
831
}
832
833
5247362
static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
834
{
835
5247362
    return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
836
}
837
838
3588943
static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
839
{
840
3588943
    return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
841
}
842
843
2574719
static av_always_inline int mvd_decode(HEVCContext *s)
844
{
845
2574719
    int ret = 2;
846
2574719
    int k = 1;
847
848

6300465
    while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
849
3725746
        ret += 1U << k;
850
3725746
        k++;
851
    }
852
2574719
    if (k == CABAC_MAX_BIN) {
853
        av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
854
        return 0;
855
    }
856
8875184
    while (k--)
857
6300465
        ret += get_cabac_bypass(&s->HEVClc->cc) << k;
858
2574719
    return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
859
}
860
861
1014224
static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
862
{
863
1014224
    return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
864
}
865
866
6784667
int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
867
{
868
6784667
    return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
869
}
870
871
14617383
int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
872
{
873
14617383
    return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
874
}
875
876
14382229
int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
877
{
878
14382229
    return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
879
}
880
881
6478284
static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
882
{
883
6478284
    return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
884
}
885
886
34172
static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
887
{
888
34172
    return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
889
}
890
891
2983
static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
892
{
893
2983
    return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
894
}
895
896
384846
int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
897
384846
    int i =0;
898
899

1222588
    while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
900
837742
        i++;
901
902
384846
    return i;
903
}
904
905
235843
int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
906
235843
    return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
907
}
908
909
13708131
static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
910
                                                   int log2_size, int *last_scx_prefix, int *last_scy_prefix)
911
{
912
13708131
    int i = 0;
913
13708131
    int max = (log2_size << 1) - 1;
914
    int ctx_offset, ctx_shift;
915
916
13708131
    if (!c_idx) {
917
9522273
        ctx_offset = 3 * (log2_size - 2)  + ((log2_size - 1) >> 2);
918
9522273
        ctx_shift = (log2_size + 1) >> 2;
919
    } else {
920
4185858
        ctx_offset = 15;
921
4185858
        ctx_shift = log2_size - 2;
922
    }
923

68703528
    while (i < max &&
924
33325013
           GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
925
21670384
        i++;
926
13708131
    *last_scx_prefix = i;
927
928
13708131
    i = 0;
929

59947432
    while (i < max &&
930
29161157
           GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
931
17078144
        i++;
932
13708131
    *last_scy_prefix = i;
933
13708131
}
934
935
2935034
static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
936
                                                 int last_significant_coeff_prefix)
937
{
938
    int i;
939
2935034
    int length = (last_significant_coeff_prefix >> 1) - 1;
940
2935034
    int value = get_cabac_bypass(&s->HEVClc->cc);
941
942
3746576
    for (i = 1; i < length; i++)
943
811542
        value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
944
2935034
    return value;
945
}
946
947
7785694
static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
948
{
949
    int inc;
950
951
7785694
    inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
952
953
7785694
    return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
954
}
955
162684528
static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
956
                                           int offset, const uint8_t *ctx_idx_map)
957
{
958
162684528
    int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
959
162684528
    return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
960
}
961
962
17719699
static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
963
{
964
17719699
    return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
965
}
966
967
87772934
static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
968
{
969
970
87772934
    if (c_idx > 0)
971
20442643
        inc += 16;
972
973
87772934
    return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
974
}
975
976
9734539
static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
977
{
978
9734539
    if (c_idx > 0)
979
1979636
        inc += 4;
980
981
9734539
    return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
982
}
983
984
39761584
static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
985
{
986
39761584
    int prefix = 0;
987
39761584
    int suffix = 0;
988
    int last_coeff_abs_level_remaining;
989
    int i;
990
991

87165424
    while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
992
47403840
        prefix++;
993
994
39761584
    if (prefix < 3) {
995
70489163
        for (i = 0; i < rc_rice_param; i++)
996
36468922
            suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
997
34020241
        last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
998
    } else {
999
5741343
        int prefix_minus3 = prefix - 3;
1000
1001

5741343
        if (prefix == CABAC_MAX_BIN || prefix_minus3 + rc_rice_param >= 31) {
1002
            av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
1003
            return 0;
1004
        }
1005
1006
24849237
        for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
1007
19107894
            suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
1008
5741343
        last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
1009
5741343
                                              << rc_rice_param) + suffix;
1010
    }
1011
39761584
    return last_coeff_abs_level_remaining;
1012
}
1013
1014
20796606
static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
1015
{
1016
    int i;
1017
20796606
    int ret = 0;
1018
1019
115239649
    for (i = 0; i < nb; i++)
1020
94443043
        ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1021
20796606
    return ret;
1022
}
1023
1024
13708131
void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1025
                                int log2_trafo_size, enum ScanType scan_idx,
1026
                                int c_idx)
1027
{
1028
#define GET_COORD(offset, n)                                    \
1029
    do {                                                        \
1030
        x_c = (x_cg << 2) + scan_x_off[n];                      \
1031
        y_c = (y_cg << 2) + scan_y_off[n];                      \
1032
    } while (0)
1033
13708131
    HEVCLocalContext *lc = s->HEVClc;
1034
13708131
    int transform_skip_flag = 0;
1035
1036
    int last_significant_coeff_x, last_significant_coeff_y;
1037
    int last_scan_pos;
1038
    int n_end;
1039
13708131
    int num_coeff = 0;
1040
13708131
    int greater1_ctx = 1;
1041
1042
    int num_last_subset;
1043
    int x_cg_last_sig, y_cg_last_sig;
1044
1045
    const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1046
1047
13708131
    ptrdiff_t stride = s->frame->linesize[c_idx];
1048
13708131
    int hshift = s->ps.sps->hshift[c_idx];
1049
13708131
    int vshift = s->ps.sps->vshift[c_idx];
1050
13708131
    uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1051
13708131
                                          ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1052
13708131
    int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1053
13708131
    uint8_t significant_coeff_group_flag[8][8] = {{0}};
1054
13708131
    int explicit_rdpcm_flag = 0;
1055
    int explicit_rdpcm_dir_flag;
1056
1057
13708131
    int trafo_size = 1 << log2_trafo_size;
1058
    int i;
1059
    int qp,shift,add,scale,scale_m;
1060
    static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1061
13708131
    const uint8_t *scale_matrix = NULL;
1062
    uint8_t dc_scale;
1063
13708131
    int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1064
                                         lc->tu.intra_pred_mode_c;
1065
1066
13708131
    memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1067
1068
    // Derive QP for dequant
1069
13708131
    if (!lc->cu.cu_transquant_bypass_flag) {
1070
        static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1071
        static const uint8_t rem6[51 + 4 * 6 + 1] = {
1072
            0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1073
            3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1074
            0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1075
            4, 5, 0, 1, 2, 3, 4, 5, 0, 1
1076
        };
1077
1078
        static const uint8_t div6[51 + 4 * 6 + 1] = {
1079
            0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3,  3,  3,
1080
            3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6,  6,  6,
1081
            7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1082
            10, 10, 11, 11, 11, 11, 11, 11, 12, 12
1083
        };
1084
13269765
        int qp_y = lc->qp_y;
1085
1086
13269765
        if (s->ps.pps->transform_skip_enabled_flag &&
1087
11222947
            log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1088
6478284
            transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1089
        }
1090
1091
13269765
        if (c_idx == 0) {
1092
9247025
            qp = qp_y + s->ps.sps->qp_bd_offset;
1093
        } else {
1094
            int qp_i, offset;
1095
1096
4022740
            if (c_idx == 1)
1097
1907702
                offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1098
1907702
                         lc->tu.cu_qp_offset_cb;
1099
            else
1100
2115038
                offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1101
2115038
                         lc->tu.cu_qp_offset_cr;
1102
1103
4022740
            qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1104
4022740
            if (s->ps.sps->chroma_format_idc == 1) {
1105
2403425
                if (qp_i < 30)
1106
725366
                    qp = qp_i;
1107
1678059
                else if (qp_i > 43)
1108
9230
                    qp = qp_i - 6;
1109
                else
1110
1668829
                    qp = qp_c[qp_i - 30];
1111
            } else {
1112
1619315
                if (qp_i > 51)
1113
                    qp = 51;
1114
                else
1115
1619315
                    qp = qp_i;
1116
            }
1117
1118
4022740
            qp += s->ps.sps->qp_bd_offset;
1119
        }
1120
1121
13269765
        shift    = s->ps.sps->bit_depth + log2_trafo_size - 5;
1122
13269765
        add      = 1 << (shift-1);
1123
13269765
        scale    = level_scale[rem6[qp]] << (div6[qp]);
1124
13269765
        scale_m  = 16; // default when no custom scaling lists.
1125
13269765
        dc_scale = 16;
1126
1127

13269765
        if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1128
919466
            const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1129
459733
            &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1130
459733
            int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1131
1132
459733
            matrix_id = 3 * matrix_id + c_idx;
1133
1134
459733
            scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1135
459733
            if (log2_trafo_size >= 4)
1136
35021
                dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1137
        }
1138
    } else {
1139
438366
        shift        = 0;
1140
438366
        add          = 0;
1141
438366
        scale        = 0;
1142
438366
        dc_scale     = 0;
1143
    }
1144
1145

13708131
    if (lc->cu.pred_mode == MODE_INTER && s->ps.sps->explicit_rdpcm_enabled_flag &&
1146
189763
        (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1147
34172
        explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
1148
34172
        if (explicit_rdpcm_flag) {
1149
2983
            explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
1150
        }
1151
    }
1152
1153
13708131
    last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1154
                                           &last_significant_coeff_x, &last_significant_coeff_y);
1155
1156
13708131
    if (last_significant_coeff_x > 3) {
1157
1695787
        int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1158
1695787
        last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1159
1695787
        (2 + (last_significant_coeff_x & 1)) +
1160
        suffix;
1161
    }
1162
1163
13708131
    if (last_significant_coeff_y > 3) {
1164
1239247
        int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1165
1239247
        last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1166
1239247
        (2 + (last_significant_coeff_y & 1)) +
1167
        suffix;
1168
    }
1169
1170
13708131
    if (scan_idx == SCAN_VERT)
1171
1796463
        FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1172
1173
13708131
    x_cg_last_sig = last_significant_coeff_x >> 2;
1174
13708131
    y_cg_last_sig = last_significant_coeff_y >> 2;
1175
1176
13708131
    switch (scan_idx) {
1177
9905762
    case SCAN_DIAG: {
1178
9905762
        int last_x_c = last_significant_coeff_x & 3;
1179
9905762
        int last_y_c = last_significant_coeff_y & 3;
1180
1181
9905762
        scan_x_off = ff_hevc_diag_scan4x4_x;
1182
9905762
        scan_y_off = ff_hevc_diag_scan4x4_y;
1183
9905762
        num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1184
9905762
        if (trafo_size == 4) {
1185
5044891
            scan_x_cg = scan_1x1;
1186
5044891
            scan_y_cg = scan_1x1;
1187
4860871
        } else if (trafo_size == 8) {
1188
2671717
            num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1189
2671717
            scan_x_cg = diag_scan2x2_x;
1190
2671717
            scan_y_cg = diag_scan2x2_y;
1191
2189154
        } else if (trafo_size == 16) {
1192
1619558
            num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1193
1619558
            scan_x_cg = ff_hevc_diag_scan4x4_x;
1194
1619558
            scan_y_cg = ff_hevc_diag_scan4x4_y;
1195
        } else { // trafo_size == 32
1196
569596
            num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1197
569596
            scan_x_cg = ff_hevc_diag_scan8x8_x;
1198
569596
            scan_y_cg = ff_hevc_diag_scan8x8_y;
1199
        }
1200
9905762
        break;
1201
    }
1202
2005906
    case SCAN_HORIZ:
1203
2005906
        scan_x_cg = horiz_scan2x2_x;
1204
2005906
        scan_y_cg = horiz_scan2x2_y;
1205
2005906
        scan_x_off = horiz_scan4x4_x;
1206
2005906
        scan_y_off = horiz_scan4x4_y;
1207
2005906
        num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1208
2005906
        break;
1209
1796463
    default: //SCAN_VERT
1210
1796463
        scan_x_cg = horiz_scan2x2_y;
1211
1796463
        scan_y_cg = horiz_scan2x2_x;
1212
1796463
        scan_x_off = horiz_scan4x4_y;
1213
1796463
        scan_y_off = horiz_scan4x4_x;
1214
1796463
        num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1215
1796463
        break;
1216
    }
1217
13708131
    num_coeff++;
1218
13708131
    num_last_subset = (num_coeff - 1) >> 4;
1219
1220
37451968
    for (i = num_last_subset; i >= 0; i--) {
1221
        int n, m;
1222
        int x_cg, y_cg, x_c, y_c, pos;
1223
23743837
        int implicit_non_zero_coeff = 0;
1224
        int64_t trans_coeff_level;
1225
23743837
        int prev_sig = 0;
1226
23743837
        int offset = i << 4;
1227
23743837
        int rice_init = 0;
1228
1229
        uint8_t significant_coeff_flag_idx[16];
1230
23743837
        uint8_t nb_significant_coeff_flag = 0;
1231
1232
23743837
        x_cg = scan_x_cg[i];
1233
23743837
        y_cg = scan_y_cg[i];
1234
1235

23743837
        if ((i < num_last_subset) && (i > 0)) {
1236
7785694
            int ctx_cg = 0;
1237
7785694
            if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1238
7091333
                ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1239
7785694
            if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1240
6560845
                ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1241
1242
7785694
            significant_coeff_group_flag[x_cg][y_cg] =
1243
7785694
                significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1244
7785694
            implicit_non_zero_coeff = 1;
1245
        } else {
1246
15958143
            significant_coeff_group_flag[x_cg][y_cg] =
1247

18208155
            ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1248
2250012
             (x_cg == 0 && y_cg == 0));
1249
        }
1250
1251
23743837
        last_scan_pos = num_coeff - offset - 1;
1252
1253
23743837
        if (i == num_last_subset) {
1254
13708131
            n_end = last_scan_pos - 1;
1255
13708131
            significant_coeff_flag_idx[0] = last_scan_pos;
1256
13708131
            nb_significant_coeff_flag = 1;
1257
        } else {
1258
10035706
            n_end = 15;
1259
        }
1260
1261
23743837
        if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1262
14141203
            prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1263
23743837
        if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1264
13729470
            prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1265
1266

23743837
        if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1267
            static const uint8_t ctx_idx_map[] = {
1268
                0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1269
                1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1270
                2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1271
                2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1272
                2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2  // default
1273
            };
1274
            const uint8_t *ctx_idx_map_p;
1275
17775971
            int scf_offset = 0;
1276

17775971
            if (s->ps.sps->transform_skip_context_enabled_flag &&
1277
875214
                (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1278
118888
                ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1279
118888
                if (c_idx == 0) {
1280
51044
                    scf_offset = 40;
1281
                } else {
1282
67844
                    scf_offset = 14 + 27;
1283
                }
1284
            } else {
1285
17657083
                if (c_idx != 0)
1286
4148843
                    scf_offset = 27;
1287
17657083
                if (log2_trafo_size == 2) {
1288
6164423
                    ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1289
                } else {
1290
11492660
                    ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1291
11492660
                    if (c_idx == 0) {
1292

9236361
                        if ((x_cg > 0 || y_cg > 0))
1293
5553405
                            scf_offset += 3;
1294
9236361
                        if (log2_trafo_size == 3) {
1295
3468738
                            scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1296
                        } else {
1297
5767623
                            scf_offset += 21;
1298
                        }
1299
                    } else {
1300
2256299
                        if (log2_trafo_size == 3)
1301
1090708
                            scf_offset += 9;
1302
                        else
1303
1165591
                            scf_offset += 12;
1304
                    }
1305
                }
1306
            }
1307
180460499
            for (n = n_end; n > 0; n--) {
1308
162684528
                x_c = scan_x_off[n];
1309
162684528
                y_c = scan_y_off[n];
1310
162684528
                if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1311
79479536
                    significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1312
79479536
                    nb_significant_coeff_flag++;
1313
79479536
                    implicit_non_zero_coeff = 0;
1314
                }
1315
            }
1316
17775971
            if (implicit_non_zero_coeff == 0) {
1317

17719699
                if (s->ps.sps->transform_skip_context_enabled_flag &&
1318
873192
                    (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1319
118494
                    if (c_idx == 0) {
1320
50789
                        scf_offset = 42;
1321
                    } else {
1322
67705
                        scf_offset = 16 + 27;
1323
                    }
1324
                } else {
1325
17601205
                    if (i == 0) {
1326
10835733
                        if (c_idx == 0)
1327
7954835
                            scf_offset = 0;
1328
                        else
1329
2880898
                            scf_offset = 27;
1330
                    } else {
1331
6765472
                        scf_offset = 2 + scf_offset;
1332
                    }
1333
                }
1334
17719699
                if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1335
11999103
                    significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1336
11999103
                    nb_significant_coeff_flag++;
1337
                }
1338
            } else {
1339
56272
                significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1340
56272
                nb_significant_coeff_flag++;
1341
            }
1342
        }
1343
1344
23743837
        n_end = nb_significant_coeff_flag;
1345
1346
1347
23743837
        if (n_end) {
1348
            int first_nz_pos_in_cg;
1349
            int last_nz_pos_in_cg;
1350
20796606
            int c_rice_param = 0;
1351
20796606
            int first_greater1_coeff_idx = -1;
1352
            uint8_t coeff_abs_level_greater1_flag[8];
1353
            uint16_t coeff_sign_flag;
1354
20796606
            int sum_abs = 0;
1355
            int sign_hidden;
1356
            int sb_type;
1357
1358
1359
            // initialize first elem of coeff_bas_level_greater1_flag
1360

20796606
            int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1361
1362
20796606
            if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
1363

1139364
                if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1364
1031667
                    sb_type = 2 * (c_idx == 0 ? 1 : 0);
1365
                else
1366
107697
                    sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1367
1139364
                c_rice_param = lc->stat_coeff[sb_type] / 4;
1368
            }
1369
1370

20796606
            if (!(i == num_last_subset) && greater1_ctx == 0)
1371
3252592
                ctx_set++;
1372
20796606
            greater1_ctx = 1;
1373
20796606
            last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1374
1375
108569540
            for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1376
87772934
                int inc = (ctx_set << 2) + greater1_ctx;
1377
87772934
                coeff_abs_level_greater1_flag[m] =
1378
87772934
                    coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1379
87772934
                if (coeff_abs_level_greater1_flag[m]) {
1380
28947160
                    greater1_ctx = 0;
1381
28947160
                    if (first_greater1_coeff_idx == -1)
1382
9734539
                        first_greater1_coeff_idx = m;
1383

58825774
                } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1384
28539089
                    greater1_ctx++;
1385
                }
1386
            }
1387
20796606
            first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1388
1389
20796606
            if (lc->cu.cu_transquant_bypass_flag ||
1390
20093119
                (lc->cu.pred_mode ==  MODE_INTRA  &&
1391

12710868
                 s->ps.sps->implicit_rdpcm_enabled_flag  &&  transform_skip_flag  &&
1392

20050538
                 (pred_mode_intra == 10 || pred_mode_intra  ==  26 )) ||
1393
                 explicit_rdpcm_flag)
1394
768971
                sign_hidden = 0;
1395
            else
1396
20027635
                sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1397
1398
20796606
            if (first_greater1_coeff_idx != -1) {
1399
9734539
                coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1400
            }
1401

20796606
            if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1402
9996607
                coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1403
            } else {
1404
10799999
                coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1405
            }
1406
1407
126039648
            for (m = 0; m < n_end; m++) {
1408
105243042
                n = significant_coeff_flag_idx[m];
1409
105243042
                GET_COORD(offset, n);
1410
105243042
                if (m < 8) {
1411
87772934
                    trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1412

87772934
                    if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1413
22291476
                        int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1414
1415
22291476
                        trans_coeff_level += last_coeff_abs_level_remaining;
1416
22291476
                        if (trans_coeff_level > (3 << c_rice_param))
1417
5759263
                            c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1418

22291476
                        if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1419
303586
                            int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1420
303586
                            if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1421
36846
                                lc->stat_coeff[sb_type]++;
1422
266740
                            else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1423
151781
                                if (lc->stat_coeff[sb_type] > 0)
1424
36732
                                    lc->stat_coeff[sb_type]--;
1425
303586
                            rice_init = 1;
1426
                        }
1427
                    }
1428
                } else {
1429
17470108
                    int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1430
1431
17470108
                    trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1432
17470108
                    if (trans_coeff_level > (3 << c_rice_param))
1433
2138634
                        c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1434

17470108
                    if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1435
36283
                        int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1436
36283
                        if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1437
1306
                            lc->stat_coeff[sb_type]++;
1438
34977
                        else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1439
24448
                            if (lc->stat_coeff[sb_type] > 0)
1440
1285
                                lc->stat_coeff[sb_type]--;
1441
36283
                        rice_init = 1;
1442
                    }
1443
                }
1444

105243042
                if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1445
78171653
                    sum_abs += trans_coeff_level;
1446

78171653
                    if (n == first_nz_pos_in_cg && (sum_abs&1))
1447
5392427
                        trans_coeff_level = -trans_coeff_level;
1448
                }
1449
105243042
                if (coeff_sign_flag >> 15)
1450
47723514
                    trans_coeff_level = -trans_coeff_level;
1451
105243042
                coeff_sign_flag <<= 1;
1452
105243042
                if(!lc->cu.cu_transquant_bypass_flag) {
1453

96558656
                    if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1454

2474528
                        if(y_c || x_c || log2_trafo_size < 4) {
1455

2448454
                            switch(log2_trafo_size) {
1456
642614
                                case 3: pos = (y_c << 3) + x_c; break;
1457
780932
                                case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1458
207910
                                case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1459
816998
                                default: pos = (y_c << 2) + x_c; break;
1460
                            }
1461
2448454
                            scale_m = scale_matrix[pos];
1462
                        } else {
1463
26074
                            scale_m = dc_scale;
1464
                        }
1465
                    }
1466
96558656
                    trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1467
96558656
                    if(trans_coeff_level < 0) {
1468
48745123
                        if((~trans_coeff_level) & 0xFffffffffff8000)
1469
162681
                            trans_coeff_level = -32768;
1470
                    } else {
1471
47813533
                        if(trans_coeff_level & 0xffffffffffff8000)
1472
162295
                            trans_coeff_level = 32767;
1473
                    }
1474
                }
1475
105243042
                coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1476
            }
1477
        }
1478
    }
1479
1480
13708131
    if (lc->cu.cu_transquant_bypass_flag) {
1481

438366
        if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1482
                                    (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1483
            int mode = s->ps.sps->implicit_rdpcm_enabled_flag ? (pred_mode_intra == 26) : explicit_rdpcm_dir_flag;
1484
1485
            s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1486
        }
1487
    } else {
1488
13269765
        if (transform_skip_flag) {
1489
64237
            int rot = s->ps.sps->transform_skip_rotation_enabled_flag &&
1490
484214
                      log2_trafo_size == 2 &&
1491
42717
                      lc->cu.pred_mode == MODE_INTRA;
1492
419977
            if (rot) {
1493
89964
                for (i = 0; i < 8; i++)
1494
79968
                    FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
1495
            }
1496
1497
419977
            s->hevcdsp.dequant(coeffs, log2_trafo_size);
1498
1499

419977
            if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
1500

61254
                                        lc->cu.pred_mode == MODE_INTRA &&
1501
16829
                                        (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1502
22494
                int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1503
1504
22494
                s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1505
            }
1506

12849788
        } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1507
3521073
            s->hevcdsp.transform_4x4_luma(coeffs);
1508
        } else {
1509
9328715
            int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1510
9328715
            if (max_xy == 0)
1511
2113398
                s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1512
            else {
1513
7215317
                int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1514
7215317
                if (max_xy < 4)
1515
5020845
                    col_limit = FFMIN(4, col_limit);
1516
2194472
                else if (max_xy < 8)
1517
1644752
                    col_limit = FFMIN(8, col_limit);
1518
549720
                else if (max_xy < 12)
1519
233288
                    col_limit = FFMIN(24, col_limit);
1520
7215317
                s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1521
            }
1522
        }
1523
    }
1524
13708131
    if (lc->tu.cross_pf) {
1525
269264
        int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1526
1527
20522080
        for (i = 0; i < (trafo_size * trafo_size); i++) {
1528
20252816
            coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1529
        }
1530
    }
1531
13708131
    s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1532
13708131
}
1533
1534
2623681
void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1535
{
1536
2623681
    HEVCLocalContext *lc = s->HEVClc;
1537
2623681
    int x = abs_mvd_greater0_flag_decode(s);
1538
2623681
    int y = abs_mvd_greater0_flag_decode(s);
1539
1540
2623681
    if (x)
1541
1830638
        x += abs_mvd_greater1_flag_decode(s);
1542
2623681
    if (y)
1543
1758305
        y += abs_mvd_greater1_flag_decode(s);
1544
1545

2623681
    switch (x) {
1546
1328950
    case 2: lc->pu.mvd.x = mvd_decode(s);           break;
1547
501688
    case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1548
793043
    case 0: lc->pu.mvd.x = 0;                       break;
1549
    }
1550
1551

2623681
    switch (y) {
1552
1245769
    case 2: lc->pu.mvd.y = mvd_decode(s);           break;
1553
512536
    case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1554
865376
    case 0: lc->pu.mvd.y = 0;                       break;
1555
    }
1556
2623681
}
1557