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