GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/hevc_cabac.c Lines: 643 667 96.4 %
Date: 2021-03-07 19:55:24 Branches: 487 523 93.1 %

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
     5, // 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
    47, // transform_skip_flag[][]
126
    49, // explicit_rdpcm_flag[][]
127
    51, // explicit_rdpcm_dir_flag[][]
128
    53, // last_significant_coeff_x_prefix
129
    71, // last_significant_coeff_y_prefix
130
    89, // last_significant_coeff_x_suffix
131
    89, // last_significant_coeff_y_suffix
132
    89, // significant_coeff_group_flag
133
    93, // significant_coeff_flag
134
    137, // coeff_abs_level_greater1_flag
135
    161, // coeff_abs_level_greater2_flag
136
    167, // coeff_abs_level_remaining
137
    167, // coeff_sign_flag
138
    167, // log2_res_scale_abs
139
    175, // res_scale_sign_flag
140
    177, // cu_chroma_qp_offset_flag
141
    178, // 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, 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, 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, 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
1395565
void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
451
{
452
1395565
    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
4942
        if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
458
            memcpy(s->stat_coeff, s->HEVClc->stat_coeff, HEVC_STAT_COEFFS);
459
        }
460
    }
461
1395565
}
462
463
3939
static void load_states(HEVCContext *s, int thread)
464
{
465
3939
    memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
466
3939
    if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
467
        const HEVCContext *prev = s->sList[(thread + s->threads_number - 1) % s->threads_number];
468
        memcpy(s->HEVClc->stat_coeff, prev->stat_coeff, HEVC_STAT_COEFFS);
469
    }
470
3939
}
471
472
7604
static int cabac_reinit(HEVCLocalContext *lc)
473
{
474
7604
    return skip_bytes(&lc->cc, 0) == NULL ? AVERROR_INVALIDDATA : 0;
475
}
476
477
27473
static int cabac_init_decoder(HEVCContext *s)
478
{
479
27473
    GetBitContext *gb = &s->HEVClc->gb;
480
27473
    skip_bits(gb, 1);
481
27473
    align_get_bits(gb);
482
82419
    return ff_init_cabac_decoder(&s->HEVClc->cc,
483
27473
                          gb->buffer + get_bits_count(gb) / 8,
484
27473
                          (get_bits_left(gb) + 7) / 8);
485
}
486
487
24754
static void cabac_init_state(HEVCContext *s)
488
{
489
24754
    int init_type = 2 - s->sh.slice_type;
490
    int i;
491
492

24754
    if (s->sh.cabac_init_flag && s->sh.slice_type != HEVC_SLICE_I)
493
6345
        init_type ^= 3;
494
495
4950800
    for (i = 0; i < HEVC_CONTEXTS; i++) {
496
4926046
        int init_value = init_values[init_type][i];
497
4926046
        int m = (init_value >> 4) * 5 - 45;
498
4926046
        int n = ((init_value & 15) << 3) - 16;
499
4926046
        int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
500
501
4926046
        pre ^= pre >> 31;
502
4926046
        if (pre > 124)
503
505720
            pre = 124 + (pre & 1);
504
4926046
        s->HEVClc->cabac_state[i] = pre;
505
    }
506
507
123770
    for (i = 0; i < 4; i++)
508
99016
        s->HEVClc->stat_coeff[i] = 0;
509
24754
}
510
511
1395566
int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts, int thread)
512
{
513
1395566
    if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
514
27473
        int ret = cabac_init_decoder(s);
515
27473
        if (ret < 0)
516
            return ret;
517
27473
        if (s->sh.dependent_slice_segment_flag == 0 ||
518
7947
            (s->ps.pps->tiles_enabled_flag &&
519
876
             s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
520
19835
            cabac_init_state(s);
521
522
27473
        if (!s->sh.first_slice_in_pic_flag &&
523
17989
            s->ps.pps->entropy_coding_sync_enabled_flag) {
524
3853
            if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
525
1636
                if (s->ps.sps->ctb_width == 1)
526
92
                    cabac_init_state(s);
527
1544
                else if (s->sh.dependent_slice_segment_flag == 1)
528
1162
                    load_states(s, thread);
529
            }
530
        }
531
    } else {
532
1368093
        if (s->ps.pps->tiles_enabled_flag &&
533
287199
            s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
534
            int ret;
535
4625
            if (s->threads_number == 1)
536
4625
                ret = cabac_reinit(s->HEVClc);
537
            else {
538
                ret = cabac_init_decoder(s);
539
            }
540
4625
            if (ret < 0)
541
                return ret;
542
4625
            cabac_init_state(s);
543
        }
544
1368093
        if (s->ps.pps->entropy_coding_sync_enabled_flag) {
545
88812
            if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
546
                int ret;
547
2979
                get_cabac_terminate(&s->HEVClc->cc);
548
2979
                if (s->threads_number == 1)
549
2979
                    ret = cabac_reinit(s->HEVClc);
550
                else {
551
                    ret = cabac_init_decoder(s);
552
                }
553
2979
                if (ret < 0)
554
                    return ret;
555
556
2979
                if (s->ps.sps->ctb_width == 1)
557
202
                    cabac_init_state(s);
558
                else
559
2777
                    load_states(s, thread);
560
            }
561
        }
562
    }
563
1395566
    return 0;
564
}
565
566
#define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
567
568
787720
int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
569
{
570
787720
    return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
571
}
572
573
354383
int ff_hevc_sao_type_idx_decode(HEVCContext *s)
574
{
575
354383
    if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
576
192798
        return 0;
577
578
161585
    if (!get_cabac_bypass(&s->HEVClc->cc))
579
53734
        return SAO_BAND;
580
107851
    return SAO_EDGE;
581
}
582
583
77629
int ff_hevc_sao_band_position_decode(HEVCContext *s)
584
{
585
    int i;
586
77629
    int value = get_cabac_bypass(&s->HEVClc->cc);
587
588
388145
    for (i = 0; i < 4; i++)
589
310516
        value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
590
77629
    return value;
591
}
592
593
864724
int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
594
{
595
864724
    int i = 0;
596
864724
    int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
597
598

2576151
    while (i < length && get_cabac_bypass(&s->HEVClc->cc))
599
1711427
        i++;
600
864724
    return i;
601
}
602
603
242504
int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
604
{
605
242504
    return get_cabac_bypass(&s->HEVClc->cc);
606
}
607
608
107851
int ff_hevc_sao_eo_class_decode(HEVCContext *s)
609
{
610
107851
    int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
611
107851
    ret    |= get_cabac_bypass(&s->HEVClc->cc);
612
107851
    return ret;
613
}
614
615
1395565
int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
616
{
617
1395565
    return get_cabac_terminate(&s->HEVClc->cc);
618
}
619
620
200139
int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
621
{
622
200139
    return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
623
}
624
625
8054524
int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
626
{
627
8054524
    int min_cb_width = s->ps.sps->min_cb_width;
628
8054524
    int inc = 0;
629
8054524
    int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
630
8054524
    int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
631
632

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

8054524
    if (s->HEVClc->ctb_up_flag || y0b)
635
7598229
        inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
636
637
8054524
    return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
638
}
639
640
579409
int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
641
{
642
579409
    int prefix_val = 0;
643
579409
    int suffix_val = 0;
644
579409
    int inc = 0;
645
646

1544718
    while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
647
965309
        prefix_val++;
648
965309
        inc = 1;
649
    }
650
579409
    if (prefix_val >= 5) {
651
105257
        int k = 0;
652

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

7409067
    if (s->HEVClc->ctb_left_flag || x0b)
702
7112120
        depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
703

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

7573400
    while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
763
3121806
        i++;
764
4451594
    return i;
765
}
766
767
2993832
int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
768
{
769
    int i;
770
2993832
    int value = get_cabac_bypass(&s->HEVClc->cc);
771
772
14969160
    for (i = 0; i < 4; i++)
773
11975328
        value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
774
2993832
    return value;
775
}
776
777
3998228
int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
778
{
779
    int ret;
780
3998228
    if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
781
2973626
        return 4;
782
783
1024602
    ret  = get_cabac_bypass(&s->HEVClc->cc) << 1;
784
1024602
    ret |= get_cabac_bypass(&s->HEVClc->cc);
785
1024602
    return ret;
786
}
787
788
6124714
int ff_hevc_merge_idx_decode(HEVCContext *s)
789
{
790
6124714
    int i = GET_CABAC(elem_offset[MERGE_IDX]);
791
792
6124714
    if (i != 0) {
793

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

3723508
    while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
821
942033
        i++;
822
2781475
    if (i == 2) {
823

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

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

1222592
    while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
907
837742
        i++;
908
909
384850
    return i;
910
}
911
912
235843
int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
913
235843
    return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
914
}
915
916
14061375
static av_always_inline void last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
917
                                                   int log2_size, int *last_scx_prefix, int *last_scy_prefix)
918
{
919
14061375
    int i = 0;
920
14061375
    int max = (log2_size << 1) - 1;
921
    int ctx_offset, ctx_shift;
922
923
14061375
    if (!c_idx) {
924
9627745
        ctx_offset = 3 * (log2_size - 2)  + ((log2_size - 1) >> 2);
925
9627745
        ctx_shift = (log2_size + 1) >> 2;
926
    } else {
927
4433630
        ctx_offset = 15;
928
4433630
        ctx_shift = log2_size - 2;
929
    }
930

70875618
    while (i < max &&
931
34396757
           GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
932
22417486
        i++;
933
14061375
    *last_scx_prefix = i;
934
935
14061375
    i = 0;
936

61294792
    while (i < max &&
937
29831189
           GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
938
17402228
        i++;
939
14061375
    *last_scy_prefix = i;
940
14061375
}
941
942
3058774
static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
943
                                                 int last_significant_coeff_prefix)
944
{
945
    int i;
946
3058774
    int length = (last_significant_coeff_prefix >> 1) - 1;
947
3058774
    int value = get_cabac_bypass(&s->HEVClc->cc);
948
949
3912730
    for (i = 1; i < length; i++)
950
853956
        value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
951
3058774
    return value;
952
}
953
954
8190536
static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
955
{
956
    int inc;
957
958
8190536
    inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
959
960
8190536
    return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
961
}
962
168184424
static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int x_c, int y_c,
963
                                           int offset, const uint8_t *ctx_idx_map)
964
{
965
168184424
    int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
966
168184424
    return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
967
}
968
969
18278307
static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
970
{
971
18278307
    return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
972
}
973
974
90008274
static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
975
{
976
977
90008274
    if (c_idx > 0)
978
21293445
        inc += 16;
979
980
90008274
    return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
981
}
982
983
10021019
static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
984
{
985
10021019
    if (c_idx > 0)
986
2126520
        inc += 4;
987
988
10021019
    return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
989
}
990
991
40579238
static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
992
{
993
40579238
    int prefix = 0;
994
40579238
    int suffix = 0;
995
    int last_coeff_abs_level_remaining;
996
    int i;
997
998

89092126
    while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
999
48512888
        prefix++;
1000
1001
40579238
    if (prefix < 3) {
1002
71567377
        for (i = 0; i < rc_rice_param; i++)
1003
36905818
            suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
1004
34661559
        last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
1005
    } else {
1006
5917679
        int prefix_minus3 = prefix - 3;
1007
1008

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

13623009
        if (s->ps.sps->scaling_list_enable_flag && !(transform_skip_flag && log2_trafo_size > 2)) {
1135
919466
            const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
1136
459733
            &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
1137
459733
            int matrix_id = lc->cu.pred_mode != MODE_INTRA;
1138
1139
459733
            matrix_id = 3 * matrix_id + c_idx;
1140
1141
459733
            scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
1142
459733
            if (log2_trafo_size >= 4)
1143
35021
                dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
1144
        }
1145
    } else {
1146
438366
        shift        = 0;
1147
438366
        add          = 0;
1148
438366
        scale        = 0;
1149
438366
        dc_scale     = 0;
1150
    }
1151
1152

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

24604999
        if ((i < num_last_subset) && (i > 0)) {
1243
8190536
            int ctx_cg = 0;
1244
8190536
            if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1245
7482757
                ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1246
8190536
            if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1247
6901373
                ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1248
1249
8190536
            significant_coeff_group_flag[x_cg][y_cg] =
1250
8190536
                significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1251
8190536
            implicit_non_zero_coeff = 1;
1252
        } else {
1253
16414463
            significant_coeff_group_flag[x_cg][y_cg] =
1254

18767551
            ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1255
2353088
             (x_cg == 0 && y_cg == 0));
1256
        }
1257
1258
24604999
        last_scan_pos = num_coeff - offset - 1;
1259
1260
24604999
        if (i == num_last_subset) {
1261
14061375
            n_end = last_scan_pos - 1;
1262
14061375
            significant_coeff_flag_idx[0] = last_scan_pos;
1263
14061375
            nb_significant_coeff_flag = 1;
1264
        } else {
1265
10543624
            n_end = 15;
1266
        }
1267
1268
24604999
        if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1269
14739859
            prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1270
24604999
        if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1271
14314692
            prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1272
1273

24604999
        if (significant_coeff_group_flag[x_cg][y_cg] && n_end >= 0) {
1274
            static const uint8_t ctx_idx_map[] = {
1275
                0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8, // log2_trafo_size == 2
1276
                1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 0
1277
                2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, // prev_sig == 1
1278
                2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, // prev_sig == 2
1279
                2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2  // default
1280
            };
1281
            const uint8_t *ctx_idx_map_p;
1282
18347473
            int scf_offset = 0;
1283

18347473
            if (s->ps.sps->transform_skip_context_enabled_flag &&
1284
875248
                (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1285
118888
                ctx_idx_map_p = (uint8_t*) &ctx_idx_map[4 * 16];
1286
118888
                if (c_idx == 0) {
1287
51044
                    scf_offset = 40;
1288
                } else {
1289
67844
                    scf_offset = 14 + 27;
1290
                }
1291
            } else {
1292
18228585
                if (c_idx != 0)
1293
4396175
                    scf_offset = 27;
1294
18228585
                if (log2_trafo_size == 2) {
1295
6310441
                    ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1296
                } else {
1297
11918144
                    ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1298
11918144
                    if (c_idx == 0) {
1299

9535249
                        if ((x_cg > 0 || y_cg > 0))
1300
5774649
                            scf_offset += 3;
1301
9535249
                        if (log2_trafo_size == 3) {
1302
3591632
                            scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1303
                        } else {
1304
5943617
                            scf_offset += 21;
1305
                        }
1306
                    } else {
1307
2382895
                        if (log2_trafo_size == 3)
1308
1133874
                            scf_offset += 9;
1309
                        else
1310
1249021
                            scf_offset += 12;
1311
                    }
1312
                }
1313
            }
1314
186531897
            for (n = n_end; n > 0; n--) {
1315
168184424
                x_c = scan_x_off[n];
1316
168184424
                y_c = scan_y_off[n];
1317
168184424
                if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1318
81280954
                    significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1319
81280954
                    nb_significant_coeff_flag++;
1320
81280954
                    implicit_non_zero_coeff = 0;
1321
                }
1322
            }
1323
18347473
            if (implicit_non_zero_coeff == 0) {
1324

18278307
                if (s->ps.sps->transform_skip_context_enabled_flag &&
1325
873226
                    (transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
1326
118494
                    if (c_idx == 0) {
1327
50789
                        scf_offset = 42;
1328
                    } else {
1329
67705
                        scf_offset = 16 + 27;
1330
                    }
1331
                } else {
1332
18159813
                    if (i == 0) {
1333
11134019
                        if (c_idx == 0)
1334
8057761
                            scf_offset = 0;
1335
                        else
1336
3076258
                            scf_offset = 27;
1337
                    } else {
1338
7025794
                        scf_offset = 2 + scf_offset;
1339
                    }
1340
                }
1341
18278307
                if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1342
12346001
                    significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1343
12346001
                    nb_significant_coeff_flag++;
1344
                }
1345
            } else {
1346
69166
                significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1347
69166
                nb_significant_coeff_flag++;
1348
            }
1349
        }
1350
1351
24604999
        n_end = nb_significant_coeff_flag;
1352
1353
1354
24604999
        if (n_end) {
1355
            int first_nz_pos_in_cg;
1356
            int last_nz_pos_in_cg;
1357
21442948
            int c_rice_param = 0;
1358
21442948
            int first_greater1_coeff_idx = -1;
1359
            uint8_t coeff_abs_level_greater1_flag[8];
1360
            uint16_t coeff_sign_flag;
1361
21442948
            int sum_abs = 0;
1362
            int sign_hidden;
1363
            int sb_type;
1364
1365
1366
            // initialize first elem of coeff_bas_level_greater1_flag
1367

21442948
            int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1368
1369
21442948
            if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
1370

1139414
                if (!transform_skip_flag && !lc->cu.cu_transquant_bypass_flag)
1371
1031717
                    sb_type = 2 * (c_idx == 0 ? 1 : 0);
1372
                else
1373
107697
                    sb_type = 2 * (c_idx == 0 ? 1 : 0) + 1;
1374
1139414
                c_rice_param = lc->stat_coeff[sb_type] / 4;
1375
            }
1376
1377

21442948
            if (!(i == num_last_subset) && greater1_ctx == 0)
1378
3305526
                ctx_set++;
1379
21442948
            greater1_ctx = 1;
1380
21442948
            last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1381
1382
111451222
            for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1383
90008274
                int inc = (ctx_set << 2) + greater1_ctx;
1384
90008274
                coeff_abs_level_greater1_flag[m] =
1385
90008274
                    coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1386
90008274
                if (coeff_abs_level_greater1_flag[m]) {
1387
29675368
                    greater1_ctx = 0;
1388
29675368
                    if (first_greater1_coeff_idx == -1)
1389
10021019
                        first_greater1_coeff_idx = m;
1390

60332906
                } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1391
29438105
                    greater1_ctx++;
1392
                }
1393
            }
1394
21442948
            first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1395
1396
21442948
            if (lc->cu.cu_transquant_bypass_flag ||
1397
20739461
                (lc->cu.pred_mode ==  MODE_INTRA  &&
1398

13357210
                 s->ps.sps->implicit_rdpcm_enabled_flag  &&  transform_skip_flag  &&
1399

20696880
                 (pred_mode_intra == 10 || pred_mode_intra  ==  26 )) ||
1400
                 explicit_rdpcm_flag)
1401
768971
                sign_hidden = 0;
1402
            else
1403
20673977
                sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
1404
1405
21442948
            if (first_greater1_coeff_idx != -1) {
1406
10021019
                coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1407
            }
1408

21442948
            if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
1409
10642915
                coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1410
            } else {
1411
10800033
                coeff_sign_flag = coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1412
            }
1413
1414
129200444
            for (m = 0; m < n_end; m++) {
1415
107757496
                n = significant_coeff_flag_idx[m];
1416
107757496
                GET_COORD(offset, n);
1417
107757496
                if (m < 8) {
1418
90008274
                    trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
1419

90008274
                    if (trans_coeff_level == ((m == first_greater1_coeff_idx) ? 3 : 2)) {
1420
22830016
                        int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1421
1422
22830016
                        trans_coeff_level += last_coeff_abs_level_remaining;
1423
22830016
                        if (trans_coeff_level > (3 << c_rice_param))
1424
5933019
                            c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1425

22830016
                        if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1426
303626
                            int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1427
303626
                            if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1428
36850
                                lc->stat_coeff[sb_type]++;
1429
266776
                            else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1430
151795
                                if (lc->stat_coeff[sb_type] > 0)
1431
36734
                                    lc->stat_coeff[sb_type]--;
1432
303626
                            rice_init = 1;
1433
                        }
1434
                    }
1435
                } else {
1436
17749222
                    int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1437
1438
17749222
                    trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1439
17749222
                    if (trans_coeff_level > (3 << c_rice_param))
1440
2216466
                        c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1441

17749222
                    if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1442
36289
                        int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1443
36289
                        if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1444
1306
                            lc->stat_coeff[sb_type]++;
1445
34983
                        else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1446
24454
                            if (lc->stat_coeff[sb_type] > 0)
1447
1287
                                lc->stat_coeff[sb_type]--;
1448
36289
                        rice_init = 1;
1449
                    }
1450
                }
1451

107757496
                if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1452
78171993
                    sum_abs += trans_coeff_level;
1453

78171993
                    if (n == first_nz_pos_in_cg && (sum_abs&1))
1454
5392455
                        trans_coeff_level = -trans_coeff_level;
1455
                }
1456
107757496
                if (coeff_sign_flag >> 15)
1457
48985544
                    trans_coeff_level = -trans_coeff_level;
1458
107757496
                coeff_sign_flag <<= 1;
1459
107757496
                if(!lc->cu.cu_transquant_bypass_flag) {
1460

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

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

2448454
                            switch(log2_trafo_size) {
1463
642614
                                case 3: pos = (y_c << 3) + x_c; break;
1464
780932
                                case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1465
207910
                                case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1466
816998
                                default: pos = (y_c << 2) + x_c; break;
1467
                            }
1468
2448454
                            scale_m = scale_matrix[pos];
1469
                        } else {
1470
26074
                            scale_m = dc_scale;
1471
                        }
1472
                    }
1473
99073110
                    trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1474
99073110
                    if(trans_coeff_level < 0) {
1475
50007181
                        if((~trans_coeff_level) & 0xFffffffffff8000)
1476
162681
                            trans_coeff_level = -32768;
1477
                    } else {
1478
49065929
                        if(trans_coeff_level & 0xffffffffffff8000)
1479
162295
                            trans_coeff_level = 32767;
1480
                    }
1481
                }
1482
107757496
                coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1483
            }
1484
        }
1485
    }
1486
1487
14061375
    if (lc->cu.cu_transquant_bypass_flag) {
1488

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

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

61254
                                        lc->cu.pred_mode == MODE_INTRA &&
1508
16829
                                        (pred_mode_intra == 10 || pred_mode_intra == 26))) {
1509
22494
                int mode = explicit_rdpcm_flag ? explicit_rdpcm_dir_flag : (pred_mode_intra == 26);
1510
1511
22494
                s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
1512
            }
1513

13203032
        } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1514
3548431
            s->hevcdsp.transform_4x4_luma(coeffs);
1515
        } else {
1516
9654601
            int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1517
9654601
            if (max_xy == 0)
1518
2166280
                s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1519
            else {
1520
7488321
                int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1521
7488321
                if (max_xy < 4)
1522
5190773
                    col_limit = FFMIN(4, col_limit);
1523
2297548
                else if (max_xy < 8)
1524
1717704
                    col_limit = FFMIN(8, col_limit);
1525
579844
                else if (max_xy < 12)
1526
248306
                    col_limit = FFMIN(24, col_limit);
1527
7488321
                s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1528
            }
1529
        }
1530
    }
1531
14061375
    if (lc->tu.cross_pf) {
1532
269268
        int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1533
1534
20522148
        for (i = 0; i < (trafo_size * trafo_size); i++) {
1535
20252880
            coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1536
        }
1537
    }
1538
14061375
    s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1539
14061375
}
1540
1541
2623681
void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1542
{
1543
2623681
    HEVCLocalContext *lc = s->HEVClc;
1544
2623681
    int x = abs_mvd_greater0_flag_decode(s);
1545
2623681
    int y = abs_mvd_greater0_flag_decode(s);
1546
1547
2623681
    if (x)
1548
1830638
        x += abs_mvd_greater1_flag_decode(s);
1549
2623681
    if (y)
1550
1758305
        y += abs_mvd_greater1_flag_decode(s);
1551
1552

2623681
    switch (x) {
1553
1328950
    case 2: lc->pu.mvd.x = mvd_decode(s);           break;
1554
501688
    case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
1555
793043
    case 0: lc->pu.mvd.x = 0;                       break;
1556
    }
1557
1558

2623681
    switch (y) {
1559
1245769
    case 2: lc->pu.mvd.y = mvd_decode(s);           break;
1560
512536
    case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
1561
865376
    case 0: lc->pu.mvd.y = 0;                       break;
1562
    }
1563
2623681
}
1564