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
9 * This file is part of FFmpeg.
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.
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.
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
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"
38 #include "bytestream.h"
39 #include "cabac_functions.h"
42 #include "hevc_data.h"
43 #include "hevc_parse.h"
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 };
51 * NOTE: Each function hls_foo correspond to the function foo in the
52 * specification (HLS stands for High Level Syntax).
59 /* free everything allocated by pic_arrays_init() */
60 static void pic_arrays_free(HEVCContext *s)
63 av_freep(&s->deblock);
65 av_freep(&s->skip_flag);
66 av_freep(&s->tab_ct_depth);
68 av_freep(&s->tab_ipm);
69 av_freep(&s->cbf_luma);
72 av_freep(&s->qp_y_tab);
73 av_freep(&s->tab_slice_address);
74 av_freep(&s->filter_slice_edges);
76 av_freep(&s->horizontal_bs);
77 av_freep(&s->vertical_bs);
79 av_freep(&s->sh.entry_point_offset);
80 av_freep(&s->sh.size);
81 av_freep(&s->sh.offset);
83 av_buffer_pool_uninit(&s->tab_mvf_pool);
84 av_buffer_pool_uninit(&s->rpl_tab_pool);
87 /* allocate arrays that depend on frame dimensions */
88 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
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;
98 s->bs_width = (width >> 2) + 1;
99 s->bs_height = (height >> 2) + 1;
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)
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)
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)
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)
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)
130 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
132 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
134 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
141 return AVERROR(ENOMEM);
144 static int pred_weight_table(HEVCContext *s, GetBitContext *gb)
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;
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;
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;
166 s->sh.chroma_log2_weight_denom = chroma_log2_weight_denom;
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;
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);
180 for (i = 0; i < s->sh.nb_refs[L0]; i++)
181 chroma_weight_l0_flag[i] = 0;
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);
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);
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;
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);
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;
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;
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);
224 for (i = 0; i < s->sh.nb_refs[L1]; i++)
225 chroma_weight_l1_flag[i] = 0;
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);
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);
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;
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);
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;
260 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
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;
269 if (!sps->long_term_ref_pics_present_flag)
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);
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;
281 rps->nb_refs = nb_sh + nb_sps;
283 for (i = 0; i < rps->nb_refs; i++) {
286 uint8_t lt_idx_sps = 0;
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));
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];
294 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
295 rps->used[i] = get_bits1(gb);
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);
303 if (i && i != nb_sps)
304 delta += prev_delta_msb;
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;
310 prev_delta_msb = delta;
317 static void export_stream_params(HEVCContext *s, const HEVCSPS *sps)
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;
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;
334 ff_set_sar(avctx, sps->vui.sar);
336 if (sps->vui.video_signal_type_present_flag)
337 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
340 avctx->color_range = AVCOL_RANGE_MPEG;
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;
347 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
348 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
349 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
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;
358 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
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;
369 if (num != 0 && den != 0)
370 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
373 if (s->sei.alternative_transfer.present &&
374 av_color_transfer_name(s->sei.alternative_transfer.preferred_transfer_characteristics) &&
375 s->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
376 avctx->color_trc = s->sei.alternative_transfer.preferred_transfer_characteristics;
380 static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
382 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
383 CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
384 CONFIG_HEVC_NVDEC_HWACCEL + \
385 CONFIG_HEVC_VAAPI_HWACCEL + \
386 CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
387 CONFIG_HEVC_VDPAU_HWACCEL)
388 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
390 switch (sps->pix_fmt) {
391 case AV_PIX_FMT_YUV420P:
392 case AV_PIX_FMT_YUVJ420P:
393 #if CONFIG_HEVC_DXVA2_HWACCEL
394 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
396 #if CONFIG_HEVC_D3D11VA_HWACCEL
397 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
398 *fmt++ = AV_PIX_FMT_D3D11;
400 #if CONFIG_HEVC_VAAPI_HWACCEL
401 *fmt++ = AV_PIX_FMT_VAAPI;
403 #if CONFIG_HEVC_VDPAU_HWACCEL
404 *fmt++ = AV_PIX_FMT_VDPAU;
406 #if CONFIG_HEVC_NVDEC_HWACCEL
407 *fmt++ = AV_PIX_FMT_CUDA;
409 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
410 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
413 case AV_PIX_FMT_YUV420P10:
414 #if CONFIG_HEVC_DXVA2_HWACCEL
415 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
417 #if CONFIG_HEVC_D3D11VA_HWACCEL
418 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
419 *fmt++ = AV_PIX_FMT_D3D11;
421 #if CONFIG_HEVC_VAAPI_HWACCEL
422 *fmt++ = AV_PIX_FMT_VAAPI;
424 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
425 *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
427 #if CONFIG_HEVC_NVDEC_HWACCEL
428 *fmt++ = AV_PIX_FMT_CUDA;
431 case AV_PIX_FMT_YUV444P:
432 #if CONFIG_HEVC_VDPAU_HWACCEL
433 *fmt++ = AV_PIX_FMT_VDPAU;
435 #if CONFIG_HEVC_NVDEC_HWACCEL
436 *fmt++ = AV_PIX_FMT_CUDA;
439 case AV_PIX_FMT_YUV422P:
440 case AV_PIX_FMT_YUV422P10LE:
441 #if CONFIG_HEVC_VAAPI_HWACCEL
442 *fmt++ = AV_PIX_FMT_VAAPI;
445 case AV_PIX_FMT_YUV420P12:
446 case AV_PIX_FMT_YUV444P10:
447 case AV_PIX_FMT_YUV444P12:
448 #if CONFIG_HEVC_NVDEC_HWACCEL
449 *fmt++ = AV_PIX_FMT_CUDA;
454 *fmt++ = sps->pix_fmt;
455 *fmt = AV_PIX_FMT_NONE;
457 return ff_thread_get_format(s->avctx, pix_fmts);
460 static int set_sps(HEVCContext *s, const HEVCSPS *sps,
461 enum AVPixelFormat pix_fmt)
472 ret = pic_arrays_init(s, sps);
476 export_stream_params(s, sps);
478 s->avctx->pix_fmt = pix_fmt;
480 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
481 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
482 ff_videodsp_init (&s->vdsp, sps->bit_depth);
484 for (i = 0; i < 3; i++) {
485 av_freep(&s->sao_pixel_buffer_h[i]);
486 av_freep(&s->sao_pixel_buffer_v[i]);
489 if (sps->sao_enabled && !s->avctx->hwaccel) {
490 int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
493 for(c_idx = 0; c_idx < c_count; c_idx++) {
494 int w = sps->width >> sps->hshift[c_idx];
495 int h = sps->height >> sps->vshift[c_idx];
496 s->sao_pixel_buffer_h[c_idx] =
497 av_malloc((w * 2 * sps->ctb_height) <<
499 s->sao_pixel_buffer_v[c_idx] =
500 av_malloc((h * 2 * sps->ctb_width) <<
506 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
516 static int hls_slice_header(HEVCContext *s)
518 GetBitContext *gb = &s->HEVClc->gb;
519 SliceHeader *sh = &s->sh;
523 sh->first_slice_in_pic_flag = get_bits1(gb);
524 if (s->ref && sh->first_slice_in_pic_flag) {
525 av_log(s->avctx, AV_LOG_ERROR, "Two slices reporting being the first in the same frame.\n");
526 return 1; // This slice will be skipped later, do not corrupt state
529 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
530 s->seq_decode = (s->seq_decode + 1) & 0xff;
533 ff_hevc_clear_refs(s);
535 sh->no_output_of_prior_pics_flag = 0;
537 sh->no_output_of_prior_pics_flag = get_bits1(gb);
539 sh->pps_id = get_ue_golomb_long(gb);
540 if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
541 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
542 return AVERROR_INVALIDDATA;
544 if (!sh->first_slice_in_pic_flag &&
545 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
546 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
547 return AVERROR_INVALIDDATA;
549 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
550 if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
551 sh->no_output_of_prior_pics_flag = 1;
553 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
554 const HEVCSPS *sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
555 const HEVCSPS *last_sps = s->ps.sps;
556 enum AVPixelFormat pix_fmt;
558 if (last_sps && IS_IRAP(s) && s->nal_unit_type != HEVC_NAL_CRA_NUT) {
559 if (sps->width != last_sps->width || sps->height != last_sps->height ||
560 sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering !=
561 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
562 sh->no_output_of_prior_pics_flag = 0;
564 ff_hevc_clear_refs(s);
566 ret = set_sps(s, sps, sps->pix_fmt);
570 pix_fmt = get_format(s, sps);
573 s->avctx->pix_fmt = pix_fmt;
575 s->seq_decode = (s->seq_decode + 1) & 0xff;
579 sh->dependent_slice_segment_flag = 0;
580 if (!sh->first_slice_in_pic_flag) {
581 int slice_address_length;
583 if (s->ps.pps->dependent_slice_segments_enabled_flag)
584 sh->dependent_slice_segment_flag = get_bits1(gb);
586 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
587 s->ps.sps->ctb_height);
588 sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
589 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
590 av_log(s->avctx, AV_LOG_ERROR,
591 "Invalid slice segment address: %u.\n",
592 sh->slice_segment_addr);
593 return AVERROR_INVALIDDATA;
596 if (!sh->dependent_slice_segment_flag) {
597 sh->slice_addr = sh->slice_segment_addr;
601 sh->slice_segment_addr = sh->slice_addr = 0;
603 s->slice_initialized = 0;
606 if (!sh->dependent_slice_segment_flag) {
607 s->slice_initialized = 0;
609 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
610 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
612 sh->slice_type = get_ue_golomb_long(gb);
613 if (!(sh->slice_type == HEVC_SLICE_I ||
614 sh->slice_type == HEVC_SLICE_P ||
615 sh->slice_type == HEVC_SLICE_B)) {
616 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
618 return AVERROR_INVALIDDATA;
620 if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
621 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
622 return AVERROR_INVALIDDATA;
625 // when flag is not present, picture is inferred to be output
626 sh->pic_output_flag = 1;
627 if (s->ps.pps->output_flag_present_flag)
628 sh->pic_output_flag = get_bits1(gb);
630 if (s->ps.sps->separate_colour_plane_flag)
631 sh->colour_plane_id = get_bits(gb, 2);
636 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
637 poc = ff_hevc_compute_poc(s->ps.sps, s->pocTid0, sh->pic_order_cnt_lsb, s->nal_unit_type);
638 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
639 av_log(s->avctx, AV_LOG_WARNING,
640 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
641 if (s->avctx->err_recognition & AV_EF_EXPLODE)
642 return AVERROR_INVALIDDATA;
647 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
648 pos = get_bits_left(gb);
649 if (!sh->short_term_ref_pic_set_sps_flag) {
650 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
654 sh->short_term_rps = &sh->slice_rps;
656 int numbits, rps_idx;
658 if (!s->ps.sps->nb_st_rps) {
659 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
660 return AVERROR_INVALIDDATA;
663 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
664 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
665 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
667 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
669 pos = get_bits_left(gb);
670 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
672 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
673 if (s->avctx->err_recognition & AV_EF_EXPLODE)
674 return AVERROR_INVALIDDATA;
676 sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
678 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
679 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
681 sh->slice_temporal_mvp_enabled_flag = 0;
683 s->sh.short_term_rps = NULL;
688 if (sh->first_slice_in_pic_flag && s->temporal_id == 0 &&
689 s->nal_unit_type != HEVC_NAL_TRAIL_N &&
690 s->nal_unit_type != HEVC_NAL_TSA_N &&
691 s->nal_unit_type != HEVC_NAL_STSA_N &&
692 s->nal_unit_type != HEVC_NAL_RADL_N &&
693 s->nal_unit_type != HEVC_NAL_RADL_R &&
694 s->nal_unit_type != HEVC_NAL_RASL_N &&
695 s->nal_unit_type != HEVC_NAL_RASL_R)
698 if (s->ps.sps->sao_enabled) {
699 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
700 if (s->ps.sps->chroma_format_idc) {
701 sh->slice_sample_adaptive_offset_flag[1] =
702 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
705 sh->slice_sample_adaptive_offset_flag[0] = 0;
706 sh->slice_sample_adaptive_offset_flag[1] = 0;
707 sh->slice_sample_adaptive_offset_flag[2] = 0;
710 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
711 if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
714 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
715 if (sh->slice_type == HEVC_SLICE_B)
716 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
718 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
719 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
720 if (sh->slice_type == HEVC_SLICE_B)
721 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
723 if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
724 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
725 sh->nb_refs[L0], sh->nb_refs[L1]);
726 return AVERROR_INVALIDDATA;
729 sh->rpl_modification_flag[0] = 0;
730 sh->rpl_modification_flag[1] = 0;
731 nb_refs = ff_hevc_frame_nb_refs(s);
733 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
734 return AVERROR_INVALIDDATA;
737 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
738 sh->rpl_modification_flag[0] = get_bits1(gb);
739 if (sh->rpl_modification_flag[0]) {
740 for (i = 0; i < sh->nb_refs[L0]; i++)
741 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
744 if (sh->slice_type == HEVC_SLICE_B) {
745 sh->rpl_modification_flag[1] = get_bits1(gb);
746 if (sh->rpl_modification_flag[1] == 1)
747 for (i = 0; i < sh->nb_refs[L1]; i++)
748 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
752 if (sh->slice_type == HEVC_SLICE_B)
753 sh->mvd_l1_zero_flag = get_bits1(gb);
755 if (s->ps.pps->cabac_init_present_flag)
756 sh->cabac_init_flag = get_bits1(gb);
758 sh->cabac_init_flag = 0;
760 sh->collocated_ref_idx = 0;
761 if (sh->slice_temporal_mvp_enabled_flag) {
762 sh->collocated_list = L0;
763 if (sh->slice_type == HEVC_SLICE_B)
764 sh->collocated_list = !get_bits1(gb);
766 if (sh->nb_refs[sh->collocated_list] > 1) {
767 sh->collocated_ref_idx = get_ue_golomb_long(gb);
768 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
769 av_log(s->avctx, AV_LOG_ERROR,
770 "Invalid collocated_ref_idx: %d.\n",
771 sh->collocated_ref_idx);
772 return AVERROR_INVALIDDATA;
777 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == HEVC_SLICE_P) ||
778 (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
779 int ret = pred_weight_table(s, gb);
784 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
785 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
786 av_log(s->avctx, AV_LOG_ERROR,
787 "Invalid number of merging MVP candidates: %d.\n",
788 sh->max_num_merge_cand);
789 return AVERROR_INVALIDDATA;
793 sh->slice_qp_delta = get_se_golomb(gb);
795 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
796 sh->slice_cb_qp_offset = get_se_golomb(gb);
797 sh->slice_cr_qp_offset = get_se_golomb(gb);
799 sh->slice_cb_qp_offset = 0;
800 sh->slice_cr_qp_offset = 0;
803 if (s->ps.pps->chroma_qp_offset_list_enabled_flag)
804 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
806 sh->cu_chroma_qp_offset_enabled_flag = 0;
808 if (s->ps.pps->deblocking_filter_control_present_flag) {
809 int deblocking_filter_override_flag = 0;
811 if (s->ps.pps->deblocking_filter_override_enabled_flag)
812 deblocking_filter_override_flag = get_bits1(gb);
814 if (deblocking_filter_override_flag) {
815 sh->disable_deblocking_filter_flag = get_bits1(gb);
816 if (!sh->disable_deblocking_filter_flag) {
817 int beta_offset_div2 = get_se_golomb(gb);
818 int tc_offset_div2 = get_se_golomb(gb) ;
819 if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
820 tc_offset_div2 < -6 || tc_offset_div2 > 6) {
821 av_log(s->avctx, AV_LOG_ERROR,
822 "Invalid deblock filter offsets: %d, %d\n",
823 beta_offset_div2, tc_offset_div2);
824 return AVERROR_INVALIDDATA;
826 sh->beta_offset = beta_offset_div2 * 2;
827 sh->tc_offset = tc_offset_div2 * 2;
830 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
831 sh->beta_offset = s->ps.pps->beta_offset;
832 sh->tc_offset = s->ps.pps->tc_offset;
835 sh->disable_deblocking_filter_flag = 0;
840 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
841 (sh->slice_sample_adaptive_offset_flag[0] ||
842 sh->slice_sample_adaptive_offset_flag[1] ||
843 !sh->disable_deblocking_filter_flag)) {
844 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
846 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
848 } else if (!s->slice_initialized) {
849 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
850 return AVERROR_INVALIDDATA;
853 sh->num_entry_point_offsets = 0;
854 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
855 unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
856 // It would be possible to bound this tighter but this here is simpler
857 if (num_entry_point_offsets > get_bits_left(gb)) {
858 av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
859 return AVERROR_INVALIDDATA;
862 sh->num_entry_point_offsets = num_entry_point_offsets;
863 if (sh->num_entry_point_offsets > 0) {
864 int offset_len = get_ue_golomb_long(gb) + 1;
866 if (offset_len < 1 || offset_len > 32) {
867 sh->num_entry_point_offsets = 0;
868 av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
869 return AVERROR_INVALIDDATA;
872 av_freep(&sh->entry_point_offset);
873 av_freep(&sh->offset);
875 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
876 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
877 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
878 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
879 sh->num_entry_point_offsets = 0;
880 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
881 return AVERROR(ENOMEM);
883 for (i = 0; i < sh->num_entry_point_offsets; i++) {
884 unsigned val = get_bits_long(gb, offset_len);
885 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
887 if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
888 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
889 s->threads_number = 1;
891 s->enable_parallel_tiles = 0;
893 s->enable_parallel_tiles = 0;
896 if (s->ps.pps->slice_header_extension_present_flag) {
897 unsigned int length = get_ue_golomb_long(gb);
898 if (length*8LL > get_bits_left(gb)) {
899 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
900 return AVERROR_INVALIDDATA;
902 for (i = 0; i < length; i++)
903 skip_bits(gb, 8); // slice_header_extension_data_byte
906 // Inferred parameters
907 sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
908 if (sh->slice_qp > 51 ||
909 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
910 av_log(s->avctx, AV_LOG_ERROR,
911 "The slice_qp %d is outside the valid range "
914 -s->ps.sps->qp_bd_offset);
915 return AVERROR_INVALIDDATA;
918 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
920 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
921 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
922 return AVERROR_INVALIDDATA;
925 if (get_bits_left(gb) < 0) {
926 av_log(s->avctx, AV_LOG_ERROR,
927 "Overread slice header by %d bits\n", -get_bits_left(gb));
928 return AVERROR_INVALIDDATA;
931 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
933 if (!s->ps.pps->cu_qp_delta_enabled_flag)
934 s->HEVClc->qp_y = s->sh.slice_qp;
936 s->slice_initialized = 1;
937 s->HEVClc->tu.cu_qp_offset_cb = 0;
938 s->HEVClc->tu.cu_qp_offset_cr = 0;
943 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
945 #define SET_SAO(elem, value) \
947 if (!sao_merge_up_flag && !sao_merge_left_flag) \
949 else if (sao_merge_left_flag) \
950 sao->elem = CTB(s->sao, rx-1, ry).elem; \
951 else if (sao_merge_up_flag) \
952 sao->elem = CTB(s->sao, rx, ry-1).elem; \
957 static void hls_sao_param(HEVCContext *s, int rx, int ry)
959 HEVCLocalContext *lc = s->HEVClc;
960 int sao_merge_left_flag = 0;
961 int sao_merge_up_flag = 0;
962 SAOParams *sao = &CTB(s->sao, rx, ry);
965 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
966 s->sh.slice_sample_adaptive_offset_flag[1]) {
968 if (lc->ctb_left_flag)
969 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
971 if (ry > 0 && !sao_merge_left_flag) {
973 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
977 for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
978 int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
979 s->ps.pps->log2_sao_offset_scale_chroma;
981 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
982 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
987 sao->type_idx[2] = sao->type_idx[1];
988 sao->eo_class[2] = sao->eo_class[1];
990 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
993 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
996 for (i = 0; i < 4; i++)
997 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
999 if (sao->type_idx[c_idx] == SAO_BAND) {
1000 for (i = 0; i < 4; i++) {
1001 if (sao->offset_abs[c_idx][i]) {
1002 SET_SAO(offset_sign[c_idx][i],
1003 ff_hevc_sao_offset_sign_decode(s));
1005 sao->offset_sign[c_idx][i] = 0;
1008 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
1009 } else if (c_idx != 2) {
1010 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
1013 // Inferred parameters
1014 sao->offset_val[c_idx][0] = 0;
1015 for (i = 0; i < 4; i++) {
1016 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
1017 if (sao->type_idx[c_idx] == SAO_EDGE) {
1019 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
1020 } else if (sao->offset_sign[c_idx][i]) {
1021 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
1023 sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
1031 static int hls_cross_component_pred(HEVCContext *s, int idx) {
1032 HEVCLocalContext *lc = s->HEVClc;
1033 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
1035 if (log2_res_scale_abs_plus1 != 0) {
1036 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
1037 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
1038 (1 - 2 * res_scale_sign_flag);
1040 lc->tu.res_scale_val = 0;
1047 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1048 int xBase, int yBase, int cb_xBase, int cb_yBase,
1049 int log2_cb_size, int log2_trafo_size,
1050 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
1052 HEVCLocalContext *lc = s->HEVClc;
1053 const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1];
1056 if (lc->cu.pred_mode == MODE_INTRA) {
1057 int trafo_size = 1 << log2_trafo_size;
1058 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1060 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1063 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1064 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1065 int scan_idx = SCAN_DIAG;
1066 int scan_idx_c = SCAN_DIAG;
1067 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1068 (s->ps.sps->chroma_format_idc == 2 &&
1069 (cbf_cb[1] || cbf_cr[1]));
1071 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1072 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1073 if (lc->tu.cu_qp_delta != 0)
1074 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1075 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1076 lc->tu.is_cu_qp_delta_coded = 1;
1078 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1079 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
1080 av_log(s->avctx, AV_LOG_ERROR,
1081 "The cu_qp_delta %d is outside the valid range "
1084 -(26 + s->ps.sps->qp_bd_offset / 2),
1085 (25 + s->ps.sps->qp_bd_offset / 2));
1086 return AVERROR_INVALIDDATA;
1089 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
1092 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1093 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
1094 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
1095 if (cu_chroma_qp_offset_flag) {
1096 int cu_chroma_qp_offset_idx = 0;
1097 if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
1098 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
1099 av_log(s->avctx, AV_LOG_ERROR,
1100 "cu_chroma_qp_offset_idx not yet tested.\n");
1102 lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
1103 lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
1105 lc->tu.cu_qp_offset_cb = 0;
1106 lc->tu.cu_qp_offset_cr = 0;
1108 lc->tu.is_cu_chroma_qp_offset_coded = 1;
1111 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1112 if (lc->tu.intra_pred_mode >= 6 &&
1113 lc->tu.intra_pred_mode <= 14) {
1114 scan_idx = SCAN_VERT;
1115 } else if (lc->tu.intra_pred_mode >= 22 &&
1116 lc->tu.intra_pred_mode <= 30) {
1117 scan_idx = SCAN_HORIZ;
1120 if (lc->tu.intra_pred_mode_c >= 6 &&
1121 lc->tu.intra_pred_mode_c <= 14) {
1122 scan_idx_c = SCAN_VERT;
1123 } else if (lc->tu.intra_pred_mode_c >= 22 &&
1124 lc->tu.intra_pred_mode_c <= 30) {
1125 scan_idx_c = SCAN_HORIZ;
1129 lc->tu.cross_pf = 0;
1132 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1133 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1134 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1135 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1136 lc->tu.cross_pf = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1137 (lc->cu.pred_mode == MODE_INTER ||
1138 (lc->tu.chroma_mode_c == 4)));
1140 if (lc->tu.cross_pf) {
1141 hls_cross_component_pred(s, 0);
1143 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1144 if (lc->cu.pred_mode == MODE_INTRA) {
1145 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1146 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1149 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1150 log2_trafo_size_c, scan_idx_c, 1);
1152 if (lc->tu.cross_pf) {
1153 ptrdiff_t stride = s->frame->linesize[1];
1154 int hshift = s->ps.sps->hshift[1];
1155 int vshift = s->ps.sps->vshift[1];
1156 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1157 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1158 int size = 1 << log2_trafo_size_c;
1160 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1161 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1162 for (i = 0; i < (size * size); i++) {
1163 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1165 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1169 if (lc->tu.cross_pf) {
1170 hls_cross_component_pred(s, 1);
1172 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1173 if (lc->cu.pred_mode == MODE_INTRA) {
1174 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1175 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1178 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1179 log2_trafo_size_c, scan_idx_c, 2);
1181 if (lc->tu.cross_pf) {
1182 ptrdiff_t stride = s->frame->linesize[2];
1183 int hshift = s->ps.sps->hshift[2];
1184 int vshift = s->ps.sps->vshift[2];
1185 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1186 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1187 int size = 1 << log2_trafo_size_c;
1189 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1190 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1191 for (i = 0; i < (size * size); i++) {
1192 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1194 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1197 } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
1198 int trafo_size_h = 1 << (log2_trafo_size + 1);
1199 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1200 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1201 if (lc->cu.pred_mode == MODE_INTRA) {
1202 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1203 trafo_size_h, trafo_size_v);
1204 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1207 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1208 log2_trafo_size, scan_idx_c, 1);
1210 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1211 if (lc->cu.pred_mode == MODE_INTRA) {
1212 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1213 trafo_size_h, trafo_size_v);
1214 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1217 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1218 log2_trafo_size, scan_idx_c, 2);
1221 } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1222 if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) {
1223 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1224 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1225 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1226 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1227 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1228 if (s->ps.sps->chroma_format_idc == 2) {
1229 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1230 trafo_size_h, trafo_size_v);
1231 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1232 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1234 } else if (blk_idx == 3) {
1235 int trafo_size_h = 1 << (log2_trafo_size + 1);
1236 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1237 ff_hevc_set_neighbour_available(s, xBase, yBase,
1238 trafo_size_h, trafo_size_v);
1239 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1240 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1241 if (s->ps.sps->chroma_format_idc == 2) {
1242 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1243 trafo_size_h, trafo_size_v);
1244 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1245 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1253 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1255 int cb_size = 1 << log2_cb_size;
1256 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1258 int min_pu_width = s->ps.sps->min_pu_width;
1259 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1260 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1263 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1264 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1265 s->is_pcm[i + j * min_pu_width] = 2;
1268 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1269 int xBase, int yBase, int cb_xBase, int cb_yBase,
1270 int log2_cb_size, int log2_trafo_size,
1271 int trafo_depth, int blk_idx,
1272 const int *base_cbf_cb, const int *base_cbf_cr)
1274 HEVCLocalContext *lc = s->HEVClc;
1275 uint8_t split_transform_flag;
1280 cbf_cb[0] = base_cbf_cb[0];
1281 cbf_cb[1] = base_cbf_cb[1];
1282 cbf_cr[0] = base_cbf_cr[0];
1283 cbf_cr[1] = base_cbf_cr[1];
1285 if (lc->cu.intra_split_flag) {
1286 if (trafo_depth == 1) {
1287 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1288 if (s->ps.sps->chroma_format_idc == 3) {
1289 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1290 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1292 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1293 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1297 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1298 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1299 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1302 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1303 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1304 trafo_depth < lc->cu.max_trafo_depth &&
1305 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1306 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1308 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1309 lc->cu.pred_mode == MODE_INTER &&
1310 lc->cu.part_mode != PART_2Nx2N &&
1313 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1314 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1318 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1319 if (trafo_depth == 0 || cbf_cb[0]) {
1320 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1321 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1322 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1326 if (trafo_depth == 0 || cbf_cr[0]) {
1327 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1328 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1329 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1334 if (split_transform_flag) {
1335 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1336 const int x1 = x0 + trafo_size_split;
1337 const int y1 = y0 + trafo_size_split;
1339 #define SUBDIVIDE(x, y, idx) \
1341 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1342 log2_trafo_size - 1, trafo_depth + 1, idx, \
1348 SUBDIVIDE(x0, y0, 0);
1349 SUBDIVIDE(x1, y0, 1);
1350 SUBDIVIDE(x0, y1, 2);
1351 SUBDIVIDE(x1, y1, 3);
1355 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1356 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1357 int min_tu_width = s->ps.sps->min_tb_width;
1360 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1361 cbf_cb[0] || cbf_cr[0] ||
1362 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1363 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1366 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1367 log2_cb_size, log2_trafo_size,
1368 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1371 // TODO: store cbf_luma somewhere else
1374 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1375 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1376 int x_tu = (x0 + j) >> log2_min_tu_size;
1377 int y_tu = (y0 + i) >> log2_min_tu_size;
1378 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1381 if (!s->sh.disable_deblocking_filter_flag) {
1382 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1383 if (s->ps.pps->transquant_bypass_enable_flag &&
1384 lc->cu.cu_transquant_bypass_flag)
1385 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1391 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1393 HEVCLocalContext *lc = s->HEVClc;
1395 int cb_size = 1 << log2_cb_size;
1396 ptrdiff_t stride0 = s->frame->linesize[0];
1397 ptrdiff_t stride1 = s->frame->linesize[1];
1398 ptrdiff_t stride2 = s->frame->linesize[2];
1399 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1400 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)];
1401 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)];
1403 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
1404 (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) +
1405 ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) *
1406 s->ps.sps->pcm.bit_depth_chroma;
1407 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1410 if (!s->sh.disable_deblocking_filter_flag)
1411 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1413 ret = init_get_bits(&gb, pcm, length);
1417 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1418 if (s->ps.sps->chroma_format_idc) {
1419 s->hevcdsp.put_pcm(dst1, stride1,
1420 cb_size >> s->ps.sps->hshift[1],
1421 cb_size >> s->ps.sps->vshift[1],
1422 &gb, s->ps.sps->pcm.bit_depth_chroma);
1423 s->hevcdsp.put_pcm(dst2, stride2,
1424 cb_size >> s->ps.sps->hshift[2],
1425 cb_size >> s->ps.sps->vshift[2],
1426 &gb, s->ps.sps->pcm.bit_depth_chroma);
1433 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1435 * @param s HEVC decoding context
1436 * @param dst target buffer for block data at block position
1437 * @param dststride stride of the dst buffer
1438 * @param ref reference picture buffer at origin (0, 0)
1439 * @param mv motion vector (relative to block position) to get pixel data from
1440 * @param x_off horizontal position of block from origin (0, 0)
1441 * @param y_off vertical position of block from origin (0, 0)
1442 * @param block_w width of block
1443 * @param block_h height of block
1444 * @param luma_weight weighting factor applied to the luma prediction
1445 * @param luma_offset additive offset applied to the luma prediction value
1448 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1449 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1450 int block_w, int block_h, int luma_weight, int luma_offset)
1452 HEVCLocalContext *lc = s->HEVClc;
1453 uint8_t *src = ref->data[0];
1454 ptrdiff_t srcstride = ref->linesize[0];
1455 int pic_width = s->ps.sps->width;
1456 int pic_height = s->ps.sps->height;
1459 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1460 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1461 int idx = ff_hevc_pel_weight[block_w];
1463 x_off += mv->x >> 2;
1464 y_off += mv->y >> 2;
1465 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1467 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1468 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1469 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1470 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1471 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1472 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1474 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1475 edge_emu_stride, srcstride,
1476 block_w + QPEL_EXTRA,
1477 block_h + QPEL_EXTRA,
1478 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1479 pic_width, pic_height);
1480 src = lc->edge_emu_buffer + buf_offset;
1481 srcstride = edge_emu_stride;
1485 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1486 block_h, mx, my, block_w);
1488 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1489 block_h, s->sh.luma_log2_weight_denom,
1490 luma_weight, luma_offset, mx, my, block_w);
1494 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1496 * @param s HEVC decoding context
1497 * @param dst target buffer for block data at block position
1498 * @param dststride stride of the dst buffer
1499 * @param ref0 reference picture0 buffer at origin (0, 0)
1500 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1501 * @param x_off horizontal position of block from origin (0, 0)
1502 * @param y_off vertical position of block from origin (0, 0)
1503 * @param block_w width of block
1504 * @param block_h height of block
1505 * @param ref1 reference picture1 buffer at origin (0, 0)
1506 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1507 * @param current_mv current motion vector structure
1509 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1510 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1511 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1513 HEVCLocalContext *lc = s->HEVClc;
1514 ptrdiff_t src0stride = ref0->linesize[0];
1515 ptrdiff_t src1stride = ref1->linesize[0];
1516 int pic_width = s->ps.sps->width;
1517 int pic_height = s->ps.sps->height;
1518 int mx0 = mv0->x & 3;
1519 int my0 = mv0->y & 3;
1520 int mx1 = mv1->x & 3;
1521 int my1 = mv1->y & 3;
1522 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1523 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1524 int x_off0 = x_off + (mv0->x >> 2);
1525 int y_off0 = y_off + (mv0->y >> 2);
1526 int x_off1 = x_off + (mv1->x >> 2);
1527 int y_off1 = y_off + (mv1->y >> 2);
1528 int idx = ff_hevc_pel_weight[block_w];
1530 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1531 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1533 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1534 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1535 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1536 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1537 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1538 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1540 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1541 edge_emu_stride, src0stride,
1542 block_w + QPEL_EXTRA,
1543 block_h + QPEL_EXTRA,
1544 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1545 pic_width, pic_height);
1546 src0 = lc->edge_emu_buffer + buf_offset;
1547 src0stride = edge_emu_stride;
1550 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1551 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1552 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1553 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1554 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1555 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1557 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1558 edge_emu_stride, src1stride,
1559 block_w + QPEL_EXTRA,
1560 block_h + QPEL_EXTRA,
1561 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1562 pic_width, pic_height);
1563 src1 = lc->edge_emu_buffer2 + buf_offset;
1564 src1stride = edge_emu_stride;
1567 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1568 block_h, mx0, my0, block_w);
1570 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1571 block_h, mx1, my1, block_w);
1573 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1574 block_h, s->sh.luma_log2_weight_denom,
1575 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1576 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1577 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1578 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1584 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1586 * @param s HEVC decoding context
1587 * @param dst1 target buffer for block data at block position (U plane)
1588 * @param dst2 target buffer for block data at block position (V plane)
1589 * @param dststride stride of the dst1 and dst2 buffers
1590 * @param ref reference picture buffer at origin (0, 0)
1591 * @param mv motion vector (relative to block position) to get pixel data from
1592 * @param x_off horizontal position of block from origin (0, 0)
1593 * @param y_off vertical position of block from origin (0, 0)
1594 * @param block_w width of block
1595 * @param block_h height of block
1596 * @param chroma_weight weighting factor applied to the chroma prediction
1597 * @param chroma_offset additive offset applied to the chroma prediction value
1600 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1601 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1602 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1604 HEVCLocalContext *lc = s->HEVClc;
1605 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1606 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1607 const Mv *mv = ¤t_mv->mv[reflist];
1608 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1609 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1610 int idx = ff_hevc_pel_weight[block_w];
1611 int hshift = s->ps.sps->hshift[1];
1612 int vshift = s->ps.sps->vshift[1];
1613 intptr_t mx = av_mod_uintp2(mv->x, 2 + hshift);
1614 intptr_t my = av_mod_uintp2(mv->y, 2 + vshift);
1615 intptr_t _mx = mx << (1 - hshift);
1616 intptr_t _my = my << (1 - vshift);
1618 x_off += mv->x >> (2 + hshift);
1619 y_off += mv->y >> (2 + vshift);
1620 src0 += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1622 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1623 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1624 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1625 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1626 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift));
1627 int buf_offset0 = EPEL_EXTRA_BEFORE *
1628 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1629 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1630 edge_emu_stride, srcstride,
1631 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1632 x_off - EPEL_EXTRA_BEFORE,
1633 y_off - EPEL_EXTRA_BEFORE,
1634 pic_width, pic_height);
1636 src0 = lc->edge_emu_buffer + buf_offset0;
1637 srcstride = edge_emu_stride;
1640 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1641 block_h, _mx, _my, block_w);
1643 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1644 block_h, s->sh.chroma_log2_weight_denom,
1645 chroma_weight, chroma_offset, _mx, _my, block_w);
1649 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1651 * @param s HEVC decoding context
1652 * @param dst target buffer for block data at block position
1653 * @param dststride stride of the dst buffer
1654 * @param ref0 reference picture0 buffer at origin (0, 0)
1655 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1656 * @param x_off horizontal position of block from origin (0, 0)
1657 * @param y_off vertical position of block from origin (0, 0)
1658 * @param block_w width of block
1659 * @param block_h height of block
1660 * @param ref1 reference picture1 buffer at origin (0, 0)
1661 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1662 * @param current_mv current motion vector structure
1663 * @param cidx chroma component(cb, cr)
1665 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1666 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1668 HEVCLocalContext *lc = s->HEVClc;
1669 uint8_t *src1 = ref0->data[cidx+1];
1670 uint8_t *src2 = ref1->data[cidx+1];
1671 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1672 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1673 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1674 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1675 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1676 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1677 Mv *mv0 = ¤t_mv->mv[0];
1678 Mv *mv1 = ¤t_mv->mv[1];
1679 int hshift = s->ps.sps->hshift[1];
1680 int vshift = s->ps.sps->vshift[1];
1682 intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1683 intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1684 intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1685 intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1686 intptr_t _mx0 = mx0 << (1 - hshift);
1687 intptr_t _my0 = my0 << (1 - vshift);
1688 intptr_t _mx1 = mx1 << (1 - hshift);
1689 intptr_t _my1 = my1 << (1 - vshift);
1691 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1692 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1693 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1694 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1695 int idx = ff_hevc_pel_weight[block_w];
1696 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1697 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1699 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1700 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1701 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1702 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1703 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1704 int buf_offset1 = EPEL_EXTRA_BEFORE *
1705 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1707 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1708 edge_emu_stride, src1stride,
1709 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1710 x_off0 - EPEL_EXTRA_BEFORE,
1711 y_off0 - EPEL_EXTRA_BEFORE,
1712 pic_width, pic_height);
1714 src1 = lc->edge_emu_buffer + buf_offset1;
1715 src1stride = edge_emu_stride;
1718 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1719 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1720 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1721 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1722 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1723 int buf_offset1 = EPEL_EXTRA_BEFORE *
1724 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1726 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1727 edge_emu_stride, src2stride,
1728 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1729 x_off1 - EPEL_EXTRA_BEFORE,
1730 y_off1 - EPEL_EXTRA_BEFORE,
1731 pic_width, pic_height);
1733 src2 = lc->edge_emu_buffer2 + buf_offset1;
1734 src2stride = edge_emu_stride;
1737 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1738 block_h, _mx0, _my0, block_w);
1740 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1741 src2, src2stride, lc->tmp,
1742 block_h, _mx1, _my1, block_w);
1744 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1745 src2, src2stride, lc->tmp,
1747 s->sh.chroma_log2_weight_denom,
1748 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1749 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1750 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1751 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1752 _mx1, _my1, block_w);
1755 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1756 const Mv *mv, int y0, int height)
1758 if (s->threads_type == FF_THREAD_FRAME ) {
1759 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1761 ff_thread_await_progress(&ref->tf, y, 0);
1765 static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
1766 int nPbH, int log2_cb_size, int part_idx,
1767 int merge_idx, MvField *mv)
1769 HEVCLocalContext *lc = s->HEVClc;
1770 enum InterPredIdc inter_pred_idc = PRED_L0;
1773 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1775 if (s->sh.slice_type == HEVC_SLICE_B)
1776 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1778 if (inter_pred_idc != PRED_L1) {
1779 if (s->sh.nb_refs[L0])
1780 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1782 mv->pred_flag = PF_L0;
1783 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1784 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1785 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1786 part_idx, merge_idx, mv, mvp_flag, 0);
1787 mv->mv[0].x += lc->pu.mvd.x;
1788 mv->mv[0].y += lc->pu.mvd.y;
1791 if (inter_pred_idc != PRED_L0) {
1792 if (s->sh.nb_refs[L1])
1793 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1795 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1796 AV_ZERO32(&lc->pu.mvd);
1798 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1801 mv->pred_flag += PF_L1;
1802 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1803 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1804 part_idx, merge_idx, mv, mvp_flag, 1);
1805 mv->mv[1].x += lc->pu.mvd.x;
1806 mv->mv[1].y += lc->pu.mvd.y;
1810 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1812 int log2_cb_size, int partIdx, int idx)
1814 #define POS(c_idx, x, y) \
1815 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1816 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1817 HEVCLocalContext *lc = s->HEVClc;
1819 struct MvField current_mv = {{{ 0 }}};
1821 int min_pu_width = s->ps.sps->min_pu_width;
1823 MvField *tab_mvf = s->ref->tab_mvf;
1824 RefPicList *refPicList = s->ref->refPicList;
1825 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1826 uint8_t *dst0 = POS(0, x0, y0);
1827 uint8_t *dst1 = POS(1, x0, y0);
1828 uint8_t *dst2 = POS(2, x0, y0);
1829 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1830 int min_cb_width = s->ps.sps->min_cb_width;
1831 int x_cb = x0 >> log2_min_cb_size;
1832 int y_cb = y0 >> log2_min_cb_size;
1836 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1839 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1841 if (skip_flag || lc->pu.merge_flag) {
1842 if (s->sh.max_num_merge_cand > 1)
1843 merge_idx = ff_hevc_merge_idx_decode(s);
1847 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1848 partIdx, merge_idx, ¤t_mv);
1850 hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1851 partIdx, merge_idx, ¤t_mv);
1854 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1855 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1857 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1858 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1859 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1861 if (current_mv.pred_flag & PF_L0) {
1862 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1865 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1867 if (current_mv.pred_flag & PF_L1) {
1868 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1871 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1874 if (current_mv.pred_flag == PF_L0) {
1875 int x0_c = x0 >> s->ps.sps->hshift[1];
1876 int y0_c = y0 >> s->ps.sps->vshift[1];
1877 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1878 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1880 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1881 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1882 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1883 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1885 if (s->ps.sps->chroma_format_idc) {
1886 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1887 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1888 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1889 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1890 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1891 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1893 } else if (current_mv.pred_flag == PF_L1) {
1894 int x0_c = x0 >> s->ps.sps->hshift[1];
1895 int y0_c = y0 >> s->ps.sps->vshift[1];
1896 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1897 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1899 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1900 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1901 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1902 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1904 if (s->ps.sps->chroma_format_idc) {
1905 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1906 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1907 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1909 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1910 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1911 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1913 } else if (current_mv.pred_flag == PF_BI) {
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];
1919 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1920 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1921 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1923 if (s->ps.sps->chroma_format_idc) {
1924 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1925 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1927 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1928 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1936 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1937 int prev_intra_luma_pred_flag)
1939 HEVCLocalContext *lc = s->HEVClc;
1940 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1941 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1942 int min_pu_width = s->ps.sps->min_pu_width;
1943 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1944 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
1945 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
1947 int cand_up = (lc->ctb_up_flag || y0b) ?
1948 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1949 int cand_left = (lc->ctb_left_flag || x0b) ?
1950 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1952 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1954 MvField *tab_mvf = s->ref->tab_mvf;
1955 int intra_pred_mode;
1959 // intra_pred_mode prediction does not cross vertical CTB boundaries
1960 if ((y0 - 1) < y_ctb)
1963 if (cand_left == cand_up) {
1964 if (cand_left < 2) {
1965 candidate[0] = INTRA_PLANAR;
1966 candidate[1] = INTRA_DC;
1967 candidate[2] = INTRA_ANGULAR_26;
1969 candidate[0] = cand_left;
1970 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1971 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1974 candidate[0] = cand_left;
1975 candidate[1] = cand_up;
1976 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1977 candidate[2] = INTRA_PLANAR;
1978 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1979 candidate[2] = INTRA_DC;
1981 candidate[2] = INTRA_ANGULAR_26;
1985 if (prev_intra_luma_pred_flag) {
1986 intra_pred_mode = candidate[lc->pu.mpm_idx];
1988 if (candidate[0] > candidate[1])
1989 FFSWAP(uint8_t, candidate[0], candidate[1]);
1990 if (candidate[0] > candidate[2])
1991 FFSWAP(uint8_t, candidate[0], candidate[2]);
1992 if (candidate[1] > candidate[2])
1993 FFSWAP(uint8_t, candidate[1], candidate[2]);
1995 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1996 for (i = 0; i < 3; i++)
1997 if (intra_pred_mode >= candidate[i])
2001 /* write the intra prediction units into the mv array */
2004 for (i = 0; i < size_in_pus; i++) {
2005 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
2006 intra_pred_mode, size_in_pus);
2008 for (j = 0; j < size_in_pus; j++) {
2009 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
2013 return intra_pred_mode;
2016 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
2017 int log2_cb_size, int ct_depth)
2019 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
2020 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
2021 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
2024 for (y = 0; y < length; y++)
2025 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
2029 static const uint8_t tab_mode_idx[] = {
2030 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
2031 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
2033 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
2036 HEVCLocalContext *lc = s->HEVClc;
2037 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2038 uint8_t prev_intra_luma_pred_flag[4];
2039 int split = lc->cu.part_mode == PART_NxN;
2040 int pb_size = (1 << log2_cb_size) >> split;
2041 int side = split + 1;
2045 for (i = 0; i < side; i++)
2046 for (j = 0; j < side; j++)
2047 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
2049 for (i = 0; i < side; i++) {
2050 for (j = 0; j < side; j++) {
2051 if (prev_intra_luma_pred_flag[2 * i + j])
2052 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
2054 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
2056 lc->pu.intra_pred_mode[2 * i + j] =
2057 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
2058 prev_intra_luma_pred_flag[2 * i + j]);
2062 if (s->ps.sps->chroma_format_idc == 3) {
2063 for (i = 0; i < side; i++) {
2064 for (j = 0; j < side; j++) {
2065 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2066 if (chroma_mode != 4) {
2067 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
2068 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
2070 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
2072 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
2076 } else if (s->ps.sps->chroma_format_idc == 2) {
2078 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2079 if (chroma_mode != 4) {
2080 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2083 mode_idx = intra_chroma_table[chroma_mode];
2085 mode_idx = lc->pu.intra_pred_mode[0];
2087 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
2088 } else if (s->ps.sps->chroma_format_idc != 0) {
2089 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2090 if (chroma_mode != 4) {
2091 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2092 lc->pu.intra_pred_mode_c[0] = 34;
2094 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
2096 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
2101 static void intra_prediction_unit_default_value(HEVCContext *s,
2105 HEVCLocalContext *lc = s->HEVClc;
2106 int pb_size = 1 << log2_cb_size;
2107 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
2108 int min_pu_width = s->ps.sps->min_pu_width;
2109 MvField *tab_mvf = s->ref->tab_mvf;
2110 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2111 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2114 if (size_in_pus == 0)
2116 for (j = 0; j < size_in_pus; j++)
2117 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2118 if (lc->cu.pred_mode == MODE_INTRA)
2119 for (j = 0; j < size_in_pus; j++)
2120 for (k = 0; k < size_in_pus; k++)
2121 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2124 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2126 int cb_size = 1 << log2_cb_size;
2127 HEVCLocalContext *lc = s->HEVClc;
2128 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2129 int length = cb_size >> log2_min_cb_size;
2130 int min_cb_width = s->ps.sps->min_cb_width;
2131 int x_cb = x0 >> log2_min_cb_size;
2132 int y_cb = y0 >> log2_min_cb_size;
2133 int idx = log2_cb_size - 2;
2134 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2139 lc->cu.pred_mode = MODE_INTRA;
2140 lc->cu.part_mode = PART_2Nx2N;
2141 lc->cu.intra_split_flag = 0;
2143 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2144 for (x = 0; x < 4; x++)
2145 lc->pu.intra_pred_mode[x] = 1;
2146 if (s->ps.pps->transquant_bypass_enable_flag) {
2147 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2148 if (lc->cu.cu_transquant_bypass_flag)
2149 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2151 lc->cu.cu_transquant_bypass_flag = 0;
2153 if (s->sh.slice_type != HEVC_SLICE_I) {
2154 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2156 x = y_cb * min_cb_width + x_cb;
2157 for (y = 0; y < length; y++) {
2158 memset(&s->skip_flag[x], skip_flag, length);
2161 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2163 x = y_cb * min_cb_width + x_cb;
2164 for (y = 0; y < length; y++) {
2165 memset(&s->skip_flag[x], 0, length);
2170 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2171 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2172 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2174 if (!s->sh.disable_deblocking_filter_flag)
2175 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2179 if (s->sh.slice_type != HEVC_SLICE_I)
2180 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2181 if (lc->cu.pred_mode != MODE_INTRA ||
2182 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2183 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2184 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2185 lc->cu.pred_mode == MODE_INTRA;
2188 if (lc->cu.pred_mode == MODE_INTRA) {
2189 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2190 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2191 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2192 pcm_flag = ff_hevc_pcm_flag_decode(s);
2195 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2196 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2197 if (s->ps.sps->pcm.loop_filter_disable_flag)
2198 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2203 intra_prediction_unit(s, x0, y0, log2_cb_size);
2206 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2207 switch (lc->cu.part_mode) {
2209 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2212 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2213 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2216 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2217 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2220 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2221 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2224 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2225 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2228 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2229 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2232 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2233 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2236 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2237 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2238 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2239 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2245 int rqt_root_cbf = 1;
2247 if (lc->cu.pred_mode != MODE_INTRA &&
2248 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2249 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2252 const static int cbf[2] = { 0 };
2253 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2254 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2255 s->ps.sps->max_transform_hierarchy_depth_inter;
2256 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2258 log2_cb_size, 0, 0, cbf, cbf);
2262 if (!s->sh.disable_deblocking_filter_flag)
2263 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2268 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2269 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2271 x = y_cb * min_cb_width + x_cb;
2272 for (y = 0; y < length; y++) {
2273 memset(&s->qp_y_tab[x], lc->qp_y, length);
2277 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2278 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2279 lc->qPy_pred = lc->qp_y;
2282 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2287 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2288 int log2_cb_size, int cb_depth)
2290 HEVCLocalContext *lc = s->HEVClc;
2291 const int cb_size = 1 << log2_cb_size;
2295 lc->ct_depth = cb_depth;
2296 if (x0 + cb_size <= s->ps.sps->width &&
2297 y0 + cb_size <= s->ps.sps->height &&
2298 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2299 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2301 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2303 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2304 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2305 lc->tu.is_cu_qp_delta_coded = 0;
2306 lc->tu.cu_qp_delta = 0;
2309 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2310 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2311 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2315 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2316 const int cb_size_split = cb_size >> 1;
2317 const int x1 = x0 + cb_size_split;
2318 const int y1 = y0 + cb_size_split;
2322 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2326 if (more_data && x1 < s->ps.sps->width) {
2327 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2331 if (more_data && y1 < s->ps.sps->height) {
2332 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2336 if (more_data && x1 < s->ps.sps->width &&
2337 y1 < s->ps.sps->height) {
2338 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2343 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2344 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2345 lc->qPy_pred = lc->qp_y;
2348 return ((x1 + cb_size_split) < s->ps.sps->width ||
2349 (y1 + cb_size_split) < s->ps.sps->height);
2353 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2356 if ((!((x0 + cb_size) %
2357 (1 << (s->ps.sps->log2_ctb_size))) ||
2358 (x0 + cb_size >= s->ps.sps->width)) &&
2360 (1 << (s->ps.sps->log2_ctb_size))) ||
2361 (y0 + cb_size >= s->ps.sps->height))) {
2362 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2363 return !end_of_slice_flag;
2372 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2375 HEVCLocalContext *lc = s->HEVClc;
2376 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2377 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2378 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2380 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2382 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2383 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2384 lc->first_qp_group = 1;
2385 lc->end_of_tiles_x = s->ps.sps->width;
2386 } else if (s->ps.pps->tiles_enabled_flag) {
2387 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2388 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2389 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2390 lc->first_qp_group = 1;
2393 lc->end_of_tiles_x = s->ps.sps->width;
2396 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2398 lc->boundary_flags = 0;
2399 if (s->ps.pps->tiles_enabled_flag) {
2400 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]])
2401 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2402 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2403 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2404 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]])
2405 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2406 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2407 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2409 if (ctb_addr_in_slice <= 0)
2410 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2411 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2412 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2415 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2416 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2417 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]]));
2418 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]]));
2421 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2423 HEVCContext *s = avctxt->priv_data;
2424 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2428 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2431 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2432 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2433 return AVERROR_INVALIDDATA;
2436 if (s->sh.dependent_slice_segment_flag) {
2437 int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2438 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2439 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2440 return AVERROR_INVALIDDATA;
2444 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2445 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2447 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2448 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2449 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2451 ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2453 s->tab_slice_address[ctb_addr_rs] = -1;
2457 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2459 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2460 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2461 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2463 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2464 if (more_data < 0) {
2465 s->tab_slice_address[ctb_addr_rs] = -1;
2471 ff_hevc_save_states(s, ctb_addr_ts);
2472 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2475 if (x_ctb + ctb_size >= s->ps.sps->width &&
2476 y_ctb + ctb_size >= s->ps.sps->height)
2477 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2482 static int hls_slice_data(HEVCContext *s)
2490 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2493 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2495 HEVCContext *s1 = avctxt->priv_data, *s;
2496 HEVCLocalContext *lc;
2497 int ctb_size = 1<< s1->ps.sps->log2_ctb_size;
2499 int *ctb_row_p = input_ctb_row;
2500 int ctb_row = ctb_row_p[job];
2501 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);
2502 int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2503 int thread = ctb_row % s1->threads_number;
2506 s = s1->sList[self_id];
2510 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2513 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2516 while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2517 int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2518 int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2520 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2522 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2524 if (atomic_load(&s1->wpp_err)) {
2525 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2529 ret = ff_hevc_cabac_init(s, ctb_addr_ts);
2532 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2533 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2535 if (more_data < 0) {
2542 ff_hevc_save_states(s, ctb_addr_ts);
2543 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2544 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2546 if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2547 atomic_store(&s1->wpp_err, 1);
2548 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2552 if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) {
2553 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2554 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2557 ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2560 if(x_ctb >= s->ps.sps->width) {
2564 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2568 s->tab_slice_address[ctb_addr_rs] = -1;
2569 atomic_store(&s1->wpp_err, 1);
2570 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2574 static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
2576 const uint8_t *data = nal->data;
2577 int length = nal->size;
2578 HEVCLocalContext *lc = s->HEVClc;
2579 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2580 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2582 int64_t startheader, cmpt = 0;
2588 return AVERROR(ENOMEM);
2591 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) {
2592 av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2593 s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets,
2594 s->ps.sps->ctb_width, s->ps.sps->ctb_height
2596 res = AVERROR_INVALIDDATA;
2600 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2603 for (i = 1; i < s->threads_number; i++) {
2604 s->sList[i] = av_malloc(sizeof(HEVCContext));
2605 memcpy(s->sList[i], s, sizeof(HEVCContext));
2606 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2607 s->sList[i]->HEVClc = s->HEVClcList[i];
2611 offset = (lc->gb.index >> 3);
2613 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2614 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2620 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2621 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2622 for (j = 0, cmpt = 0, startheader = offset
2623 + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2624 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2629 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2630 s->sh.offset[i - 1] = offset;
2633 if (s->sh.num_entry_point_offsets != 0) {
2634 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2635 if (length < offset) {
2636 av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2637 res = AVERROR_INVALIDDATA;
2640 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2641 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2646 for (i = 1; i < s->threads_number; i++) {
2647 s->sList[i]->HEVClc->first_qp_group = 1;
2648 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2649 memcpy(s->sList[i], s, sizeof(HEVCContext));
2650 s->sList[i]->HEVClc = s->HEVClcList[i];
2653 atomic_store(&s->wpp_err, 0);
2654 ff_reset_entries(s->avctx);
2656 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2661 if (s->ps.pps->entropy_coding_sync_enabled_flag)
2662 s->avctx->execute2(s->avctx, hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2664 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2672 static int set_side_data(HEVCContext *s)
2674 AVFrame *out = s->ref->frame;
2676 if (s->sei.frame_packing.present &&
2677 s->sei.frame_packing.arrangement_type >= 3 &&
2678 s->sei.frame_packing.arrangement_type <= 5 &&
2679 s->sei.frame_packing.content_interpretation_type > 0 &&
2680 s->sei.frame_packing.content_interpretation_type < 3) {
2681 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2683 return AVERROR(ENOMEM);
2685 switch (s->sei.frame_packing.arrangement_type) {
2687 if (s->sei.frame_packing.quincunx_subsampling)
2688 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2690 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2693 stereo->type = AV_STEREO3D_TOPBOTTOM;
2696 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2700 if (s->sei.frame_packing.content_interpretation_type == 2)
2701 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2703 if (s->sei.frame_packing.arrangement_type == 5) {
2704 if (s->sei.frame_packing.current_frame_is_frame0_flag)
2705 stereo->view = AV_STEREO3D_VIEW_LEFT;
2707 stereo->view = AV_STEREO3D_VIEW_RIGHT;
2711 if (s->sei.display_orientation.present &&
2712 (s->sei.display_orientation.anticlockwise_rotation ||
2713 s->sei.display_orientation.hflip || s->sei.display_orientation.vflip)) {
2714 double angle = s->sei.display_orientation.anticlockwise_rotation * 360 / (double) (1 << 16);
2715 AVFrameSideData *rotation = av_frame_new_side_data(out,
2716 AV_FRAME_DATA_DISPLAYMATRIX,
2717 sizeof(int32_t) * 9);
2719 return AVERROR(ENOMEM);
2721 av_display_rotation_set((int32_t *)rotation->data, angle);
2722 av_display_matrix_flip((int32_t *)rotation->data,
2723 s->sei.display_orientation.hflip,
2724 s->sei.display_orientation.vflip);
2727 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2728 // so the side data persists for the entire coded video sequence.
2729 if (s->sei.mastering_display.present > 0 &&
2730 IS_IRAP(s) && s->no_rasl_output_flag) {
2731 s->sei.mastering_display.present--;
2733 if (s->sei.mastering_display.present) {
2734 // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
2735 const int mapping[3] = {2, 0, 1};
2736 const int chroma_den = 50000;
2737 const int luma_den = 10000;
2739 AVMasteringDisplayMetadata *metadata =
2740 av_mastering_display_metadata_create_side_data(out);
2742 return AVERROR(ENOMEM);
2744 for (i = 0; i < 3; i++) {
2745 const int j = mapping[i];
2746 metadata->display_primaries[i][0].num = s->sei.mastering_display.display_primaries[j][0];
2747 metadata->display_primaries[i][0].den = chroma_den;
2748 metadata->display_primaries[i][1].num = s->sei.mastering_display.display_primaries[j][1];
2749 metadata->display_primaries[i][1].den = chroma_den;
2751 metadata->white_point[0].num = s->sei.mastering_display.white_point[0];
2752 metadata->white_point[0].den = chroma_den;
2753 metadata->white_point[1].num = s->sei.mastering_display.white_point[1];
2754 metadata->white_point[1].den = chroma_den;
2756 metadata->max_luminance.num = s->sei.mastering_display.max_luminance;
2757 metadata->max_luminance.den = luma_den;
2758 metadata->min_luminance.num = s->sei.mastering_display.min_luminance;
2759 metadata->min_luminance.den = luma_den;
2760 metadata->has_luminance = 1;
2761 metadata->has_primaries = 1;
2763 av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n");
2764 av_log(s->avctx, AV_LOG_DEBUG,
2765 "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2766 av_q2d(metadata->display_primaries[0][0]),
2767 av_q2d(metadata->display_primaries[0][1]),
2768 av_q2d(metadata->display_primaries[1][0]),
2769 av_q2d(metadata->display_primaries[1][1]),
2770 av_q2d(metadata->display_primaries[2][0]),
2771 av_q2d(metadata->display_primaries[2][1]),
2772 av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]));
2773 av_log(s->avctx, AV_LOG_DEBUG,
2774 "min_luminance=%f, max_luminance=%f\n",
2775 av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
2777 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2778 // so the side data persists for the entire coded video sequence.
2779 if (s->sei.content_light.present > 0 &&
2780 IS_IRAP(s) && s->no_rasl_output_flag) {
2781 s->sei.content_light.present--;
2783 if (s->sei.content_light.present) {
2784 AVContentLightMetadata *metadata =
2785 av_content_light_metadata_create_side_data(out);
2787 return AVERROR(ENOMEM);
2788 metadata->MaxCLL = s->sei.content_light.max_content_light_level;
2789 metadata->MaxFALL = s->sei.content_light.max_pic_average_light_level;
2791 av_log(s->avctx, AV_LOG_DEBUG, "Content Light Level Metadata:\n");
2792 av_log(s->avctx, AV_LOG_DEBUG, "MaxCLL=%d, MaxFALL=%d\n",
2793 metadata->MaxCLL, metadata->MaxFALL);
2796 if (s->sei.a53_caption.buf_ref) {
2797 HEVCSEIA53Caption *a53 = &s->sei.a53_caption;
2799 AVFrameSideData *sd = av_frame_new_side_data_from_buf(out, AV_FRAME_DATA_A53_CC, a53->buf_ref);
2801 av_buffer_unref(&a53->buf_ref);
2802 a53->buf_ref = NULL;
2804 s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2807 for (int i = 0; i < s->sei.unregistered.nb_buf_ref; i++) {
2808 HEVCSEIUnregistered *unreg = &s->sei.unregistered;
2810 if (unreg->buf_ref[i]) {
2811 AVFrameSideData *sd = av_frame_new_side_data_from_buf(out,
2812 AV_FRAME_DATA_SEI_UNREGISTERED,
2815 av_buffer_unref(&unreg->buf_ref[i]);
2816 unreg->buf_ref[i] = NULL;
2819 s->sei.unregistered.nb_buf_ref = 0;
2821 if (s->sei.timecode.present) {
2823 AVFrameSideData *tcside = av_frame_new_side_data(out, AV_FRAME_DATA_S12M_TIMECODE,
2824 sizeof(uint32_t) * 4);
2826 return AVERROR(ENOMEM);
2828 tc_sd = (uint32_t*)tcside->data;
2829 tc_sd[0] = s->sei.timecode.num_clock_ts;
2831 for (int i = 0; i < tc_sd[0]; i++) {
2832 int drop = s->sei.timecode.cnt_dropped_flag[i];
2833 int hh = s->sei.timecode.hours_value[i];
2834 int mm = s->sei.timecode.minutes_value[i];
2835 int ss = s->sei.timecode.seconds_value[i];
2836 int ff = s->sei.timecode.n_frames[i];
2838 tc_sd[i + 1] = av_timecode_get_smpte(s->avctx->framerate, drop, hh, mm, ss, ff);
2841 s->sei.timecode.num_clock_ts = 0;
2847 static int hevc_frame_start(HEVCContext *s)
2849 HEVCLocalContext *lc = s->HEVClc;
2850 int pic_size_in_ctb = ((s->ps.sps->width >> s->ps.sps->log2_min_cb_size) + 1) *
2851 ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1);
2854 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2855 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2856 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2857 memset(s->is_pcm, 0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1));
2858 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2861 s->first_nal_type = s->nal_unit_type;
2863 s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos);
2865 if (s->ps.pps->tiles_enabled_flag)
2866 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2868 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2872 ret = ff_hevc_frame_rps(s);
2874 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2878 s->ref->frame->key_frame = IS_IRAP(s);
2880 ret = set_side_data(s);
2884 s->frame->pict_type = 3 - s->sh.slice_type;
2887 ff_hevc_bump_frame(s);
2889 av_frame_unref(s->output_frame);
2890 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2894 if (!s->avctx->hwaccel)
2895 ff_thread_finish_setup(s->avctx);
2901 ff_hevc_unref_frame(s, s->ref, ~0);
2906 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2908 HEVCLocalContext *lc = s->HEVClc;
2909 GetBitContext *gb = &lc->gb;
2910 int ctb_addr_ts, ret;
2913 s->nal_unit_type = nal->type;
2914 s->temporal_id = nal->temporal_id;
2916 switch (s->nal_unit_type) {
2918 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2919 ret = s->avctx->hwaccel->decode_params(s->avctx,
2926 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2931 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2932 ret = s->avctx->hwaccel->decode_params(s->avctx,
2939 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2940 s->apply_defdispwin);
2945 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2946 ret = s->avctx->hwaccel->decode_params(s->avctx,
2953 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2957 case HEVC_NAL_SEI_PREFIX:
2958 case HEVC_NAL_SEI_SUFFIX:
2959 if (s->avctx->hwaccel && s->avctx->hwaccel->decode_params) {
2960 ret = s->avctx->hwaccel->decode_params(s->avctx,
2967 ret = ff_hevc_decode_nal_sei(gb, s->avctx, &s->sei, &s->ps, s->nal_unit_type);
2971 case HEVC_NAL_TRAIL_R:
2972 case HEVC_NAL_TRAIL_N:
2973 case HEVC_NAL_TSA_N:
2974 case HEVC_NAL_TSA_R:
2975 case HEVC_NAL_STSA_N:
2976 case HEVC_NAL_STSA_R:
2977 case HEVC_NAL_BLA_W_LP:
2978 case HEVC_NAL_BLA_W_RADL:
2979 case HEVC_NAL_BLA_N_LP:
2980 case HEVC_NAL_IDR_W_RADL:
2981 case HEVC_NAL_IDR_N_LP:
2982 case HEVC_NAL_CRA_NUT:
2983 case HEVC_NAL_RADL_N:
2984 case HEVC_NAL_RADL_R:
2985 case HEVC_NAL_RASL_N:
2986 case HEVC_NAL_RASL_R:
2987 ret = hls_slice_header(s);
2991 ret = AVERROR_INVALIDDATA;
2997 (s->avctx->skip_frame >= AVDISCARD_BIDIR && s->sh.slice_type == HEVC_SLICE_B) ||
2998 (s->avctx->skip_frame >= AVDISCARD_NONINTRA && s->sh.slice_type != HEVC_SLICE_I) ||
2999 (s->avctx->skip_frame >= AVDISCARD_NONKEY && !IS_IRAP(s))) {
3003 if (s->sh.first_slice_in_pic_flag) {
3004 if (s->max_ra == INT_MAX) {
3005 if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
3009 s->max_ra = INT_MIN;
3013 if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
3014 s->poc <= s->max_ra) {
3018 if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
3019 s->max_ra = INT_MIN;
3023 ret = hevc_frame_start(s);
3026 } else if (!s->ref) {
3027 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
3031 if (s->nal_unit_type != s->first_nal_type) {
3032 av_log(s->avctx, AV_LOG_ERROR,
3033 "Non-matching NAL types of the VCL NALUs: %d %d\n",
3034 s->first_nal_type, s->nal_unit_type);
3035 return AVERROR_INVALIDDATA;
3038 if (!s->sh.dependent_slice_segment_flag &&
3039 s->sh.slice_type != HEVC_SLICE_I) {
3040 ret = ff_hevc_slice_rpl(s);
3042 av_log(s->avctx, AV_LOG_WARNING,
3043 "Error constructing the reference lists for the current slice.\n");
3048 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
3049 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
3054 if (s->avctx->hwaccel) {
3055 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
3059 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
3060 ctb_addr_ts = hls_slice_data_wpp(s, nal);
3062 ctb_addr_ts = hls_slice_data(s);
3063 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
3067 if (ctb_addr_ts < 0) {
3073 case HEVC_NAL_EOS_NUT:
3074 case HEVC_NAL_EOB_NUT:
3075 s->seq_decode = (s->seq_decode + 1) & 0xff;
3076 s->max_ra = INT_MAX;
3079 case HEVC_NAL_FD_NUT:
3082 av_log(s->avctx, AV_LOG_INFO,
3083 "Skipping NAL unit %d\n", s->nal_unit_type);
3088 if (s->avctx->err_recognition & AV_EF_EXPLODE)
3093 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
3096 int eos_at_start = 1;
3099 s->last_eos = s->eos;
3103 /* split the input packet into NAL units, so we know the upper bound on the
3104 * number of slices in the frame */
3105 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
3106 s->nal_length_size, s->avctx->codec_id, 1, 0);
3108 av_log(s->avctx, AV_LOG_ERROR,
3109 "Error splitting the input into NAL units.\n");
3113 for (i = 0; i < s->pkt.nb_nals; i++) {
3114 if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
3115 s->pkt.nals[i].type == HEVC_NAL_EOS_NUT) {
3126 /* decode the NAL units */
3127 for (i = 0; i < s->pkt.nb_nals; i++) {
3128 H2645NAL *nal = &s->pkt.nals[i];
3130 if (s->avctx->skip_frame >= AVDISCARD_ALL ||
3131 (s->avctx->skip_frame >= AVDISCARD_NONREF
3132 && ff_hevc_nal_is_nonref(nal->type)) || nal->nuh_layer_id > 0)
3135 ret = decode_nal_unit(s, nal);
3136 if (ret >= 0 && s->overlap > 2)
3137 ret = AVERROR_INVALIDDATA;
3139 av_log(s->avctx, AV_LOG_WARNING,
3140 "Error parsing NAL unit #%d.\n", i);
3146 if (s->ref && s->threads_type == FF_THREAD_FRAME)
3147 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
3152 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
3155 for (i = 0; i < 16; i++)
3156 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
3159 static int verify_md5(HEVCContext *s, AVFrame *frame)
3161 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
3166 return AVERROR(EINVAL);
3168 pixel_shift = desc->comp[0].depth > 8;
3170 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
3173 /* the checksums are LE, so we have to byteswap for >8bpp formats
3176 if (pixel_shift && !s->checksum_buf) {
3177 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3178 FFMAX3(frame->linesize[0], frame->linesize[1],
3179 frame->linesize[2]));
3180 if (!s->checksum_buf)
3181 return AVERROR(ENOMEM);
3185 for (i = 0; frame->data[i]; i++) {
3186 int width = s->avctx->coded_width;
3187 int height = s->avctx->coded_height;
3188 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
3189 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3192 av_md5_init(s->md5_ctx);
3193 for (j = 0; j < h; j++) {
3194 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3197 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3198 (const uint16_t *) src, w);
3199 src = s->checksum_buf;
3202 av_md5_update(s->md5_ctx, src, w << pixel_shift);
3204 av_md5_final(s->md5_ctx, md5);
3206 if (!memcmp(md5, s->sei.picture_hash.md5[i], 16)) {
3207 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3208 print_md5(s->avctx, AV_LOG_DEBUG, md5);
3209 av_log (s->avctx, AV_LOG_DEBUG, "; ");
3211 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3212 print_md5(s->avctx, AV_LOG_ERROR, md5);
3213 av_log (s->avctx, AV_LOG_ERROR, " != ");
3214 print_md5(s->avctx, AV_LOG_ERROR, s->sei.picture_hash.md5[i]);
3215 av_log (s->avctx, AV_LOG_ERROR, "\n");
3216 return AVERROR_INVALIDDATA;
3220 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3225 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first)
3229 ret = ff_hevc_decode_extradata(buf, length, &s->ps, &s->sei, &s->is_nalff,
3230 &s->nal_length_size, s->avctx->err_recognition,
3231 s->apply_defdispwin, s->avctx);
3235 /* export stream parameters from the first SPS */
3236 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3237 if (first && s->ps.sps_list[i]) {
3238 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3239 export_stream_params(s, sps);
3247 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3251 int new_extradata_size;
3252 uint8_t *new_extradata;
3253 HEVCContext *s = avctx->priv_data;
3256 ret = ff_hevc_output_frame(s, data, 1);
3264 new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
3265 &new_extradata_size);
3266 if (new_extradata && new_extradata_size > 0) {
3267 ret = hevc_decode_extradata(s, new_extradata, new_extradata_size, 0);
3273 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3277 if (avctx->hwaccel) {
3278 if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) {
3279 av_log(avctx, AV_LOG_ERROR,
3280 "hardware accelerator failed to decode picture\n");
3281 ff_hevc_unref_frame(s, s->ref, ~0);
3285 /* verify the SEI checksum */
3286 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3287 s->sei.picture_hash.is_md5) {
3288 ret = verify_md5(s, s->ref->frame);
3289 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3290 ff_hevc_unref_frame(s, s->ref, ~0);
3295 s->sei.picture_hash.is_md5 = 0;
3297 if (s->is_decoded) {
3298 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3302 if (s->output_frame->buf[0]) {
3303 av_frame_move_ref(data, s->output_frame);
3310 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3314 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3318 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3319 if (!dst->tab_mvf_buf)
3321 dst->tab_mvf = src->tab_mvf;
3323 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3324 if (!dst->rpl_tab_buf)
3326 dst->rpl_tab = src->rpl_tab;
3328 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3332 dst->poc = src->poc;
3333 dst->ctb_count = src->ctb_count;
3334 dst->flags = src->flags;
3335 dst->sequence = src->sequence;
3337 if (src->hwaccel_picture_private) {
3338 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3339 if (!dst->hwaccel_priv_buf)
3341 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3346 ff_hevc_unref_frame(s, dst, ~0);
3347 return AVERROR(ENOMEM);
3350 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3352 HEVCContext *s = avctx->priv_data;
3357 av_freep(&s->md5_ctx);
3359 av_freep(&s->cabac_state);
3361 for (i = 0; i < 3; i++) {
3362 av_freep(&s->sao_pixel_buffer_h[i]);
3363 av_freep(&s->sao_pixel_buffer_v[i]);
3365 av_frame_free(&s->output_frame);
3367 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3368 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3369 av_frame_free(&s->DPB[i].frame);
3372 ff_hevc_ps_uninit(&s->ps);
3374 av_freep(&s->sh.entry_point_offset);
3375 av_freep(&s->sh.offset);
3376 av_freep(&s->sh.size);
3378 for (i = 1; i < s->threads_number; i++) {
3379 HEVCLocalContext *lc = s->HEVClcList[i];
3381 av_freep(&s->HEVClcList[i]);
3382 av_freep(&s->sList[i]);
3385 if (s->HEVClc == s->HEVClcList[0])
3387 av_freep(&s->HEVClcList[0]);
3389 ff_h2645_packet_uninit(&s->pkt);
3391 ff_hevc_reset_sei(&s->sei);
3396 static av_cold int hevc_init_context(AVCodecContext *avctx)
3398 HEVCContext *s = avctx->priv_data;
3403 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3406 s->HEVClcList[0] = s->HEVClc;
3409 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3410 if (!s->cabac_state)
3413 s->output_frame = av_frame_alloc();
3414 if (!s->output_frame)
3417 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3418 s->DPB[i].frame = av_frame_alloc();
3419 if (!s->DPB[i].frame)
3421 s->DPB[i].tf.f = s->DPB[i].frame;
3424 s->max_ra = INT_MAX;
3426 s->md5_ctx = av_md5_alloc();
3430 ff_bswapdsp_init(&s->bdsp);
3432 s->context_initialized = 1;
3435 ff_hevc_reset_sei(&s->sei);
3440 hevc_decode_free(avctx);
3441 return AVERROR(ENOMEM);
3445 static int hevc_update_thread_context(AVCodecContext *dst,
3446 const AVCodecContext *src)
3448 HEVCContext *s = dst->priv_data;
3449 HEVCContext *s0 = src->priv_data;
3452 if (!s->context_initialized) {
3453 ret = hevc_init_context(dst);
3458 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3459 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3460 if (s0->DPB[i].frame->buf[0]) {
3461 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3467 if (s->ps.sps != s0->ps.sps)
3469 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
3470 av_buffer_unref(&s->ps.vps_list[i]);
3471 if (s0->ps.vps_list[i]) {
3472 s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
3473 if (!s->ps.vps_list[i])
3474 return AVERROR(ENOMEM);
3478 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3479 av_buffer_unref(&s->ps.sps_list[i]);
3480 if (s0->ps.sps_list[i]) {
3481 s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
3482 if (!s->ps.sps_list[i])
3483 return AVERROR(ENOMEM);
3487 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
3488 av_buffer_unref(&s->ps.pps_list[i]);
3489 if (s0->ps.pps_list[i]) {
3490 s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
3491 if (!s->ps.pps_list[i])
3492 return AVERROR(ENOMEM);
3496 if (s->ps.sps != s0->ps.sps)
3497 if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
3500 s->seq_decode = s0->seq_decode;
3501 s->seq_output = s0->seq_output;
3502 s->pocTid0 = s0->pocTid0;
3503 s->max_ra = s0->max_ra;
3505 s->no_rasl_output_flag = s0->no_rasl_output_flag;
3507 s->is_nalff = s0->is_nalff;
3508 s->nal_length_size = s0->nal_length_size;
3510 s->threads_number = s0->threads_number;
3511 s->threads_type = s0->threads_type;
3514 s->seq_decode = (s->seq_decode + 1) & 0xff;
3515 s->max_ra = INT_MAX;
3518 av_buffer_unref(&s->sei.a53_caption.buf_ref);
3519 if (s0->sei.a53_caption.buf_ref) {
3520 s->sei.a53_caption.buf_ref = av_buffer_ref(s0->sei.a53_caption.buf_ref);
3521 if (!s->sei.a53_caption.buf_ref)
3522 return AVERROR(ENOMEM);
3525 s->sei.frame_packing = s0->sei.frame_packing;
3526 s->sei.display_orientation = s0->sei.display_orientation;
3527 s->sei.mastering_display = s0->sei.mastering_display;
3528 s->sei.content_light = s0->sei.content_light;
3529 s->sei.alternative_transfer = s0->sei.alternative_transfer;
3535 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3537 HEVCContext *s = avctx->priv_data;
3540 ret = hevc_init_context(avctx);
3544 s->enable_parallel_tiles = 0;
3545 s->sei.picture_timing.picture_struct = 0;
3548 atomic_init(&s->wpp_err, 0);
3550 if(avctx->active_thread_type & FF_THREAD_SLICE)
3551 s->threads_number = avctx->thread_count;
3553 s->threads_number = 1;
3555 if (!avctx->internal->is_copy) {
3556 if (avctx->extradata_size > 0 && avctx->extradata) {
3557 ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size, 1);
3559 hevc_decode_free(avctx);
3565 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3566 s->threads_type = FF_THREAD_FRAME;
3568 s->threads_type = FF_THREAD_SLICE;
3573 static void hevc_decode_flush(AVCodecContext *avctx)
3575 HEVCContext *s = avctx->priv_data;
3576 ff_hevc_flush_dpb(s);
3577 ff_hevc_reset_sei(&s->sei);
3578 s->max_ra = INT_MAX;
3582 #define OFFSET(x) offsetof(HEVCContext, x)
3583 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3585 static const AVOption options[] = {
3586 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3587 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3588 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3589 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3593 static const AVClass hevc_decoder_class = {
3594 .class_name = "HEVC decoder",
3595 .item_name = av_default_item_name,
3597 .version = LIBAVUTIL_VERSION_INT,
3600 AVCodec ff_hevc_decoder = {
3602 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3603 .type = AVMEDIA_TYPE_VIDEO,
3604 .id = AV_CODEC_ID_HEVC,
3605 .priv_data_size = sizeof(HEVCContext),
3606 .priv_class = &hevc_decoder_class,
3607 .init = hevc_decode_init,
3608 .close = hevc_decode_free,
3609 .decode = hevc_decode_frame,
3610 .flush = hevc_decode_flush,
3611 .update_thread_context = ONLY_IF_THREADS_ENABLED(hevc_update_thread_context),
3612 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3613 AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
3614 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING |
3615 FF_CODEC_CAP_ALLOCATE_PROGRESS,
3616 .profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
3617 .hw_configs = (const AVCodecHWConfigInternal*[]) {
3618 #if CONFIG_HEVC_DXVA2_HWACCEL
3619 HWACCEL_DXVA2(hevc),
3621 #if CONFIG_HEVC_D3D11VA_HWACCEL
3622 HWACCEL_D3D11VA(hevc),
3624 #if CONFIG_HEVC_D3D11VA2_HWACCEL
3625 HWACCEL_D3D11VA2(hevc),
3627 #if CONFIG_HEVC_NVDEC_HWACCEL
3628 HWACCEL_NVDEC(hevc),
3630 #if CONFIG_HEVC_VAAPI_HWACCEL
3631 HWACCEL_VAAPI(hevc),
3633 #if CONFIG_HEVC_VDPAU_HWACCEL
3634 HWACCEL_VDPAU(hevc),
3636 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
3637 HWACCEL_VIDEOTOOLBOX(hevc),