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