hevc: Change type of array stride parameters to ptrdiff_t
[libav.git] / libavcodec / hevc.c
CommitLineData
064698d3
GM
1/*
2 * HEVC video decoder
3 *
4 * Copyright (C) 2012 - 2013 Guillaume Martres
5 * Copyright (C) 2012 - 2013 Mickael Raulet
6 * Copyright (C) 2012 - 2013 Gildas Cocherel
7 * Copyright (C) 2012 - 2013 Wassim Hamidouche
8 *
9 * This file is part of Libav.
10 *
11 * Libav is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * Libav is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with Libav; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 */
25
26#include "libavutil/attributes.h"
27#include "libavutil/common.h"
0569a7e0 28#include "libavutil/display.h"
064698d3
GM
29#include "libavutil/internal.h"
30#include "libavutil/md5.h"
31#include "libavutil/opt.h"
32#include "libavutil/pixdesc.h"
acb77dff 33#include "libavutil/stereo3d.h"
064698d3 34
c67b449b 35#include "bswapdsp.h"
064698d3
GM
36#include "bytestream.h"
37#include "cabac_functions.h"
064698d3
GM
38#include "golomb.h"
39#include "hevc.h"
2c681139 40#include "profiles.h"
064698d3 41
e7078e84
AK
42const uint8_t ff_hevc_qpel_extra_before[4] = { 0, 3, 3, 3 };
43const uint8_t ff_hevc_qpel_extra_after[4] = { 0, 4, 4, 4 };
44const uint8_t ff_hevc_qpel_extra[4] = { 0, 7, 7, 7 };
064698d3
GM
45
46static const uint8_t scan_1x1[1] = { 0 };
47
48static const uint8_t horiz_scan2x2_x[4] = { 0, 1, 0, 1 };
49
50static const uint8_t horiz_scan2x2_y[4] = { 0, 0, 1, 1 };
51
52static const uint8_t horiz_scan4x4_x[16] = {
53 0, 1, 2, 3,
54 0, 1, 2, 3,
55 0, 1, 2, 3,
56 0, 1, 2, 3,
57};
58
59static const uint8_t horiz_scan4x4_y[16] = {
60 0, 0, 0, 0,
61 1, 1, 1, 1,
62 2, 2, 2, 2,
63 3, 3, 3, 3,
64};
65
66static const uint8_t horiz_scan8x8_inv[8][8] = {
67 { 0, 1, 2, 3, 16, 17, 18, 19, },
68 { 4, 5, 6, 7, 20, 21, 22, 23, },
69 { 8, 9, 10, 11, 24, 25, 26, 27, },
70 { 12, 13, 14, 15, 28, 29, 30, 31, },
71 { 32, 33, 34, 35, 48, 49, 50, 51, },
72 { 36, 37, 38, 39, 52, 53, 54, 55, },
73 { 40, 41, 42, 43, 56, 57, 58, 59, },
74 { 44, 45, 46, 47, 60, 61, 62, 63, },
75};
76
77static const uint8_t diag_scan2x2_x[4] = { 0, 0, 1, 1 };
78
79static const uint8_t diag_scan2x2_y[4] = { 0, 1, 0, 1 };
80
81static const uint8_t diag_scan2x2_inv[2][2] = {
82 { 0, 2, },
83 { 1, 3, },
84};
85
064698d3
GM
86static const uint8_t diag_scan4x4_inv[4][4] = {
87 { 0, 2, 5, 9, },
88 { 1, 4, 8, 12, },
89 { 3, 7, 11, 14, },
90 { 6, 10, 13, 15, },
91};
92
064698d3
GM
93static const uint8_t diag_scan8x8_inv[8][8] = {
94 { 0, 2, 5, 9, 14, 20, 27, 35, },
95 { 1, 4, 8, 13, 19, 26, 34, 42, },
96 { 3, 7, 12, 18, 25, 33, 41, 48, },
97 { 6, 11, 17, 24, 32, 40, 47, 53, },
98 { 10, 16, 23, 31, 39, 46, 52, 57, },
99 { 15, 22, 30, 38, 45, 51, 56, 60, },
100 { 21, 29, 37, 44, 50, 55, 59, 62, },
101 { 28, 36, 43, 49, 54, 58, 61, 63, },
102};
103
104/**
105 * NOTE: Each function hls_foo correspond to the function foo in the
106 * specification (HLS stands for High Level Syntax).
107 */
108
109/**
110 * Section 5.7
111 */
112
113/* free everything allocated by pic_arrays_init() */
114static void pic_arrays_free(HEVCContext *s)
115{
116 av_freep(&s->sao);
117 av_freep(&s->deblock);
064698d3
GM
118
119 av_freep(&s->skip_flag);
120 av_freep(&s->tab_ct_depth);
121
122 av_freep(&s->tab_ipm);
123 av_freep(&s->cbf_luma);
124 av_freep(&s->is_pcm);
125
126 av_freep(&s->qp_y_tab);
127 av_freep(&s->tab_slice_address);
128 av_freep(&s->filter_slice_edges);
129
130 av_freep(&s->horizontal_bs);
131 av_freep(&s->vertical_bs);
132
133 av_buffer_pool_uninit(&s->tab_mvf_pool);
134 av_buffer_pool_uninit(&s->rpl_tab_pool);
135}
136
137/* allocate arrays that depend on frame dimensions */
138static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
139{
140 int log2_min_cb_size = sps->log2_min_cb_size;
141 int width = sps->width;
142 int height = sps->height;
064698d3
GM
143 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
144 ((height >> log2_min_cb_size) + 1);
145 int ctb_count = sps->ctb_width * sps->ctb_height;
146 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
147
148 s->bs_width = width >> 3;
149 s->bs_height = height >> 3;
150
151 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
152 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
e36a2f4c 153 if (!s->sao || !s->deblock)
064698d3
GM
154 goto fail;
155
156 s->skip_flag = av_malloc(pic_size_in_ctb);
157 s->tab_ct_depth = av_malloc(sps->min_cb_height * sps->min_cb_width);
158 if (!s->skip_flag || !s->tab_ct_depth)
159 goto fail;
160
161 s->cbf_luma = av_malloc(sps->min_tb_width * sps->min_tb_height);
6cc94e97 162 s->tab_ipm = av_mallocz(min_pu_size);
064698d3
GM
163 s->is_pcm = av_malloc(min_pu_size);
164 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
165 goto fail;
166
167 s->filter_slice_edges = av_malloc(ctb_count);
168 s->tab_slice_address = av_malloc(pic_size_in_ctb *
169 sizeof(*s->tab_slice_address));
170 s->qp_y_tab = av_malloc(pic_size_in_ctb *
171 sizeof(*s->qp_y_tab));
172 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
173 goto fail;
174
175 s->horizontal_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
176 s->vertical_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
177 if (!s->horizontal_bs || !s->vertical_bs)
178 goto fail;
179
180 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
181 av_buffer_alloc);
182 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
183 av_buffer_allocz);
184 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
185 goto fail;
186
187 return 0;
188
189fail:
190 pic_arrays_free(s);
191 return AVERROR(ENOMEM);
192}
193
194static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
195{
196 int i = 0;
197 int j = 0;
198 uint8_t luma_weight_l0_flag[16];
199 uint8_t chroma_weight_l0_flag[16];
200 uint8_t luma_weight_l1_flag[16];
201 uint8_t chroma_weight_l1_flag[16];
202
eea769df 203 s->sh.luma_log2_weight_denom = av_clip(get_ue_golomb_long(gb), 0, 7);
b11acd57 204 if (s->ps.sps->chroma_format_idc != 0) {
064698d3 205 int delta = get_se_golomb(gb);
eea769df 206 s->sh.chroma_log2_weight_denom = av_clip(s->sh.luma_log2_weight_denom + delta, 0, 7);
064698d3
GM
207 }
208
209 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
210 luma_weight_l0_flag[i] = get_bits1(gb);
211 if (!luma_weight_l0_flag[i]) {
212 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
213 s->sh.luma_offset_l0[i] = 0;
214 }
215 }
b11acd57 216 if (s->ps.sps->chroma_format_idc != 0) { // FIXME: invert "if" and "for"
064698d3
GM
217 for (i = 0; i < s->sh.nb_refs[L0]; i++)
218 chroma_weight_l0_flag[i] = get_bits1(gb);
219 } else {
220 for (i = 0; i < s->sh.nb_refs[L0]; i++)
221 chroma_weight_l0_flag[i] = 0;
222 }
223 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
224 if (luma_weight_l0_flag[i]) {
225 int delta_luma_weight_l0 = get_se_golomb(gb);
226 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
227 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
228 }
229 if (chroma_weight_l0_flag[i]) {
230 for (j = 0; j < 2; j++) {
231 int delta_chroma_weight_l0 = get_se_golomb(gb);
232 int delta_chroma_offset_l0 = get_se_golomb(gb);
233 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
eea769df 234 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
064698d3
GM
235 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
236 }
237 } else {
238 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
239 s->sh.chroma_offset_l0[i][0] = 0;
240 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
241 s->sh.chroma_offset_l0[i][1] = 0;
242 }
243 }
244 if (s->sh.slice_type == B_SLICE) {
245 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
246 luma_weight_l1_flag[i] = get_bits1(gb);
247 if (!luma_weight_l1_flag[i]) {
248 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
249 s->sh.luma_offset_l1[i] = 0;
250 }
251 }
b11acd57 252 if (s->ps.sps->chroma_format_idc != 0) {
064698d3
GM
253 for (i = 0; i < s->sh.nb_refs[L1]; i++)
254 chroma_weight_l1_flag[i] = get_bits1(gb);
255 } else {
256 for (i = 0; i < s->sh.nb_refs[L1]; i++)
257 chroma_weight_l1_flag[i] = 0;
258 }
259 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
260 if (luma_weight_l1_flag[i]) {
261 int delta_luma_weight_l1 = get_se_golomb(gb);
262 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
263 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
264 }
265 if (chroma_weight_l1_flag[i]) {
266 for (j = 0; j < 2; j++) {
267 int delta_chroma_weight_l1 = get_se_golomb(gb);
268 int delta_chroma_offset_l1 = get_se_golomb(gb);
269 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
eea769df 270 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
064698d3
GM
271 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
272 }
273 } else {
274 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
275 s->sh.chroma_offset_l1[i][0] = 0;
276 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
277 s->sh.chroma_offset_l1[i][1] = 0;
278 }
279 }
280 }
281}
282
283static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
284{
b11acd57 285 const HEVCSPS *sps = s->ps.sps;
064698d3
GM
286 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
287 int prev_delta_msb = 0;
838740e6 288 unsigned int nb_sps = 0, nb_sh;
064698d3
GM
289 int i;
290
291 rps->nb_refs = 0;
292 if (!sps->long_term_ref_pics_present_flag)
293 return 0;
294
295 if (sps->num_long_term_ref_pics_sps > 0)
296 nb_sps = get_ue_golomb_long(gb);
297 nb_sh = get_ue_golomb_long(gb);
298
299 if (nb_sh + nb_sps > FF_ARRAY_ELEMS(rps->poc))
300 return AVERROR_INVALIDDATA;
301
302 rps->nb_refs = nb_sh + nb_sps;
303
304 for (i = 0; i < rps->nb_refs; i++) {
305 uint8_t delta_poc_msb_present;
306
307 if (i < nb_sps) {
308 uint8_t lt_idx_sps = 0;
309
310 if (sps->num_long_term_ref_pics_sps > 1)
311 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
312
313 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
314 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
315 } else {
316 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
317 rps->used[i] = get_bits1(gb);
318 }
319
320 delta_poc_msb_present = get_bits1(gb);
321 if (delta_poc_msb_present) {
322 int delta = get_ue_golomb_long(gb);
323
324 if (i && i != nb_sps)
325 delta += prev_delta_msb;
326
327 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
328 prev_delta_msb = delta;
329 }
330 }
331
332 return 0;
333}
334
18156b53
AK
335static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
336 const HEVCSPS *sps)
1ae7afd2 337{
18156b53 338 const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
1ae7afd2
AK
339 unsigned int num = 0, den = 0;
340
341 avctx->pix_fmt = sps->pix_fmt;
342 avctx->coded_width = sps->width;
343 avctx->coded_height = sps->height;
344 avctx->width = sps->output_width;
345 avctx->height = sps->output_height;
346 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
347 avctx->profile = sps->ptl.general_ptl.profile_idc;
348 avctx->level = sps->ptl.general_ptl.level_idc;
349
350 ff_set_sar(avctx, sps->vui.sar);
351
352 if (sps->vui.video_signal_type_present_flag)
353 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
354 : AVCOL_RANGE_MPEG;
355 else
356 avctx->color_range = AVCOL_RANGE_MPEG;
357
358 if (sps->vui.colour_description_present_flag) {
359 avctx->color_primaries = sps->vui.colour_primaries;
360 avctx->color_trc = sps->vui.transfer_characteristic;
361 avctx->colorspace = sps->vui.matrix_coeffs;
362 } else {
363 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
364 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
365 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
366 }
367
368 if (vps->vps_timing_info_present_flag) {
369 num = vps->vps_num_units_in_tick;
370 den = vps->vps_time_scale;
371 } else if (sps->vui.vui_timing_info_present_flag) {
372 num = sps->vui.vui_num_units_in_tick;
373 den = sps->vui.vui_time_scale;
374 }
375
376 if (num != 0 && den != 0)
377 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
378 num, den, 1 << 30);
379}
380
064698d3
GM
381static int set_sps(HEVCContext *s, const HEVCSPS *sps)
382{
8d34a2f8 383 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
e72e8c5a 384 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
064698d3 385 int ret;
1ae7afd2 386
064698d3 387 pic_arrays_free(s);
077b5594
AK
388 s->ps.sps = NULL;
389 s->ps.vps = NULL;
390
391 if (!sps)
392 return 0;
393
064698d3
GM
394 ret = pic_arrays_init(s, sps);
395 if (ret < 0)
396 goto fail;
397
077b5594
AK
398 export_stream_params(s->avctx, &s->ps, sps);
399
33f6690e
AK
400 if (sps->pix_fmt == AV_PIX_FMT_YUV420P || sps->pix_fmt == AV_PIX_FMT_YUVJ420P ||
401 sps->pix_fmt == AV_PIX_FMT_YUV420P10) {
7e850fa6
HL
402#if CONFIG_HEVC_DXVA2_HWACCEL
403 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
404#endif
33f6690e
AK
405 }
406 if (sps->pix_fmt == AV_PIX_FMT_YUV420P || sps->pix_fmt == AV_PIX_FMT_YUVJ420P) {
d8039ef8
SL
407#if CONFIG_HEVC_D3D11VA_HWACCEL
408 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
409#endif
8d34a2f8
PL
410#if CONFIG_HEVC_VDPAU_HWACCEL
411 *fmt++ = AV_PIX_FMT_VDPAU;
412#endif
7e850fa6
HL
413 }
414
e72e8c5a
HL
415 *fmt++ = sps->pix_fmt;
416 *fmt = AV_PIX_FMT_NONE;
417
418 ret = ff_get_format(s->avctx, pix_fmts);
419 if (ret < 0)
420 goto fail;
421 s->avctx->pix_fmt = ret;
422
064698d3
GM
423 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
424 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
425 ff_videodsp_init (&s->vdsp, sps->bit_depth);
426
e72e8c5a 427 if (sps->sao_enabled && !s->avctx->hwaccel) {
064698d3
GM
428 av_frame_unref(s->tmp_frame);
429 ret = ff_get_buffer(s->avctx, s->tmp_frame, AV_GET_BUFFER_FLAG_REF);
430 if (ret < 0)
431 goto fail;
432 s->frame = s->tmp_frame;
433 }
434
b11acd57
AK
435 s->ps.sps = sps;
436 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
17a10d51 437
064698d3
GM
438 return 0;
439
440fail:
441 pic_arrays_free(s);
b11acd57 442 s->ps.sps = NULL;
064698d3
GM
443 return ret;
444}
445
446static int hls_slice_header(HEVCContext *s)
447{
448 GetBitContext *gb = &s->HEVClc.gb;
449 SliceHeader *sh = &s->sh;
450 int i, ret;
451
452 // Coded parameters
453 sh->first_slice_in_pic_flag = get_bits1(gb);
454 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
455 s->seq_decode = (s->seq_decode + 1) & 0xff;
456 s->max_ra = INT_MAX;
457 if (IS_IDR(s))
458 ff_hevc_clear_refs(s);
459 }
1493b237 460 if (IS_IRAP(s))
064698d3
GM
461 sh->no_output_of_prior_pics_flag = get_bits1(gb);
462
463 sh->pps_id = get_ue_golomb_long(gb);
b11acd57 464 if (sh->pps_id >= MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
064698d3
GM
465 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
466 return AVERROR_INVALIDDATA;
467 }
468 if (!sh->first_slice_in_pic_flag &&
b11acd57 469 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
064698d3
GM
470 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
471 return AVERROR_INVALIDDATA;
472 }
b11acd57 473 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
064698d3 474
b11acd57
AK
475 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
476 s->ps.sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
064698d3
GM
477
478 ff_hevc_clear_refs(s);
b11acd57 479 ret = set_sps(s, s->ps.sps);
064698d3
GM
480 if (ret < 0)
481 return ret;
482
483 s->seq_decode = (s->seq_decode + 1) & 0xff;
484 s->max_ra = INT_MAX;
485 }
486
487 sh->dependent_slice_segment_flag = 0;
488 if (!sh->first_slice_in_pic_flag) {
489 int slice_address_length;
490
b11acd57 491 if (s->ps.pps->dependent_slice_segments_enabled_flag)
064698d3
GM
492 sh->dependent_slice_segment_flag = get_bits1(gb);
493
b11acd57
AK
494 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
495 s->ps.sps->ctb_height);
9f4c7397 496 sh->slice_segment_addr = slice_address_length ? get_bits(gb, slice_address_length) : 0;
b11acd57 497 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
064698d3
GM
498 av_log(s->avctx, AV_LOG_ERROR,
499 "Invalid slice segment address: %u.\n",
500 sh->slice_segment_addr);
501 return AVERROR_INVALIDDATA;
502 }
503
504 if (!sh->dependent_slice_segment_flag) {
505 sh->slice_addr = sh->slice_segment_addr;
506 s->slice_idx++;
507 }
508 } else {
509 sh->slice_segment_addr = sh->slice_addr = 0;
510 s->slice_idx = 0;
511 s->slice_initialized = 0;
512 }
513
514 if (!sh->dependent_slice_segment_flag) {
515 s->slice_initialized = 0;
516
b11acd57 517 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
064698d3
GM
518 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
519
520 sh->slice_type = get_ue_golomb_long(gb);
521 if (!(sh->slice_type == I_SLICE ||
522 sh->slice_type == P_SLICE ||
523 sh->slice_type == B_SLICE)) {
524 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
525 sh->slice_type);
526 return AVERROR_INVALIDDATA;
527 }
528 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
529 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
530 return AVERROR_INVALIDDATA;
531 }
532
458e7c94
GC
533 // when flag is not present, picture is inferred to be output
534 sh->pic_output_flag = 1;
b11acd57 535 if (s->ps.pps->output_flag_present_flag)
064698d3
GM
536 sh->pic_output_flag = get_bits1(gb);
537
b11acd57 538 if (s->ps.sps->separate_colour_plane_flag)
064698d3
GM
539 sh->colour_plane_id = get_bits(gb, 2);
540
541 if (!IS_IDR(s)) {
8958c5c6 542 int poc, pos;
064698d3 543
b11acd57 544 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
064698d3
GM
545 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
546 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
547 av_log(s->avctx, AV_LOG_WARNING,
548 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
549 if (s->avctx->err_recognition & AV_EF_EXPLODE)
550 return AVERROR_INVALIDDATA;
551 poc = s->poc;
552 }
553 s->poc = poc;
554
4b95e95d 555 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
8958c5c6 556 pos = get_bits_left(gb);
4b95e95d 557 if (!sh->short_term_ref_pic_set_sps_flag) {
b11acd57 558 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
064698d3
GM
559 if (ret < 0)
560 return ret;
561
562 sh->short_term_rps = &sh->slice_rps;
563 } else {
564 int numbits, rps_idx;
565
b11acd57 566 if (!s->ps.sps->nb_st_rps) {
064698d3
GM
567 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
568 return AVERROR_INVALIDDATA;
569 }
570
b11acd57 571 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
064698d3 572 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
b11acd57 573 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
064698d3 574 }
8958c5c6 575 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
064698d3 576
8958c5c6 577 pos = get_bits_left(gb);
064698d3
GM
578 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
579 if (ret < 0) {
580 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
581 if (s->avctx->err_recognition & AV_EF_EXPLODE)
582 return AVERROR_INVALIDDATA;
583 }
8958c5c6 584 sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
064698d3 585
b11acd57 586 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
064698d3
GM
587 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
588 else
589 sh->slice_temporal_mvp_enabled_flag = 0;
590 } else {
591 s->sh.short_term_rps = NULL;
592 s->poc = 0;
593 }
594
595 /* 8.3.1 */
596 if (s->temporal_id == 0 &&
597 s->nal_unit_type != NAL_TRAIL_N &&
598 s->nal_unit_type != NAL_TSA_N &&
599 s->nal_unit_type != NAL_STSA_N &&
600 s->nal_unit_type != NAL_RADL_N &&
601 s->nal_unit_type != NAL_RADL_R &&
602 s->nal_unit_type != NAL_RASL_N &&
603 s->nal_unit_type != NAL_RASL_R)
604 s->pocTid0 = s->poc;
605
b11acd57 606 if (s->ps.sps->sao_enabled) {
064698d3
GM
607 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
608 sh->slice_sample_adaptive_offset_flag[1] =
609 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
610 } else {
611 sh->slice_sample_adaptive_offset_flag[0] = 0;
612 sh->slice_sample_adaptive_offset_flag[1] = 0;
613 sh->slice_sample_adaptive_offset_flag[2] = 0;
614 }
615
616 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
617 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
618 int nb_refs;
619
b11acd57 620 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
064698d3 621 if (sh->slice_type == B_SLICE)
b11acd57 622 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
064698d3
GM
623
624 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
625 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
626 if (sh->slice_type == B_SLICE)
627 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
628 }
629 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
630 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
631 sh->nb_refs[L0], sh->nb_refs[L1]);
632 return AVERROR_INVALIDDATA;
633 }
634
635 sh->rpl_modification_flag[0] = 0;
636 sh->rpl_modification_flag[1] = 0;
637 nb_refs = ff_hevc_frame_nb_refs(s);
638 if (!nb_refs) {
639 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
640 return AVERROR_INVALIDDATA;
641 }
642
b11acd57 643 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
064698d3
GM
644 sh->rpl_modification_flag[0] = get_bits1(gb);
645 if (sh->rpl_modification_flag[0]) {
646 for (i = 0; i < sh->nb_refs[L0]; i++)
647 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
648 }
649
650 if (sh->slice_type == B_SLICE) {
651 sh->rpl_modification_flag[1] = get_bits1(gb);
652 if (sh->rpl_modification_flag[1] == 1)
653 for (i = 0; i < sh->nb_refs[L1]; i++)
654 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
655 }
656 }
657
658 if (sh->slice_type == B_SLICE)
659 sh->mvd_l1_zero_flag = get_bits1(gb);
660
b11acd57 661 if (s->ps.pps->cabac_init_present_flag)
064698d3
GM
662 sh->cabac_init_flag = get_bits1(gb);
663 else
664 sh->cabac_init_flag = 0;
665
666 sh->collocated_ref_idx = 0;
667 if (sh->slice_temporal_mvp_enabled_flag) {
668 sh->collocated_list = L0;
669 if (sh->slice_type == B_SLICE)
670 sh->collocated_list = !get_bits1(gb);
671
672 if (sh->nb_refs[sh->collocated_list] > 1) {
673 sh->collocated_ref_idx = get_ue_golomb_long(gb);
674 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
675 av_log(s->avctx, AV_LOG_ERROR,
676 "Invalid collocated_ref_idx: %d.\n",
677 sh->collocated_ref_idx);
678 return AVERROR_INVALIDDATA;
679 }
680 }
681 }
682
b11acd57
AK
683 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
684 (s->ps.pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
064698d3
GM
685 pred_weight_table(s, gb);
686 }
687
688 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
689 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
690 av_log(s->avctx, AV_LOG_ERROR,
691 "Invalid number of merging MVP candidates: %d.\n",
692 sh->max_num_merge_cand);
693 return AVERROR_INVALIDDATA;
694 }
695 }
696
697 sh->slice_qp_delta = get_se_golomb(gb);
0d999333 698
b11acd57 699 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
064698d3
GM
700 sh->slice_cb_qp_offset = get_se_golomb(gb);
701 sh->slice_cr_qp_offset = get_se_golomb(gb);
702 } else {
703 sh->slice_cb_qp_offset = 0;
704 sh->slice_cr_qp_offset = 0;
705 }
706
b11acd57 707 if (s->ps.pps->deblocking_filter_control_present_flag) {
064698d3
GM
708 int deblocking_filter_override_flag = 0;
709
b11acd57 710 if (s->ps.pps->deblocking_filter_override_enabled_flag)
064698d3
GM
711 deblocking_filter_override_flag = get_bits1(gb);
712
713 if (deblocking_filter_override_flag) {
714 sh->disable_deblocking_filter_flag = get_bits1(gb);
715 if (!sh->disable_deblocking_filter_flag) {
716 sh->beta_offset = get_se_golomb(gb) * 2;
717 sh->tc_offset = get_se_golomb(gb) * 2;
718 }
719 } else {
b11acd57
AK
720 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
721 sh->beta_offset = s->ps.pps->beta_offset;
722 sh->tc_offset = s->ps.pps->tc_offset;
064698d3
GM
723 }
724 } else {
725 sh->disable_deblocking_filter_flag = 0;
726 sh->beta_offset = 0;
727 sh->tc_offset = 0;
728 }
729
b11acd57 730 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
064698d3
GM
731 (sh->slice_sample_adaptive_offset_flag[0] ||
732 sh->slice_sample_adaptive_offset_flag[1] ||
733 !sh->disable_deblocking_filter_flag)) {
734 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
735 } else {
b11acd57 736 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
064698d3
GM
737 }
738 } else if (!s->slice_initialized) {
739 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
740 return AVERROR_INVALIDDATA;
741 }
742
743 sh->num_entry_point_offsets = 0;
b11acd57 744 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
064698d3
GM
745 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
746 if (sh->num_entry_point_offsets > 0) {
747 int offset_len = get_ue_golomb_long(gb) + 1;
748
749 for (i = 0; i < sh->num_entry_point_offsets; i++)
750 skip_bits(gb, offset_len);
751 }
752 }
753
b11acd57 754 if (s->ps.pps->slice_header_extension_present_flag) {
838740e6 755 unsigned int length = get_ue_golomb_long(gb);
064698d3
GM
756 for (i = 0; i < length; i++)
757 skip_bits(gb, 8); // slice_header_extension_data_byte
758 }
759
760 // Inferred parameters
b11acd57 761 sh->slice_qp = 26 + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
0d999333 762 if (sh->slice_qp > 51 ||
b11acd57 763 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
0d999333
LB
764 av_log(s->avctx, AV_LOG_ERROR,
765 "The slice_qp %d is outside the valid range "
766 "[%d, 51].\n",
767 sh->slice_qp,
b11acd57 768 -s->ps.sps->qp_bd_offset);
0d999333
LB
769 return AVERROR_INVALIDDATA;
770 }
771
064698d3
GM
772 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
773
816e5b99
LB
774 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
775 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
776 return AVERROR_INVALIDDATA;
777 }
778
064698d3
GM
779 s->HEVClc.first_qp_group = !s->sh.dependent_slice_segment_flag;
780
b11acd57
AK
781 if (!s->ps.pps->cu_qp_delta_enabled_flag)
782 s->HEVClc.qp_y = FFUMOD(s->sh.slice_qp + 52 + 2 * s->ps.sps->qp_bd_offset,
783 52 + s->ps.sps->qp_bd_offset) - s->ps.sps->qp_bd_offset;
064698d3
GM
784
785 s->slice_initialized = 1;
786
787 return 0;
788}
789
b11acd57 790#define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
064698d3
GM
791
792#define SET_SAO(elem, value) \
793do { \
794 if (!sao_merge_up_flag && !sao_merge_left_flag) \
795 sao->elem = value; \
796 else if (sao_merge_left_flag) \
797 sao->elem = CTB(s->sao, rx-1, ry).elem; \
798 else if (sao_merge_up_flag) \
799 sao->elem = CTB(s->sao, rx, ry-1).elem; \
800 else \
801 sao->elem = 0; \
802} while (0)
803
804static void hls_sao_param(HEVCContext *s, int rx, int ry)
805{
806 HEVCLocalContext *lc = &s->HEVClc;
807 int sao_merge_left_flag = 0;
808 int sao_merge_up_flag = 0;
b11acd57 809 int shift = s->ps.sps->bit_depth - FFMIN(s->ps.sps->bit_depth, 10);
064698d3
GM
810 SAOParams *sao = &CTB(s->sao, rx, ry);
811 int c_idx, i;
812
813 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
814 s->sh.slice_sample_adaptive_offset_flag[1]) {
815 if (rx > 0) {
816 if (lc->ctb_left_flag)
817 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
818 }
819 if (ry > 0 && !sao_merge_left_flag) {
820 if (lc->ctb_up_flag)
821 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
822 }
823 }
824
825 for (c_idx = 0; c_idx < 3; c_idx++) {
826 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
827 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
828 continue;
829 }
830
831 if (c_idx == 2) {
832 sao->type_idx[2] = sao->type_idx[1];
833 sao->eo_class[2] = sao->eo_class[1];
834 } else {
835 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
836 }
837
838 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
839 continue;
840
841 for (i = 0; i < 4; i++)
842 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
843
844 if (sao->type_idx[c_idx] == SAO_BAND) {
845 for (i = 0; i < 4; i++) {
846 if (sao->offset_abs[c_idx][i]) {
847 SET_SAO(offset_sign[c_idx][i],
848 ff_hevc_sao_offset_sign_decode(s));
849 } else {
850 sao->offset_sign[c_idx][i] = 0;
851 }
852 }
853 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
854 } else if (c_idx != 2) {
855 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
856 }
857
858 // Inferred parameters
859 sao->offset_val[c_idx][0] = 0;
860 for (i = 0; i < 4; i++) {
861 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i] << shift;
862 if (sao->type_idx[c_idx] == SAO_EDGE) {
863 if (i > 1)
864 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
865 } else if (sao->offset_sign[c_idx][i]) {
866 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
867 }
868 }
869 }
870}
871
872#undef SET_SAO
873#undef CTB
874
875static void hls_residual_coding(HEVCContext *s, int x0, int y0,
876 int log2_trafo_size, enum ScanType scan_idx,
877 int c_idx)
878{
879#define GET_COORD(offset, n) \
880 do { \
881 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
882 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
883 } while (0)
884 HEVCLocalContext *lc = &s->HEVClc;
885 int transform_skip_flag = 0;
886
887 int last_significant_coeff_x, last_significant_coeff_y;
888 int last_scan_pos;
889 int n_end;
890 int num_coeff = 0;
891 int greater1_ctx = 1;
892
893 int num_last_subset;
894 int x_cg_last_sig, y_cg_last_sig;
895
896 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
897
898 ptrdiff_t stride = s->frame->linesize[c_idx];
b11acd57
AK
899 int hshift = s->ps.sps->hshift[c_idx];
900 int vshift = s->ps.sps->vshift[c_idx];
064698d3 901 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
b11acd57 902 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
fca3c3b6 903 DECLARE_ALIGNED(32, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = { 0 };
064698d3
GM
904 DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = { { 0 } };
905
906 int trafo_size = 1 << log2_trafo_size;
907 int i, qp, shift, add, scale, scale_m;
5afb94c8 908 static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
064698d3
GM
909 const uint8_t *scale_matrix;
910 uint8_t dc_scale;
911
912 // Derive QP for dequant
913 if (!lc->cu.cu_transquant_bypass_flag) {
914 static const int qp_c[] = {
915 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37
916 };
917
918 static const uint8_t rem6[51 + 2 * 6 + 1] = {
919 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
920 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
921 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
922 };
923
924 static const uint8_t div6[51 + 2 * 6 + 1] = {
925 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
926 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
927 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
928 };
929 int qp_y = lc->qp_y;
930
931 if (c_idx == 0) {
b11acd57 932 qp = qp_y + s->ps.sps->qp_bd_offset;
064698d3
GM
933 } else {
934 int qp_i, offset;
935
936 if (c_idx == 1)
b11acd57 937 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
064698d3 938 else
b11acd57 939 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
064698d3 940
b11acd57 941 qp_i = av_clip(qp_y + offset, -s->ps.sps->qp_bd_offset, 57);
064698d3
GM
942 if (qp_i < 30)
943 qp = qp_i;
944 else if (qp_i > 43)
945 qp = qp_i - 6;
946 else
947 qp = qp_c[qp_i - 30];
948
b11acd57 949 qp += s->ps.sps->qp_bd_offset;
064698d3
GM
950 }
951
b11acd57 952 shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
064698d3
GM
953 add = 1 << (shift - 1);
954 scale = level_scale[rem6[qp]] << (div6[qp]);
955 scale_m = 16; // default when no custom scaling lists.
956 dc_scale = 16;
957
b11acd57
AK
958 if (s->ps.sps->scaling_list_enable_flag) {
959 const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
960 &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
064698d3
GM
961 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
962
963 if (log2_trafo_size != 5)
964 matrix_id = 3 * matrix_id + c_idx;
965
966 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
967 if (log2_trafo_size >= 4)
968 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
969 }
970 }
971
b11acd57 972 if (s->ps.pps->transform_skip_enabled_flag &&
064698d3
GM
973 !lc->cu.cu_transquant_bypass_flag &&
974 log2_trafo_size == 2) {
975 transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
976 }
977
978 last_significant_coeff_x =
979 ff_hevc_last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
980 last_significant_coeff_y =
981 ff_hevc_last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
982
983 if (last_significant_coeff_x > 3) {
984 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
985 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
986 (2 + (last_significant_coeff_x & 1)) +
987 suffix;
988 }
989
990 if (last_significant_coeff_y > 3) {
991 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
992 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
993 (2 + (last_significant_coeff_y & 1)) +
994 suffix;
995 }
996
997 if (scan_idx == SCAN_VERT)
998 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
999
1000 x_cg_last_sig = last_significant_coeff_x >> 2;
1001 y_cg_last_sig = last_significant_coeff_y >> 2;
1002
1003 switch (scan_idx) {
1004 case SCAN_DIAG: {
1005 int last_x_c = last_significant_coeff_x & 3;
1006 int last_y_c = last_significant_coeff_y & 3;
1007
1008 scan_x_off = ff_hevc_diag_scan4x4_x;
1009 scan_y_off = ff_hevc_diag_scan4x4_y;
1010 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1011 if (trafo_size == 4) {
1012 scan_x_cg = scan_1x1;
1013 scan_y_cg = scan_1x1;
1014 } else if (trafo_size == 8) {
1015 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1016 scan_x_cg = diag_scan2x2_x;
1017 scan_y_cg = diag_scan2x2_y;
1018 } else if (trafo_size == 16) {
1019 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1020 scan_x_cg = ff_hevc_diag_scan4x4_x;
1021 scan_y_cg = ff_hevc_diag_scan4x4_y;
1022 } else { // trafo_size == 32
1023 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1024 scan_x_cg = ff_hevc_diag_scan8x8_x;
1025 scan_y_cg = ff_hevc_diag_scan8x8_y;
1026 }
1027 break;
1028 }
1029 case SCAN_HORIZ:
1030 scan_x_cg = horiz_scan2x2_x;
1031 scan_y_cg = horiz_scan2x2_y;
1032 scan_x_off = horiz_scan4x4_x;
1033 scan_y_off = horiz_scan4x4_y;
1034 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1035 break;
1036 default: //SCAN_VERT
1037 scan_x_cg = horiz_scan2x2_y;
1038 scan_y_cg = horiz_scan2x2_x;
1039 scan_x_off = horiz_scan4x4_y;
1040 scan_y_off = horiz_scan4x4_x;
1041 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1042 break;
1043 }
1044 num_coeff++;
1045 num_last_subset = (num_coeff - 1) >> 4;
1046
1047 for (i = num_last_subset; i >= 0; i--) {
1048 int n, m;
1049 int x_cg, y_cg, x_c, y_c;
1050 int implicit_non_zero_coeff = 0;
1051 int64_t trans_coeff_level;
1052 int prev_sig = 0;
1053 int offset = i << 4;
1054
1055 uint8_t significant_coeff_flag_idx[16];
1056 uint8_t nb_significant_coeff_flag = 0;
1057
1058 x_cg = scan_x_cg[i];
1059 y_cg = scan_y_cg[i];
1060
1061 if (i < num_last_subset && i > 0) {
1062 int ctx_cg = 0;
1063 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1064 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1065 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1066 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1067
1068 significant_coeff_group_flag[x_cg][y_cg] =
1069 ff_hevc_significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1070 implicit_non_zero_coeff = 1;
1071 } else {
1072 significant_coeff_group_flag[x_cg][y_cg] =
1073 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1074 (x_cg == 0 && y_cg == 0));
1075 }
1076
1077 last_scan_pos = num_coeff - offset - 1;
1078
1079 if (i == num_last_subset) {
1080 n_end = last_scan_pos - 1;
1081 significant_coeff_flag_idx[0] = last_scan_pos;
1082 nb_significant_coeff_flag = 1;
1083 } else {
1084 n_end = 15;
1085 }
1086
1087 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1088 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1089 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1090 prev_sig += significant_coeff_group_flag[x_cg][y_cg + 1] << 1;
1091
1092 for (n = n_end; n >= 0; n--) {
1093 GET_COORD(offset, n);
1094
1095 if (significant_coeff_group_flag[x_cg][y_cg] &&
1096 (n > 0 || implicit_non_zero_coeff == 0)) {
1097 if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c,
1098 log2_trafo_size,
1099 scan_idx,
1100 prev_sig) == 1) {
1101 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1102 nb_significant_coeff_flag++;
1103 implicit_non_zero_coeff = 0;
1104 }
1105 } else {
1106 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1107 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1108 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1109 nb_significant_coeff_flag++;
1110 }
1111 }
1112 }
1113
1114 n_end = nb_significant_coeff_flag;
1115
1116 if (n_end) {
1117 int first_nz_pos_in_cg = 16;
1118 int last_nz_pos_in_cg = -1;
1119 int c_rice_param = 0;
1120 int first_greater1_coeff_idx = -1;
1121 uint8_t coeff_abs_level_greater1_flag[16] = { 0 };
1122 uint16_t coeff_sign_flag;
1123 int sum_abs = 0;
1124 int sign_hidden = 0;
1125
1126 // initialize first elem of coeff_bas_level_greater1_flag
1127 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1128
1129 if (!(i == num_last_subset) && greater1_ctx == 0)
1130 ctx_set++;
1131 greater1_ctx = 1;
1132 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1133
1134 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1135 int n_idx = significant_coeff_flag_idx[m];
1136 int inc = (ctx_set << 2) + greater1_ctx;
1137 coeff_abs_level_greater1_flag[n_idx] =
1138 ff_hevc_coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1139 if (coeff_abs_level_greater1_flag[n_idx]) {
1140 greater1_ctx = 0;
1141 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1142 greater1_ctx++;
1143 }
1144
1145 if (coeff_abs_level_greater1_flag[n_idx] &&
1146 first_greater1_coeff_idx == -1)
1147 first_greater1_coeff_idx = n_idx;
1148 }
1149 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1150 sign_hidden = last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1151 !lc->cu.cu_transquant_bypass_flag;
1152
1153 if (first_greater1_coeff_idx != -1) {
1154 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1155 }
b11acd57 1156 if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden) {
064698d3
GM
1157 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1158 } else {
1159 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1160 }
1161
1162 for (m = 0; m < n_end; m++) {
1163 n = significant_coeff_flag_idx[m];
1164 GET_COORD(offset, n);
1165 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1166 if (trans_coeff_level == ((m < 8) ?
1167 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1168 int last_coeff_abs_level_remaining = ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param);
1169
1170 trans_coeff_level += last_coeff_abs_level_remaining;
1171 if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1172 c_rice_param = FFMIN(c_rice_param + 1, 4);
1173 }
b11acd57 1174 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
064698d3
GM
1175 sum_abs += trans_coeff_level;
1176 if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1177 trans_coeff_level = -trans_coeff_level;
1178 }
1179 if (coeff_sign_flag >> 15)
1180 trans_coeff_level = -trans_coeff_level;
1181 coeff_sign_flag <<= 1;
1182 if (!lc->cu.cu_transquant_bypass_flag) {
b11acd57 1183 if (s->ps.sps->scaling_list_enable_flag) {
064698d3
GM
1184 if (y_c || x_c || log2_trafo_size < 4) {
1185 int pos;
1186 switch (log2_trafo_size) {
1187 case 3: pos = (y_c << 3) + x_c; break;
1188 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1189 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1190 default: pos = (y_c << 2) + x_c;
1191 }
1192 scale_m = scale_matrix[pos];
1193 } else {
1194 scale_m = dc_scale;
1195 }
1196 }
1197 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1198 if(trans_coeff_level < 0) {
1199 if((~trans_coeff_level) & 0xFffffffffff8000)
1200 trans_coeff_level = -32768;
1201 } else {
1202 if (trans_coeff_level & 0xffffffffffff8000)
1203 trans_coeff_level = 32767;
1204 }
1205 }
1206 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1207 }
1208 }
1209 }
1210
1bd890ad 1211 if (!lc->cu.cu_transquant_bypass_flag) {
064698d3 1212 if (transform_skip_flag)
1bd890ad 1213 s->hevcdsp.dequant(coeffs);
064698d3
GM
1214 else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 &&
1215 log2_trafo_size == 2)
1bd890ad 1216 s->hevcdsp.transform_4x4_luma(coeffs);
a92fd8a0
MR
1217 else {
1218 int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1219 if (max_xy == 0)
1220 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
cc16da75
MR
1221 else {
1222 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1223 if (max_xy < 4)
1224 col_limit = FFMIN(4, col_limit);
1225 else if (max_xy < 8)
1226 col_limit = FFMIN(8, col_limit);
1227 else if (max_xy < 12)
1228 col_limit = FFMIN(24, col_limit);
1229 s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1230 }
a92fd8a0 1231 }
064698d3 1232 }
1bd890ad 1233 s->hevcdsp.add_residual[log2_trafo_size - 2](dst, coeffs, stride);
064698d3
GM
1234}
1235
e22ebd04
LB
1236static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1237 int xBase, int yBase, int cb_xBase, int cb_yBase,
1238 int log2_cb_size, int log2_trafo_size,
16c01fb4 1239 int blk_idx, int cbf_luma, int cbf_cb, int cbf_cr)
064698d3
GM
1240{
1241 HEVCLocalContext *lc = &s->HEVClc;
1242
1243 if (lc->cu.pred_mode == MODE_INTRA) {
1244 int trafo_size = 1 << log2_trafo_size;
1245 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1246
a1c2b480 1247 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
064698d3 1248 if (log2_trafo_size > 2) {
b11acd57 1249 trafo_size = trafo_size << (s->ps.sps->hshift[1] - 1);
064698d3 1250 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
a1c2b480
AK
1251 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 1);
1252 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 2);
064698d3 1253 } else if (blk_idx == 3) {
b11acd57 1254 trafo_size = trafo_size << s->ps.sps->hshift[1];
064698d3
GM
1255 ff_hevc_set_neighbour_available(s, xBase, yBase,
1256 trafo_size, trafo_size);
a1c2b480
AK
1257 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1258 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
064698d3
GM
1259 }
1260 }
1261
e76f2d11 1262 if (cbf_luma || cbf_cb || cbf_cr) {
064698d3
GM
1263 int scan_idx = SCAN_DIAG;
1264 int scan_idx_c = SCAN_DIAG;
1265
b11acd57 1266 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
064698d3
GM
1267 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1268 if (lc->tu.cu_qp_delta != 0)
1269 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1270 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1271 lc->tu.is_cu_qp_delta_coded = 1;
e22ebd04 1272
b11acd57
AK
1273 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1274 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
e22ebd04
LB
1275 av_log(s->avctx, AV_LOG_ERROR,
1276 "The cu_qp_delta %d is outside the valid range "
1277 "[%d, %d].\n",
1278 lc->tu.cu_qp_delta,
b11acd57
AK
1279 -(26 + s->ps.sps->qp_bd_offset / 2),
1280 (25 + s->ps.sps->qp_bd_offset / 2));
e22ebd04
LB
1281 return AVERROR_INVALIDDATA;
1282 }
1283
064698d3
GM
1284 ff_hevc_set_qPy(s, x0, y0, cb_xBase, cb_yBase, log2_cb_size);
1285 }
1286
1287 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1288 if (lc->tu.cur_intra_pred_mode >= 6 &&
1289 lc->tu.cur_intra_pred_mode <= 14) {
1290 scan_idx = SCAN_VERT;
1291 } else if (lc->tu.cur_intra_pred_mode >= 22 &&
1292 lc->tu.cur_intra_pred_mode <= 30) {
1293 scan_idx = SCAN_HORIZ;
1294 }
1295
1296 if (lc->pu.intra_pred_mode_c >= 6 &&
1297 lc->pu.intra_pred_mode_c <= 14) {
1298 scan_idx_c = SCAN_VERT;
1299 } else if (lc->pu.intra_pred_mode_c >= 22 &&
1300 lc->pu.intra_pred_mode_c <= 30) {
1301 scan_idx_c = SCAN_HORIZ;
1302 }
1303 }
1304
e76f2d11 1305 if (cbf_luma)
064698d3
GM
1306 hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1307 if (log2_trafo_size > 2) {
4aa80808 1308 if (cbf_cb)
064698d3 1309 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 1);
4aa80808 1310 if (cbf_cr)
064698d3
GM
1311 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 2);
1312 } else if (blk_idx == 3) {
4aa80808 1313 if (cbf_cb)
064698d3 1314 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 1);
4aa80808 1315 if (cbf_cr)
064698d3
GM
1316 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 2);
1317 }
1318 }
e22ebd04 1319 return 0;
064698d3
GM
1320}
1321
1322static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1323{
1324 int cb_size = 1 << log2_cb_size;
b11acd57 1325 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
064698d3 1326
b11acd57
AK
1327 int min_pu_width = s->ps.sps->min_pu_width;
1328 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1329 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
064698d3
GM
1330 int i, j;
1331
1332 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1333 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1334 s->is_pcm[i + j * min_pu_width] = 2;
1335}
1336
e22ebd04
LB
1337static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1338 int xBase, int yBase, int cb_xBase, int cb_yBase,
1339 int log2_cb_size, int log2_trafo_size,
4aa80808
AK
1340 int trafo_depth, int blk_idx,
1341 int cbf_cb, int cbf_cr)
064698d3
GM
1342{
1343 HEVCLocalContext *lc = &s->HEVClc;
1344 uint8_t split_transform_flag;
e22ebd04 1345 int ret;
064698d3 1346
064698d3
GM
1347 if (lc->cu.intra_split_flag) {
1348 if (trafo_depth == 1)
1349 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1350 } else {
1351 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[0];
1352 }
1353
b11acd57
AK
1354 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1355 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
064698d3
GM
1356 trafo_depth < lc->cu.max_trafo_depth &&
1357 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1358 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1359 } else {
b11acd57 1360 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
0daa2554
AK
1361 lc->cu.pred_mode == MODE_INTER &&
1362 lc->cu.part_mode != PART_2Nx2N &&
1363 trafo_depth == 0;
1364
b11acd57 1365 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
064698d3 1366 (lc->cu.intra_split_flag && trafo_depth == 0) ||
0daa2554 1367 inter_split;
064698d3
GM
1368 }
1369
4aa80808
AK
1370 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cb))
1371 cbf_cb = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1372 else if (log2_trafo_size > 2 || trafo_depth == 0)
1373 cbf_cb = 0;
1374 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cr))
1375 cbf_cr = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1376 else if (log2_trafo_size > 2 || trafo_depth == 0)
1377 cbf_cr = 0;
064698d3
GM
1378
1379 if (split_transform_flag) {
53a11135
AK
1380 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1381 const int x1 = x0 + trafo_size_split;
1382 const int y1 = y0 + trafo_size_split;
1383
1384#define SUBDIVIDE(x, y, idx) \
1385do { \
1386 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
4aa80808
AK
1387 log2_trafo_size - 1, trafo_depth + 1, idx, \
1388 cbf_cb, cbf_cr); \
53a11135
AK
1389 if (ret < 0) \
1390 return ret; \
1391} while (0)
064698d3 1392
53a11135
AK
1393 SUBDIVIDE(x0, y0, 0);
1394 SUBDIVIDE(x1, y0, 1);
1395 SUBDIVIDE(x0, y1, 2);
1396 SUBDIVIDE(x1, y1, 3);
1397
1398#undef SUBDIVIDE
064698d3 1399 } else {
b11acd57
AK
1400 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1401 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1402 int min_tu_width = s->ps.sps->min_tb_width;
e76f2d11 1403 int cbf_luma = 1;
064698d3
GM
1404
1405 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
4aa80808 1406 cbf_cb || cbf_cr)
e76f2d11 1407 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
064698d3 1408
e22ebd04 1409 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
16c01fb4 1410 log2_cb_size, log2_trafo_size,
e76f2d11 1411 blk_idx, cbf_luma, cbf_cb, cbf_cr);
e22ebd04
LB
1412 if (ret < 0)
1413 return ret;
064698d3 1414 // TODO: store cbf_luma somewhere else
e76f2d11 1415 if (cbf_luma) {
064698d3
GM
1416 int i, j;
1417 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1418 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1419 int x_tu = (x0 + j) >> log2_min_tu_size;
1420 int y_tu = (y0 + i) >> log2_min_tu_size;
1421 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1422 }
1423 }
1424 if (!s->sh.disable_deblocking_filter_flag) {
70211539 1425 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
b11acd57 1426 if (s->ps.pps->transquant_bypass_enable_flag &&
064698d3
GM
1427 lc->cu.cu_transquant_bypass_flag)
1428 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1429 }
1430 }
e22ebd04 1431 return 0;
064698d3
GM
1432}
1433
1434static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1435{
1436 //TODO: non-4:2:0 support
1437 HEVCLocalContext *lc = &s->HEVClc;
1438 GetBitContext gb;
1439 int cb_size = 1 << log2_cb_size;
ba479f3d
DB
1440 ptrdiff_t stride0 = s->frame->linesize[0];
1441 ptrdiff_t stride1 = s->frame->linesize[1];
1442 ptrdiff_t stride2 = s->frame->linesize[2];
b11acd57 1443 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
b11acd57 1444 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->ps.sps->vshift[1]) * stride1 + ((x0 >> s->ps.sps->hshift[1]) << s->ps.sps->pixel_shift)];
b11acd57 1445 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->ps.sps->vshift[2]) * stride2 + ((x0 >> s->ps.sps->hshift[2]) << s->ps.sps->pixel_shift)];
064698d3 1446
b11acd57 1447 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth + ((cb_size * cb_size) >> 1) * s->ps.sps->pcm.bit_depth_chroma;
df949b64 1448 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
064698d3
GM
1449 int ret;
1450
70211539
AK
1451 if (!s->sh.disable_deblocking_filter_flag)
1452 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
064698d3
GM
1453
1454 ret = init_get_bits(&gb, pcm, length);
1455 if (ret < 0)
1456 return ret;
1457
b11acd57
AK
1458 s->hevcdsp.put_pcm(dst0, stride0, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1459 s->hevcdsp.put_pcm(dst1, stride1, cb_size / 2, &gb, s->ps.sps->pcm.bit_depth_chroma);
1460 s->hevcdsp.put_pcm(dst2, stride2, cb_size / 2, &gb, s->ps.sps->pcm.bit_depth_chroma);
064698d3
GM
1461 return 0;
1462}
1463
1464static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1465{
1466 HEVCLocalContext *lc = &s->HEVClc;
1467 int x = ff_hevc_abs_mvd_greater0_flag_decode(s);
1468 int y = ff_hevc_abs_mvd_greater0_flag_decode(s);
1469
1470 if (x)
1471 x += ff_hevc_abs_mvd_greater1_flag_decode(s);
1472 if (y)
1473 y += ff_hevc_abs_mvd_greater1_flag_decode(s);
1474
1475 switch (x) {
1476 case 2: lc->pu.mvd.x = ff_hevc_mvd_decode(s); break;
1477 case 1: lc->pu.mvd.x = ff_hevc_mvd_sign_flag_decode(s); break;
1478 case 0: lc->pu.mvd.x = 0; break;
1479 }
1480
1481 switch (y) {
1482 case 2: lc->pu.mvd.y = ff_hevc_mvd_decode(s); break;
1483 case 1: lc->pu.mvd.y = ff_hevc_mvd_sign_flag_decode(s); break;
1484 case 0: lc->pu.mvd.y = 0; break;
1485 }
1486}
1487
1488/**
1489 * 8.5.3.2.2.1 Luma sample interpolation process
1490 *
1491 * @param s HEVC decoding context
1492 * @param dst target buffer for block data at block position
1493 * @param dststride stride of the dst buffer
1494 * @param ref reference picture buffer at origin (0, 0)
1495 * @param mv motion vector (relative to block position) to get pixel data from
1496 * @param x_off horizontal position of block from origin (0, 0)
1497 * @param y_off vertical position of block from origin (0, 0)
1498 * @param block_w width of block
1499 * @param block_h height of block
1500 */
1501static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride,
1502 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1f821750 1503 int block_w, int block_h, int pred_idx)
064698d3
GM
1504{
1505 HEVCLocalContext *lc = &s->HEVClc;
1506 uint8_t *src = ref->data[0];
1507 ptrdiff_t srcstride = ref->linesize[0];
b11acd57
AK
1508 int pic_width = s->ps.sps->width;
1509 int pic_height = s->ps.sps->height;
064698d3
GM
1510
1511 int mx = mv->x & 3;
1512 int my = mv->y & 3;
1513 int extra_left = ff_hevc_qpel_extra_before[mx];
1514 int extra_top = ff_hevc_qpel_extra_before[my];
1515
1516 x_off += mv->x >> 2;
1517 y_off += mv->y >> 2;
a1926a29 1518 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
064698d3
GM
1519
1520 if (x_off < extra_left || y_off < extra_top ||
1521 x_off >= pic_width - block_w - ff_hevc_qpel_extra_after[mx] ||
1522 y_off >= pic_height - block_h - ff_hevc_qpel_extra_after[my]) {
ba479f3d 1523 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
b11acd57 1524 int offset = extra_top * srcstride + (extra_left << s->ps.sps->pixel_shift);
e588615d 1525 int buf_offset = extra_top *
b11acd57 1526 edge_emu_stride + (extra_left << s->ps.sps->pixel_shift);
064698d3 1527
458446ac 1528 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
e588615d 1529 edge_emu_stride, srcstride,
064698d3
GM
1530 block_w + ff_hevc_qpel_extra[mx],
1531 block_h + ff_hevc_qpel_extra[my],
1532 x_off - extra_left, y_off - extra_top,
1533 pic_width, pic_height);
e588615d
GM
1534 src = lc->edge_emu_buffer + buf_offset;
1535 srcstride = edge_emu_stride;
064698d3 1536 }
1f821750
AK
1537 s->hevcdsp.put_hevc_qpel[!!my][!!mx][pred_idx](dst, dststride, src, srcstride,
1538 block_h, mx, my, lc->mc_buffer);
064698d3
GM
1539}
1540
1541/**
1542 * 8.5.3.2.2.2 Chroma sample interpolation process
1543 *
1544 * @param s HEVC decoding context
1545 * @param dst1 target buffer for block data at block position (U plane)
1546 * @param dst2 target buffer for block data at block position (V plane)
1547 * @param dststride stride of the dst1 and dst2 buffers
1548 * @param ref reference picture buffer at origin (0, 0)
1549 * @param mv motion vector (relative to block position) to get pixel data from
1550 * @param x_off horizontal position of block from origin (0, 0)
1551 * @param y_off vertical position of block from origin (0, 0)
1552 * @param block_w width of block
1553 * @param block_h height of block
1554 */
1555static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1556 ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
818bfe7f 1557 int x_off, int y_off, int block_w, int block_h, int pred_idx)
064698d3
GM
1558{
1559 HEVCLocalContext *lc = &s->HEVClc;
1560 uint8_t *src1 = ref->data[1];
1561 uint8_t *src2 = ref->data[2];
1562 ptrdiff_t src1stride = ref->linesize[1];
1563 ptrdiff_t src2stride = ref->linesize[2];
b11acd57
AK
1564 int pic_width = s->ps.sps->width >> 1;
1565 int pic_height = s->ps.sps->height >> 1;
064698d3
GM
1566
1567 int mx = mv->x & 7;
1568 int my = mv->y & 7;
1569
1570 x_off += mv->x >> 3;
1571 y_off += mv->y >> 3;
a1926a29
AK
1572 src1 += y_off * src1stride + (x_off * (1 << s->ps.sps->pixel_shift));
1573 src2 += y_off * src2stride + (x_off * (1 << s->ps.sps->pixel_shift));
064698d3
GM
1574
1575 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1576 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1577 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
ba479f3d 1578 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
b11acd57 1579 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
e588615d 1580 int buf_offset1 = EPEL_EXTRA_BEFORE *
b11acd57
AK
1581 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1582 int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
e588615d 1583 int buf_offset2 = EPEL_EXTRA_BEFORE *
b11acd57 1584 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
064698d3 1585
458446ac 1586 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
e588615d 1587 edge_emu_stride, src1stride,
064698d3
GM
1588 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1589 x_off - EPEL_EXTRA_BEFORE,
1590 y_off - EPEL_EXTRA_BEFORE,
1591 pic_width, pic_height);
1592
e588615d
GM
1593 src1 = lc->edge_emu_buffer + buf_offset1;
1594 src1stride = edge_emu_stride;
818bfe7f
AK
1595 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst1, dststride, src1, src1stride,
1596 block_h, mx, my, lc->mc_buffer);
064698d3 1597
458446ac 1598 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2,
e588615d 1599 edge_emu_stride, src2stride,
064698d3
GM
1600 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1601 x_off - EPEL_EXTRA_BEFORE,
1602 y_off - EPEL_EXTRA_BEFORE,
1603 pic_width, pic_height);
e588615d
GM
1604 src2 = lc->edge_emu_buffer + buf_offset2;
1605 src2stride = edge_emu_stride;
1606
818bfe7f
AK
1607 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst2, dststride, src2, src2stride,
1608 block_h, mx, my, lc->mc_buffer);
064698d3 1609 } else {
818bfe7f
AK
1610 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst1, dststride, src1, src1stride,
1611 block_h, mx, my, lc->mc_buffer);
1612 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst2, dststride, src2, src2stride,
1613 block_h, mx, my, lc->mc_buffer);
064698d3
GM
1614 }
1615}
1616
1617static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1618 const Mv *mv, int y0, int height)
1619{
1620 int y = (mv->y >> 2) + y0 + height + 9;
1621 ff_thread_await_progress(&ref->tf, y, 0);
1622}
1623
cd975d56
LB
1624static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1625 int nPbH, int log2_cb_size, int part_idx,
1626 int merge_idx, MvField *mv)
1627{
1628 HEVCLocalContext *lc = &s->HEVClc;
1629 enum InterPredIdc inter_pred_idc = PRED_L0;
1630 int mvp_flag;
1631
1632 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1633 if (s->sh.slice_type == B_SLICE)
1634 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1635
1636 if (inter_pred_idc != PRED_L1) {
1637 if (s->sh.nb_refs[L0])
1638 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1639
1640 mv->pred_flag[0] = 1;
1641 hls_mvd_coding(s, x0, y0, 0);
1642 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1643 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1644 part_idx, merge_idx, mv, mvp_flag, 0);
1645 mv->mv[0].x += lc->pu.mvd.x;
1646 mv->mv[0].y += lc->pu.mvd.y;
1647 }
1648
1649 if (inter_pred_idc != PRED_L0) {
1650 if (s->sh.nb_refs[L1])
1651 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1652
1653 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1654 AV_ZERO32(&lc->pu.mvd);
1655 } else {
1656 hls_mvd_coding(s, x0, y0, 1);
1657 }
1658
1659 mv->pred_flag[1] = 1;
1660 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1661 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1662 part_idx, merge_idx, mv, mvp_flag, 1);
1663 mv->mv[1].x += lc->pu.mvd.x;
1664 mv->mv[1].y += lc->pu.mvd.y;
1665 }
1666}
1667
064698d3
GM
1668static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1669 int nPbW, int nPbH,
1670 int log2_cb_size, int partIdx)
1671{
1f821750
AK
1672 static const int pred_indices[] = {
1673 [4] = 0, [8] = 1, [12] = 2, [16] = 3, [24] = 4, [32] = 5, [48] = 6, [64] = 7,
1674 };
1675 const int pred_idx = pred_indices[nPbW];
1676
064698d3 1677#define POS(c_idx, x, y) \
b11acd57
AK
1678 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1679 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
064698d3
GM
1680 HEVCLocalContext *lc = &s->HEVClc;
1681 int merge_idx = 0;
1682 struct MvField current_mv = {{{ 0 }}};
1683
b11acd57 1684 int min_pu_width = s->ps.sps->min_pu_width;
064698d3
GM
1685
1686 MvField *tab_mvf = s->ref->tab_mvf;
1687 RefPicList *refPicList = s->ref->refPicList;
1688 HEVCFrame *ref0, *ref1;
1689
ba479f3d 1690 ptrdiff_t tmpstride = MAX_PB_SIZE * sizeof(int16_t);
064698d3
GM
1691
1692 uint8_t *dst0 = POS(0, x0, y0);
1693 uint8_t *dst1 = POS(1, x0, y0);
1694 uint8_t *dst2 = POS(2, x0, y0);
b11acd57
AK
1695 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1696 int min_cb_width = s->ps.sps->min_cb_width;
064698d3
GM
1697 int x_cb = x0 >> log2_min_cb_size;
1698 int y_cb = y0 >> log2_min_cb_size;
064698d3
GM
1699 int x_pu, y_pu;
1700 int i, j;
1701
a7b365ae
AK
1702 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1703
1704 if (!skip_flag)
1705 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1706
1707 if (skip_flag || lc->pu.merge_flag) {
064698d3
GM
1708 if (s->sh.max_num_merge_cand > 1)
1709 merge_idx = ff_hevc_merge_idx_decode(s);
1710 else
1711 merge_idx = 0;
1712
a7b365ae
AK
1713 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1714 partIdx, merge_idx, &current_mv);
a7b365ae 1715 } else {
cd975d56
LB
1716 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1717 partIdx, merge_idx, &current_mv);
84c0ece5 1718 }
a7b365ae 1719
b11acd57
AK
1720 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1721 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
a7b365ae 1722
b11acd57
AK
1723 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1724 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
84c0ece5 1725 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
064698d3
GM
1726
1727 if (current_mv.pred_flag[0]) {
1728 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1729 if (!ref0)
1730 return;
1731 hevc_await_progress(s, ref0, &current_mv.mv[0], y0, nPbH);
1732 }
1733 if (current_mv.pred_flag[1]) {
1734 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1735 if (!ref1)
1736 return;
1737 hevc_await_progress(s, ref1, &current_mv.mv[1], y0, nPbH);
1738 }
1739
1740 if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1741 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1742 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1743
1744 luma_mc(s, tmp, tmpstride, ref0->frame,
1f821750 1745 &current_mv.mv[0], x0, y0, nPbW, nPbH, pred_idx);
064698d3 1746
b11acd57
AK
1747 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1748 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
68841739
AK
1749 s->hevcdsp.weighted_pred[pred_idx](s->sh.luma_log2_weight_denom,
1750 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1751 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1752 dst0, s->frame->linesize[0], tmp,
1753 tmpstride, nPbH);
064698d3 1754 } else {
68841739 1755 s->hevcdsp.put_unweighted_pred[pred_idx](dst0, s->frame->linesize[0], tmp, tmpstride, nPbH);
064698d3
GM
1756 }
1757 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
818bfe7f 1758 &current_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
064698d3 1759
b11acd57
AK
1760 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1761 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
68841739
AK
1762 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1763 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1764 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1765 dst1, s->frame->linesize[1], tmp, tmpstride,
1766 nPbH / 2);
1767 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1768 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1769 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1770 dst2, s->frame->linesize[2], tmp2, tmpstride,
1771 nPbH / 2);
064698d3 1772 } else {
68841739
AK
1773 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst1, s->frame->linesize[1], tmp, tmpstride, nPbH / 2);
1774 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst2, s->frame->linesize[2], tmp2, tmpstride, nPbH / 2);
064698d3
GM
1775 }
1776 } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1777 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1778 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1779
064698d3 1780 luma_mc(s, tmp, tmpstride, ref1->frame,
1f821750 1781 &current_mv.mv[1], x0, y0, nPbW, nPbH, pred_idx);
064698d3 1782
b11acd57
AK
1783 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1784 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
68841739
AK
1785 s->hevcdsp.weighted_pred[pred_idx](s->sh.luma_log2_weight_denom,
1786 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1787 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1788 dst0, s->frame->linesize[0], tmp, tmpstride,
1789 nPbH);
064698d3 1790 } else {
68841739 1791 s->hevcdsp.put_unweighted_pred[pred_idx](dst0, s->frame->linesize[0], tmp, tmpstride, nPbH);
064698d3
GM
1792 }
1793
1794 chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
818bfe7f 1795 &current_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
064698d3 1796
b11acd57
AK
1797 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1798 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
68841739
AK
1799 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1800 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1801 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1802 dst1, s->frame->linesize[1], tmp, tmpstride, nPbH/2);
1803 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1804 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1805 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1806 dst2, s->frame->linesize[2], tmp2, tmpstride, nPbH/2);
064698d3 1807 } else {
68841739
AK
1808 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst1, s->frame->linesize[1], tmp, tmpstride, nPbH / 2);
1809 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst2, s->frame->linesize[2], tmp2, tmpstride, nPbH / 2);
064698d3
GM
1810 }
1811 } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1812 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1813 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1814 DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1815 DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
064698d3
GM
1816
1817 luma_mc(s, tmp, tmpstride, ref0->frame,
1f821750 1818 &current_mv.mv[0], x0, y0, nPbW, nPbH, pred_idx);
064698d3 1819 luma_mc(s, tmp2, tmpstride, ref1->frame,
1f821750 1820 &current_mv.mv[1], x0, y0, nPbW, nPbH, pred_idx);
064698d3 1821
b11acd57
AK
1822 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1823 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
68841739
AK
1824 s->hevcdsp.weighted_pred_avg[pred_idx](s->sh.luma_log2_weight_denom,
1825 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1826 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1827 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1828 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1829 dst0, s->frame->linesize[0],
1830 tmp, tmp2, tmpstride, nPbH);
064698d3 1831 } else {
68841739
AK
1832 s->hevcdsp.put_unweighted_pred_avg[pred_idx](dst0, s->frame->linesize[0],
1833 tmp, tmp2, tmpstride, nPbH);
064698d3
GM
1834 }
1835
1836 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
818bfe7f 1837 &current_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
064698d3 1838 chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
818bfe7f 1839 &current_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
064698d3 1840
b11acd57
AK
1841 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1842 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
68841739
AK
1843 s->hevcdsp.weighted_pred_avg_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1844 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1845 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1846 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1847 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1848 dst1, s->frame->linesize[1], tmp, tmp3,
1849 tmpstride, nPbH / 2);
1850 s->hevcdsp.weighted_pred_avg_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1851 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1852 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1853 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1854 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1855 dst2, s->frame->linesize[2], tmp2, tmp4,
1856 tmpstride, nPbH / 2);
064698d3 1857 } else {
68841739
AK
1858 s->hevcdsp.put_unweighted_pred_avg_chroma[pred_idx](dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbH/2);
1859 s->hevcdsp.put_unweighted_pred_avg_chroma[pred_idx](dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbH/2);
064698d3
GM
1860 }
1861 }
1862}
1863
1864/**
1865 * 8.4.1
1866 */
1867static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1868 int prev_intra_luma_pred_flag)
1869{
1870 HEVCLocalContext *lc = &s->HEVClc;
b11acd57
AK
1871 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1872 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1873 int min_pu_width = s->ps.sps->min_pu_width;
1874 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1875 int x0b = x0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
1876 int y0b = y0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
064698d3
GM
1877
1878 int cand_up = (lc->ctb_up_flag || y0b) ?
1879 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1880 int cand_left = (lc->ctb_left_flag || x0b) ?
1881 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1882
b11acd57 1883 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
064698d3
GM
1884
1885 MvField *tab_mvf = s->ref->tab_mvf;
1886 int intra_pred_mode;
1887 int candidate[3];
1888 int i, j;
1889
1890 // intra_pred_mode prediction does not cross vertical CTB boundaries
1891 if ((y0 - 1) < y_ctb)
1892 cand_up = INTRA_DC;
1893
1894 if (cand_left == cand_up) {
1895 if (cand_left < 2) {
1896 candidate[0] = INTRA_PLANAR;
1897 candidate[1] = INTRA_DC;
1898 candidate[2] = INTRA_ANGULAR_26;
1899 } else {
1900 candidate[0] = cand_left;
1901 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1902 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1903 }
1904 } else {
1905 candidate[0] = cand_left;
1906 candidate[1] = cand_up;
1907 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1908 candidate[2] = INTRA_PLANAR;
1909 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1910 candidate[2] = INTRA_DC;
1911 } else {
1912 candidate[2] = INTRA_ANGULAR_26;
1913 }
1914 }
1915
1916 if (prev_intra_luma_pred_flag) {
1917 intra_pred_mode = candidate[lc->pu.mpm_idx];
1918 } else {
1919 if (candidate[0] > candidate[1])
1920 FFSWAP(uint8_t, candidate[0], candidate[1]);
1921 if (candidate[0] > candidate[2])
1922 FFSWAP(uint8_t, candidate[0], candidate[2]);
1923 if (candidate[1] > candidate[2])
1924 FFSWAP(uint8_t, candidate[1], candidate[2]);
1925
1926 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1927 for (i = 0; i < 3; i++)
1928 if (intra_pred_mode >= candidate[i])
1929 intra_pred_mode++;
1930 }
1931
1932 /* write the intra prediction units into the mv array */
1933 if (!size_in_pus)
1934 size_in_pus = 1;
1935 for (i = 0; i < size_in_pus; i++) {
1936 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1937 intra_pred_mode, size_in_pus);
1938
1939 for (j = 0; j < size_in_pus; j++) {
1940 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1941 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1942 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1943 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1944 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1945 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1946 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1947 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1948 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1949 }
1950 }
1951
1952 return intra_pred_mode;
1953}
1954
1955static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1956 int log2_cb_size, int ct_depth)
1957{
b11acd57
AK
1958 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1959 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
1960 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
064698d3
GM
1961 int y;
1962
1963 for (y = 0; y < length; y++)
b11acd57 1964 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
064698d3
GM
1965 ct_depth, length);
1966}
1967
1968static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1969 int log2_cb_size)
1970{
1971 HEVCLocalContext *lc = &s->HEVClc;
1972 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1973 uint8_t prev_intra_luma_pred_flag[4];
1974 int split = lc->cu.part_mode == PART_NxN;
1975 int pb_size = (1 << log2_cb_size) >> split;
1976 int side = split + 1;
1977 int chroma_mode;
1978 int i, j;
1979
1980 for (i = 0; i < side; i++)
1981 for (j = 0; j < side; j++)
1982 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1983
1984 for (i = 0; i < side; i++) {
1985 for (j = 0; j < side; j++) {
1986 if (prev_intra_luma_pred_flag[2 * i + j])
1987 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1988 else
1989 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1990
1991 lc->pu.intra_pred_mode[2 * i + j] =
1992 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1993 prev_intra_luma_pred_flag[2 * i + j]);
1994 }
1995 }
1996
1997 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1998 if (chroma_mode != 4) {
1999 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2000 lc->pu.intra_pred_mode_c = 34;
2001 else
2002 lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
2003 } else {
2004 lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
2005 }
2006}
2007
2008static void intra_prediction_unit_default_value(HEVCContext *s,
2009 int x0, int y0,
2010 int log2_cb_size)
2011{
2012 HEVCLocalContext *lc = &s->HEVClc;
2013 int pb_size = 1 << log2_cb_size;
b11acd57
AK
2014 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
2015 int min_pu_width = s->ps.sps->min_pu_width;
064698d3 2016 MvField *tab_mvf = s->ref->tab_mvf;
b11acd57
AK
2017 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2018 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
064698d3
GM
2019 int j, k;
2020
2021 if (size_in_pus == 0)
2022 size_in_pus = 1;
2023 for (j = 0; j < size_in_pus; j++) {
2024 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2025 for (k = 0; k < size_in_pus; k++)
2026 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
2027 }
2028}
2029
2030static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2031{
2032 int cb_size = 1 << log2_cb_size;
2033 HEVCLocalContext *lc = &s->HEVClc;
b11acd57 2034 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
064698d3 2035 int length = cb_size >> log2_min_cb_size;
b11acd57 2036 int min_cb_width = s->ps.sps->min_cb_width;
064698d3
GM
2037 int x_cb = x0 >> log2_min_cb_size;
2038 int y_cb = y0 >> log2_min_cb_size;
e22ebd04 2039 int x, y, ret;
064698d3
GM
2040
2041 lc->cu.x = x0;
2042 lc->cu.y = y0;
064698d3
GM
2043 lc->cu.pred_mode = MODE_INTRA;
2044 lc->cu.part_mode = PART_2Nx2N;
2045 lc->cu.intra_split_flag = 0;
064698d3
GM
2046
2047 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2048 for (x = 0; x < 4; x++)
2049 lc->pu.intra_pred_mode[x] = 1;
b11acd57 2050 if (s->ps.pps->transquant_bypass_enable_flag) {
064698d3
GM
2051 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2052 if (lc->cu.cu_transquant_bypass_flag)
2053 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2054 } else
2055 lc->cu.cu_transquant_bypass_flag = 0;
2056
2057 if (s->sh.slice_type != I_SLICE) {
2058 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2059
064698d3
GM
2060 x = y_cb * min_cb_width + x_cb;
2061 for (y = 0; y < length; y++) {
2062 memset(&s->skip_flag[x], skip_flag, length);
2063 x += min_cb_width;
2064 }
2065 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2066 }
2067
2068 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2069 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2070 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2071
2072 if (!s->sh.disable_deblocking_filter_flag)
70211539 2073 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
064698d3 2074 } else {
920bca3e
AK
2075 int pcm_flag = 0;
2076
064698d3
GM
2077 if (s->sh.slice_type != I_SLICE)
2078 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2079 if (lc->cu.pred_mode != MODE_INTRA ||
b11acd57 2080 log2_cb_size == s->ps.sps->log2_min_cb_size) {
064698d3
GM
2081 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2082 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2083 lc->cu.pred_mode == MODE_INTRA;
2084 }
2085
2086 if (lc->cu.pred_mode == MODE_INTRA) {
b11acd57
AK
2087 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2088 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2089 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
920bca3e 2090 pcm_flag = ff_hevc_pcm_flag_decode(s);
064698d3 2091 }
920bca3e 2092 if (pcm_flag) {
064698d3
GM
2093 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2094 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
b11acd57 2095 if (s->ps.sps->pcm.loop_filter_disable_flag)
064698d3
GM
2096 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2097
2098 if (ret < 0)
2099 return ret;
2100 } else {
2101 intra_prediction_unit(s, x0, y0, log2_cb_size);
2102 }
2103 } else {
2104 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2105 switch (lc->cu.part_mode) {
2106 case PART_2Nx2N:
2107 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2108 break;
2109 case PART_2NxN:
2110 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0);
2111 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1);
2112 break;
2113 case PART_Nx2N:
2114 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0);
2115 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1);
2116 break;
2117 case PART_2NxnU:
2118 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0);
2119 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1);
2120 break;
2121 case PART_2NxnD:
2122 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0);
2123 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1);
2124 break;
2125 case PART_nLx2N:
2126 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0);
2127 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1);
2128 break;
2129 case PART_nRx2N:
2130 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0);
2131 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1);
2132 break;
2133 case PART_NxN:
2134 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0);
2135 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1);
2136 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2);
2137 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2138 break;
2139 }
2140 }
2141
920bca3e 2142 if (!pcm_flag) {
2c6a7f93
AK
2143 int rqt_root_cbf = 1;
2144
064698d3
GM
2145 if (lc->cu.pred_mode != MODE_INTRA &&
2146 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2c6a7f93 2147 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
064698d3 2148 }
2c6a7f93 2149 if (rqt_root_cbf) {
064698d3 2150 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
b11acd57
AK
2151 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2152 s->ps.sps->max_transform_hierarchy_depth_inter;
e22ebd04
LB
2153 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2154 log2_cb_size,
4aa80808 2155 log2_cb_size, 0, 0, 0, 0);
e22ebd04
LB
2156 if (ret < 0)
2157 return ret;
064698d3
GM
2158 } else {
2159 if (!s->sh.disable_deblocking_filter_flag)
70211539 2160 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
064698d3
GM
2161 }
2162 }
2163 }
2164
b11acd57 2165 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
064698d3
GM
2166 ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2167
2168 x = y_cb * min_cb_width + x_cb;
2169 for (y = 0; y < length; y++) {
2170 memset(&s->qp_y_tab[x], lc->qp_y, length);
2171 x += min_cb_width;
2172 }
2173
2174 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2175
2176 return 0;
2177}
2178
2179static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2180 int log2_cb_size, int cb_depth)
2181{
2182 HEVCLocalContext *lc = &s->HEVClc;
2183 const int cb_size = 1 << log2_cb_size;
e36a2f4c 2184 int split_cu;
064698d3
GM
2185
2186 lc->ct.depth = cb_depth;
b11acd57
AK
2187 if (x0 + cb_size <= s->ps.sps->width &&
2188 y0 + cb_size <= s->ps.sps->height &&
2189 log2_cb_size > s->ps.sps->log2_min_cb_size) {
e36a2f4c 2190 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
064698d3 2191 } else {
b11acd57 2192 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
064698d3 2193 }
b11acd57
AK
2194 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2195 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
064698d3
GM
2196 lc->tu.is_cu_qp_delta_coded = 0;
2197 lc->tu.cu_qp_delta = 0;
2198 }
2199
e36a2f4c 2200 if (split_cu) {
064698d3
GM
2201 const int cb_size_split = cb_size >> 1;
2202 const int x1 = x0 + cb_size_split;
2203 const int y1 = y0 + cb_size_split;
2204
2205 log2_cb_size--;
2206 cb_depth++;
2207
2208#define SUBDIVIDE(x, y) \
2209do { \
b11acd57 2210 if (x < s->ps.sps->width && y < s->ps.sps->height) { \
064698d3
GM
2211 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2212 if (ret < 0) \
2213 return ret; \
2214 } \
2215} while (0)
2216
2217 SUBDIVIDE(x0, y0);
2218 SUBDIVIDE(x1, y0);
2219 SUBDIVIDE(x0, y1);
2220 SUBDIVIDE(x1, y1);
2221 } else {
2222 int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2223 if (ret < 0)
2224 return ret;
2225 }
2226
2227 return 0;
2228}
2229
2230static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2231 int ctb_addr_ts)
2232{
2233 HEVCLocalContext *lc = &s->HEVClc;
b11acd57
AK
2234 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2235 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
064698d3
GM
2236 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2237
064698d3
GM
2238 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2239
b11acd57 2240 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
064698d3
GM
2241 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2242 lc->first_qp_group = 1;
b11acd57
AK
2243 lc->end_of_tiles_x = s->ps.sps->width;
2244 } else if (s->ps.pps->tiles_enabled_flag) {
2245 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2246 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
064698d3 2247 lc->start_of_tiles_x = x_ctb;
b11acd57 2248 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
064698d3
GM
2249 lc->first_qp_group = 1;
2250 }
2251 } else {
b11acd57 2252 lc->end_of_tiles_x = s->ps.sps->width;
064698d3
GM
2253 }
2254
b11acd57 2255 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
064698d3 2256
70211539 2257 lc->boundary_flags = 0;
b11acd57
AK
2258 if (s->ps.pps->tiles_enabled_flag) {
2259 if (x_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
70211539
AK
2260 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2261 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2262 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
b11acd57 2263 if (y_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->ps.sps->ctb_width]])
70211539 2264 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
b11acd57 2265 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
70211539 2266 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
064698d3 2267 } else {
b8b13acd 2268 if (!ctb_addr_in_slice)
70211539 2269 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
b11acd57 2270 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
70211539 2271 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
064698d3 2272 }
70211539
AK
2273
2274 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
b11acd57
AK
2275 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2276 lc->ctb_up_right_flag = ((y_ctb > 0) && (ctb_addr_in_slice+1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 - s->ps.sps->ctb_width]]));
2277 lc->ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0) && (ctb_addr_in_slice-1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 - s->ps.sps->ctb_width]]));
064698d3
GM
2278}
2279
2280static int hls_slice_data(HEVCContext *s)
2281{
b11acd57 2282 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
064698d3
GM
2283 int more_data = 1;
2284 int x_ctb = 0;
2285 int y_ctb = 0;
b11acd57 2286 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
064698d3
GM
2287 int ret;
2288
b11acd57
AK
2289 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2290 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
064698d3 2291
b11acd57
AK
2292 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2293 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
064698d3
GM
2294 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2295
2296 ff_hevc_cabac_init(s, ctb_addr_ts);
2297
b11acd57 2298 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
064698d3
GM
2299
2300 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2301 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2302 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2303
b11acd57 2304 ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
064698d3
GM
2305 if (ret < 0)
2306 return ret;
2307 more_data = !ff_hevc_end_of_slice_flag_decode(s);
2308
2309 ctb_addr_ts++;
2310 ff_hevc_save_states(s, ctb_addr_ts);
2311 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2312 }
2313
b11acd57
AK
2314 if (x_ctb + ctb_size >= s->ps.sps->width &&
2315 y_ctb + ctb_size >= s->ps.sps->height)
064698d3
GM
2316 ff_hevc_hls_filter(s, x_ctb, y_ctb);
2317
2318 return ctb_addr_ts;
2319}
2320
064698d3
GM
2321static void restore_tqb_pixels(HEVCContext *s)
2322{
b11acd57 2323 int min_pu_size = 1 << s->ps.sps->log2_min_pu_size;
064698d3
GM
2324 int x, y, c_idx;
2325
2326 for (c_idx = 0; c_idx < 3; c_idx++) {
2327 ptrdiff_t stride = s->frame->linesize[c_idx];
b11acd57
AK
2328 int hshift = s->ps.sps->hshift[c_idx];
2329 int vshift = s->ps.sps->vshift[c_idx];
2330 for (y = 0; y < s->ps.sps->min_pu_height; y++) {
2331 for (x = 0; x < s->ps.sps->min_pu_width; x++) {
2332 if (s->is_pcm[y * s->ps.sps->min_pu_width + x]) {
064698d3
GM
2333 int n;
2334 int len = min_pu_size >> hshift;
b11acd57
AK
2335 uint8_t *src = &s->frame->data[c_idx][((y << s->ps.sps->log2_min_pu_size) >> vshift) * stride + (((x << s->ps.sps->log2_min_pu_size) >> hshift) << s->ps.sps->pixel_shift)];
2336 uint8_t *dst = &s->sao_frame->data[c_idx][((y << s->ps.sps->log2_min_pu_size) >> vshift) * stride + (((x << s->ps.sps->log2_min_pu_size) >> hshift) << s->ps.sps->pixel_shift)];
064698d3
GM
2337 for (n = 0; n < (min_pu_size >> vshift); n++) {
2338 memcpy(dst, src, len);
2339 src += stride;
2340 dst += stride;
2341 }
2342 }
2343 }
2344 }
2345 }
2346}
2347
acb77dff
VG
2348static int set_side_data(HEVCContext *s)
2349{
2350 AVFrame *out = s->ref->frame;
2351
2352 if (s->sei_frame_packing_present &&
2353 s->frame_packing_arrangement_type >= 3 &&
2354 s->frame_packing_arrangement_type <= 5 &&
2355 s->content_interpretation_type > 0 &&
2356 s->content_interpretation_type < 3) {
2357 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2358 if (!stereo)
2359 return AVERROR(ENOMEM);
2360
2361 switch (s->frame_packing_arrangement_type) {
2362 case 3:
2363 if (s->quincunx_subsampling)
2364 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2365 else
2366 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2367 break;
2368 case 4:
2369 stereo->type = AV_STEREO3D_TOPBOTTOM;
2370 break;
2371 case 5:
2372 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2373 break;
2374 }
2375
2376 if (s->content_interpretation_type == 2)
2377 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2378 }
2379
0569a7e0
VG
2380 if (s->sei_display_orientation_present &&
2381 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2382 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2383 AVFrameSideData *rotation = av_frame_new_side_data(out,
2384 AV_FRAME_DATA_DISPLAYMATRIX,
2385 sizeof(int32_t) * 9);
2386 if (!rotation)
2387 return AVERROR(ENOMEM);
2388
2389 av_display_rotation_set((int32_t *)rotation->data, angle);
2390 av_display_matrix_flip((int32_t *)rotation->data,
b1b1a737 2391 s->sei_hflip, s->sei_vflip);
0569a7e0
VG
2392 }
2393
acb77dff
VG
2394 return 0;
2395}
2396
064698d3
GM
2397static int hevc_frame_start(HEVCContext *s)
2398{
2399 HEVCLocalContext *lc = &s->HEVClc;
2400 int ret;
2401
2402 memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2403 memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
b11acd57
AK
2404 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2405 memset(s->is_pcm, 0, s->ps.sps->min_pu_width * s->ps.sps->min_pu_height);
064698d3
GM
2406
2407 lc->start_of_tiles_x = 0;
2408 s->is_decoded = 0;
b25e84b7 2409 s->first_nal_type = s->nal_unit_type;
064698d3 2410
b11acd57
AK
2411 if (s->ps.pps->tiles_enabled_flag)
2412 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
064698d3 2413
b11acd57 2414 ret = ff_hevc_set_new_ref(s, s->ps.sps->sao_enabled ? &s->sao_frame : &s->frame,
064698d3
GM
2415 s->poc);
2416 if (ret < 0)
2417 goto fail;
2418
064698d3
GM
2419 ret = ff_hevc_frame_rps(s);
2420 if (ret < 0) {
2421 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2422 goto fail;
2423 }
2424
f43789b7
MR
2425 s->ref->frame->key_frame = IS_IRAP(s);
2426
acb77dff
VG
2427 ret = set_side_data(s);
2428 if (ret < 0)
2429 goto fail;
2430
064698d3
GM
2431 av_frame_unref(s->output_frame);
2432 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2433 if (ret < 0)
2434 goto fail;
2435
2436 ff_thread_finish_setup(s->avctx);
2437
2438 return 0;
2439
2440fail:
2441 if (s->ref)
443b7192 2442 ff_hevc_unref_frame(s, s->ref, ~0);
064698d3
GM
2443 s->ref = NULL;
2444 return ret;
2445}
2446
fa936a30 2447static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
064698d3
GM
2448{
2449 HEVCLocalContext *lc = &s->HEVClc;
2450 GetBitContext *gb = &lc->gb;
2451 int ctb_addr_ts, ret;
2452
ae05b486
AK
2453 *gb = nal->gb;
2454 s->nal_unit_type = nal->type;
2455 s->temporal_id = nal->temporal_id;
064698d3
GM
2456
2457 switch (s->nal_unit_type) {
2458 case NAL_VPS:
b11acd57 2459 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
064698d3 2460 if (ret < 0)
521726ff 2461 goto fail;
064698d3
GM
2462 break;
2463 case NAL_SPS:
b11acd57
AK
2464 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2465 s->apply_defdispwin);
064698d3 2466 if (ret < 0)
521726ff 2467 goto fail;
064698d3
GM
2468 break;
2469 case NAL_PPS:
b11acd57 2470 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
064698d3 2471 if (ret < 0)
521726ff 2472 goto fail;
064698d3
GM
2473 break;
2474 case NAL_SEI_PREFIX:
2475 case NAL_SEI_SUFFIX:
2476 ret = ff_hevc_decode_nal_sei(s);
2477 if (ret < 0)
521726ff 2478 goto fail;
064698d3
GM
2479 break;
2480 case NAL_TRAIL_R:
2481 case NAL_TRAIL_N:
2482 case NAL_TSA_N:
2483 case NAL_TSA_R:
2484 case NAL_STSA_N:
2485 case NAL_STSA_R:
2486 case NAL_BLA_W_LP:
2487 case NAL_BLA_W_RADL:
2488 case NAL_BLA_N_LP:
2489 case NAL_IDR_W_RADL:
2490 case NAL_IDR_N_LP:
2491 case NAL_CRA_NUT:
2492 case NAL_RADL_N:
2493 case NAL_RADL_R:
2494 case NAL_RASL_N:
2495 case NAL_RASL_R:
2496 ret = hls_slice_header(s);
2497 if (ret < 0)
2498 return ret;
2499
2500 if (s->max_ra == INT_MAX) {
2501 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2502 s->max_ra = s->poc;
2503 } else {
2504 if (IS_IDR(s))
2505 s->max_ra = INT_MIN;
2506 }
2507 }
2508
2509 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2510 s->poc <= s->max_ra) {
2511 s->is_decoded = 0;
2512 break;
2513 } else {
2514 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2515 s->max_ra = INT_MIN;
2516 }
2517
2518 if (s->sh.first_slice_in_pic_flag) {
2519 ret = hevc_frame_start(s);
2520 if (ret < 0)
2521 return ret;
2522 } else if (!s->ref) {
2523 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
521726ff 2524 goto fail;
064698d3
GM
2525 }
2526
b25e84b7
AK
2527 if (s->nal_unit_type != s->first_nal_type) {
2528 av_log(s->avctx, AV_LOG_ERROR,
2529 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2530 s->first_nal_type, s->nal_unit_type);
2531 return AVERROR_INVALIDDATA;
2532 }
2533
064698d3
GM
2534 if (!s->sh.dependent_slice_segment_flag &&
2535 s->sh.slice_type != I_SLICE) {
2536 ret = ff_hevc_slice_rpl(s);
2537 if (ret < 0) {
2538 av_log(s->avctx, AV_LOG_WARNING,
2539 "Error constructing the reference lists for the current slice.\n");
521726ff 2540 goto fail;
064698d3
GM
2541 }
2542 }
2543
e72e8c5a
HL
2544 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2545 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2546 if (ret < 0)
2547 goto fail;
2548 }
2549
2550 if (s->avctx->hwaccel) {
2551 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2552 if (ret < 0)
2553 goto fail;
2554 } else {
b82722df 2555 ctb_addr_ts = hls_slice_data(s);
b11acd57 2556 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
b82722df 2557 s->is_decoded = 1;
b11acd57
AK
2558 if ((s->ps.pps->transquant_bypass_enable_flag ||
2559 (s->ps.sps->pcm.loop_filter_disable_flag && s->ps.sps->pcm_enabled_flag)) &&
2560 s->ps.sps->sao_enabled)
b82722df
HL
2561 restore_tqb_pixels(s);
2562 }
064698d3 2563
b82722df
HL
2564 if (ctb_addr_ts < 0) {
2565 ret = ctb_addr_ts;
2566 goto fail;
2567 }
e72e8c5a 2568 }
064698d3
GM
2569 break;
2570 case NAL_EOS_NUT:
2571 case NAL_EOB_NUT:
2572 s->seq_decode = (s->seq_decode + 1) & 0xff;
2573 s->max_ra = INT_MAX;
2574 break;
2575 case NAL_AUD:
2576 case NAL_FD_NUT:
2577 break;
2578 default:
2579 av_log(s->avctx, AV_LOG_INFO,
2580 "Skipping NAL unit %d\n", s->nal_unit_type);
2581 }
2582
2583 return 0;
521726ff
LB
2584fail:
2585 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2586 return ret;
2587 return 0;
064698d3
GM
2588}
2589
064698d3
GM
2590static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2591{
d82e1adc 2592 int i, ret = 0;
064698d3
GM
2593
2594 s->ref = NULL;
2595 s->eos = 0;
2596
2597 /* split the input packet into NAL units, so we know the upper bound on the
2598 * number of slices in the frame */
fa936a30 2599 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
b667252a 2600 s->nal_length_size, s->avctx->codec_id);
d82e1adc
AK
2601 if (ret < 0) {
2602 av_log(s->avctx, AV_LOG_ERROR,
2603 "Error splitting the input into NAL units.\n");
2604 return ret;
2605 }
064698d3 2606
d82e1adc
AK
2607 for (i = 0; i < s->pkt.nb_nals; i++) {
2608 if (s->pkt.nals[i].type == NAL_EOB_NUT ||
2609 s->pkt.nals[i].type == NAL_EOS_NUT)
064698d3 2610 s->eos = 1;
064698d3
GM
2611 }
2612
7f78155d 2613 /* decode the NAL units */
d82e1adc
AK
2614 for (i = 0; i < s->pkt.nb_nals; i++) {
2615 ret = decode_nal_unit(s, &s->pkt.nals[i]);
064698d3
GM
2616 if (ret < 0) {
2617 av_log(s->avctx, AV_LOG_WARNING,
2618 "Error parsing NAL unit #%d.\n", i);
521726ff 2619 goto fail;
064698d3
GM
2620 }
2621 }
2622
2623fail:
2624 if (s->ref)
2625 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2626
2627 return ret;
2628}
2629
2630static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2631{
2632 int i;
2633 for (i = 0; i < 16; i++)
2634 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2635}
2636
2637static int verify_md5(HEVCContext *s, AVFrame *frame)
2638{
2639 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
b769cf4b 2640 int pixel_shift;
064698d3
GM
2641 int i, j;
2642
2643 if (!desc)
2644 return AVERROR(EINVAL);
2645
2268db2c 2646 pixel_shift = desc->comp[0].depth > 8;
b769cf4b 2647
064698d3
GM
2648 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2649 s->poc);
2650
2651 /* the checksums are LE, so we have to byteswap for >8bpp formats
2652 * on BE arches */
2653#if HAVE_BIGENDIAN
2654 if (pixel_shift && !s->checksum_buf) {
2655 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2656 FFMAX3(frame->linesize[0], frame->linesize[1],
2657 frame->linesize[2]));
2658 if (!s->checksum_buf)
2659 return AVERROR(ENOMEM);
2660 }
2661#endif
2662
2663 for (i = 0; frame->data[i]; i++) {
2664 int width = s->avctx->coded_width;
2665 int height = s->avctx->coded_height;
2666 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2667 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2668 uint8_t md5[16];
2669
2670 av_md5_init(s->md5_ctx);
2671 for (j = 0; j < h; j++) {
2672 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2673#if HAVE_BIGENDIAN
2674 if (pixel_shift) {
c67b449b
DB
2675 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2676 (const uint16_t *) src, w);
064698d3
GM
2677 src = s->checksum_buf;
2678 }
2679#endif
2680 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2681 }
2682 av_md5_final(s->md5_ctx, md5);
2683
2684 if (!memcmp(md5, s->md5[i], 16)) {
2685 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2686 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2687 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2688 } else {
2689 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2690 print_md5(s->avctx, AV_LOG_ERROR, md5);
2691 av_log (s->avctx, AV_LOG_ERROR, " != ");
2692 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2693 av_log (s->avctx, AV_LOG_ERROR, "\n");
2694 return AVERROR_INVALIDDATA;
2695 }
2696 }
2697
2698 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2699
2700 return 0;
2701}
2702
2703static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2704 AVPacket *avpkt)
2705{
2706 int ret;
2707 HEVCContext *s = avctx->priv_data;
2708
2709 if (!avpkt->size) {
2710 ret = ff_hevc_output_frame(s, data, 1);
2711 if (ret < 0)
2712 return ret;
2713
2714 *got_output = ret;
2715 return 0;
2716 }
2717
2718 s->ref = NULL;
2719 ret = decode_nal_units(s, avpkt->data, avpkt->size);
2720 if (ret < 0)
2721 return ret;
2722
e72e8c5a
HL
2723 if (avctx->hwaccel) {
2724 if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
2725 av_log(avctx, AV_LOG_ERROR,
2726 "hardware accelerator failed to decode picture\n");
2727 } else {
b82722df
HL
2728 /* verify the SEI checksum */
2729 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2730 s->is_md5) {
2731 ret = verify_md5(s, s->ref->frame);
2732 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2733 ff_hevc_unref_frame(s, s->ref, ~0);
2734 return ret;
2735 }
064698d3
GM
2736 }
2737 }
2738 s->is_md5 = 0;
2739
2740 if (s->is_decoded) {
2741 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2742 s->is_decoded = 0;
2743 }
2744
2745 if (s->output_frame->buf[0]) {
2746 av_frame_move_ref(data, s->output_frame);
2747 *got_output = 1;
2748 }
2749
2750 return avpkt->size;
2751}
2752
2753static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2754{
2755 int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2756 if (ret < 0)
2757 return ret;
2758
2759 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2760 if (!dst->tab_mvf_buf)
2761 goto fail;
2762 dst->tab_mvf = src->tab_mvf;
2763
2764 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2765 if (!dst->rpl_tab_buf)
2766 goto fail;
2767 dst->rpl_tab = src->rpl_tab;
2768
2769 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2770 if (!dst->rpl_buf)
2771 goto fail;
2772
2773 dst->poc = src->poc;
2774 dst->ctb_count = src->ctb_count;
2775 dst->window = src->window;
2776 dst->flags = src->flags;
2777 dst->sequence = src->sequence;
2778
e72e8c5a
HL
2779 if (src->hwaccel_picture_private) {
2780 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
2781 if (!dst->hwaccel_priv_buf)
2782 goto fail;
2783 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
2784 }
2785
064698d3
GM
2786 return 0;
2787fail:
2788 ff_hevc_unref_frame(s, dst, ~0);
2789 return AVERROR(ENOMEM);
2790}
2791
2792static av_cold int hevc_decode_free(AVCodecContext *avctx)
2793{
2794 HEVCContext *s = avctx->priv_data;
064698d3
GM
2795 int i;
2796
2797 pic_arrays_free(s);
2798
064698d3
GM
2799 av_freep(&s->md5_ctx);
2800
2801 av_frame_free(&s->tmp_frame);
2802 av_frame_free(&s->output_frame);
2803
2804 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2805 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2806 av_frame_free(&s->DPB[i].frame);
2807 }
2808
b11acd57
AK
2809 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
2810 av_buffer_unref(&s->ps.vps_list[i]);
2811 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
2812 av_buffer_unref(&s->ps.sps_list[i]);
2813 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
2814 av_buffer_unref(&s->ps.pps_list[i]);
064698d3 2815
8229eff4 2816 ff_h2645_packet_uninit(&s->pkt);
064698d3
GM
2817
2818 return 0;
2819}
2820
2821static av_cold int hevc_init_context(AVCodecContext *avctx)
2822{
2823 HEVCContext *s = avctx->priv_data;
2824 int i;
2825
2826 s->avctx = avctx;
2827
2828 s->tmp_frame = av_frame_alloc();
2829 if (!s->tmp_frame)
2830 goto fail;
2831
2832 s->output_frame = av_frame_alloc();
2833 if (!s->output_frame)
2834 goto fail;
2835
2836 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2837 s->DPB[i].frame = av_frame_alloc();
2838 if (!s->DPB[i].frame)
2839 goto fail;
2840 s->DPB[i].tf.f = s->DPB[i].frame;
2841 }
2842
2843 s->max_ra = INT_MAX;
2844
2845 s->md5_ctx = av_md5_alloc();
2846 if (!s->md5_ctx)
2847 goto fail;
2848
c67b449b 2849 ff_bswapdsp_init(&s->bdsp);
064698d3
GM
2850
2851 s->context_initialized = 1;
2852
2853 return 0;
2854
2855fail:
2856 hevc_decode_free(avctx);
2857 return AVERROR(ENOMEM);
2858}
2859
2860static int hevc_update_thread_context(AVCodecContext *dst,
2861 const AVCodecContext *src)
2862{
2863 HEVCContext *s = dst->priv_data;
2864 HEVCContext *s0 = src->priv_data;
2865 int i, ret;
2866
2867 if (!s->context_initialized) {
2868 ret = hevc_init_context(dst);
2869 if (ret < 0)
2870 return ret;
2871 }
2872
2873 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2874 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2875 if (s0->DPB[i].frame->buf[0]) {
2876 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
2877 if (ret < 0)
2878 return ret;
2879 }
2880 }
2881
b11acd57
AK
2882 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
2883 av_buffer_unref(&s->ps.vps_list[i]);
2884 if (s0->ps.vps_list[i]) {
2885 s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
2886 if (!s->ps.vps_list[i])
33452aed
GC
2887 return AVERROR(ENOMEM);
2888 }
2889 }
2890
b11acd57
AK
2891 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
2892 av_buffer_unref(&s->ps.sps_list[i]);
2893 if (s0->ps.sps_list[i]) {
2894 s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
2895 if (!s->ps.sps_list[i])
064698d3
GM
2896 return AVERROR(ENOMEM);
2897 }
2898 }
2899
b11acd57
AK
2900 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
2901 av_buffer_unref(&s->ps.pps_list[i]);
2902 if (s0->ps.pps_list[i]) {
2903 s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
2904 if (!s->ps.pps_list[i])
064698d3
GM
2905 return AVERROR(ENOMEM);
2906 }
2907 }
2908
b11acd57
AK
2909 if (s->ps.sps != s0->ps.sps)
2910 ret = set_sps(s, s0->ps.sps);
064698d3
GM
2911
2912 s->seq_decode = s0->seq_decode;
2913 s->seq_output = s0->seq_output;
2914 s->pocTid0 = s0->pocTid0;
2915 s->max_ra = s0->max_ra;
2916
2917 s->is_nalff = s0->is_nalff;
2918 s->nal_length_size = s0->nal_length_size;
2919
2920 if (s0->eos) {
2921 s->seq_decode = (s->seq_decode + 1) & 0xff;
2922 s->max_ra = INT_MAX;
2923 }
2924
2925 return 0;
2926}
2927
2928static int hevc_decode_extradata(HEVCContext *s)
2929{
2930 AVCodecContext *avctx = s->avctx;
2931 GetByteContext gb;
7693ba0a 2932 int ret, i;
064698d3
GM
2933
2934 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
2935
2936 if (avctx->extradata_size > 3 &&
2937 (avctx->extradata[0] || avctx->extradata[1] ||
2938 avctx->extradata[2] > 1)) {
2939 /* It seems the extradata is encoded as hvcC format.
2940 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
2941 * is finalized. When finalized, configurationVersion will be 1 and we
2942 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
2943 int i, j, num_arrays, nal_len_size;
2944
2945 s->is_nalff = 1;
2946
2947 bytestream2_skip(&gb, 21);
2948 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
2949 num_arrays = bytestream2_get_byte(&gb);
2950
2951 /* nal units in the hvcC always have length coded with 2 bytes,
2952 * so put a fake nal_length_size = 2 while parsing them */
2953 s->nal_length_size = 2;
2954
2955 /* Decode nal units from hvcC. */
2956 for (i = 0; i < num_arrays; i++) {
2957 int type = bytestream2_get_byte(&gb) & 0x3f;
2958 int cnt = bytestream2_get_be16(&gb);
2959
2960 for (j = 0; j < cnt; j++) {
2961 // +2 for the nal size field
2962 int nalsize = bytestream2_peek_be16(&gb) + 2;
2963 if (bytestream2_get_bytes_left(&gb) < nalsize) {
2964 av_log(s->avctx, AV_LOG_ERROR,
2965 "Invalid NAL unit size in extradata.\n");
2966 return AVERROR_INVALIDDATA;
2967 }
2968
2969 ret = decode_nal_units(s, gb.buffer, nalsize);
2970 if (ret < 0) {
2971 av_log(avctx, AV_LOG_ERROR,
2972 "Decoding nal unit %d %d from hvcC failed\n",
2973 type, i);
2974 return ret;
2975 }
2976 bytestream2_skip(&gb, nalsize);
2977 }
2978 }
2979
2980 /* Now store right nal length size, that will be used to parse
2981 * all other nals */
2982 s->nal_length_size = nal_len_size;
2983 } else {
2984 s->is_nalff = 0;
2985 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
2986 if (ret < 0)
2987 return ret;
2988 }
7693ba0a
AK
2989
2990 /* export stream parameters from the first SPS */
b11acd57
AK
2991 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
2992 if (s->ps.sps_list[i]) {
2993 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
18156b53 2994 export_stream_params(s->avctx, &s->ps, sps);
7693ba0a
AK
2995 break;
2996 }
2997 }
2998
064698d3
GM
2999 return 0;
3000}
3001
3002static av_cold int hevc_decode_init(AVCodecContext *avctx)
3003{
3004 HEVCContext *s = avctx->priv_data;
3005 int ret;
3006
064698d3
GM
3007 avctx->internal->allocate_progress = 1;
3008
3009 ret = hevc_init_context(avctx);
3010 if (ret < 0)
3011 return ret;
3012
3013 if (avctx->extradata_size > 0 && avctx->extradata) {
3014 ret = hevc_decode_extradata(s);
3015 if (ret < 0) {
3016 hevc_decode_free(avctx);
3017 return ret;
3018 }
3019 }
3020
3021 return 0;
3022}
3023
3024static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3025{
3026 HEVCContext *s = avctx->priv_data;
3027 int ret;
3028
3029 memset(s, 0, sizeof(*s));
3030
3031 ret = hevc_init_context(avctx);
3032 if (ret < 0)
3033 return ret;
3034
3035 return 0;
3036}
3037
3038static void hevc_decode_flush(AVCodecContext *avctx)
3039{
3040 HEVCContext *s = avctx->priv_data;
3041 ff_hevc_flush_dpb(s);
3042 s->max_ra = INT_MAX;
3043}
3044
3045#define OFFSET(x) offsetof(HEVCContext, x)
3046#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
2a41826b 3047
064698d3
GM
3048static const AVOption options[] = {
3049 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3050 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3051 { NULL },
3052};
3053
3054static const AVClass hevc_decoder_class = {
3055 .class_name = "HEVC decoder",
3056 .item_name = av_default_item_name,
3057 .option = options,
3058 .version = LIBAVUTIL_VERSION_INT,
3059};
3060
3061AVCodec ff_hevc_decoder = {
3062 .name = "hevc",
3063 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3064 .type = AVMEDIA_TYPE_VIDEO,
3065 .id = AV_CODEC_ID_HEVC,
3066 .priv_data_size = sizeof(HEVCContext),
3067 .priv_class = &hevc_decoder_class,
3068 .init = hevc_decode_init,
3069 .close = hevc_decode_free,
3070 .decode = hevc_decode_frame,
3071 .flush = hevc_decode_flush,
3072 .update_thread_context = hevc_update_thread_context,
3073 .init_thread_copy = hevc_init_thread_copy,
def97856
VG
3074 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3075 AV_CODEC_CAP_FRAME_THREADS,
2c681139 3076 .profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
064698d3 3077};