GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/hevc_cabac.c Lines: 641 662 96.8 %
Date: 2020-11-28 20:53:16 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
     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
1393725
void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
451
{
452
1393725
    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
1393725
}
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
7604
static int cabac_reinit(HEVCLocalContext *lc)
466
{
467
7604
    return skip_bytes(&lc->cc, 0) == NULL ? AVERROR_INVALIDDATA : 0;
468
}
469
470
27469
static int cabac_init_decoder(HEVCContext *s)
471
{
472
27469
    GetBitContext *gb = &s->HEVClc->gb;
473
27469
    skip_bits(gb, 1);
474
27469
    align_get_bits(gb);
475
82407
    return ff_init_cabac_decoder(&s->HEVClc->cc,
476
27469
                          gb->buffer + get_bits_count(gb) / 8,
477
27469
                          (get_bits_left(gb) + 7) / 8);
478
}
479
480
24750
static void cabac_init_state(HEVCContext *s)
481
{
482
24750
    int init_type = 2 - s->sh.slice_type;
483
    int i;
484
485

24750
    if (s->sh.cabac_init_flag && s->sh.slice_type != HEVC_SLICE_I)
486
6345
        init_type ^= 3;
487
488
4950000
    for (i = 0; i < HEVC_CONTEXTS; i++) {
489
4925250
        int init_value = init_values[init_type][i];
490
4925250
        int m = (init_value >> 4) * 5 - 45;
491
4925250
        int n = ((init_value & 15) << 3) - 16;
492
4925250
        int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
493
494
4925250
        pre ^= pre >> 31;
495
4925250
        if (pre > 124)
496
505640
            pre = 124 + (pre & 1);
497
4925250
        s->HEVClc->cabac_state[i] = pre;
498
    }
499
500
123750
    for (i = 0; i < 4; i++)
501
99000
        s->HEVClc->stat_coeff[i] = 0;
502
24750
}
503
504
1393726
int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
505
{
506
1393726
    if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
507
27469
        int ret = cabac_init_decoder(s);
508
27469
        if (ret < 0)
509
            return ret;
510
27469
        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
19831
            cabac_init_state(s);
514
515
27469
        if (!s->sh.first_slice_in_pic_flag &&
516
17987
            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
1366257
        if (s->ps.pps->tiles_enabled_flag &&
526
285363
            s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
527
            int ret;
528
4625
            if (s->threads_number == 1)
529
4625
                ret = cabac_reinit(s->HEVClc);
530
            else {
531
                ret = cabac_init_decoder(s);
532
            }
533
4625
            if (ret < 0)
534
                return ret;
535
4625
            cabac_init_state(s);
536
        }
537
1366257
        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
1393726
    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
353975
int ff_hevc_sao_type_idx_decode(HEVCContext *s)
567
{
568
353975
    if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
569
192530
        return 0;
570
571
161445
    if (!get_cabac_bypass(&s->HEVClc->cc))
572
53680
        return SAO_BAND;
573
107765
    return SAO_EDGE;
574
}
575
576
77573
int ff_hevc_sao_band_position_decode(HEVCContext *s)
577
{
578
    int i;
579
77573
    int value = get_cabac_bypass(&s->HEVClc->cc);
580
581
387865
    for (i = 0; i < 4; i++)
582
310292
        value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
583
77573
    return value;
584
}
585
586
864156
int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
587
{
588
864156
    int i = 0;
589
864156
    int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
590
591

2574739
    while (i < length && get_cabac_bypass(&s->HEVClc->cc))
592
1710583
        i++;
593
864156
    return i;
594
}
595
596
242366
int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
597
{
598
242366
    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
1393725
int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
609
{
610
1393725
    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
577569
int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
634
{
635
577569
    int prefix_val = 0;
636
577569
    int suffix_val = 0;
637
577569
    int inc = 0;
638
639

1540876
    while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
640
963307
        prefix_val++;
641
963307
        inc = 1;
642
    }
643
577569
    if (prefix_val >= 5) {
644
104915
        int k = 0;
645

357700
        while (k < 7 && get_cabac_bypass(&s->HEVClc->cc)) {
646
252785
            suffix_val += 1 << k;
647
252785
            k++;
648
        }
649
104915
        if (k == 7) {
650
            av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
651
            return AVERROR_INVALIDDATA;
652
        }
653
654
357700
        while (k--)
655
252785
            suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
656
    }
657
577569
    return prefix_val + suffix_val;
658
}
659
660
364015
int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
661
{
662
364015
    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
7402011
int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
687
{
688
7402011
    int inc = 0, depth_left = 0, depth_top = 0;
689
7402011
    int x0b  = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
690
7402011
    int y0b  = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
691
7402011
    int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
692
7402011
    int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
693
694

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

7402011
    if (s->HEVClc->ctb_up_flag || y0b)
697
6752349
        depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
698
699
7402011
    inc += (depth_left > ct_depth);
700
7402011
    inc += (depth_top  > ct_depth);
701
702
7402011
    return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
703
}
704
705
6117441
int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
706
{
707
6117441
    if (GET_CABAC(elem_offset[PART_MODE])) // 1
708
3565945
        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
7402036
int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
748
{
749
7402036
    return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
750
}
751
752
4422926
int ff_hevc_mpm_idx_decode(HEVCContext *s)
753
{
754
4422926
    int i = 0;
755

7522668
    while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
756
3099742
        i++;
757
4422926
    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
3984418
int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
771
{
772
    int ret;
773
3984418
    if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
774
2959816
        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
6818987
int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
867
{
868
6818987
    return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
869
}
870
871
14943579
int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
872
{
873
14943579
    return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
874
}
875
876
14457729
int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
877
{
878
14457729
    return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
879
}
880
881
6478334
static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
882
{
883
6478334
    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
384850
int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
897
384850
    int i =0;
898
899

1222592
    while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
900
837742
        i++;
901
902
384850
    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
14029651
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
14029651
    int i = 0;
913
14029651
    int max = (log2_size << 1) - 1;
914
    int ctx_offset, ctx_shift;
915
916
14029651
    if (!c_idx) {
917
9597003
        ctx_offset = 3 * (log2_size - 2)  + ((log2_size - 1) >> 2);
918
9597003
        ctx_shift = (log2_size + 1) >> 2;
919
    } else {
920
4432648
        ctx_offset = 15;
921
4432648
        ctx_shift = log2_size - 2;
922
    }
923

70695550
    while (i < max &&
924
34312067
           GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_X_PREFIX] + (i >> ctx_shift) + ctx_offset))
925
22353832
        i++;
926
14029651
    *last_scx_prefix = i;
927
928
14029651
    i = 0;
929

61159354
    while (i < max &&
930
29765143
           GET_CABAC(elem_offset[LAST_SIGNIFICANT_COEFF_Y_PREFIX] + (i >> ctx_shift) + ctx_offset))
931
17364560
        i++;
932
14029651
    *last_scy_prefix = i;
933
14029651
}
934
935
3055796
static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s,
936
                                                 int last_significant_coeff_prefix)
937
{
938
    int i;
939
3055796
    int length = (last_significant_coeff_prefix >> 1) - 1;
940
3055796
    int value = get_cabac_bypass(&s->HEVClc->cc);
941
942
3907444
    for (i = 1; i < length; i++)
943
851648
        value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
944
3055796
    return value;
945
}
946
947
8168096
static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
948
{
949
    int inc;
950
951
8168096
    inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
952
953
8168096
    return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
954
}
955
167859860
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
167859860
    int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
959
167859860
    return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
960
}
961
962
18242653
static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s, int c_idx, int offset)
963
{
964
18242653
    return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
965
}
966
967
89826470
static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
968
{
969
970
89826470
    if (c_idx > 0)
971
21292337
        inc += 16;
972
973
89826470
    return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
974
}
975
976
9998491
static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
977
{
978
9998491
    if (c_idx > 0)
979
2126446
        inc += 4;
980
981
9998491
    return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
982
}
983
984
40499274
static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int rc_rice_param)
985
{
986
40499274
    int prefix = 0;
987
40499274
    int suffix = 0;
988
    int last_coeff_abs_level_remaining;
989
    int i;
990
991

88912510
    while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
992
48413236
        prefix++;
993
994
40499274
    if (prefix < 3) {
995
71462051
        for (i = 0; i < rc_rice_param; i++)
996
36864990
            suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
997
34597061
        last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
998
    } else {
999
5902213
        int prefix_minus3 = prefix - 3;
1000
1001

5902213
        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
25296763
        for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
1007
19394550
            suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
1008
5902213
        last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
1009
5902213
                                              << rc_rice_param) + suffix;
1010
    }
1011
40499274
    return last_coeff_abs_level_remaining;
1012
}
1013
1014
21403750
static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
1015
{
1016
    int i;
1017
21403750
    int ret = 0;
1018
1019
118161973
    for (i = 0; i < nb; i++)
1020
96758223
        ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
1021
21403750
    return ret;
1022
}
1023
1024
14029651
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
14029651
    HEVCLocalContext *lc = s->HEVClc;
1034
14029651
    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
14029651
    int num_coeff = 0;
1040
14029651
    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
14029651
    ptrdiff_t stride = s->frame->linesize[c_idx];
1048
14029651
    int hshift = s->ps.sps->hshift[c_idx];
1049
14029651
    int vshift = s->ps.sps->vshift[c_idx];
1050
14029651
    uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
1051
14029651
                                          ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1052
14029651
    int16_t *coeffs = (int16_t*)(c_idx ? lc->edge_emu_buffer2 : lc->edge_emu_buffer);
1053
14029651
    uint8_t significant_coeff_group_flag[8][8] = {{0}};
1054
14029651
    int explicit_rdpcm_flag = 0;
1055
    int explicit_rdpcm_dir_flag;
1056
1057
14029651
    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
14029651
    const uint8_t *scale_matrix = NULL;
1062
    uint8_t dc_scale;
1063
14029651
    int pred_mode_intra = (c_idx == 0) ? lc->tu.intra_pred_mode :
1064
                                         lc->tu.intra_pred_mode_c;
1065
1066
14029651
    memset(coeffs, 0, trafo_size * trafo_size * sizeof(int16_t));
1067
1068
    // Derive QP for dequant
1069
14029651
    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
13591285
        int qp_y = lc->qp_y;
1085
1086
13591285
        if (s->ps.pps->transform_skip_enabled_flag &&
1087
11222997
            log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
1088
6478334
            transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
1089
        }
1090
1091
13591285
        if (c_idx == 0) {
1092
9321755
            qp = qp_y + s->ps.sps->qp_bd_offset;
1093
        } else {
1094
            int qp_i, offset;
1095
1096
4269530
            if (c_idx == 1)
1097
2038282
                offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset +
1098
2038282
                         lc->tu.cu_qp_offset_cb;
1099
            else
1100
2231248
                offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset +
1101
2231248
                         lc->tu.cu_qp_offset_cr;
1102
1103
4269530
            qp_i = av_clip(qp_y + offset, - s->ps.sps->qp_bd_offset, 57);
1104
4269530
            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
1866105
                if (qp_i > 51)
1113
                    qp = 51;
1114
                else
1115
1866105
                    qp = qp_i;
1116
            }
1117
1118
4269530
            qp += s->ps.sps->qp_bd_offset;
1119
        }
1120
1121
13591285
        shift    = s->ps.sps->bit_depth + log2_trafo_size - 5;
1122
13591285
        add      = 1 << (shift-1);
1123
13591285
        scale    = level_scale[rem6[qp]] << (div6[qp]);
1124
13591285
        scale_m  = 16; // default when no custom scaling lists.
1125
13591285
        dc_scale = 16;
1126
1127

13591285
        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

14029651
    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
14029651
    last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
1154
                                           &last_significant_coeff_x, &last_significant_coeff_y);
1155
1156
14029651
    if (last_significant_coeff_x > 3) {
1157
1786303
        int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
1158
1786303
        last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1159
1786303
        (2 + (last_significant_coeff_x & 1)) +
1160
        suffix;
1161
    }
1162
1163
14029651
    if (last_significant_coeff_y > 3) {
1164
1269493
        int suffix = last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1165
1269493
        last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1166
1269493
        (2 + (last_significant_coeff_y & 1)) +
1167
        suffix;
1168
    }
1169
1170
14029651
    if (scan_idx == SCAN_VERT)
1171
1796463
        FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1172
1173
14029651
    x_cg_last_sig = last_significant_coeff_x >> 2;
1174
14029651
    y_cg_last_sig = last_significant_coeff_y >> 2;
1175
1176
14029651
    switch (scan_idx) {
1177
10227282
    case SCAN_DIAG: {
1178
10227282
        int last_x_c = last_significant_coeff_x & 3;
1179
10227282
        int last_y_c = last_significant_coeff_y & 3;
1180
1181
10227282
        scan_x_off = ff_hevc_diag_scan4x4_x;
1182
10227282
        scan_y_off = ff_hevc_diag_scan4x4_y;
1183
10227282
        num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1184
10227282
        if (trafo_size == 4) {
1185
5213335
            scan_x_cg = scan_1x1;
1186
5213335
            scan_y_cg = scan_1x1;
1187
5013947
        } else if (trafo_size == 8) {
1188
2766215
            num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1189
2766215
            scan_x_cg = diag_scan2x2_x;
1190
2766215
            scan_y_cg = diag_scan2x2_y;
1191
2247732
        } else if (trafo_size == 16) {
1192
1668188
            num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1193
1668188
            scan_x_cg = ff_hevc_diag_scan4x4_x;
1194
1668188
            scan_y_cg = ff_hevc_diag_scan4x4_y;
1195
        } else { // trafo_size == 32
1196
579544
            num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1197
579544
            scan_x_cg = ff_hevc_diag_scan8x8_x;
1198
579544
            scan_y_cg = ff_hevc_diag_scan8x8_y;
1199
        }
1200
10227282
        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
14029651
    num_coeff++;
1218
14029651
    num_last_subset = (num_coeff - 1) >> 4;
1219
1220
38577936
    for (i = num_last_subset; i >= 0; i--) {
1221
        int n, m;
1222
        int x_cg, y_cg, x_c, y_c, pos;
1223
24548285
        int implicit_non_zero_coeff = 0;
1224
        int64_t trans_coeff_level;
1225
24548285
        int prev_sig = 0;
1226
24548285
        int offset = i << 4;
1227
24548285
        int rice_init = 0;
1228
1229
        uint8_t significant_coeff_flag_idx[16];
1230
24548285
        uint8_t nb_significant_coeff_flag = 0;
1231
1232
24548285
        x_cg = scan_x_cg[i];
1233
24548285
        y_cg = scan_y_cg[i];
1234
1235

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

18730727
            ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1248
2350538
             (x_cg == 0 && y_cg == 0));
1249
        }
1250
1251
24548285
        last_scan_pos = num_coeff - offset - 1;
1252
1253
24548285
        if (i == num_last_subset) {
1254
14029651
            n_end = last_scan_pos - 1;
1255
14029651
            significant_coeff_flag_idx[0] = last_scan_pos;
1256
14029651
            nb_significant_coeff_flag = 1;
1257
        } else {
1258
10518634
            n_end = 15;
1259
        }
1260
1261
24548285
        if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1262
14712525
            prev_sig = !!significant_coeff_group_flag[x_cg + 1][y_cg];
1263
24548285
        if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1264
14287324
            prev_sig += (!!significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1265
1266

24548285
        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
18311497
            int scf_offset = 0;
1276

18311497
            if (s->ps.sps->transform_skip_context_enabled_flag &&
1277
875248
                (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
18192609
                if (c_idx != 0)
1286
4396005
                    scf_offset = 27;
1287
18192609
                if (log2_trafo_size == 2) {
1288
6285145
                    ctx_idx_map_p = (uint8_t*) &ctx_idx_map[0];
1289
                } else {
1290
11907464
                    ctx_idx_map_p = (uint8_t*) &ctx_idx_map[(prev_sig + 1) << 4];
1291
11907464
                    if (c_idx == 0) {
1292

9524725
                        if ((x_cg > 0 || y_cg > 0))
1293
5767163
                            scf_offset += 3;
1294
9524725
                        if (log2_trafo_size == 3) {
1295
3590572
                            scf_offset += (scan_idx == SCAN_DIAG) ? 9 : 15;
1296
                        } else {
1297
5934153
                            scf_offset += 21;
1298
                        }
1299
                    } else {
1300
2382739
                        if (log2_trafo_size == 3)
1301
1133844
                            scf_offset += 9;
1302
                        else
1303
1248895
                            scf_offset += 12;
1304
                    }
1305
                }
1306
            }
1307
186171357
            for (n = n_end; n > 0; n--) {
1308
167859860
                x_c = scan_x_off[n];
1309
167859860
                y_c = scan_y_off[n];
1310
167859860
                if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset, ctx_idx_map_p)) {
1311
81137434
                    significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1312
81137434
                    nb_significant_coeff_flag++;
1313
81137434
                    implicit_non_zero_coeff = 0;
1314
                }
1315
            }
1316
18311497
            if (implicit_non_zero_coeff == 0) {
1317

18242653
                if (s->ps.sps->transform_skip_context_enabled_flag &&
1318
873226
                    (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
18124159
                    if (i == 0) {
1326
11105531
                        if (c_idx == 0)
1327
8029441
                            scf_offset = 0;
1328
                        else
1329
3076090
                            scf_offset = 27;
1330
                    } else {
1331
7018628
                        scf_offset = 2 + scf_offset;
1332
                    }
1333
                }
1334
18242653
                if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) == 1) {
1335
12322327
                    significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1336
12322327
                    nb_significant_coeff_flag++;
1337
                }
1338
            } else {
1339
68844
                significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
1340
68844
                nb_significant_coeff_flag++;
1341
            }
1342
        }
1343
1344
24548285
        n_end = nb_significant_coeff_flag;
1345
1346
1347
24548285
        if (n_end) {
1348
            int first_nz_pos_in_cg;
1349
            int last_nz_pos_in_cg;
1350
21403750
            int c_rice_param = 0;
1351
21403750
            int first_greater1_coeff_idx = -1;
1352
            uint8_t coeff_abs_level_greater1_flag[8];
1353
            uint16_t coeff_sign_flag;
1354
21403750
            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

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

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

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

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

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

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

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

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

22767488
                        if (s->ps.sps->persistent_rice_adaptation_enabled_flag && !rice_init) {
1419
303626
                            int c_rice_p_init = lc->stat_coeff[sb_type] / 4;
1420
303626
                            if (last_coeff_abs_level_remaining >= (3 << c_rice_p_init))
1421
36850
                                lc->stat_coeff[sb_type]++;
1422
266776
                            else if (2 * last_coeff_abs_level_remaining < (1 << c_rice_p_init))
1423
151795
                                if (lc->stat_coeff[sb_type] > 0)
1424
36734
                                    lc->stat_coeff[sb_type]--;
1425
303626
                            rice_init = 1;
1426
                        }
1427
                    }
1428
                } else {
1429
17731786
                    int last_coeff_abs_level_remaining = coeff_abs_level_remaining_decode(s, c_rice_param);
1430
1431
17731786
                    trans_coeff_level = 1 + last_coeff_abs_level_remaining;
1432
17731786
                    if (trans_coeff_level > (3 << c_rice_param))
1433
2212886
                        c_rice_param = s->ps.sps->persistent_rice_adaptation_enabled_flag ? c_rice_param + 1 : FFMIN(c_rice_param + 1, 4);
1434

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

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

78171993
                    if (n == first_nz_pos_in_cg && (sum_abs&1))
1447
5392455
                        trans_coeff_level = -trans_coeff_level;
1448
                }
1449
107558256
                if (coeff_sign_flag >> 15)
1450
48883310
                    trans_coeff_level = -trans_coeff_level;
1451
107558256
                coeff_sign_flag <<= 1;
1452
107558256
                if(!lc->cu.cu_transquant_bypass_flag) {
1453

98873870
                    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
98873870
                    trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1467
98873870
                    if(trans_coeff_level < 0) {
1468
49904947
                        if((~trans_coeff_level) & 0xFffffffffff8000)
1469
162681
                            trans_coeff_level = -32768;
1470
                    } else {
1471
48968923
                        if(trans_coeff_level & 0xffffffffffff8000)
1472
162295
                            trans_coeff_level = 32767;
1473
                    }
1474
                }
1475
107558256
                coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1476
            }
1477
        }
1478
    }
1479
1480
14029651
    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
13591285
        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

13171308
        } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
1507
3521075
            s->hevcdsp.transform_4x4_luma(coeffs);
1508
        } else {
1509
9650233
            int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1510
9650233
            if (max_xy == 0)
1511
2165118
                s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1512
            else {
1513
7485115
                int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1514
7485115
                if (max_xy < 4)
1515
5190117
                    col_limit = FFMIN(4, col_limit);
1516
2294998
                else if (max_xy < 8)
1517
1717012
                    col_limit = FFMIN(8, col_limit);
1518
577986
                else if (max_xy < 12)
1519
248100
                    col_limit = FFMIN(24, col_limit);
1520
7485115
                s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1521
            }
1522
        }
1523
    }
1524
14029651
    if (lc->tu.cross_pf) {
1525
269268
        int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1526
1527
20522148
        for (i = 0; i < (trafo_size * trafo_size); i++) {
1528
20252880
            coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1529
        }
1530
    }
1531
14029651
    s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
1532
14029651
}
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