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 FFmpeg.
10 *
11 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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"
28 #include "libavutil/display.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/mastering_display_metadata.h"
31 #include "libavutil/md5.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/stereo3d.h"
35
36 #include "bswapdsp.h"
37 #include "bytestream.h"
38 #include "cabac_functions.h"
39 #include "golomb.h"
40 #include "hevc.h"
41 #include "hevc_data.h"
42 #include "hevc_parse.h"
43 #include "hevcdec.h"
44 #include "hwconfig.h"
45 #include "profiles.h"
46
47 const uint8_t ff_hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
48
49 /**
50 * NOTE: Each function hls_foo correspond to the function foo in the
51 * specification (HLS stands for High Level Syntax).
52 */
53
54 /**
55 * Section 5.7
56 */
57
58 /* free everything allocated by pic_arrays_init() */
pic_arrays_free(HEVCContext * s)59 static void pic_arrays_free(HEVCContext *s)
60 {
61 av_freep(&s->sao);
62 av_freep(&s->deblock);
63
64 av_freep(&s->skip_flag);
65 av_freep(&s->tab_ct_depth);
66
67 av_freep(&s->tab_ipm);
68 av_freep(&s->cbf_luma);
69 av_freep(&s->is_pcm);
70
71 av_freep(&s->qp_y_tab);
72 av_freep(&s->tab_slice_address);
73 av_freep(&s->filter_slice_edges);
74
75 av_freep(&s->horizontal_bs);
76 av_freep(&s->vertical_bs);
77
78 av_freep(&s->sh.entry_point_offset);
79 av_freep(&s->sh.size);
80 av_freep(&s->sh.offset);
81
82 av_buffer_pool_uninit(&s->tab_mvf_pool);
83 av_buffer_pool_uninit(&s->rpl_tab_pool);
84 }
85
86 /* allocate arrays that depend on frame dimensions */
pic_arrays_init(HEVCContext * s,const HEVCSPS * sps)87 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
88 {
89 int log2_min_cb_size = sps->log2_min_cb_size;
90 int width = sps->width;
91 int height = sps->height;
92 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
93 ((height >> log2_min_cb_size) + 1);
94 int ctb_count = sps->ctb_width * sps->ctb_height;
95 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
96
97 s->bs_width = (width >> 2) + 1;
98 s->bs_height = (height >> 2) + 1;
99
100 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
101 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
102 if (!s->sao || !s->deblock)
103 goto fail;
104
105 s->skip_flag = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
106 s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
107 if (!s->skip_flag || !s->tab_ct_depth)
108 goto fail;
109
110 s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
111 s->tab_ipm = av_mallocz(min_pu_size);
112 s->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
113 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
114 goto fail;
115
116 s->filter_slice_edges = av_mallocz(ctb_count);
117 s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
118 sizeof(*s->tab_slice_address));
119 s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
120 sizeof(*s->qp_y_tab));
121 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
122 goto fail;
123
124 s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
125 s->vertical_bs = av_mallocz_array(s->bs_width, s->bs_height);
126 if (!s->horizontal_bs || !s->vertical_bs)
127 goto fail;
128
129 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
130 av_buffer_allocz);
131 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
132 av_buffer_allocz);
133 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
134 goto fail;
135
136 return 0;
137
138 fail:
139 pic_arrays_free(s);
140 return AVERROR(ENOMEM);
141 }
142
pred_weight_table(HEVCContext * s,GetBitContext * gb)143 static int pred_weight_table(HEVCContext *s, GetBitContext *gb)
144 {
145 int i = 0;
146 int j = 0;
147 uint8_t luma_weight_l0_flag[16];
148 uint8_t chroma_weight_l0_flag[16];
149 uint8_t luma_weight_l1_flag[16];
150 uint8_t chroma_weight_l1_flag[16];
151 int luma_log2_weight_denom;
152
153 luma_log2_weight_denom = get_ue_golomb_long(gb);
154 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) {
155 av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
156 return AVERROR_INVALIDDATA;
157 }
158 s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
159 if (s->ps.sps->chroma_format_idc != 0) {
160 int64_t chroma_log2_weight_denom = luma_log2_weight_denom + (int64_t)get_se_golomb(gb);
161 if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) {
162 av_log(s->avctx, AV_LOG_ERROR, "chroma_log2_weight_denom %"PRId64" is invalid\n", chroma_log2_weight_denom);
163 return AVERROR_INVALIDDATA;
164 }
165 s->sh.chroma_log2_weight_denom = chroma_log2_weight_denom;
166 }
167
168 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
169 luma_weight_l0_flag[i] = get_bits1(gb);
170 if (!luma_weight_l0_flag[i]) {
171 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
172 s->sh.luma_offset_l0[i] = 0;
173 }
174 }
175 if (s->ps.sps->chroma_format_idc != 0) {
176 for (i = 0; i < s->sh.nb_refs[L0]; i++)
177 chroma_weight_l0_flag[i] = get_bits1(gb);
178 } else {
179 for (i = 0; i < s->sh.nb_refs[L0]; i++)
180 chroma_weight_l0_flag[i] = 0;
181 }
182 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
183 if (luma_weight_l0_flag[i]) {
184 int delta_luma_weight_l0 = get_se_golomb(gb);
185 if ((int8_t)delta_luma_weight_l0 != delta_luma_weight_l0)
186 return AVERROR_INVALIDDATA;
187 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
188 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
189 }
190 if (chroma_weight_l0_flag[i]) {
191 for (j = 0; j < 2; j++) {
192 int delta_chroma_weight_l0 = get_se_golomb(gb);
193 int delta_chroma_offset_l0 = get_se_golomb(gb);
194
195 if ( (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
196 || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
197 return AVERROR_INVALIDDATA;
198 }
199
200 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
201 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
202 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
203 }
204 } else {
205 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
206 s->sh.chroma_offset_l0[i][0] = 0;
207 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
208 s->sh.chroma_offset_l0[i][1] = 0;
209 }
210 }
211 if (s->sh.slice_type == HEVC_SLICE_B) {
212 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
213 luma_weight_l1_flag[i] = get_bits1(gb);
214 if (!luma_weight_l1_flag[i]) {
215 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
216 s->sh.luma_offset_l1[i] = 0;
217 }
218 }
219 if (s->ps.sps->chroma_format_idc != 0) {
220 for (i = 0; i < s->sh.nb_refs[L1]; i++)
221 chroma_weight_l1_flag[i] = get_bits1(gb);
222 } else {
223 for (i = 0; i < s->sh.nb_refs[L1]; i++)
224 chroma_weight_l1_flag[i] = 0;
225 }
226 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
227 if (luma_weight_l1_flag[i]) {
228 int delta_luma_weight_l1 = get_se_golomb(gb);
229 if ((int8_t)delta_luma_weight_l1 != delta_luma_weight_l1)
230 return AVERROR_INVALIDDATA;
231 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
232 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
233 }
234 if (chroma_weight_l1_flag[i]) {
235 for (j = 0; j < 2; j++) {
236 int delta_chroma_weight_l1 = get_se_golomb(gb);
237 int delta_chroma_offset_l1 = get_se_golomb(gb);
238
239 if ( (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
240 || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
241 return AVERROR_INVALIDDATA;
242 }
243
244 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
245 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
246 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
247 }
248 } else {
249 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
250 s->sh.chroma_offset_l1[i][0] = 0;
251 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
252 s->sh.chroma_offset_l1[i][1] = 0;
253 }
254 }
255 }
256 return 0;
257 }
258
decode_lt_rps(HEVCContext * s,LongTermRPS * rps,GetBitContext * gb)259 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
260 {
261 const HEVCSPS *sps = s->ps.sps;
262 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
263 int prev_delta_msb = 0;
264 unsigned int nb_sps = 0, nb_sh;
265 int i;
266
267 rps->nb_refs = 0;
268 if (!sps->long_term_ref_pics_present_flag)
269 return 0;
270
271 if (sps->num_long_term_ref_pics_sps > 0)
272 nb_sps = get_ue_golomb_long(gb);
273 nb_sh = get_ue_golomb_long(gb);
274
275 if (nb_sps > sps->num_long_term_ref_pics_sps)
276 return AVERROR_INVALIDDATA;
277 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
278 return AVERROR_INVALIDDATA;
279
280 rps->nb_refs = nb_sh + nb_sps;
281
282 for (i = 0; i < rps->nb_refs; i++) {
283
284 if (i < nb_sps) {
285 uint8_t lt_idx_sps = 0;
286
287 if (sps->num_long_term_ref_pics_sps > 1)
288 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
289
290 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
291 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
292 } else {
293 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
294 rps->used[i] = get_bits1(gb);
295 }
296
297 rps->poc_msb_present[i] = get_bits1(gb);
298 if (rps->poc_msb_present[i]) {
299 int64_t delta = get_ue_golomb_long(gb);
300 int64_t poc;
301
302 if (i && i != nb_sps)
303 delta += prev_delta_msb;
304
305 poc = rps->poc[i] + s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
306 if (poc != (int32_t)poc)
307 return AVERROR_INVALIDDATA;
308 rps->poc[i] = poc;
309 prev_delta_msb = delta;
310 }
311 }
312
313 return 0;
314 }
315
export_stream_params(HEVCContext * s,const HEVCSPS * sps)316 static void export_stream_params(HEVCContext *s, const HEVCSPS *sps)
317 {
318 AVCodecContext *avctx = s->avctx;
319 const HEVCParamSets *ps = &s->ps;
320 const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
321 const HEVCWindow *ow = &sps->output_window;
322 unsigned int num = 0, den = 0;
323
324 avctx->pix_fmt = sps->pix_fmt;
325 avctx->coded_width = sps->width;
326 avctx->coded_height = sps->height;
327 avctx->width = sps->width - ow->left_offset - ow->right_offset;
328 avctx->height = sps->height - ow->top_offset - ow->bottom_offset;
329 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
330 avctx->profile = sps->ptl.general_ptl.profile_idc;
331 avctx->level = sps->ptl.general_ptl.level_idc;
332
333 ff_set_sar(avctx, sps->vui.sar);
334
335 if (sps->vui.video_signal_type_present_flag)
336 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
337 : AVCOL_RANGE_MPEG;
338 else
339 avctx->color_range = AVCOL_RANGE_MPEG;
340
341 if (sps->vui.colour_description_present_flag) {
342 avctx->color_primaries = sps->vui.colour_primaries;
343 avctx->color_trc = sps->vui.transfer_characteristic;
344 avctx->colorspace = sps->vui.matrix_coeffs;
345 } else {
346 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
347 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
348 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
349 }
350
351 if (vps->vps_timing_info_present_flag) {
352 num = vps->vps_num_units_in_tick;
353 den = vps->vps_time_scale;
354 } else if (sps->vui.vui_timing_info_present_flag) {
355 num = sps->vui.vui_num_units_in_tick;
356 den = sps->vui.vui_time_scale;
357 }
358
359 if (num != 0 && den != 0)
360 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
361 num, den, 1 << 30);
362
363 if (s->sei.alternative_transfer.present &&
364 av_color_transfer_name(s->sei.alternative_transfer.preferred_transfer_characteristics) &&
365 s->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
366 avctx->color_trc = s->sei.alternative_transfer.preferred_transfer_characteristics;
367 }
368 }
369
get_format(HEVCContext * s,const HEVCSPS * sps)370 static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
371 {
372 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
373 CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
374 CONFIG_HEVC_NVDEC_HWACCEL + \
375 CONFIG_HEVC_VAAPI_HWACCEL + \
376 CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
377 CONFIG_HEVC_VDPAU_HWACCEL)
378 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
379
380 switch (sps->pix_fmt) {
381 case AV_PIX_FMT_YUV420P:
382 case AV_PIX_FMT_YUVJ420P:
383 #if CONFIG_HEVC_DXVA2_HWACCEL
384 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
385 #endif
386 #if CONFIG_HEVC_D3D11VA_HWACCEL
387 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
388 *fmt++ = AV_PIX_FMT_D3D11;
389 #endif
390 #if CONFIG_HEVC_VAAPI_HWACCEL
391 *fmt++ = AV_PIX_FMT_VAAPI;
392 #endif
393 #if CONFIG_HEVC_VDPAU_HWACCEL
394 *fmt++ = AV_PIX_FMT_VDPAU;
395 #endif
396 #if CONFIG_HEVC_NVDEC_HWACCEL
397 *fmt++ = AV_PIX_FMT_CUDA;
398 #endif
399 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
400 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
401 #endif
402 break;
403 case AV_PIX_FMT_YUV420P10:
404 #if CONFIG_HEVC_DXVA2_HWACCEL
405 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
406 #endif
407 #if CONFIG_HEVC_D3D11VA_HWACCEL
408 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
409 *fmt++ = AV_PIX_FMT_D3D11;
410 #endif
411 #if CONFIG_HEVC_VAAPI_HWACCEL
412 *fmt++ = AV_PIX_FMT_VAAPI;
413 #endif
414 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
415 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
416 #endif
417 #if CONFIG_HEVC_NVDEC_HWACCEL
418 *fmt++ = AV_PIX_FMT_CUDA;
419 #endif
420 break;
421 case AV_PIX_FMT_YUV444P:
422 #if CONFIG_HEVC_VDPAU_HWACCEL
423 *fmt++ = AV_PIX_FMT_VDPAU;
424 #endif
425 #if CONFIG_HEVC_NVDEC_HWACCEL
426 *fmt++ = AV_PIX_FMT_CUDA;
427 #endif
428 break;
429 case AV_PIX_FMT_YUV422P:
430 case AV_PIX_FMT_YUV422P10LE:
431 #if CONFIG_HEVC_VAAPI_HWACCEL
432 *fmt++ = AV_PIX_FMT_VAAPI;
433 #endif
434 break;
435 case AV_PIX_FMT_YUV420P12:
436 case AV_PIX_FMT_YUV444P10:
437 case AV_PIX_FMT_YUV444P12:
438 #if CONFIG_HEVC_NVDEC_HWACCEL
439 *fmt++ = AV_PIX_FMT_CUDA;
440 #endif
441 break;
442 }
443
444 *fmt++ = sps->pix_fmt;
445 *fmt = AV_PIX_FMT_NONE;
446
447 return ff_thread_get_format(s->avctx, pix_fmts);
448 }
449
set_sps(HEVCContext * s,const HEVCSPS * sps,enum AVPixelFormat pix_fmt)450 static int set_sps(HEVCContext *s, const HEVCSPS *sps,
451 enum AVPixelFormat pix_fmt)
452 {
453 int ret, i;
454
455 pic_arrays_free(s);
456 s->ps.sps = NULL;
457 s->ps.vps = NULL;
458
459 if (!sps)
460 return 0;
461
462 ret = pic_arrays_init(s, sps);
463 if (ret < 0)
464 goto fail;
465
466 export_stream_params(s, sps);
467
468 s->avctx->pix_fmt = pix_fmt;
469
470 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
471 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
472 ff_videodsp_init (&s->vdsp, sps->bit_depth);
473
474 for (i = 0; i < 3; i++) {
475 av_freep(&s->sao_pixel_buffer_h[i]);
476 av_freep(&s->sao_pixel_buffer_v[i]);
477 }
478
479 if (sps->sao_enabled && !s->avctx->hwaccel) {
480 int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
481 int c_idx;
482
483 for(c_idx = 0; c_idx < c_count; c_idx++) {
484 int w = sps->width >> sps->hshift[c_idx];
485 int h = sps->height >> sps->vshift[c_idx];
486 s->sao_pixel_buffer_h[c_idx] =
487 av_malloc((w * 2 * sps->ctb_height) <<
488 sps->pixel_shift);
489 s->sao_pixel_buffer_v[c_idx] =
490 av_malloc((h * 2 * sps->ctb_width) <<
491 sps->pixel_shift);
492 }
493 }
494
495 s->ps.sps = sps;
496 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
497
498 return 0;
499
500 fail:
501 pic_arrays_free(s);
502 s->ps.sps = NULL;
503 return ret;
504 }
505
hls_slice_header(HEVCContext * s)506 static int hls_slice_header(HEVCContext *s)
507 {
508 GetBitContext *gb = &s->HEVClc->gb;
509 SliceHeader *sh = &s->sh;
510 int i, ret;
511
512 // Coded parameters
513 sh->first_slice_in_pic_flag = get_bits1(gb);
514 if (s->ref && sh->first_slice_in_pic_flag) {
515 av_log(s->avctx, AV_LOG_ERROR, "Two slices reporting being the first in the same frame.\n");
516 return 1; // This slice will be skipped later, do not corrupt state
517 }
518
519 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
520 s->seq_decode = (s->seq_decode + 1) & 0xff;
521 s->max_ra = INT_MAX;
522 if (IS_IDR(s))
523 ff_hevc_clear_refs(s);
524 }
525 sh->no_output_of_prior_pics_flag = 0;
526 if (IS_IRAP(s))
527 sh->no_output_of_prior_pics_flag = get_bits1(gb);
528
529 sh->pps_id = get_ue_golomb_long(gb);
530 if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
531 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
532 return AVERROR_INVALIDDATA;
533 }
534 if (!sh->first_slice_in_pic_flag &&
535 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
536 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
537 return AVERROR_INVALIDDATA;
538 }
539 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
540 if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
541 sh->no_output_of_prior_pics_flag = 1;
542
543 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
544 const HEVCSPS *sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
545 const HEVCSPS *last_sps = s->ps.sps;
546 enum AVPixelFormat pix_fmt;
547
548 if (last_sps && IS_IRAP(s) && s->nal_unit_type != HEVC_NAL_CRA_NUT) {
549 if (sps->width != last_sps->width || sps->height != last_sps->height ||
550 sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering !=
551 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
552 sh->no_output_of_prior_pics_flag = 0;
553 }
554 ff_hevc_clear_refs(s);
555
556 ret = set_sps(s, sps, sps->pix_fmt);
557 if (ret < 0)
558 return ret;
559
560 pix_fmt = get_format(s, sps);
561 if (pix_fmt < 0)
562 return pix_fmt;
563 s->avctx->pix_fmt = pix_fmt;
564
565 s->seq_decode = (s->seq_decode + 1) & 0xff;
566 s->max_ra = INT_MAX;
567 }
568
569 sh->dependent_slice_segment_flag = 0;
570 if (!sh->first_slice_in_pic_flag) {
571 int slice_address_length;
572
573 if (s->ps.pps->dependent_slice_segments_enabled_flag)
574 sh->dependent_slice_segment_flag = get_bits1(gb);
575
576 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
577 s->ps.sps->ctb_height);
578 sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
579 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
580 av_log(s->avctx, AV_LOG_ERROR,
581 "Invalid slice segment address: %u.\n",
582 sh->slice_segment_addr);
583 return AVERROR_INVALIDDATA;
584 }
585
586 if (!sh->dependent_slice_segment_flag) {
587 sh->slice_addr = sh->slice_segment_addr;
588 s->slice_idx++;
589 }
590 } else {
591 sh->slice_segment_addr = sh->slice_addr = 0;
592 s->slice_idx = 0;
593 s->slice_initialized = 0;
594 }
595
596 if (!sh->dependent_slice_segment_flag) {
597 s->slice_initialized = 0;
598
599 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
600 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
601
602 sh->slice_type = get_ue_golomb_long(gb);
603 if (!(sh->slice_type == HEVC_SLICE_I ||
604 sh->slice_type == HEVC_SLICE_P ||
605 sh->slice_type == HEVC_SLICE_B)) {
606 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
607 sh->slice_type);
608 return AVERROR_INVALIDDATA;
609 }
610 if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
611 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
612 return AVERROR_INVALIDDATA;
613 }
614
615 // when flag is not present, picture is inferred to be output
616 sh->pic_output_flag = 1;
617 if (s->ps.pps->output_flag_present_flag)
618 sh->pic_output_flag = get_bits1(gb);
619
620 if (s->ps.sps->separate_colour_plane_flag)
621 sh->colour_plane_id = get_bits(gb, 2);
622
623 if (!IS_IDR(s)) {
624 int poc, pos;
625
626 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
627 poc = ff_hevc_compute_poc(s->ps.sps, s->pocTid0, sh->pic_order_cnt_lsb, s->nal_unit_type);
628 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
629 av_log(s->avctx, AV_LOG_WARNING,
630 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
631 if (s->avctx->err_recognition & AV_EF_EXPLODE)
632 return AVERROR_INVALIDDATA;
633 poc = s->poc;
634 }
635 s->poc = poc;
636
637 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
638 pos = get_bits_left(gb);
639 if (!sh->short_term_ref_pic_set_sps_flag) {
640 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
641 if (ret < 0)
642 return ret;
643
644 sh->short_term_rps = &sh->slice_rps;
645 } else {
646 int numbits, rps_idx;
647
648 if (!s->ps.sps->nb_st_rps) {
649 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
650 return AVERROR_INVALIDDATA;
651 }
652
653 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
654 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
655 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
656 }
657 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
658
659 pos = get_bits_left(gb);
660 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
661 if (ret < 0) {
662 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
663 if (s->avctx->err_recognition & AV_EF_EXPLODE)
664 return AVERROR_INVALIDDATA;
665 }
666 sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
667
668 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
669 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
670 else
671 sh->slice_temporal_mvp_enabled_flag = 0;
672 } else {
673 s->sh.short_term_rps = NULL;
674 s->poc = 0;
675 }
676
677 /* 8.3.1 */
678 if (sh->first_slice_in_pic_flag && s->temporal_id == 0 &&
679 s->nal_unit_type != HEVC_NAL_TRAIL_N &&
680 s->nal_unit_type != HEVC_NAL_TSA_N &&
681 s->nal_unit_type != HEVC_NAL_STSA_N &&
682 s->nal_unit_type != HEVC_NAL_RADL_N &&
683 s->nal_unit_type != HEVC_NAL_RADL_R &&
684 s->nal_unit_type != HEVC_NAL_RASL_N &&
685 s->nal_unit_type != HEVC_NAL_RASL_R)
686 s->pocTid0 = s->poc;
687
688 if (s->ps.sps->sao_enabled) {
689 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
690 if (s->ps.sps->chroma_format_idc) {
691 sh->slice_sample_adaptive_offset_flag[1] =
692 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
693 }
694 } else {
695 sh->slice_sample_adaptive_offset_flag[0] = 0;
696 sh->slice_sample_adaptive_offset_flag[1] = 0;
697 sh->slice_sample_adaptive_offset_flag[2] = 0;
698 }
699
700 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
701 if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
702 int nb_refs;
703
704 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
705 if (sh->slice_type == HEVC_SLICE_B)
706 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
707
708 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
709 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
710 if (sh->slice_type == HEVC_SLICE_B)
711 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
712 }
713 if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
714 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
715 sh->nb_refs[L0], sh->nb_refs[L1]);
716 return AVERROR_INVALIDDATA;
717 }
718
719 sh->rpl_modification_flag[0] = 0;
720 sh->rpl_modification_flag[1] = 0;
721 nb_refs = ff_hevc_frame_nb_refs(s);
722 if (!nb_refs) {
723 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
724 return AVERROR_INVALIDDATA;
725 }
726
727 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
728 sh->rpl_modification_flag[0] = get_bits1(gb);
729 if (sh->rpl_modification_flag[0]) {
730 for (i = 0; i < sh->nb_refs[L0]; i++)
731 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
732 }
733
734 if (sh->slice_type == HEVC_SLICE_B) {
735 sh->rpl_modification_flag[1] = get_bits1(gb);
736 if (sh->rpl_modification_flag[1] == 1)
737 for (i = 0; i < sh->nb_refs[L1]; i++)
738 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
739 }
740 }
741
742 if (sh->slice_type == HEVC_SLICE_B)
743 sh->mvd_l1_zero_flag = get_bits1(gb);
744
745 if (s->ps.pps->cabac_init_present_flag)
746 sh->cabac_init_flag = get_bits1(gb);
747 else
748 sh->cabac_init_flag = 0;
749
750 sh->collocated_ref_idx = 0;
751 if (sh->slice_temporal_mvp_enabled_flag) {
752 sh->collocated_list = L0;
753 if (sh->slice_type == HEVC_SLICE_B)
754 sh->collocated_list = !get_bits1(gb);
755
756 if (sh->nb_refs[sh->collocated_list] > 1) {
757 sh->collocated_ref_idx = get_ue_golomb_long(gb);
758 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
759 av_log(s->avctx, AV_LOG_ERROR,
760 "Invalid collocated_ref_idx: %d.\n",
761 sh->collocated_ref_idx);
762 return AVERROR_INVALIDDATA;
763 }
764 }
765 }
766
767 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == HEVC_SLICE_P) ||
768 (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
769 int ret = pred_weight_table(s, gb);
770 if (ret < 0)
771 return ret;
772 }
773
774 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
775 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
776 av_log(s->avctx, AV_LOG_ERROR,
777 "Invalid number of merging MVP candidates: %d.\n",
778 sh->max_num_merge_cand);
779 return AVERROR_INVALIDDATA;
780 }
781 }
782
783 sh->slice_qp_delta = get_se_golomb(gb);
784
785 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
786 sh->slice_cb_qp_offset = get_se_golomb(gb);
787 sh->slice_cr_qp_offset = get_se_golomb(gb);
788 if (sh->slice_cb_qp_offset < -12 || sh->slice_cb_qp_offset > 12 ||
789 sh->slice_cr_qp_offset < -12 || sh->slice_cr_qp_offset > 12) {
790 av_log(s->avctx, AV_LOG_ERROR, "Invalid slice cx qp offset.\n");
791 return AVERROR_INVALIDDATA;
792 }
793 } else {
794 sh->slice_cb_qp_offset = 0;
795 sh->slice_cr_qp_offset = 0;
796 }
797
798 if (s->ps.pps->chroma_qp_offset_list_enabled_flag)
799 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
800 else
801 sh->cu_chroma_qp_offset_enabled_flag = 0;
802
803 if (s->ps.pps->deblocking_filter_control_present_flag) {
804 int deblocking_filter_override_flag = 0;
805
806 if (s->ps.pps->deblocking_filter_override_enabled_flag)
807 deblocking_filter_override_flag = get_bits1(gb);
808
809 if (deblocking_filter_override_flag) {
810 sh->disable_deblocking_filter_flag = get_bits1(gb);
811 if (!sh->disable_deblocking_filter_flag) {
812 int beta_offset_div2 = get_se_golomb(gb);
813 int tc_offset_div2 = get_se_golomb(gb) ;
814 if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
815 tc_offset_div2 < -6 || tc_offset_div2 > 6) {
816 av_log(s->avctx, AV_LOG_ERROR,
817 "Invalid deblock filter offsets: %d, %d\n",
818 beta_offset_div2, tc_offset_div2);
819 return AVERROR_INVALIDDATA;
820 }
821 sh->beta_offset = beta_offset_div2 * 2;
822 sh->tc_offset = tc_offset_div2 * 2;
823 }
824 } else {
825 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
826 sh->beta_offset = s->ps.pps->beta_offset;
827 sh->tc_offset = s->ps.pps->tc_offset;
828 }
829 } else {
830 sh->disable_deblocking_filter_flag = 0;
831 sh->beta_offset = 0;
832 sh->tc_offset = 0;
833 }
834
835 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
836 (sh->slice_sample_adaptive_offset_flag[0] ||
837 sh->slice_sample_adaptive_offset_flag[1] ||
838 !sh->disable_deblocking_filter_flag)) {
839 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
840 } else {
841 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
842 }
843 } else if (!s->slice_initialized) {
844 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
845 return AVERROR_INVALIDDATA;
846 }
847
848 sh->num_entry_point_offsets = 0;
849 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
850 unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
851 // It would be possible to bound this tighter but this here is simpler
852 if (num_entry_point_offsets > get_bits_left(gb)) {
853 av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
854 return AVERROR_INVALIDDATA;
855 }
856
857 sh->num_entry_point_offsets = num_entry_point_offsets;
858 if (sh->num_entry_point_offsets > 0) {
859 int offset_len = get_ue_golomb_long(gb) + 1;
860
861 if (offset_len < 1 || offset_len > 32) {
862 sh->num_entry_point_offsets = 0;
863 av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
864 return AVERROR_INVALIDDATA;
865 }
866
867 av_freep(&sh->entry_point_offset);
868 av_freep(&sh->offset);
869 av_freep(&sh->size);
870 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
871 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
872 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
873 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
874 sh->num_entry_point_offsets = 0;
875 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
876 return AVERROR(ENOMEM);
877 }
878 for (i = 0; i < sh->num_entry_point_offsets; i++) {
879 unsigned val = get_bits_long(gb, offset_len);
880 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
881 }
882 if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
883 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
884 s->threads_number = 1;
885 } else
886 s->enable_parallel_tiles = 0;
887 } else
888 s->enable_parallel_tiles = 0;
889 }
890
891 if (s->ps.pps->slice_header_extension_present_flag) {
892 unsigned int length = get_ue_golomb_long(gb);
893 if (length*8LL > get_bits_left(gb)) {
894 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
895 return AVERROR_INVALIDDATA;
896 }
897 for (i = 0; i < length; i++)
898 skip_bits(gb, 8); // slice_header_extension_data_byte
899 }
900
901 // Inferred parameters
902 sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
903 if (sh->slice_qp > 51 ||
904 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
905 av_log(s->avctx, AV_LOG_ERROR,
906 "The slice_qp %d is outside the valid range "
907 "[%d, 51].\n",
908 sh->slice_qp,
909 -s->ps.sps->qp_bd_offset);
910 return AVERROR_INVALIDDATA;
911 }
912
913 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
914
915 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
916 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
917 return AVERROR_INVALIDDATA;
918 }
919
920 if (get_bits_left(gb) < 0) {
921 av_log(s->avctx, AV_LOG_ERROR,
922 "Overread slice header by %d bits\n", -get_bits_left(gb));
923 return AVERROR_INVALIDDATA;
924 }
925
926 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
927
928 if (!s->ps.pps->cu_qp_delta_enabled_flag)
929 s->HEVClc->qp_y = s->sh.slice_qp;
930
931 s->slice_initialized = 1;
932 s->HEVClc->tu.cu_qp_offset_cb = 0;
933 s->HEVClc->tu.cu_qp_offset_cr = 0;
934
935 return 0;
936 }
937
938 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
939
940 #define SET_SAO(elem, value) \
941 do { \
942 if (!sao_merge_up_flag && !sao_merge_left_flag) \
943 sao->elem = value; \
944 else if (sao_merge_left_flag) \
945 sao->elem = CTB(s->sao, rx-1, ry).elem; \
946 else if (sao_merge_up_flag) \
947 sao->elem = CTB(s->sao, rx, ry-1).elem; \
948 else \
949 sao->elem = 0; \
950 } while (0)
951
hls_sao_param(HEVCContext * s,int rx,int ry)952 static void hls_sao_param(HEVCContext *s, int rx, int ry)
953 {
954 HEVCLocalContext *lc = s->HEVClc;
955 int sao_merge_left_flag = 0;
956 int sao_merge_up_flag = 0;
957 SAOParams *sao = &CTB(s->sao, rx, ry);
958 int c_idx, i;
959
960 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
961 s->sh.slice_sample_adaptive_offset_flag[1]) {
962 if (rx > 0) {
963 if (lc->ctb_left_flag)
964 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
965 }
966 if (ry > 0 && !sao_merge_left_flag) {
967 if (lc->ctb_up_flag)
968 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
969 }
970 }
971
972 for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
973 int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
974 s->ps.pps->log2_sao_offset_scale_chroma;
975
976 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
977 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
978 continue;
979 }
980
981 if (c_idx == 2) {
982 sao->type_idx[2] = sao->type_idx[1];
983 sao->eo_class[2] = sao->eo_class[1];
984 } else {
985 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
986 }
987
988 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
989 continue;
990
991 for (i = 0; i < 4; i++)
992 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
993
994 if (sao->type_idx[c_idx] == SAO_BAND) {
995 for (i = 0; i < 4; i++) {
996 if (sao->offset_abs[c_idx][i]) {
997 SET_SAO(offset_sign[c_idx][i],
998 ff_hevc_sao_offset_sign_decode(s));
999 } else {
1000 sao->offset_sign[c_idx][i] = 0;
1001 }
1002 }
1003 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
1004 } else if (c_idx != 2) {
1005 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
1006 }
1007
1008 // Inferred parameters
1009 sao->offset_val[c_idx][0] = 0;
1010 for (i = 0; i < 4; i++) {
1011 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
1012 if (sao->type_idx[c_idx] == SAO_EDGE) {
1013 if (i > 1)
1014 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
1015 } else if (sao->offset_sign[c_idx][i]) {
1016 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
1017 }
1018 sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
1019 }
1020 }
1021 }
1022
1023 #undef SET_SAO
1024 #undef CTB
1025
hls_cross_component_pred(HEVCContext * s,int idx)1026 static int hls_cross_component_pred(HEVCContext *s, int idx) {
1027 HEVCLocalContext *lc = s->HEVClc;
1028 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
1029
1030 if (log2_res_scale_abs_plus1 != 0) {
1031 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
1032 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
1033 (1 - 2 * res_scale_sign_flag);
1034 } else {
1035 lc->tu.res_scale_val = 0;
1036 }
1037
1038
1039 return 0;
1040 }
1041
hls_transform_unit(HEVCContext * s,int x0,int y0,int xBase,int yBase,int cb_xBase,int cb_yBase,int log2_cb_size,int log2_trafo_size,int blk_idx,int cbf_luma,int * cbf_cb,int * cbf_cr)1042 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1043 int xBase, int yBase, int cb_xBase, int cb_yBase,
1044 int log2_cb_size, int log2_trafo_size,
1045 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
1046 {
1047 HEVCLocalContext *lc = s->HEVClc;
1048 const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1];
1049 int i;
1050
1051 if (lc->cu.pred_mode == MODE_INTRA) {
1052 int trafo_size = 1 << log2_trafo_size;
1053 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1054
1055 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1056 }
1057
1058 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1059 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1060 int scan_idx = SCAN_DIAG;
1061 int scan_idx_c = SCAN_DIAG;
1062 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1063 (s->ps.sps->chroma_format_idc == 2 &&
1064 (cbf_cb[1] || cbf_cr[1]));
1065
1066 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1067 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1068 if (lc->tu.cu_qp_delta != 0)
1069 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1070 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1071 lc->tu.is_cu_qp_delta_coded = 1;
1072
1073 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1074 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
1075 av_log(s->avctx, AV_LOG_ERROR,
1076 "The cu_qp_delta %d is outside the valid range "
1077 "[%d, %d].\n",
1078 lc->tu.cu_qp_delta,
1079 -(26 + s->ps.sps->qp_bd_offset / 2),
1080 (25 + s->ps.sps->qp_bd_offset / 2));
1081 return AVERROR_INVALIDDATA;
1082 }
1083
1084 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
1085 }
1086
1087 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1088 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
1089 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
1090 if (cu_chroma_qp_offset_flag) {
1091 int cu_chroma_qp_offset_idx = 0;
1092 if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
1093 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
1094 av_log(s->avctx, AV_LOG_ERROR,
1095 "cu_chroma_qp_offset_idx not yet tested.\n");
1096 }
1097 lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
1098 lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
1099 } else {
1100 lc->tu.cu_qp_offset_cb = 0;
1101 lc->tu.cu_qp_offset_cr = 0;
1102 }
1103 lc->tu.is_cu_chroma_qp_offset_coded = 1;
1104 }
1105
1106 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1107 if (lc->tu.intra_pred_mode >= 6 &&
1108 lc->tu.intra_pred_mode <= 14) {
1109 scan_idx = SCAN_VERT;
1110 } else if (lc->tu.intra_pred_mode >= 22 &&
1111 lc->tu.intra_pred_mode <= 30) {
1112 scan_idx = SCAN_HORIZ;
1113 }
1114
1115 if (lc->tu.intra_pred_mode_c >= 6 &&
1116 lc->tu.intra_pred_mode_c <= 14) {
1117 scan_idx_c = SCAN_VERT;
1118 } else if (lc->tu.intra_pred_mode_c >= 22 &&
1119 lc->tu.intra_pred_mode_c <= 30) {
1120 scan_idx_c = SCAN_HORIZ;
1121 }
1122 }
1123
1124 lc->tu.cross_pf = 0;
1125
1126 if (cbf_luma)
1127 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1128 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1129 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1130 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1131 lc->tu.cross_pf = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1132 (lc->cu.pred_mode == MODE_INTER ||
1133 (lc->tu.chroma_mode_c == 4)));
1134
1135 if (lc->tu.cross_pf) {
1136 hls_cross_component_pred(s, 0);
1137 }
1138 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1139 if (lc->cu.pred_mode == MODE_INTRA) {
1140 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1141 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1142 }
1143 if (cbf_cb[i])
1144 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1145 log2_trafo_size_c, scan_idx_c, 1);
1146 else
1147 if (lc->tu.cross_pf) {
1148 ptrdiff_t stride = s->frame->linesize[1];
1149 int hshift = s->ps.sps->hshift[1];
1150 int vshift = s->ps.sps->vshift[1];
1151 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1152 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1153 int size = 1 << log2_trafo_size_c;
1154
1155 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1156 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1157 for (i = 0; i < (size * size); i++) {
1158 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1159 }
1160 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1161 }
1162 }
1163
1164 if (lc->tu.cross_pf) {
1165 hls_cross_component_pred(s, 1);
1166 }
1167 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1168 if (lc->cu.pred_mode == MODE_INTRA) {
1169 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1170 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1171 }
1172 if (cbf_cr[i])
1173 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1174 log2_trafo_size_c, scan_idx_c, 2);
1175 else
1176 if (lc->tu.cross_pf) {
1177 ptrdiff_t stride = s->frame->linesize[2];
1178 int hshift = s->ps.sps->hshift[2];
1179 int vshift = s->ps.sps->vshift[2];
1180 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1181 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1182 int size = 1 << log2_trafo_size_c;
1183
1184 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1185 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1186 for (i = 0; i < (size * size); i++) {
1187 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1188 }
1189 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1190 }
1191 }
1192 } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
1193 int trafo_size_h = 1 << (log2_trafo_size + 1);
1194 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1195 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1196 if (lc->cu.pred_mode == MODE_INTRA) {
1197 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1198 trafo_size_h, trafo_size_v);
1199 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1200 }
1201 if (cbf_cb[i])
1202 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1203 log2_trafo_size, scan_idx_c, 1);
1204 }
1205 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1206 if (lc->cu.pred_mode == MODE_INTRA) {
1207 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1208 trafo_size_h, trafo_size_v);
1209 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1210 }
1211 if (cbf_cr[i])
1212 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1213 log2_trafo_size, scan_idx_c, 2);
1214 }
1215 }
1216 } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1217 if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) {
1218 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1219 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1220 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1221 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1222 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1223 if (s->ps.sps->chroma_format_idc == 2) {
1224 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1225 trafo_size_h, trafo_size_v);
1226 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1227 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1228 }
1229 } else if (blk_idx == 3) {
1230 int trafo_size_h = 1 << (log2_trafo_size + 1);
1231 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1232 ff_hevc_set_neighbour_available(s, xBase, yBase,
1233 trafo_size_h, trafo_size_v);
1234 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1235 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1236 if (s->ps.sps->chroma_format_idc == 2) {
1237 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1238 trafo_size_h, trafo_size_v);
1239 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1240 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1241 }
1242 }
1243 }
1244
1245 return 0;
1246 }
1247
set_deblocking_bypass(HEVCContext * s,int x0,int y0,int log2_cb_size)1248 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1249 {
1250 int cb_size = 1 << log2_cb_size;
1251 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1252
1253 int min_pu_width = s->ps.sps->min_pu_width;
1254 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1255 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1256 int i, j;
1257
1258 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1259 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1260 s->is_pcm[i + j * min_pu_width] = 2;
1261 }
1262
hls_transform_tree(HEVCContext * s,int x0,int y0,int xBase,int yBase,int cb_xBase,int cb_yBase,int log2_cb_size,int log2_trafo_size,int trafo_depth,int blk_idx,const int * base_cbf_cb,const int * base_cbf_cr)1263 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1264 int xBase, int yBase, int cb_xBase, int cb_yBase,
1265 int log2_cb_size, int log2_trafo_size,
1266 int trafo_depth, int blk_idx,
1267 const int *base_cbf_cb, const int *base_cbf_cr)
1268 {
1269 HEVCLocalContext *lc = s->HEVClc;
1270 uint8_t split_transform_flag;
1271 int cbf_cb[2];
1272 int cbf_cr[2];
1273 int ret;
1274
1275 cbf_cb[0] = base_cbf_cb[0];
1276 cbf_cb[1] = base_cbf_cb[1];
1277 cbf_cr[0] = base_cbf_cr[0];
1278 cbf_cr[1] = base_cbf_cr[1];
1279
1280 if (lc->cu.intra_split_flag) {
1281 if (trafo_depth == 1) {
1282 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1283 if (s->ps.sps->chroma_format_idc == 3) {
1284 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1285 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1286 } else {
1287 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1288 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1289 }
1290 }
1291 } else {
1292 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1293 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1294 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1295 }
1296
1297 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1298 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1299 trafo_depth < lc->cu.max_trafo_depth &&
1300 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1301 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1302 } else {
1303 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1304 lc->cu.pred_mode == MODE_INTER &&
1305 lc->cu.part_mode != PART_2Nx2N &&
1306 trafo_depth == 0;
1307
1308 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1309 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1310 inter_split;
1311 }
1312
1313 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1314 if (trafo_depth == 0 || cbf_cb[0]) {
1315 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1316 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1317 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1318 }
1319 }
1320
1321 if (trafo_depth == 0 || cbf_cr[0]) {
1322 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1323 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1324 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1325 }
1326 }
1327 }
1328
1329 if (split_transform_flag) {
1330 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1331 const int x1 = x0 + trafo_size_split;
1332 const int y1 = y0 + trafo_size_split;
1333
1334 #define SUBDIVIDE(x, y, idx) \
1335 do { \
1336 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1337 log2_trafo_size - 1, trafo_depth + 1, idx, \
1338 cbf_cb, cbf_cr); \
1339 if (ret < 0) \
1340 return ret; \
1341 } while (0)
1342
1343 SUBDIVIDE(x0, y0, 0);
1344 SUBDIVIDE(x1, y0, 1);
1345 SUBDIVIDE(x0, y1, 2);
1346 SUBDIVIDE(x1, y1, 3);
1347
1348 #undef SUBDIVIDE
1349 } else {
1350 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1351 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1352 int min_tu_width = s->ps.sps->min_tb_width;
1353 int cbf_luma = 1;
1354
1355 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1356 cbf_cb[0] || cbf_cr[0] ||
1357 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1358 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1359 }
1360
1361 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1362 log2_cb_size, log2_trafo_size,
1363 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1364 if (ret < 0)
1365 return ret;
1366 // TODO: store cbf_luma somewhere else
1367 if (cbf_luma) {
1368 int i, j;
1369 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1370 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1371 int x_tu = (x0 + j) >> log2_min_tu_size;
1372 int y_tu = (y0 + i) >> log2_min_tu_size;
1373 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1374 }
1375 }
1376 if (!s->sh.disable_deblocking_filter_flag) {
1377 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1378 if (s->ps.pps->transquant_bypass_enable_flag &&
1379 lc->cu.cu_transquant_bypass_flag)
1380 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1381 }
1382 }
1383 return 0;
1384 }
1385
hls_pcm_sample(HEVCContext * s,int x0,int y0,int log2_cb_size)1386 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1387 {
1388 HEVCLocalContext *lc = s->HEVClc;
1389 GetBitContext gb;
1390 int cb_size = 1 << log2_cb_size;
1391 ptrdiff_t stride0 = s->frame->linesize[0];
1392 ptrdiff_t stride1 = s->frame->linesize[1];
1393 ptrdiff_t stride2 = s->frame->linesize[2];
1394 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1395 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)];
1396 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)];
1397
1398 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
1399 (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) +
1400 ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) *
1401 s->ps.sps->pcm.bit_depth_chroma;
1402 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1403 int ret;
1404
1405 if (!s->sh.disable_deblocking_filter_flag)
1406 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1407
1408 ret = init_get_bits(&gb, pcm, length);
1409 if (ret < 0)
1410 return ret;
1411
1412 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1413 if (s->ps.sps->chroma_format_idc) {
1414 s->hevcdsp.put_pcm(dst1, stride1,
1415 cb_size >> s->ps.sps->hshift[1],
1416 cb_size >> s->ps.sps->vshift[1],
1417 &gb, s->ps.sps->pcm.bit_depth_chroma);
1418 s->hevcdsp.put_pcm(dst2, stride2,
1419 cb_size >> s->ps.sps->hshift[2],
1420 cb_size >> s->ps.sps->vshift[2],
1421 &gb, s->ps.sps->pcm.bit_depth_chroma);
1422 }
1423
1424 return 0;
1425 }
1426
1427 /**
1428 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1429 *
1430 * @param s HEVC decoding context
1431 * @param dst target buffer for block data at block position
1432 * @param dststride stride of the dst buffer
1433 * @param ref reference picture buffer at origin (0, 0)
1434 * @param mv motion vector (relative to block position) to get pixel data from
1435 * @param x_off horizontal position of block from origin (0, 0)
1436 * @param y_off vertical position of block from origin (0, 0)
1437 * @param block_w width of block
1438 * @param block_h height of block
1439 * @param luma_weight weighting factor applied to the luma prediction
1440 * @param luma_offset additive offset applied to the luma prediction value
1441 */
1442
luma_mc_uni(HEVCContext * s,uint8_t * dst,ptrdiff_t dststride,AVFrame * ref,const Mv * mv,int x_off,int y_off,int block_w,int block_h,int luma_weight,int luma_offset)1443 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1444 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1445 int block_w, int block_h, int luma_weight, int luma_offset)
1446 {
1447 HEVCLocalContext *lc = s->HEVClc;
1448 uint8_t *src = ref->data[0];
1449 ptrdiff_t srcstride = ref->linesize[0];
1450 int pic_width = s->ps.sps->width;
1451 int pic_height = s->ps.sps->height;
1452 int mx = mv->x & 3;
1453 int my = mv->y & 3;
1454 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1455 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1456 int idx = ff_hevc_pel_weight[block_w];
1457
1458 x_off += mv->x >> 2;
1459 y_off += mv->y >> 2;
1460 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1461
1462 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1463 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1464 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1465 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1466 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1467 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1468
1469 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1470 edge_emu_stride, srcstride,
1471 block_w + QPEL_EXTRA,
1472 block_h + QPEL_EXTRA,
1473 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1474 pic_width, pic_height);
1475 src = lc->edge_emu_buffer + buf_offset;
1476 srcstride = edge_emu_stride;
1477 }
1478
1479 if (!weight_flag)
1480 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1481 block_h, mx, my, block_w);
1482 else
1483 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1484 block_h, s->sh.luma_log2_weight_denom,
1485 luma_weight, luma_offset, mx, my, block_w);
1486 }
1487
1488 /**
1489 * 8.5.3.2.2.1 Luma sample bidirectional 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 ref0 reference picture0 buffer at origin (0, 0)
1495 * @param mv0 motion vector0 (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 * @param ref1 reference picture1 buffer at origin (0, 0)
1501 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1502 * @param current_mv current motion vector structure
1503 */
luma_mc_bi(HEVCContext * s,uint8_t * dst,ptrdiff_t dststride,AVFrame * ref0,const Mv * mv0,int x_off,int y_off,int block_w,int block_h,AVFrame * ref1,const Mv * mv1,struct MvField * current_mv)1504 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1505 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1506 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1507 {
1508 HEVCLocalContext *lc = s->HEVClc;
1509 ptrdiff_t src0stride = ref0->linesize[0];
1510 ptrdiff_t src1stride = ref1->linesize[0];
1511 int pic_width = s->ps.sps->width;
1512 int pic_height = s->ps.sps->height;
1513 int mx0 = mv0->x & 3;
1514 int my0 = mv0->y & 3;
1515 int mx1 = mv1->x & 3;
1516 int my1 = mv1->y & 3;
1517 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1518 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1519 int x_off0 = x_off + (mv0->x >> 2);
1520 int y_off0 = y_off + (mv0->y >> 2);
1521 int x_off1 = x_off + (mv1->x >> 2);
1522 int y_off1 = y_off + (mv1->y >> 2);
1523 int idx = ff_hevc_pel_weight[block_w];
1524
1525 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1526 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1527
1528 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1529 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1530 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1531 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1532 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1533 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1534
1535 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1536 edge_emu_stride, src0stride,
1537 block_w + QPEL_EXTRA,
1538 block_h + QPEL_EXTRA,
1539 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1540 pic_width, pic_height);
1541 src0 = lc->edge_emu_buffer + buf_offset;
1542 src0stride = edge_emu_stride;
1543 }
1544
1545 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1546 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1547 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1548 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1549 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1550 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1551
1552 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1553 edge_emu_stride, src1stride,
1554 block_w + QPEL_EXTRA,
1555 block_h + QPEL_EXTRA,
1556 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1557 pic_width, pic_height);
1558 src1 = lc->edge_emu_buffer2 + buf_offset;
1559 src1stride = edge_emu_stride;
1560 }
1561
1562 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1563 block_h, mx0, my0, block_w);
1564 if (!weight_flag)
1565 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1566 block_h, mx1, my1, block_w);
1567 else
1568 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1569 block_h, s->sh.luma_log2_weight_denom,
1570 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1571 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1572 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1573 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1574 mx1, my1, block_w);
1575
1576 }
1577
1578 /**
1579 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1580 *
1581 * @param s HEVC decoding context
1582 * @param dst1 target buffer for block data at block position (U plane)
1583 * @param dst2 target buffer for block data at block position (V plane)
1584 * @param dststride stride of the dst1 and dst2 buffers
1585 * @param ref reference picture buffer at origin (0, 0)
1586 * @param mv motion vector (relative to block position) to get pixel data from
1587 * @param x_off horizontal position of block from origin (0, 0)
1588 * @param y_off vertical position of block from origin (0, 0)
1589 * @param block_w width of block
1590 * @param block_h height of block
1591 * @param chroma_weight weighting factor applied to the chroma prediction
1592 * @param chroma_offset additive offset applied to the chroma prediction value
1593 */
1594
chroma_mc_uni(HEVCContext * s,uint8_t * dst0,ptrdiff_t dststride,uint8_t * src0,ptrdiff_t srcstride,int reflist,int x_off,int y_off,int block_w,int block_h,struct MvField * current_mv,int chroma_weight,int chroma_offset)1595 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1596 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1597 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1598 {
1599 HEVCLocalContext *lc = s->HEVClc;
1600 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1601 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1602 const Mv *mv = ¤t_mv->mv[reflist];
1603 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1604 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1605 int idx = ff_hevc_pel_weight[block_w];
1606 int hshift = s->ps.sps->hshift[1];
1607 int vshift = s->ps.sps->vshift[1];
1608 intptr_t mx = av_mod_uintp2(mv->x, 2 + hshift);
1609 intptr_t my = av_mod_uintp2(mv->y, 2 + vshift);
1610 intptr_t _mx = mx << (1 - hshift);
1611 intptr_t _my = my << (1 - vshift);
1612
1613 x_off += mv->x >> (2 + hshift);
1614 y_off += mv->y >> (2 + vshift);
1615 src0 += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1616
1617 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1618 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1619 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1620 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1621 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift));
1622 int buf_offset0 = EPEL_EXTRA_BEFORE *
1623 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1624 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1625 edge_emu_stride, srcstride,
1626 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1627 x_off - EPEL_EXTRA_BEFORE,
1628 y_off - EPEL_EXTRA_BEFORE,
1629 pic_width, pic_height);
1630
1631 src0 = lc->edge_emu_buffer + buf_offset0;
1632 srcstride = edge_emu_stride;
1633 }
1634 if (!weight_flag)
1635 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1636 block_h, _mx, _my, block_w);
1637 else
1638 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1639 block_h, s->sh.chroma_log2_weight_denom,
1640 chroma_weight, chroma_offset, _mx, _my, block_w);
1641 }
1642
1643 /**
1644 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1645 *
1646 * @param s HEVC decoding context
1647 * @param dst target buffer for block data at block position
1648 * @param dststride stride of the dst buffer
1649 * @param ref0 reference picture0 buffer at origin (0, 0)
1650 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1651 * @param x_off horizontal position of block from origin (0, 0)
1652 * @param y_off vertical position of block from origin (0, 0)
1653 * @param block_w width of block
1654 * @param block_h height of block
1655 * @param ref1 reference picture1 buffer at origin (0, 0)
1656 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1657 * @param current_mv current motion vector structure
1658 * @param cidx chroma component(cb, cr)
1659 */
chroma_mc_bi(HEVCContext * s,uint8_t * dst0,ptrdiff_t dststride,AVFrame * ref0,AVFrame * ref1,int x_off,int y_off,int block_w,int block_h,struct MvField * current_mv,int cidx)1660 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1661 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1662 {
1663 HEVCLocalContext *lc = s->HEVClc;
1664 uint8_t *src1 = ref0->data[cidx+1];
1665 uint8_t *src2 = ref1->data[cidx+1];
1666 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1667 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1668 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1669 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1670 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1671 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1672 Mv *mv0 = ¤t_mv->mv[0];
1673 Mv *mv1 = ¤t_mv->mv[1];
1674 int hshift = s->ps.sps->hshift[1];
1675 int vshift = s->ps.sps->vshift[1];
1676
1677 intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1678 intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1679 intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1680 intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1681 intptr_t _mx0 = mx0 << (1 - hshift);
1682 intptr_t _my0 = my0 << (1 - vshift);
1683 intptr_t _mx1 = mx1 << (1 - hshift);
1684 intptr_t _my1 = my1 << (1 - vshift);
1685
1686 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1687 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1688 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1689 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1690 int idx = ff_hevc_pel_weight[block_w];
1691 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1692 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1693
1694 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1695 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1696 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1697 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1698 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1699 int buf_offset1 = EPEL_EXTRA_BEFORE *
1700 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1701
1702 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1703 edge_emu_stride, src1stride,
1704 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1705 x_off0 - EPEL_EXTRA_BEFORE,
1706 y_off0 - EPEL_EXTRA_BEFORE,
1707 pic_width, pic_height);
1708
1709 src1 = lc->edge_emu_buffer + buf_offset1;
1710 src1stride = edge_emu_stride;
1711 }
1712
1713 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1714 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1715 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1716 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1717 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1718 int buf_offset1 = EPEL_EXTRA_BEFORE *
1719 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1720
1721 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1722 edge_emu_stride, src2stride,
1723 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1724 x_off1 - EPEL_EXTRA_BEFORE,
1725 y_off1 - EPEL_EXTRA_BEFORE,
1726 pic_width, pic_height);
1727
1728 src2 = lc->edge_emu_buffer2 + buf_offset1;
1729 src2stride = edge_emu_stride;
1730 }
1731
1732 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1733 block_h, _mx0, _my0, block_w);
1734 if (!weight_flag)
1735 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1736 src2, src2stride, lc->tmp,
1737 block_h, _mx1, _my1, block_w);
1738 else
1739 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1740 src2, src2stride, lc->tmp,
1741 block_h,
1742 s->sh.chroma_log2_weight_denom,
1743 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1744 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1745 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1746 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1747 _mx1, _my1, block_w);
1748 }
1749
hevc_await_progress(HEVCContext * s,HEVCFrame * ref,const Mv * mv,int y0,int height)1750 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1751 const Mv *mv, int y0, int height)
1752 {
1753 if (s->threads_type == FF_THREAD_FRAME ) {
1754 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1755
1756 ff_thread_await_progress(&ref->tf, y, 0);
1757 }
1758 }
1759
hevc_luma_mv_mvp_mode(HEVCContext * s,int x0,int y0,int nPbW,int nPbH,int log2_cb_size,int part_idx,int merge_idx,MvField * mv)1760 static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
1761 int nPbH, int log2_cb_size, int part_idx,
1762 int merge_idx, MvField *mv)
1763 {
1764 HEVCLocalContext *lc = s->HEVClc;
1765 enum InterPredIdc inter_pred_idc = PRED_L0;
1766 int mvp_flag;
1767
1768 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1769 mv->pred_flag = 0;
1770 if (s->sh.slice_type == HEVC_SLICE_B)
1771 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1772
1773 if (inter_pred_idc != PRED_L1) {
1774 if (s->sh.nb_refs[L0])
1775 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1776
1777 mv->pred_flag = PF_L0;
1778 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1779 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1780 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1781 part_idx, merge_idx, mv, mvp_flag, 0);
1782 mv->mv[0].x += lc->pu.mvd.x;
1783 mv->mv[0].y += lc->pu.mvd.y;
1784 }
1785
1786 if (inter_pred_idc != PRED_L0) {
1787 if (s->sh.nb_refs[L1])
1788 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1789
1790 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1791 AV_ZERO32(&lc->pu.mvd);
1792 } else {
1793 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1794 }
1795
1796 mv->pred_flag += PF_L1;
1797 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1798 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1799 part_idx, merge_idx, mv, mvp_flag, 1);
1800 mv->mv[1].x += lc->pu.mvd.x;
1801 mv->mv[1].y += lc->pu.mvd.y;
1802 }
1803 }
1804
hls_prediction_unit(HEVCContext * s,int x0,int y0,int nPbW,int nPbH,int log2_cb_size,int partIdx,int idx)1805 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1806 int nPbW, int nPbH,
1807 int log2_cb_size, int partIdx, int idx)
1808 {
1809 #define POS(c_idx, x, y) \
1810 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1811 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1812 HEVCLocalContext *lc = s->HEVClc;
1813 int merge_idx = 0;
1814 struct MvField current_mv = {{{ 0 }}};
1815
1816 int min_pu_width = s->ps.sps->min_pu_width;
1817
1818 MvField *tab_mvf = s->ref->tab_mvf;
1819 RefPicList *refPicList = s->ref->refPicList;
1820 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1821 uint8_t *dst0 = POS(0, x0, y0);
1822 uint8_t *dst1 = POS(1, x0, y0);
1823 uint8_t *dst2 = POS(2, x0, y0);
1824 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1825 int min_cb_width = s->ps.sps->min_cb_width;
1826 int x_cb = x0 >> log2_min_cb_size;
1827 int y_cb = y0 >> log2_min_cb_size;
1828 int x_pu, y_pu;
1829 int i, j;
1830
1831 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1832
1833 if (!skip_flag)
1834 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1835
1836 if (skip_flag || lc->pu.merge_flag) {
1837 if (s->sh.max_num_merge_cand > 1)
1838 merge_idx = ff_hevc_merge_idx_decode(s);
1839 else
1840 merge_idx = 0;
1841
1842 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1843 partIdx, merge_idx, ¤t_mv);
1844 } else {
1845 hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1846 partIdx, merge_idx, ¤t_mv);
1847 }
1848
1849 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1850 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1851
1852 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1853 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1854 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1855
1856 if (current_mv.pred_flag & PF_L0) {
1857 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1858 if (!ref0)
1859 return;
1860 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1861 }
1862 if (current_mv.pred_flag & PF_L1) {
1863 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1864 if (!ref1)
1865 return;
1866 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1867 }
1868
1869 if (current_mv.pred_flag == PF_L0) {
1870 int x0_c = x0 >> s->ps.sps->hshift[1];
1871 int y0_c = y0 >> s->ps.sps->vshift[1];
1872 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1873 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1874
1875 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1876 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1877 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1878 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1879
1880 if (s->ps.sps->chroma_format_idc) {
1881 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1882 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1883 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1884 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1885 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1886 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1887 }
1888 } else if (current_mv.pred_flag == PF_L1) {
1889 int x0_c = x0 >> s->ps.sps->hshift[1];
1890 int y0_c = y0 >> s->ps.sps->vshift[1];
1891 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1892 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1893
1894 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1895 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1896 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1897 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1898
1899 if (s->ps.sps->chroma_format_idc) {
1900 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1901 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1902 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1903
1904 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1905 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1906 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1907 }
1908 } else if (current_mv.pred_flag == PF_BI) {
1909 int x0_c = x0 >> s->ps.sps->hshift[1];
1910 int y0_c = y0 >> s->ps.sps->vshift[1];
1911 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1912 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1913
1914 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1915 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1916 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1917
1918 if (s->ps.sps->chroma_format_idc) {
1919 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1920 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1921
1922 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1923 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1924 }
1925 }
1926 }
1927
1928 /**
1929 * 8.4.1
1930 */
luma_intra_pred_mode(HEVCContext * s,int x0,int y0,int pu_size,int prev_intra_luma_pred_flag)1931 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1932 int prev_intra_luma_pred_flag)
1933 {
1934 HEVCLocalContext *lc = s->HEVClc;
1935 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1936 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1937 int min_pu_width = s->ps.sps->min_pu_width;
1938 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1939 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
1940 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
1941
1942 int cand_up = (lc->ctb_up_flag || y0b) ?
1943 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1944 int cand_left = (lc->ctb_left_flag || x0b) ?
1945 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1946
1947 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1948
1949 MvField *tab_mvf = s->ref->tab_mvf;
1950 int intra_pred_mode;
1951 int candidate[3];
1952 int i, j;
1953
1954 // intra_pred_mode prediction does not cross vertical CTB boundaries
1955 if ((y0 - 1) < y_ctb)
1956 cand_up = INTRA_DC;
1957
1958 if (cand_left == cand_up) {
1959 if (cand_left < 2) {
1960 candidate[0] = INTRA_PLANAR;
1961 candidate[1] = INTRA_DC;
1962 candidate[2] = INTRA_ANGULAR_26;
1963 } else {
1964 candidate[0] = cand_left;
1965 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1966 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1967 }
1968 } else {
1969 candidate[0] = cand_left;
1970 candidate[1] = cand_up;
1971 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1972 candidate[2] = INTRA_PLANAR;
1973 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1974 candidate[2] = INTRA_DC;
1975 } else {
1976 candidate[2] = INTRA_ANGULAR_26;
1977 }
1978 }
1979
1980 if (prev_intra_luma_pred_flag) {
1981 intra_pred_mode = candidate[lc->pu.mpm_idx];
1982 } else {
1983 if (candidate[0] > candidate[1])
1984 FFSWAP(uint8_t, candidate[0], candidate[1]);
1985 if (candidate[0] > candidate[2])
1986 FFSWAP(uint8_t, candidate[0], candidate[2]);
1987 if (candidate[1] > candidate[2])
1988 FFSWAP(uint8_t, candidate[1], candidate[2]);
1989
1990 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1991 for (i = 0; i < 3; i++)
1992 if (intra_pred_mode >= candidate[i])
1993 intra_pred_mode++;
1994 }
1995
1996 /* write the intra prediction units into the mv array */
1997 if (!size_in_pus)
1998 size_in_pus = 1;
1999 for (i = 0; i < size_in_pus; i++) {
2000 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
2001 intra_pred_mode, size_in_pus);
2002
2003 for (j = 0; j < size_in_pus; j++) {
2004 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
2005 }
2006 }
2007
2008 return intra_pred_mode;
2009 }
2010
set_ct_depth(HEVCContext * s,int x0,int y0,int log2_cb_size,int ct_depth)2011 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
2012 int log2_cb_size, int ct_depth)
2013 {
2014 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
2015 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
2016 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
2017 int y;
2018
2019 for (y = 0; y < length; y++)
2020 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
2021 ct_depth, length);
2022 }
2023
2024 static const uint8_t tab_mode_idx[] = {
2025 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
2026 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
2027
intra_prediction_unit(HEVCContext * s,int x0,int y0,int log2_cb_size)2028 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
2029 int log2_cb_size)
2030 {
2031 HEVCLocalContext *lc = s->HEVClc;
2032 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2033 uint8_t prev_intra_luma_pred_flag[4];
2034 int split = lc->cu.part_mode == PART_NxN;
2035 int pb_size = (1 << log2_cb_size) >> split;
2036 int side = split + 1;
2037 int chroma_mode;
2038 int i, j;
2039
2040 for (i = 0; i < side; i++)
2041 for (j = 0; j < side; j++)
2042 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
2043
2044 for (i = 0; i < side; i++) {
2045 for (j = 0; j < side; j++) {
2046 if (prev_intra_luma_pred_flag[2 * i + j])
2047 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
2048 else
2049 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
2050
2051 lc->pu.intra_pred_mode[2 * i + j] =
2052 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
2053 prev_intra_luma_pred_flag[2 * i + j]);
2054 }
2055 }
2056
2057 if (s->ps.sps->chroma_format_idc == 3) {
2058 for (i = 0; i < side; i++) {
2059 for (j = 0; j < side; j++) {
2060 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2061 if (chroma_mode != 4) {
2062 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
2063 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
2064 else
2065 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
2066 } else {
2067 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
2068 }
2069 }
2070 }
2071 } else if (s->ps.sps->chroma_format_idc == 2) {
2072 int mode_idx;
2073 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2074 if (chroma_mode != 4) {
2075 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2076 mode_idx = 34;
2077 else
2078 mode_idx = intra_chroma_table[chroma_mode];
2079 } else {
2080 mode_idx = lc->pu.intra_pred_mode[0];
2081 }
2082 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
2083 } else if (s->ps.sps->chroma_format_idc != 0) {
2084 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2085 if (chroma_mode != 4) {
2086 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2087 lc->pu.intra_pred_mode_c[0] = 34;
2088 else
2089 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
2090 } else {
2091 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
2092 }
2093 }
2094 }
2095
intra_prediction_unit_default_value(HEVCContext * s,int x0,int y0,int log2_cb_size)2096 static void intra_prediction_unit_default_value(HEVCContext *s,
2097 int x0, int y0,
2098 int log2_cb_size)
2099 {
2100 HEVCLocalContext *lc = s->HEVClc;
2101 int pb_size = 1 << log2_cb_size;
2102 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
2103 int min_pu_width = s->ps.sps->min_pu_width;
2104 MvField *tab_mvf = s->ref->tab_mvf;
2105 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2106 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2107 int j, k;
2108
2109 if (size_in_pus == 0)
2110 size_in_pus = 1;
2111 for (j = 0; j < size_in_pus; j++)
2112 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2113 if (lc->cu.pred_mode == MODE_INTRA)
2114 for (j = 0; j < size_in_pus; j++)
2115 for (k = 0; k < size_in_pus; k++)
2116 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2117 }
2118
hls_coding_unit(HEVCContext * s,int x0,int y0,int log2_cb_size)2119 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2120 {
2121 int cb_size = 1 << log2_cb_size;
2122 HEVCLocalContext *lc = s->HEVClc;
2123 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2124 int length = cb_size >> log2_min_cb_size;
2125 int min_cb_width = s->ps.sps->min_cb_width;
2126 int x_cb = x0 >> log2_min_cb_size;
2127 int y_cb = y0 >> log2_min_cb_size;
2128 int idx = log2_cb_size - 2;
2129 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2130 int x, y, ret;
2131
2132 lc->cu.x = x0;
2133 lc->cu.y = y0;
2134 lc->cu.pred_mode = MODE_INTRA;
2135 lc->cu.part_mode = PART_2Nx2N;
2136 lc->cu.intra_split_flag = 0;
2137
2138 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2139 for (x = 0; x < 4; x++)
2140 lc->pu.intra_pred_mode[x] = 1;
2141 if (s->ps.pps->transquant_bypass_enable_flag) {
2142 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2143 if (lc->cu.cu_transquant_bypass_flag)
2144 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2145 } else
2146 lc->cu.cu_transquant_bypass_flag = 0;
2147
2148 if (s->sh.slice_type != HEVC_SLICE_I) {
2149 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2150
2151 x = y_cb * min_cb_width + x_cb;
2152 for (y = 0; y < length; y++) {
2153 memset(&s->skip_flag[x], skip_flag, length);
2154 x += min_cb_width;
2155 }
2156 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2157 } else {
2158 x = y_cb * min_cb_width + x_cb;
2159 for (y = 0; y < length; y++) {
2160 memset(&s->skip_flag[x], 0, length);
2161 x += min_cb_width;
2162 }
2163 }
2164
2165 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2166 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2167 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2168
2169 if (!s->sh.disable_deblocking_filter_flag)
2170 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2171 } else {
2172 int pcm_flag = 0;
2173
2174 if (s->sh.slice_type != HEVC_SLICE_I)
2175 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2176 if (lc->cu.pred_mode != MODE_INTRA ||
2177 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2178 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2179 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2180 lc->cu.pred_mode == MODE_INTRA;
2181 }
2182
2183 if (lc->cu.pred_mode == MODE_INTRA) {
2184 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2185 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2186 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2187 pcm_flag = ff_hevc_pcm_flag_decode(s);
2188 }
2189 if (pcm_flag) {
2190 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2191 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2192 if (s->ps.sps->pcm.loop_filter_disable_flag)
2193 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2194
2195 if (ret < 0)
2196 return ret;
2197 } else {
2198 intra_prediction_unit(s, x0, y0, log2_cb_size);
2199 }
2200 } else {
2201 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2202 switch (lc->cu.part_mode) {
2203 case PART_2Nx2N:
2204 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2205 break;
2206 case PART_2NxN:
2207 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2208 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2209 break;
2210 case PART_Nx2N:
2211 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2212 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2213 break;
2214 case PART_2NxnU:
2215 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2216 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2217 break;
2218 case PART_2NxnD:
2219 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2220 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2221 break;
2222 case PART_nLx2N:
2223 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2224 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2225 break;
2226 case PART_nRx2N:
2227 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2228 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2229 break;
2230 case PART_NxN:
2231 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2232 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2233 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2234 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2235 break;
2236 }
2237 }
2238
2239 if (!pcm_flag) {
2240 int rqt_root_cbf = 1;
2241
2242 if (lc->cu.pred_mode != MODE_INTRA &&
2243 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2244 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2245 }
2246 if (rqt_root_cbf) {
2247 const static int cbf[2] = { 0 };
2248 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2249 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2250 s->ps.sps->max_transform_hierarchy_depth_inter;
2251 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2252 log2_cb_size,
2253 log2_cb_size, 0, 0, cbf, cbf);
2254 if (ret < 0)
2255 return ret;
2256 } else {
2257 if (!s->sh.disable_deblocking_filter_flag)
2258 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2259 }
2260 }
2261 }
2262
2263 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2264 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2265
2266 x = y_cb * min_cb_width + x_cb;
2267 for (y = 0; y < length; y++) {
2268 memset(&s->qp_y_tab[x], lc->qp_y, length);
2269 x += min_cb_width;
2270 }
2271
2272 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2273 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2274 lc->qPy_pred = lc->qp_y;
2275 }
2276
2277 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2278
2279 return 0;
2280 }
2281
hls_coding_quadtree(HEVCContext * s,int x0,int y0,int log2_cb_size,int cb_depth)2282 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2283 int log2_cb_size, int cb_depth)
2284 {
2285 HEVCLocalContext *lc = s->HEVClc;
2286 const int cb_size = 1 << log2_cb_size;
2287 int ret;
2288 int split_cu;
2289
2290 lc->ct_depth = cb_depth;
2291 if (x0 + cb_size <= s->ps.sps->width &&
2292 y0 + cb_size <= s->ps.sps->height &&
2293 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2294 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2295 } else {
2296 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2297 }
2298 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2299 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2300 lc->tu.is_cu_qp_delta_coded = 0;
2301 lc->tu.cu_qp_delta = 0;
2302 }
2303
2304 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2305 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2306 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2307 }
2308
2309 if (split_cu) {
2310 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2311 const int cb_size_split = cb_size >> 1;
2312 const int x1 = x0 + cb_size_split;
2313 const int y1 = y0 + cb_size_split;
2314
2315 int more_data = 0;
2316
2317 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2318 if (more_data < 0)
2319 return more_data;
2320
2321 if (more_data && x1 < s->ps.sps->width) {
2322 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2323 if (more_data < 0)
2324 return more_data;
2325 }
2326 if (more_data && y1 < s->ps.sps->height) {
2327 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2328 if (more_data < 0)
2329 return more_data;
2330 }
2331 if (more_data && x1 < s->ps.sps->width &&
2332 y1 < s->ps.sps->height) {
2333 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2334 if (more_data < 0)
2335 return more_data;
2336 }
2337
2338 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2339 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2340 lc->qPy_pred = lc->qp_y;
2341
2342 if (more_data)
2343 return ((x1 + cb_size_split) < s->ps.sps->width ||
2344 (y1 + cb_size_split) < s->ps.sps->height);
2345 else
2346 return 0;
2347 } else {
2348 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2349 if (ret < 0)
2350 return ret;
2351 if ((!((x0 + cb_size) %
2352 (1 << (s->ps.sps->log2_ctb_size))) ||
2353 (x0 + cb_size >= s->ps.sps->width)) &&
2354 (!((y0 + cb_size) %
2355 (1 << (s->ps.sps->log2_ctb_size))) ||
2356 (y0 + cb_size >= s->ps.sps->height))) {
2357 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2358 return !end_of_slice_flag;
2359 } else {
2360 return 1;
2361 }
2362 }
2363
2364 return 0;
2365 }
2366
hls_decode_neighbour(HEVCContext * s,int x_ctb,int y_ctb,int ctb_addr_ts)2367 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2368 int ctb_addr_ts)
2369 {
2370 HEVCLocalContext *lc = s->HEVClc;
2371 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2372 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2373 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2374
2375 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2376
2377 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2378 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2379 lc->first_qp_group = 1;
2380 lc->end_of_tiles_x = s->ps.sps->width;
2381 } else if (s->ps.pps->tiles_enabled_flag) {
2382 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2383 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2384 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2385 lc->first_qp_group = 1;
2386 }
2387 } else {
2388 lc->end_of_tiles_x = s->ps.sps->width;
2389 }
2390
2391 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2392
2393 lc->boundary_flags = 0;
2394 if (s->ps.pps->tiles_enabled_flag) {
2395 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]])
2396 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2397 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2398 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2399 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]])
2400 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2401 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2402 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2403 } else {
2404 if (ctb_addr_in_slice <= 0)
2405 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2406 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2407 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2408 }
2409
2410 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2411 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2412 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]]));
2413 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]]));
2414 }
2415
hls_decode_entry(AVCodecContext * avctxt,void * isFilterThread)2416 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2417 {
2418 HEVCContext *s = avctxt->priv_data;
2419 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2420 int more_data = 1;
2421 int x_ctb = 0;
2422 int y_ctb = 0;
2423 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2424 int ret;
2425
2426 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2427 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2428 return AVERROR_INVALIDDATA;
2429 }
2430
2431 if (s->sh.dependent_slice_segment_flag) {
2432 int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2433 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2434 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2435 return AVERROR_INVALIDDATA;
2436 }
2437 }
2438
2439 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2440 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2441
2442 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2443 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2444 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2445
2446 ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2447 if (ret < 0) {
2448 s->tab_slice_address[ctb_addr_rs] = -1;
2449 return ret;
2450 }
2451
2452 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2453
2454 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2455 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2456 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2457
2458 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2459 if (more_data < 0) {
2460 s->tab_slice_address[ctb_addr_rs] = -1;
2461 return more_data;
2462 }
2463
2464
2465 ctb_addr_ts++;
2466 ff_hevc_save_states(s, ctb_addr_ts);
2467 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2468 }
2469
2470 if (x_ctb + ctb_size >= s->ps.sps->width &&
2471 y_ctb + ctb_size >= s->ps.sps->height)
2472 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2473
2474 return ctb_addr_ts;
2475 }
2476
hls_slice_data(HEVCContext * s)2477 static int hls_slice_data(HEVCContext *s)
2478 {
2479 int arg[2];
2480 int ret[2];
2481
2482 arg[0] = 0;
2483 arg[1] = 1;
2484
2485 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2486 return ret[0];
2487 }
hls_decode_entry_wpp(AVCodecContext * avctxt,void * input_ctb_row,int job,int self_id)2488 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2489 {
2490 HEVCContext *s1 = avctxt->priv_data, *s;
2491 HEVCLocalContext *lc;
2492 int ctb_size = 1<< s1->ps.sps->log2_ctb_size;
2493 int more_data = 1;
2494 int *ctb_row_p = input_ctb_row;
2495 int ctb_row = ctb_row_p[job];
2496 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->ps.sps->width + ctb_size - 1) >> s1->ps.sps->log2_ctb_size);
2497 int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2498 int thread = ctb_row % s1->threads_number;
2499 int ret;
2500
2501 s = s1->sList[self_id];
2502 lc = s->HEVClc;
2503
2504 if(ctb_row) {
2505 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2506 if (ret < 0)
2507 goto error;
2508 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2509 }
2510
2511 while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2512 int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2513 int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2514
2515 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2516
2517 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2518
2519 if (atomic_load(&s1->wpp_err)) {
2520 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2521 return 0;
2522 }
2523
2524 ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2525 if (ret < 0)
2526 goto error;
2527 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2528 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2529
2530 if (more_data < 0) {
2531 ret = more_data;
2532 goto error;
2533 }
2534
2535 ctb_addr_ts++;
2536
2537 ff_hevc_save_states(s, ctb_addr_ts);
2538 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2539 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2540
2541 if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2542 atomic_store(&s1->wpp_err, 1);
2543 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2544 return 0;
2545 }
2546
2547 if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) {
2548 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2549 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2550 return ctb_addr_ts;
2551 }
2552 ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2553 x_ctb+=ctb_size;
2554
2555 if(x_ctb >= s->ps.sps->width) {
2556 break;
2557 }
2558 }
2559 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2560
2561 return 0;
2562 error:
2563 s->tab_slice_address[ctb_addr_rs] = -1;
2564 atomic_store(&s1->wpp_err, 1);
2565 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2566 return ret;
2567 }
2568
hls_slice_data_wpp(HEVCContext * s,const H2645NAL * nal)2569 static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
2570 {
2571 const uint8_t *data = nal->data;
2572 int length = nal->size;
2573 HEVCLocalContext *lc = s->HEVClc;
2574 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2575 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2576 int64_t offset;
2577 int64_t startheader, cmpt = 0;
2578 int i, j, res = 0;
2579
2580 if (!ret || !arg) {
2581 av_free(ret);
2582 av_free(arg);
2583 return AVERROR(ENOMEM);
2584 }
2585
2586 if (s->sh.slice_ctb_addr_rs + s->sh.num_entry_point_offsets * s->ps.sps->ctb_width >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
2587 av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2588 s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets,
2589 s->ps.sps->ctb_width, s->ps.sps->ctb_height
2590 );
2591 res = AVERROR_INVALIDDATA;
2592 goto error;
2593 }
2594
2595 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2596
2597 if (!s->sList[1]) {
2598 for (i = 1; i < s->threads_number; i++) {
2599 s->sList[i] = av_malloc(sizeof(HEVCContext));
2600 memcpy(s->sList[i], s, sizeof(HEVCContext));
2601 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2602 s->sList[i]->HEVClc = s->HEVClcList[i];
2603 }
2604 }
2605
2606 offset = (lc->gb.index >> 3);
2607
2608 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2609 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2610 startheader--;
2611 cmpt++;
2612 }
2613 }
2614
2615 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2616 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2617 for (j = 0, cmpt = 0, startheader = offset
2618 + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2619 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2620 startheader--;
2621 cmpt++;
2622 }
2623 }
2624 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2625 s->sh.offset[i - 1] = offset;
2626
2627 }
2628 if (s->sh.num_entry_point_offsets != 0) {
2629 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2630 if (length < offset) {
2631 av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2632 res = AVERROR_INVALIDDATA;
2633 goto error;
2634 }
2635 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2636 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2637
2638 }
2639 s->data = data;
2640
2641 for (i = 1; i < s->threads_number; i++) {
2642 s->sList[i]->HEVClc->first_qp_group = 1;
2643 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2644 memcpy(s->sList[i], s, sizeof(HEVCContext));
2645 s->sList[i]->HEVClc = s->HEVClcList[i];
2646 }
2647
2648 atomic_store(&s->wpp_err, 0);
2649 ff_reset_entries(s->avctx);
2650
2651 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2652 arg[i] = i;
2653 ret[i] = 0;
2654 }
2655
2656 if (s->ps.pps->entropy_coding_sync_enabled_flag)
2657 s->avctx->execute2(s->avctx, hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2658
2659 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2660 res += ret[i];
2661 error:
2662 av_free(ret);
2663 av_free(arg);
2664 return res;
2665 }
2666
set_side_data(HEVCContext * s)2667 static int set_side_data(HEVCContext *s)
2668 {
2669 AVFrame *out = s->ref->frame;
2670
2671 if (s->sei.frame_packing.present &&
2672 s->sei.frame_packing.arrangement_type >= 3 &&
2673 s->sei.frame_packing.arrangement_type <= 5 &&
2674 s->sei.frame_packing.content_interpretation_type > 0 &&
2675 s->sei.frame_packing.content_interpretation_type < 3) {
2676 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2677 if (!stereo)
2678 return AVERROR(ENOMEM);
2679
2680 switch (s->sei.frame_packing.arrangement_type) {
2681 case 3:
2682 if (s->sei.frame_packing.quincunx_subsampling)
2683 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2684 else
2685 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2686 break;
2687 case 4:
2688 stereo->type = AV_STEREO3D_TOPBOTTOM;
2689 break;
2690 case 5:
2691 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2692 break;
2693 }
2694
2695 if (s->sei.frame_packing.content_interpretation_type == 2)
2696 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2697
2698 if (s->sei.frame_packing.arrangement_type == 5) {
2699 if (s->sei.frame_packing.current_frame_is_frame0_flag)
2700 stereo->view = AV_STEREO3D_VIEW_LEFT;
2701 else
2702 stereo->view = AV_STEREO3D_VIEW_RIGHT;
2703 }
2704 }
2705
2706 if (s->sei.display_orientation.present &&
2707 (s->sei.display_orientation.anticlockwise_rotation ||
2708 s->sei.display_orientation.hflip || s->sei.display_orientation.vflip)) {
2709 double angle = s->sei.display_orientation.anticlockwise_rotation * 360 / (double) (1 << 16);
2710 AVFrameSideData *rotation = av_frame_new_side_data(out,
2711 AV_FRAME_DATA_DISPLAYMATRIX,
2712 sizeof(int32_t) * 9);
2713 if (!rotation)
2714 return AVERROR(ENOMEM);
2715
2716 av_display_rotation_set((int32_t *)rotation->data, angle);
2717 av_display_matrix_flip((int32_t *)rotation->data,
2718 s->sei.display_orientation.hflip,
2719 s->sei.display_orientation.vflip);
2720 }
2721
2722 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2723 // so the side data persists for the entire coded video sequence.
2724 if (s->sei.mastering_display.present > 0 &&
2725 IS_IRAP(s) && s->no_rasl_output_flag) {
2726 s->sei.mastering_display.present--;
2727 }
2728 if (s->sei.mastering_display.present) {
2729 // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
2730 const int mapping[3] = {2, 0, 1};
2731 const int chroma_den = 50000;
2732 const int luma_den = 10000;
2733 int i;
2734 AVMasteringDisplayMetadata *metadata =
2735 av_mastering_display_metadata_create_side_data(out);
2736 if (!metadata)
2737 return AVERROR(ENOMEM);
2738
2739 for (i = 0; i < 3; i++) {
2740 const int j = mapping[i];
2741 metadata->display_primaries[i][0].num = s->sei.mastering_display.display_primaries[j][0];
2742 metadata->display_primaries[i][0].den = chroma_den;
2743 metadata->display_primaries[i][1].num = s->sei.mastering_display.display_primaries[j][1];
2744 metadata->display_primaries[i][1].den = chroma_den;
2745 }
2746 metadata->white_point[0].num = s->sei.mastering_display.white_point[0];
2747 metadata->white_point[0].den = chroma_den;
2748 metadata->white_point[1].num = s->sei.mastering_display.white_point[1];
2749 metadata->white_point[1].den = chroma_den;
2750
2751 metadata->max_luminance.num = s->sei.mastering_display.max_luminance;
2752 metadata->max_luminance.den = luma_den;
2753 metadata->min_luminance.num = s->sei.mastering_display.min_luminance;
2754 metadata->min_luminance.den = luma_den;
2755 metadata->has_luminance = 1;
2756 metadata->has_primaries = 1;
2757
2758 av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n");
2759 av_log(s->avctx, AV_LOG_DEBUG,
2760 "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2761 av_q2d(metadata->display_primaries[0][0]),
2762 av_q2d(metadata->display_primaries[0][1]),
2763 av_q2d(metadata->display_primaries[1][0]),
2764 av_q2d(metadata->display_primaries[1][1]),
2765 av_q2d(metadata->display_primaries[2][0]),
2766 av_q2d(metadata->display_primaries[2][1]),
2767 av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]));
2768 av_log(s->avctx, AV_LOG_DEBUG,
2769 "min_luminance=%f, max_luminance=%f\n",
2770 av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
2771 }
2772 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2773 // so the side data persists for the entire coded video sequence.
2774 if (s->sei.content_light.present > 0 &&
2775 IS_IRAP(s) && s->no_rasl_output_flag) {
2776 s->sei.content_light.present--;
2777 }
2778 if (s->sei.content_light.present) {
2779 AVContentLightMetadata *metadata =
2780 av_content_light_metadata_create_side_data(out);
2781 if (!metadata)
2782 return AVERROR(ENOMEM);
2783 metadata->MaxCLL = s->sei.content_light.max_content_light_level;
2784 metadata->MaxFALL = s->sei.content_light.max_pic_average_light_level;
2785
2786 av_log(s->avctx, AV_LOG_DEBUG, "Content Light Level Metadata:\n");
2787 av_log(s->avctx, AV_LOG_DEBUG, "MaxCLL=%d, MaxFALL=%d\n",
2788 metadata->MaxCLL, metadata->MaxFALL);
2789 }
2790
2791 if (s->sei.a53_caption.buf_ref) {
2792 HEVCSEIA53Caption *a53 = &s->sei.a53_caption;
2793
2794 AVFrameSideData *sd = av_frame_new_side_data_from_buf(out, AV_FRAME_DATA_A53_CC, a53->buf_ref);
2795 if (!sd)
2796 av_buffer_unref(&a53->buf_ref);
2797 a53->buf_ref = NULL;
2798
2799 s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2800 }
2801
2802 return 0;
2803 }
2804
hevc_frame_start(HEVCContext * s)2805 static int hevc_frame_start(HEVCContext *s)
2806 {
2807 HEVCLocalContext *lc = s->HEVClc;
2808 int pic_size_in_ctb = ((s->ps.sps->width >> s->ps.sps->log2_min_cb_size) + 1) *
2809 ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1);
2810 int ret;
2811
2812 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2813 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2814 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2815 memset(s->is_pcm, 0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1));
2816 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2817
2818 s->is_decoded = 0;
2819 s->first_nal_type = s->nal_unit_type;
2820
2821 s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos);
2822
2823 if (s->ps.pps->tiles_enabled_flag)
2824 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2825
2826 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2827 if (ret < 0)
2828 goto fail;
2829
2830 ret = ff_hevc_frame_rps(s);
2831 if (ret < 0) {
2832 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2833 goto fail;
2834 }
2835
2836 s->ref->frame->key_frame = IS_IRAP(s);
2837
2838 ret = set_side_data(s);
2839 if (ret < 0)
2840 goto fail;
2841
2842 s->frame->pict_type = 3 - s->sh.slice_type;
2843
2844 if (!IS_IRAP(s))
2845 ff_hevc_bump_frame(s);
2846
2847 av_frame_unref(s->output_frame);
2848 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2849 if (ret < 0)
2850 goto fail;
2851
2852 if (!s->avctx->hwaccel)
2853 ff_thread_finish_setup(s->avctx);
2854
2855 return 0;
2856
2857 fail:
2858 if (s->ref)
2859 ff_hevc_unref_frame(s, s->ref, ~0);
2860 s->ref = NULL;
2861 return ret;
2862 }
2863
decode_nal_unit(HEVCContext * s,const H2645NAL * nal)2864 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2865 {
2866 HEVCLocalContext *lc = s->HEVClc;
2867 GetBitContext *gb = &lc->gb;
2868 int ctb_addr_ts, ret;
2869
2870 *gb = nal->gb;
2871 s->nal_unit_type = nal->type;
2872 s->temporal_id = nal->temporal_id;
2873
2874 switch (s->nal_unit_type) {
2875 case HEVC_NAL_VPS:
2876 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2877 ret = s->avctx->hwaccel->decode_params(s->avctx,
2878 nal->type,
2879 nal->raw_data,
2880 nal->raw_size);
2881 if (ret < 0)
2882 goto fail;
2883 }
2884 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2885 if (ret < 0)
2886 goto fail;
2887 break;
2888 case HEVC_NAL_SPS:
2889 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2890 ret = s->avctx->hwaccel->decode_params(s->avctx,
2891 nal->type,
2892 nal->raw_data,
2893 nal->raw_size);
2894 if (ret < 0)
2895 goto fail;
2896 }
2897 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2898 s->apply_defdispwin);
2899 if (ret < 0)
2900 goto fail;
2901 break;
2902 case HEVC_NAL_PPS:
2903 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2904 ret = s->avctx->hwaccel->decode_params(s->avctx,
2905 nal->type,
2906 nal->raw_data,
2907 nal->raw_size);
2908 if (ret < 0)
2909 goto fail;
2910 }
2911 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2912 if (ret < 0)
2913 goto fail;
2914 break;
2915 case HEVC_NAL_SEI_PREFIX:
2916 case HEVC_NAL_SEI_SUFFIX:
2917 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2918 ret = s->avctx->hwaccel->decode_params(s->avctx,
2919 nal->type,
2920 nal->raw_data,
2921 nal->raw_size);
2922 if (ret < 0)
2923 goto fail;
2924 }
2925 ret = ff_hevc_decode_nal_sei(gb, s->avctx, &s->sei, &s->ps, s->nal_unit_type);
2926 if (ret < 0)
2927 goto fail;
2928 break;
2929 case HEVC_NAL_TRAIL_R:
2930 case HEVC_NAL_TRAIL_N:
2931 case HEVC_NAL_TSA_N:
2932 case HEVC_NAL_TSA_R:
2933 case HEVC_NAL_STSA_N:
2934 case HEVC_NAL_STSA_R:
2935 case HEVC_NAL_BLA_W_LP:
2936 case HEVC_NAL_BLA_W_RADL:
2937 case HEVC_NAL_BLA_N_LP:
2938 case HEVC_NAL_IDR_W_RADL:
2939 case HEVC_NAL_IDR_N_LP:
2940 case HEVC_NAL_CRA_NUT:
2941 case HEVC_NAL_RADL_N:
2942 case HEVC_NAL_RADL_R:
2943 case HEVC_NAL_RASL_N:
2944 case HEVC_NAL_RASL_R:
2945 ret = hls_slice_header(s);
2946 if (ret < 0)
2947 return ret;
2948 if (ret == 1) {
2949 ret = AVERROR_INVALIDDATA;
2950 goto fail;
2951 }
2952
2953
2954 if (
2955 (s->avctx->skip_frame >= AVDISCARD_BIDIR && s->sh.slice_type == HEVC_SLICE_B) ||
2956 (s->avctx->skip_frame >= AVDISCARD_NONINTRA && s->sh.slice_type != HEVC_SLICE_I) ||
2957 (s->avctx->skip_frame >= AVDISCARD_NONKEY && !IS_IRAP(s))) {
2958 break;
2959 }
2960
2961 if (s->sh.first_slice_in_pic_flag) {
2962 if (s->max_ra == INT_MAX) {
2963 if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
2964 s->max_ra = s->poc;
2965 } else {
2966 if (IS_IDR(s))
2967 s->max_ra = INT_MIN;
2968 }
2969 }
2970
2971 if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
2972 s->poc <= s->max_ra) {
2973 s->is_decoded = 0;
2974 break;
2975 } else {
2976 if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
2977 s->max_ra = INT_MIN;
2978 }
2979
2980 s->overlap ++;
2981 ret = hevc_frame_start(s);
2982 if (ret < 0)
2983 return ret;
2984 } else if (!s->ref) {
2985 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2986 goto fail;
2987 }
2988
2989 if (s->nal_unit_type != s->first_nal_type) {
2990 av_log(s->avctx, AV_LOG_ERROR,
2991 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2992 s->first_nal_type, s->nal_unit_type);
2993 return AVERROR_INVALIDDATA;
2994 }
2995
2996 if (!s->sh.dependent_slice_segment_flag &&
2997 s->sh.slice_type != HEVC_SLICE_I) {
2998 ret = ff_hevc_slice_rpl(s);
2999 if (ret < 0) {
3000 av_log(s->avctx, AV_LOG_WARNING,
3001 "Error constructing the reference lists for the current slice.\n");
3002 goto fail;
3003 }
3004 }
3005
3006 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
3007 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
3008 if (ret < 0)
3009 goto fail;
3010 }
3011
3012 if (s->avctx->hwaccel) {
3013 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
3014 if (ret < 0)
3015 goto fail;
3016 } else {
3017 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
3018 ctb_addr_ts = hls_slice_data_wpp(s, nal);
3019 else
3020 ctb_addr_ts = hls_slice_data(s);
3021 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
3022 s->is_decoded = 1;
3023 }
3024
3025 if (ctb_addr_ts < 0) {
3026 ret = ctb_addr_ts;
3027 goto fail;
3028 }
3029 }
3030 break;
3031 case HEVC_NAL_EOS_NUT:
3032 case HEVC_NAL_EOB_NUT:
3033 s->seq_decode = (s->seq_decode + 1) & 0xff;
3034 s->max_ra = INT_MAX;
3035 break;
3036 case HEVC_NAL_AUD:
3037 case HEVC_NAL_FD_NUT:
3038 break;
3039 default:
3040 av_log(s->avctx, AV_LOG_INFO,
3041 "Skipping NAL unit %d\n", s->nal_unit_type);
3042 }
3043
3044 return 0;
3045 fail:
3046 if (s->avctx->err_recognition & AV_EF_EXPLODE)
3047 return ret;
3048 return 0;
3049 }
3050
decode_nal_units(HEVCContext * s,const uint8_t * buf,int length)3051 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
3052 {
3053 int i, ret = 0;
3054 int eos_at_start = 1;
3055
3056 s->ref = NULL;
3057 s->last_eos = s->eos;
3058 s->eos = 0;
3059 s->overlap = 0;
3060
3061 /* split the input packet into NAL units, so we know the upper bound on the
3062 * number of slices in the frame */
3063 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
3064 s->nal_length_size, s->avctx->codec_id, 1, 0);
3065 if (ret < 0) {
3066 av_log(s->avctx, AV_LOG_ERROR,
3067 "Error splitting the input into NAL units.\n");
3068 return ret;
3069 }
3070
3071 for (i = 0; i < s->pkt.nb_nals; i++) {
3072 if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
3073 s->pkt.nals[i].type == HEVC_NAL_EOS_NUT) {
3074 if (eos_at_start) {
3075 s->last_eos = 1;
3076 } else {
3077 s->eos = 1;
3078 }
3079 } else {
3080 eos_at_start = 0;
3081 }
3082 }
3083
3084 /* decode the NAL units */
3085 for (i = 0; i < s->pkt.nb_nals; i++) {
3086 H2645NAL *nal = &s->pkt.nals[i];
3087
3088 if (s->avctx->skip_frame >= AVDISCARD_ALL ||
3089 (s->avctx->skip_frame >= AVDISCARD_NONREF
3090 && ff_hevc_nal_is_nonref(nal->type)) || nal->nuh_layer_id > 0)
3091 continue;
3092
3093 ret = decode_nal_unit(s, nal);
3094 if (ret >= 0 && s->overlap > 2)
3095 ret = AVERROR_INVALIDDATA;
3096 if (ret < 0) {
3097 av_log(s->avctx, AV_LOG_WARNING,
3098 "Error parsing NAL unit #%d.\n", i);
3099 goto fail;
3100 }
3101 }
3102
3103 fail:
3104 if (s->ref && s->threads_type == FF_THREAD_FRAME)
3105 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
3106
3107 return ret;
3108 }
3109
print_md5(void * log_ctx,int level,uint8_t md5[16])3110 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
3111 {
3112 int i;
3113 for (i = 0; i < 16; i++)
3114 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3115 }
3116
verify_md5(HEVCContext * s,AVFrame * frame)3117 static int verify_md5(HEVCContext *s, AVFrame *frame)
3118 {
3119 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3120 int pixel_shift;
3121 int i, j;
3122
3123 if (!desc)
3124 return AVERROR(EINVAL);
3125
3126 pixel_shift = desc->comp[0].depth > 8;
3127
3128 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3129 s->poc);
3130
3131 /* the checksums are LE, so we have to byteswap for >8bpp formats
3132 * on BE arches */
3133 #if HAVE_BIGENDIAN
3134 if (pixel_shift && !s->checksum_buf) {
3135 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3136 FFMAX3(frame->linesize[0], frame->linesize[1],
3137 frame->linesize[2]));
3138 if (!s->checksum_buf)
3139 return AVERROR(ENOMEM);
3140 }
3141 #endif
3142
3143 for (i = 0; frame->data[i]; i++) {
3144 int width = s->avctx->coded_width;
3145 int height = s->avctx->coded_height;
3146 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
3147 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3148 uint8_t md5[16];
3149
3150 av_md5_init(s->md5_ctx);
3151 for (j = 0; j < h; j++) {
3152 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3153 #if HAVE_BIGENDIAN
3154 if (pixel_shift) {
3155 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3156 (const uint16_t *) src, w);
3157 src = s->checksum_buf;
3158 }
3159 #endif
3160 av_md5_update(s->md5_ctx, src, w << pixel_shift);
3161 }
3162 av_md5_final(s->md5_ctx, md5);
3163
3164 if (!memcmp(md5, s->sei.picture_hash.md5[i], 16)) {
3165 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3166 print_md5(s->avctx, AV_LOG_DEBUG, md5);
3167 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3168 } else {
3169 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3170 print_md5(s->avctx, AV_LOG_ERROR, md5);
3171 av_log (s->avctx, AV_LOG_ERROR, " != ");
3172 print_md5(s->avctx, AV_LOG_ERROR, s->sei.picture_hash.md5[i]);
3173 av_log (s->avctx, AV_LOG_ERROR, "\n");
3174 return AVERROR_INVALIDDATA;
3175 }
3176 }
3177
3178 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3179
3180 return 0;
3181 }
3182
hevc_decode_extradata(HEVCContext * s,uint8_t * buf,int length,int first)3183 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first)
3184 {
3185 int ret, i;
3186
3187 ret = ff_hevc_decode_extradata(buf, length, &s->ps, &s->sei, &s->is_nalff,
3188 &s->nal_length_size, s->avctx->err_recognition,
3189 s->apply_defdispwin, s->avctx);
3190 if (ret < 0)
3191 return ret;
3192
3193 /* export stream parameters from the first SPS */
3194 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3195 if (first && s->ps.sps_list[i]) {
3196 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3197 export_stream_params(s, sps);
3198 break;
3199 }
3200 }
3201
3202 return 0;
3203 }
3204
hevc_decode_frame(AVCodecContext * avctx,void * data,int * got_output,AVPacket * avpkt)3205 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3206 AVPacket *avpkt)
3207 {
3208 int ret;
3209 int new_extradata_size;
3210 uint8_t *new_extradata;
3211 HEVCContext *s = avctx->priv_data;
3212
3213 if (!avpkt->size) {
3214 ret = ff_hevc_output_frame(s, data, 1);
3215 if (ret < 0)
3216 return ret;
3217
3218 *got_output = ret;
3219 return 0;
3220 }
3221
3222 new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
3223 &new_extradata_size);
3224 if (new_extradata && new_extradata_size > 0) {
3225 ret = hevc_decode_extradata(s, new_extradata, new_extradata_size, 0);
3226 if (ret < 0)
3227 return ret;
3228 }
3229
3230 s->ref = NULL;
3231 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3232 if (ret < 0)
3233 return ret;
3234
3235 if (avctx->hwaccel) {
3236 if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) {
3237 av_log(avctx, AV_LOG_ERROR,
3238 "hardware accelerator failed to decode picture\n");
3239 ff_hevc_unref_frame(s, s->ref, ~0);
3240 return ret;
3241 }
3242 } else {
3243 /* verify the SEI checksum */
3244 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3245 s->sei.picture_hash.is_md5) {
3246 ret = verify_md5(s, s->ref->frame);
3247 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3248 ff_hevc_unref_frame(s, s->ref, ~0);
3249 return ret;
3250 }
3251 }
3252 }
3253 s->sei.picture_hash.is_md5 = 0;
3254
3255 if (s->is_decoded) {
3256 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3257 s->is_decoded = 0;
3258 }
3259
3260 if (s->output_frame->buf[0]) {
3261 av_frame_move_ref(data, s->output_frame);
3262 *got_output = 1;
3263 }
3264
3265 return avpkt->size;
3266 }
3267
hevc_ref_frame(HEVCContext * s,HEVCFrame * dst,HEVCFrame * src)3268 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3269 {
3270 int ret;
3271
3272 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3273 if (ret < 0)
3274 return ret;
3275
3276 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3277 if (!dst->tab_mvf_buf)
3278 goto fail;
3279 dst->tab_mvf = src->tab_mvf;
3280
3281 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3282 if (!dst->rpl_tab_buf)
3283 goto fail;
3284 dst->rpl_tab = src->rpl_tab;
3285
3286 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3287 if (!dst->rpl_buf)
3288 goto fail;
3289
3290 dst->poc = src->poc;
3291 dst->ctb_count = src->ctb_count;
3292 dst->flags = src->flags;
3293 dst->sequence = src->sequence;
3294
3295 if (src->hwaccel_picture_private) {
3296 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3297 if (!dst->hwaccel_priv_buf)
3298 goto fail;
3299 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3300 }
3301
3302 return 0;
3303 fail:
3304 ff_hevc_unref_frame(s, dst, ~0);
3305 return AVERROR(ENOMEM);
3306 }
3307
hevc_decode_free(AVCodecContext * avctx)3308 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3309 {
3310 HEVCContext *s = avctx->priv_data;
3311 int i;
3312
3313 pic_arrays_free(s);
3314
3315 av_freep(&s->md5_ctx);
3316
3317 av_freep(&s->cabac_state);
3318
3319 for (i = 0; i < 3; i++) {
3320 av_freep(&s->sao_pixel_buffer_h[i]);
3321 av_freep(&s->sao_pixel_buffer_v[i]);
3322 }
3323 av_frame_free(&s->output_frame);
3324
3325 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3326 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3327 av_frame_free(&s->DPB[i].frame);
3328 }
3329
3330 ff_hevc_ps_uninit(&s->ps);
3331
3332 av_freep(&s->sh.entry_point_offset);
3333 av_freep(&s->sh.offset);
3334 av_freep(&s->sh.size);
3335
3336 for (i = 1; i < s->threads_number; i++) {
3337 HEVCLocalContext *lc = s->HEVClcList[i];
3338 if (lc) {
3339 av_freep(&s->HEVClcList[i]);
3340 av_freep(&s->sList[i]);
3341 }
3342 }
3343 if (s->HEVClc == s->HEVClcList[0])
3344 s->HEVClc = NULL;
3345 av_freep(&s->HEVClcList[0]);
3346
3347 ff_h2645_packet_uninit(&s->pkt);
3348
3349 ff_hevc_reset_sei(&s->sei);
3350
3351 return 0;
3352 }
3353
hevc_init_context(AVCodecContext * avctx)3354 static av_cold int hevc_init_context(AVCodecContext *avctx)
3355 {
3356 HEVCContext *s = avctx->priv_data;
3357 int i;
3358
3359 s->avctx = avctx;
3360
3361 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3362 if (!s->HEVClc)
3363 goto fail;
3364 s->HEVClcList[0] = s->HEVClc;
3365 s->sList[0] = s;
3366
3367 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3368 if (!s->cabac_state)
3369 goto fail;
3370
3371 s->output_frame = av_frame_alloc();
3372 if (!s->output_frame)
3373 goto fail;
3374
3375 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3376 s->DPB[i].frame = av_frame_alloc();
3377 if (!s->DPB[i].frame)
3378 goto fail;
3379 s->DPB[i].tf.f = s->DPB[i].frame;
3380 }
3381
3382 s->max_ra = INT_MAX;
3383
3384 s->md5_ctx = av_md5_alloc();
3385 if (!s->md5_ctx)
3386 goto fail;
3387
3388 ff_bswapdsp_init(&s->bdsp);
3389
3390 s->context_initialized = 1;
3391 s->eos = 0;
3392
3393 ff_hevc_reset_sei(&s->sei);
3394
3395 return 0;
3396
3397 fail:
3398 hevc_decode_free(avctx);
3399 return AVERROR(ENOMEM);
3400 }
3401
3402 #if HAVE_THREADS
hevc_update_thread_context(AVCodecContext * dst,const AVCodecContext * src)3403 static int hevc_update_thread_context(AVCodecContext *dst,
3404 const AVCodecContext *src)
3405 {
3406 HEVCContext *s = dst->priv_data;
3407 HEVCContext *s0 = src->priv_data;
3408 int i, ret;
3409
3410 if (!s->context_initialized) {
3411 ret = hevc_init_context(dst);
3412 if (ret < 0)
3413 return ret;
3414 }
3415
3416 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3417 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3418 if (s0->DPB[i].frame->buf[0]) {
3419 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3420 if (ret < 0)
3421 return ret;
3422 }
3423 }
3424
3425 if (s->ps.sps != s0->ps.sps)
3426 s->ps.sps = NULL;
3427 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
3428 av_buffer_unref(&s->ps.vps_list[i]);
3429 if (s0->ps.vps_list[i]) {
3430 s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
3431 if (!s->ps.vps_list[i])
3432 return AVERROR(ENOMEM);
3433 }
3434 }
3435
3436 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3437 av_buffer_unref(&s->ps.sps_list[i]);
3438 if (s0->ps.sps_list[i]) {
3439 s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
3440 if (!s->ps.sps_list[i])
3441 return AVERROR(ENOMEM);
3442 }
3443 }
3444
3445 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
3446 av_buffer_unref(&s->ps.pps_list[i]);
3447 if (s0->ps.pps_list[i]) {
3448 s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
3449 if (!s->ps.pps_list[i])
3450 return AVERROR(ENOMEM);
3451 }
3452 }
3453
3454 if (s->ps.sps != s0->ps.sps)
3455 if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
3456 return ret;
3457
3458 s->seq_decode = s0->seq_decode;
3459 s->seq_output = s0->seq_output;
3460 s->pocTid0 = s0->pocTid0;
3461 s->max_ra = s0->max_ra;
3462 s->eos = s0->eos;
3463 s->no_rasl_output_flag = s0->no_rasl_output_flag;
3464
3465 s->is_nalff = s0->is_nalff;
3466 s->nal_length_size = s0->nal_length_size;
3467
3468 s->threads_number = s0->threads_number;
3469 s->threads_type = s0->threads_type;
3470
3471 if (s0->eos) {
3472 s->seq_decode = (s->seq_decode + 1) & 0xff;
3473 s->max_ra = INT_MAX;
3474 }
3475
3476 av_buffer_unref(&s->sei.a53_caption.buf_ref);
3477 if (s0->sei.a53_caption.buf_ref) {
3478 s->sei.a53_caption.buf_ref = av_buffer_ref(s0->sei.a53_caption.buf_ref);
3479 if (!s->sei.a53_caption.buf_ref)
3480 return AVERROR(ENOMEM);
3481 }
3482
3483 s->sei.frame_packing = s0->sei.frame_packing;
3484 s->sei.display_orientation = s0->sei.display_orientation;
3485 s->sei.mastering_display = s0->sei.mastering_display;
3486 s->sei.content_light = s0->sei.content_light;
3487 s->sei.alternative_transfer = s0->sei.alternative_transfer;
3488
3489 return 0;
3490 }
3491 #endif
3492
hevc_decode_init(AVCodecContext * avctx)3493 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3494 {
3495 HEVCContext *s = avctx->priv_data;
3496 int ret;
3497
3498 ret = hevc_init_context(avctx);
3499 if (ret < 0)
3500 return ret;
3501
3502 s->enable_parallel_tiles = 0;
3503 s->sei.picture_timing.picture_struct = 0;
3504 s->eos = 1;
3505
3506 atomic_init(&s->wpp_err, 0);
3507
3508 if(avctx->active_thread_type & FF_THREAD_SLICE)
3509 s->threads_number = avctx->thread_count;
3510 else
3511 s->threads_number = 1;
3512
3513 if (!avctx->internal->is_copy) {
3514 if (avctx->extradata_size > 0 && avctx->extradata) {
3515 ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size, 1);
3516 if (ret < 0) {
3517 hevc_decode_free(avctx);
3518 return ret;
3519 }
3520 }
3521 }
3522
3523 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3524 s->threads_type = FF_THREAD_FRAME;
3525 else
3526 s->threads_type = FF_THREAD_SLICE;
3527
3528 return 0;
3529 }
3530
hevc_decode_flush(AVCodecContext * avctx)3531 static void hevc_decode_flush(AVCodecContext *avctx)
3532 {
3533 HEVCContext *s = avctx->priv_data;
3534 ff_hevc_flush_dpb(s);
3535 ff_hevc_reset_sei(&s->sei);
3536 s->max_ra = INT_MAX;
3537 s->eos = 1;
3538 }
3539
3540 #define OFFSET(x) offsetof(HEVCContext, x)
3541 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3542
3543 static const AVOption options[] = {
3544 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3545 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3546 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3547 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3548 { NULL },
3549 };
3550
3551 static const AVClass hevc_decoder_class = {
3552 .class_name = "HEVC decoder",
3553 .item_name = av_default_item_name,
3554 .option = options,
3555 .version = LIBAVUTIL_VERSION_INT,
3556 };
3557
3558 AVCodec ff_hevc_decoder = {
3559 .name = "hevc",
3560 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3561 .type = AVMEDIA_TYPE_VIDEO,
3562 .id = AV_CODEC_ID_HEVC,
3563 .priv_data_size = sizeof(HEVCContext),
3564 .priv_class = &hevc_decoder_class,
3565 .init = hevc_decode_init,
3566 .close = hevc_decode_free,
3567 .decode = hevc_decode_frame,
3568 .flush = hevc_decode_flush,
3569 .update_thread_context = ONLY_IF_THREADS_ENABLED(hevc_update_thread_context),
3570 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3571 AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
3572 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING |
3573 FF_CODEC_CAP_ALLOCATE_PROGRESS,
3574 .profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
3575 .hw_configs = (const AVCodecHWConfigInternal*[]) {
3576 #if CONFIG_HEVC_DXVA2_HWACCEL
3577 HWACCEL_DXVA2(hevc),
3578 #endif
3579 #if CONFIG_HEVC_D3D11VA_HWACCEL
3580 HWACCEL_D3D11VA(hevc),
3581 #endif
3582 #if CONFIG_HEVC_D3D11VA2_HWACCEL
3583 HWACCEL_D3D11VA2(hevc),
3584 #endif
3585 #if CONFIG_HEVC_NVDEC_HWACCEL
3586 HWACCEL_NVDEC(hevc),
3587 #endif
3588 #if CONFIG_HEVC_VAAPI_HWACCEL
3589 HWACCEL_VAAPI(hevc),
3590 #endif
3591 #if CONFIG_HEVC_VDPAU_HWACCEL
3592 HWACCEL_VDPAU(hevc),
3593 #endif
3594 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
3595 HWACCEL_VIDEOTOOLBOX(hevc),
3596 #endif
3597 NULL
3598 },
3599 };
3600