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"
37 #include "bytestream.h"
38 #include "cabac_functions.h"
41 #include "hevc_data.h"
45 const uint8_t ff_hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
48 * NOTE: Each function hls_foo correspond to the function foo in the
49 * specification (HLS stands for High Level Syntax).
56 /* free everything allocated by pic_arrays_init() */
57 static void pic_arrays_free(HEVCContext *s)
60 av_freep(&s->deblock);
62 av_freep(&s->skip_flag);
63 av_freep(&s->tab_ct_depth);
65 av_freep(&s->tab_ipm);
66 av_freep(&s->cbf_luma);
69 av_freep(&s->qp_y_tab);
70 av_freep(&s->tab_slice_address);
71 av_freep(&s->filter_slice_edges);
73 av_freep(&s->horizontal_bs);
74 av_freep(&s->vertical_bs);
76 av_freep(&s->sh.entry_point_offset);
77 av_freep(&s->sh.size);
78 av_freep(&s->sh.offset);
80 av_buffer_pool_uninit(&s->tab_mvf_pool);
81 av_buffer_pool_uninit(&s->rpl_tab_pool);
84 /* allocate arrays that depend on frame dimensions */
85 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
87 int log2_min_cb_size = sps->log2_min_cb_size;
88 int width = sps->width;
89 int height = sps->height;
90 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
91 ((height >> log2_min_cb_size) + 1);
92 int ctb_count = sps->ctb_width * sps->ctb_height;
93 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
95 s->bs_width = (width >> 2) + 1;
96 s->bs_height = (height >> 2) + 1;
98 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
99 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
100 if (!s->sao || !s->deblock)
103 s->skip_flag = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
104 s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
105 if (!s->skip_flag || !s->tab_ct_depth)
108 s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
109 s->tab_ipm = av_mallocz(min_pu_size);
110 s->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
111 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
114 s->filter_slice_edges = av_mallocz(ctb_count);
115 s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
116 sizeof(*s->tab_slice_address));
117 s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
118 sizeof(*s->qp_y_tab));
119 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
122 s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
123 s->vertical_bs = av_mallocz_array(s->bs_width, s->bs_height);
124 if (!s->horizontal_bs || !s->vertical_bs)
127 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
129 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
131 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
138 return AVERROR(ENOMEM);
141 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
145 uint8_t luma_weight_l0_flag[16];
146 uint8_t chroma_weight_l0_flag[16];
147 uint8_t luma_weight_l1_flag[16];
148 uint8_t chroma_weight_l1_flag[16];
149 int luma_log2_weight_denom;
151 luma_log2_weight_denom = get_ue_golomb_long(gb);
152 if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7)
153 av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
154 s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
155 if (s->ps.sps->chroma_format_idc != 0) {
156 int delta = get_se_golomb(gb);
157 s->sh.chroma_log2_weight_denom = av_clip_uintp2(s->sh.luma_log2_weight_denom + delta, 3);
160 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
161 luma_weight_l0_flag[i] = get_bits1(gb);
162 if (!luma_weight_l0_flag[i]) {
163 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
164 s->sh.luma_offset_l0[i] = 0;
167 if (s->ps.sps->chroma_format_idc != 0) {
168 for (i = 0; i < s->sh.nb_refs[L0]; i++)
169 chroma_weight_l0_flag[i] = get_bits1(gb);
171 for (i = 0; i < s->sh.nb_refs[L0]; i++)
172 chroma_weight_l0_flag[i] = 0;
174 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
175 if (luma_weight_l0_flag[i]) {
176 int delta_luma_weight_l0 = get_se_golomb(gb);
177 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
178 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
180 if (chroma_weight_l0_flag[i]) {
181 for (j = 0; j < 2; j++) {
182 int delta_chroma_weight_l0 = get_se_golomb(gb);
183 int delta_chroma_offset_l0 = get_se_golomb(gb);
184 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
185 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
186 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
189 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
190 s->sh.chroma_offset_l0[i][0] = 0;
191 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
192 s->sh.chroma_offset_l0[i][1] = 0;
195 if (s->sh.slice_type == HEVC_SLICE_B) {
196 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
197 luma_weight_l1_flag[i] = get_bits1(gb);
198 if (!luma_weight_l1_flag[i]) {
199 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
200 s->sh.luma_offset_l1[i] = 0;
203 if (s->ps.sps->chroma_format_idc != 0) {
204 for (i = 0; i < s->sh.nb_refs[L1]; i++)
205 chroma_weight_l1_flag[i] = get_bits1(gb);
207 for (i = 0; i < s->sh.nb_refs[L1]; i++)
208 chroma_weight_l1_flag[i] = 0;
210 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
211 if (luma_weight_l1_flag[i]) {
212 int delta_luma_weight_l1 = get_se_golomb(gb);
213 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
214 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
216 if (chroma_weight_l1_flag[i]) {
217 for (j = 0; j < 2; j++) {
218 int delta_chroma_weight_l1 = get_se_golomb(gb);
219 int delta_chroma_offset_l1 = get_se_golomb(gb);
220 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
221 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
222 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
225 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
226 s->sh.chroma_offset_l1[i][0] = 0;
227 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
228 s->sh.chroma_offset_l1[i][1] = 0;
234 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
236 const HEVCSPS *sps = s->ps.sps;
237 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
238 int prev_delta_msb = 0;
239 unsigned int nb_sps = 0, nb_sh;
243 if (!sps->long_term_ref_pics_present_flag)
246 if (sps->num_long_term_ref_pics_sps > 0)
247 nb_sps = get_ue_golomb_long(gb);
248 nb_sh = get_ue_golomb_long(gb);
250 if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
251 return AVERROR_INVALIDDATA;
253 rps->nb_refs = nb_sh + nb_sps;
255 for (i = 0; i < rps->nb_refs; i++) {
256 uint8_t delta_poc_msb_present;
259 uint8_t lt_idx_sps = 0;
261 if (sps->num_long_term_ref_pics_sps > 1)
262 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
264 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
265 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
267 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
268 rps->used[i] = get_bits1(gb);
271 delta_poc_msb_present = get_bits1(gb);
272 if (delta_poc_msb_present) {
273 int delta = get_ue_golomb_long(gb);
275 if (i && i != nb_sps)
276 delta += prev_delta_msb;
278 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
279 prev_delta_msb = delta;
286 static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
289 const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
290 unsigned int num = 0, den = 0;
292 avctx->pix_fmt = sps->pix_fmt;
293 avctx->coded_width = sps->width;
294 avctx->coded_height = sps->height;
295 avctx->width = sps->output_width;
296 avctx->height = sps->output_height;
297 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
298 avctx->profile = sps->ptl.general_ptl.profile_idc;
299 avctx->level = sps->ptl.general_ptl.level_idc;
301 ff_set_sar(avctx, sps->vui.sar);
303 if (sps->vui.video_signal_type_present_flag)
304 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
307 avctx->color_range = AVCOL_RANGE_MPEG;
309 if (sps->vui.colour_description_present_flag) {
310 avctx->color_primaries = sps->vui.colour_primaries;
311 avctx->color_trc = sps->vui.transfer_characteristic;
312 avctx->colorspace = sps->vui.matrix_coeffs;
314 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
315 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
316 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
319 if (vps->vps_timing_info_present_flag) {
320 num = vps->vps_num_units_in_tick;
321 den = vps->vps_time_scale;
322 } else if (sps->vui.vui_timing_info_present_flag) {
323 num = sps->vui.vui_num_units_in_tick;
324 den = sps->vui.vui_time_scale;
327 if (num != 0 && den != 0)
328 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
332 static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fmt)
334 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VAAPI_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
335 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
345 ret = pic_arrays_init(s, sps);
349 export_stream_params(s->avctx, &s->ps, sps);
351 switch (sps->pix_fmt) {
352 case AV_PIX_FMT_YUV420P:
353 case AV_PIX_FMT_YUVJ420P:
354 #if CONFIG_HEVC_DXVA2_HWACCEL
355 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
357 #if CONFIG_HEVC_D3D11VA_HWACCEL
358 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
360 #if CONFIG_HEVC_VAAPI_HWACCEL
361 *fmt++ = AV_PIX_FMT_VAAPI;
363 #if CONFIG_HEVC_VDPAU_HWACCEL
364 *fmt++ = AV_PIX_FMT_VDPAU;
367 case AV_PIX_FMT_YUV420P10:
368 #if CONFIG_HEVC_DXVA2_HWACCEL
369 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
371 #if CONFIG_HEVC_D3D11VA_HWACCEL
372 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
374 #if CONFIG_HEVC_VAAPI_HWACCEL
375 *fmt++ = AV_PIX_FMT_VAAPI;
380 if (pix_fmt == AV_PIX_FMT_NONE) {
381 *fmt++ = sps->pix_fmt;
382 *fmt = AV_PIX_FMT_NONE;
384 ret = ff_thread_get_format(s->avctx, pix_fmts);
387 s->avctx->pix_fmt = ret;
390 s->avctx->pix_fmt = pix_fmt;
393 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
394 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
395 ff_videodsp_init (&s->vdsp, sps->bit_depth);
397 for (i = 0; i < 3; i++) {
398 av_freep(&s->sao_pixel_buffer_h[i]);
399 av_freep(&s->sao_pixel_buffer_v[i]);
402 if (sps->sao_enabled && !s->avctx->hwaccel) {
403 int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
406 for(c_idx = 0; c_idx < c_count; c_idx++) {
407 int w = sps->width >> sps->hshift[c_idx];
408 int h = sps->height >> sps->vshift[c_idx];
409 s->sao_pixel_buffer_h[c_idx] =
410 av_malloc((w * 2 * sps->ctb_height) <<
412 s->sao_pixel_buffer_v[c_idx] =
413 av_malloc((h * 2 * sps->ctb_width) <<
419 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
429 static int hls_slice_header(HEVCContext *s)
431 GetBitContext *gb = &s->HEVClc->gb;
432 SliceHeader *sh = &s->sh;
436 sh->first_slice_in_pic_flag = get_bits1(gb);
437 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
438 s->seq_decode = (s->seq_decode + 1) & 0xff;
441 ff_hevc_clear_refs(s);
443 sh->no_output_of_prior_pics_flag = 0;
445 sh->no_output_of_prior_pics_flag = get_bits1(gb);
447 sh->pps_id = get_ue_golomb_long(gb);
448 if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
449 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
450 return AVERROR_INVALIDDATA;
452 if (!sh->first_slice_in_pic_flag &&
453 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
454 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
455 return AVERROR_INVALIDDATA;
457 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
458 if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
459 sh->no_output_of_prior_pics_flag = 1;
461 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
462 const HEVCSPS* last_sps = s->ps.sps;
463 s->ps.sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
464 if (last_sps && IS_IRAP(s) && s->nal_unit_type != HEVC_NAL_CRA_NUT) {
465 if (s->ps.sps->width != last_sps->width || s->ps.sps->height != last_sps->height ||
466 s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering !=
467 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
468 sh->no_output_of_prior_pics_flag = 0;
470 ff_hevc_clear_refs(s);
471 ret = set_sps(s, s->ps.sps, AV_PIX_FMT_NONE);
475 s->seq_decode = (s->seq_decode + 1) & 0xff;
479 sh->dependent_slice_segment_flag = 0;
480 if (!sh->first_slice_in_pic_flag) {
481 int slice_address_length;
483 if (s->ps.pps->dependent_slice_segments_enabled_flag)
484 sh->dependent_slice_segment_flag = get_bits1(gb);
486 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
487 s->ps.sps->ctb_height);
488 sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
489 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
490 av_log(s->avctx, AV_LOG_ERROR,
491 "Invalid slice segment address: %u.\n",
492 sh->slice_segment_addr);
493 return AVERROR_INVALIDDATA;
496 if (!sh->dependent_slice_segment_flag) {
497 sh->slice_addr = sh->slice_segment_addr;
501 sh->slice_segment_addr = sh->slice_addr = 0;
503 s->slice_initialized = 0;
506 if (!sh->dependent_slice_segment_flag) {
507 s->slice_initialized = 0;
509 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
510 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
512 sh->slice_type = get_ue_golomb_long(gb);
513 if (!(sh->slice_type == HEVC_SLICE_I ||
514 sh->slice_type == HEVC_SLICE_P ||
515 sh->slice_type == HEVC_SLICE_B)) {
516 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
518 return AVERROR_INVALIDDATA;
520 if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
521 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
522 return AVERROR_INVALIDDATA;
525 // when flag is not present, picture is inferred to be output
526 sh->pic_output_flag = 1;
527 if (s->ps.pps->output_flag_present_flag)
528 sh->pic_output_flag = get_bits1(gb);
530 if (s->ps.sps->separate_colour_plane_flag)
531 sh->colour_plane_id = get_bits(gb, 2);
536 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
537 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
538 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
539 av_log(s->avctx, AV_LOG_WARNING,
540 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
541 if (s->avctx->err_recognition & AV_EF_EXPLODE)
542 return AVERROR_INVALIDDATA;
547 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
548 pos = get_bits_left(gb);
549 if (!sh->short_term_ref_pic_set_sps_flag) {
550 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
554 sh->short_term_rps = &sh->slice_rps;
556 int numbits, rps_idx;
558 if (!s->ps.sps->nb_st_rps) {
559 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
560 return AVERROR_INVALIDDATA;
563 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
564 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
565 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
567 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
569 pos = get_bits_left(gb);
570 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
572 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
573 if (s->avctx->err_recognition & AV_EF_EXPLODE)
574 return AVERROR_INVALIDDATA;
576 sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
578 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
579 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
581 sh->slice_temporal_mvp_enabled_flag = 0;
583 s->sh.short_term_rps = NULL;
588 if (s->temporal_id == 0 &&
589 s->nal_unit_type != HEVC_NAL_TRAIL_N &&
590 s->nal_unit_type != HEVC_NAL_TSA_N &&
591 s->nal_unit_type != HEVC_NAL_STSA_N &&
592 s->nal_unit_type != HEVC_NAL_RADL_N &&
593 s->nal_unit_type != HEVC_NAL_RADL_R &&
594 s->nal_unit_type != HEVC_NAL_RASL_N &&
595 s->nal_unit_type != HEVC_NAL_RASL_R)
598 if (s->ps.sps->sao_enabled) {
599 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
600 if (s->ps.sps->chroma_format_idc) {
601 sh->slice_sample_adaptive_offset_flag[1] =
602 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
605 sh->slice_sample_adaptive_offset_flag[0] = 0;
606 sh->slice_sample_adaptive_offset_flag[1] = 0;
607 sh->slice_sample_adaptive_offset_flag[2] = 0;
610 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
611 if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
614 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
615 if (sh->slice_type == HEVC_SLICE_B)
616 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
618 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
619 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
620 if (sh->slice_type == HEVC_SLICE_B)
621 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
623 if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
624 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
625 sh->nb_refs[L0], sh->nb_refs[L1]);
626 return AVERROR_INVALIDDATA;
629 sh->rpl_modification_flag[0] = 0;
630 sh->rpl_modification_flag[1] = 0;
631 nb_refs = ff_hevc_frame_nb_refs(s);
633 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
634 return AVERROR_INVALIDDATA;
637 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
638 sh->rpl_modification_flag[0] = get_bits1(gb);
639 if (sh->rpl_modification_flag[0]) {
640 for (i = 0; i < sh->nb_refs[L0]; i++)
641 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
644 if (sh->slice_type == HEVC_SLICE_B) {
645 sh->rpl_modification_flag[1] = get_bits1(gb);
646 if (sh->rpl_modification_flag[1] == 1)
647 for (i = 0; i < sh->nb_refs[L1]; i++)
648 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
652 if (sh->slice_type == HEVC_SLICE_B)
653 sh->mvd_l1_zero_flag = get_bits1(gb);
655 if (s->ps.pps->cabac_init_present_flag)
656 sh->cabac_init_flag = get_bits1(gb);
658 sh->cabac_init_flag = 0;
660 sh->collocated_ref_idx = 0;
661 if (sh->slice_temporal_mvp_enabled_flag) {
662 sh->collocated_list = L0;
663 if (sh->slice_type == HEVC_SLICE_B)
664 sh->collocated_list = !get_bits1(gb);
666 if (sh->nb_refs[sh->collocated_list] > 1) {
667 sh->collocated_ref_idx = get_ue_golomb_long(gb);
668 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
669 av_log(s->avctx, AV_LOG_ERROR,
670 "Invalid collocated_ref_idx: %d.\n",
671 sh->collocated_ref_idx);
672 return AVERROR_INVALIDDATA;
677 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == HEVC_SLICE_P) ||
678 (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
679 pred_weight_table(s, gb);
682 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
683 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
684 av_log(s->avctx, AV_LOG_ERROR,
685 "Invalid number of merging MVP candidates: %d.\n",
686 sh->max_num_merge_cand);
687 return AVERROR_INVALIDDATA;
691 sh->slice_qp_delta = get_se_golomb(gb);
693 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
694 sh->slice_cb_qp_offset = get_se_golomb(gb);
695 sh->slice_cr_qp_offset = get_se_golomb(gb);
697 sh->slice_cb_qp_offset = 0;
698 sh->slice_cr_qp_offset = 0;
701 if (s->ps.pps->chroma_qp_offset_list_enabled_flag)
702 sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
704 sh->cu_chroma_qp_offset_enabled_flag = 0;
706 if (s->ps.pps->deblocking_filter_control_present_flag) {
707 int deblocking_filter_override_flag = 0;
709 if (s->ps.pps->deblocking_filter_override_enabled_flag)
710 deblocking_filter_override_flag = get_bits1(gb);
712 if (deblocking_filter_override_flag) {
713 sh->disable_deblocking_filter_flag = get_bits1(gb);
714 if (!sh->disable_deblocking_filter_flag) {
715 sh->beta_offset = get_se_golomb(gb) * 2;
716 sh->tc_offset = get_se_golomb(gb) * 2;
719 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
720 sh->beta_offset = s->ps.pps->beta_offset;
721 sh->tc_offset = s->ps.pps->tc_offset;
724 sh->disable_deblocking_filter_flag = 0;
729 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
730 (sh->slice_sample_adaptive_offset_flag[0] ||
731 sh->slice_sample_adaptive_offset_flag[1] ||
732 !sh->disable_deblocking_filter_flag)) {
733 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
735 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
737 } else if (!s->slice_initialized) {
738 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
739 return AVERROR_INVALIDDATA;
742 sh->num_entry_point_offsets = 0;
743 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
744 unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
745 // It would be possible to bound this tighter but this here is simpler
746 if (num_entry_point_offsets > get_bits_left(gb)) {
747 av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
748 return AVERROR_INVALIDDATA;
751 sh->num_entry_point_offsets = num_entry_point_offsets;
752 if (sh->num_entry_point_offsets > 0) {
753 int offset_len = get_ue_golomb_long(gb) + 1;
755 if (offset_len < 1 || offset_len > 32) {
756 sh->num_entry_point_offsets = 0;
757 av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
758 return AVERROR_INVALIDDATA;
761 av_freep(&sh->entry_point_offset);
762 av_freep(&sh->offset);
764 sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
765 sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
766 sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
767 if (!sh->entry_point_offset || !sh->offset || !sh->size) {
768 sh->num_entry_point_offsets = 0;
769 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
770 return AVERROR(ENOMEM);
772 for (i = 0; i < sh->num_entry_point_offsets; i++) {
773 unsigned val = get_bits_long(gb, offset_len);
774 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
776 if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
777 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
778 s->threads_number = 1;
780 s->enable_parallel_tiles = 0;
782 s->enable_parallel_tiles = 0;
785 if (s->ps.pps->slice_header_extension_present_flag) {
786 unsigned int length = get_ue_golomb_long(gb);
787 if (length*8LL > get_bits_left(gb)) {
788 av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
789 return AVERROR_INVALIDDATA;
791 for (i = 0; i < length; i++)
792 skip_bits(gb, 8); // slice_header_extension_data_byte
795 // Inferred parameters
796 sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
797 if (sh->slice_qp > 51 ||
798 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
799 av_log(s->avctx, AV_LOG_ERROR,
800 "The slice_qp %d is outside the valid range "
803 -s->ps.sps->qp_bd_offset);
804 return AVERROR_INVALIDDATA;
807 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
809 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
810 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
811 return AVERROR_INVALIDDATA;
814 if (get_bits_left(gb) < 0) {
815 av_log(s->avctx, AV_LOG_ERROR,
816 "Overread slice header by %d bits\n", -get_bits_left(gb));
817 return AVERROR_INVALIDDATA;
820 s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
822 if (!s->ps.pps->cu_qp_delta_enabled_flag)
823 s->HEVClc->qp_y = s->sh.slice_qp;
825 s->slice_initialized = 1;
826 s->HEVClc->tu.cu_qp_offset_cb = 0;
827 s->HEVClc->tu.cu_qp_offset_cr = 0;
832 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
834 #define SET_SAO(elem, value) \
836 if (!sao_merge_up_flag && !sao_merge_left_flag) \
838 else if (sao_merge_left_flag) \
839 sao->elem = CTB(s->sao, rx-1, ry).elem; \
840 else if (sao_merge_up_flag) \
841 sao->elem = CTB(s->sao, rx, ry-1).elem; \
846 static void hls_sao_param(HEVCContext *s, int rx, int ry)
848 HEVCLocalContext *lc = s->HEVClc;
849 int sao_merge_left_flag = 0;
850 int sao_merge_up_flag = 0;
851 SAOParams *sao = &CTB(s->sao, rx, ry);
854 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
855 s->sh.slice_sample_adaptive_offset_flag[1]) {
857 if (lc->ctb_left_flag)
858 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
860 if (ry > 0 && !sao_merge_left_flag) {
862 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
866 for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
867 int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
868 s->ps.pps->log2_sao_offset_scale_chroma;
870 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
871 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
876 sao->type_idx[2] = sao->type_idx[1];
877 sao->eo_class[2] = sao->eo_class[1];
879 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
882 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
885 for (i = 0; i < 4; i++)
886 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
888 if (sao->type_idx[c_idx] == SAO_BAND) {
889 for (i = 0; i < 4; i++) {
890 if (sao->offset_abs[c_idx][i]) {
891 SET_SAO(offset_sign[c_idx][i],
892 ff_hevc_sao_offset_sign_decode(s));
894 sao->offset_sign[c_idx][i] = 0;
897 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
898 } else if (c_idx != 2) {
899 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
902 // Inferred parameters
903 sao->offset_val[c_idx][0] = 0;
904 for (i = 0; i < 4; i++) {
905 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
906 if (sao->type_idx[c_idx] == SAO_EDGE) {
908 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
909 } else if (sao->offset_sign[c_idx][i]) {
910 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
912 sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
920 static int hls_cross_component_pred(HEVCContext *s, int idx) {
921 HEVCLocalContext *lc = s->HEVClc;
922 int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
924 if (log2_res_scale_abs_plus1 != 0) {
925 int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
926 lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
927 (1 - 2 * res_scale_sign_flag);
929 lc->tu.res_scale_val = 0;
936 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
937 int xBase, int yBase, int cb_xBase, int cb_yBase,
938 int log2_cb_size, int log2_trafo_size,
939 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
941 HEVCLocalContext *lc = s->HEVClc;
942 const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1];
945 if (lc->cu.pred_mode == MODE_INTRA) {
946 int trafo_size = 1 << log2_trafo_size;
947 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
949 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
952 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
953 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
954 int scan_idx = SCAN_DIAG;
955 int scan_idx_c = SCAN_DIAG;
956 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
957 (s->ps.sps->chroma_format_idc == 2 &&
958 (cbf_cb[1] || cbf_cr[1]));
960 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
961 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
962 if (lc->tu.cu_qp_delta != 0)
963 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
964 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
965 lc->tu.is_cu_qp_delta_coded = 1;
967 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
968 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
969 av_log(s->avctx, AV_LOG_ERROR,
970 "The cu_qp_delta %d is outside the valid range "
973 -(26 + s->ps.sps->qp_bd_offset / 2),
974 (25 + s->ps.sps->qp_bd_offset / 2));
975 return AVERROR_INVALIDDATA;
978 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
981 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
982 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
983 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
984 if (cu_chroma_qp_offset_flag) {
985 int cu_chroma_qp_offset_idx = 0;
986 if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
987 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
988 av_log(s->avctx, AV_LOG_ERROR,
989 "cu_chroma_qp_offset_idx not yet tested.\n");
991 lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
992 lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
994 lc->tu.cu_qp_offset_cb = 0;
995 lc->tu.cu_qp_offset_cr = 0;
997 lc->tu.is_cu_chroma_qp_offset_coded = 1;
1000 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1001 if (lc->tu.intra_pred_mode >= 6 &&
1002 lc->tu.intra_pred_mode <= 14) {
1003 scan_idx = SCAN_VERT;
1004 } else if (lc->tu.intra_pred_mode >= 22 &&
1005 lc->tu.intra_pred_mode <= 30) {
1006 scan_idx = SCAN_HORIZ;
1009 if (lc->tu.intra_pred_mode_c >= 6 &&
1010 lc->tu.intra_pred_mode_c <= 14) {
1011 scan_idx_c = SCAN_VERT;
1012 } else if (lc->tu.intra_pred_mode_c >= 22 &&
1013 lc->tu.intra_pred_mode_c <= 30) {
1014 scan_idx_c = SCAN_HORIZ;
1018 lc->tu.cross_pf = 0;
1021 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1022 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1023 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1024 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1025 lc->tu.cross_pf = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1026 (lc->cu.pred_mode == MODE_INTER ||
1027 (lc->tu.chroma_mode_c == 4)));
1029 if (lc->tu.cross_pf) {
1030 hls_cross_component_pred(s, 0);
1032 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1033 if (lc->cu.pred_mode == MODE_INTRA) {
1034 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1035 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1038 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1039 log2_trafo_size_c, scan_idx_c, 1);
1041 if (lc->tu.cross_pf) {
1042 ptrdiff_t stride = s->frame->linesize[1];
1043 int hshift = s->ps.sps->hshift[1];
1044 int vshift = s->ps.sps->vshift[1];
1045 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1046 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1047 int size = 1 << log2_trafo_size_c;
1049 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1050 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1051 for (i = 0; i < (size * size); i++) {
1052 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1054 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1058 if (lc->tu.cross_pf) {
1059 hls_cross_component_pred(s, 1);
1061 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1062 if (lc->cu.pred_mode == MODE_INTRA) {
1063 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1064 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1067 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1068 log2_trafo_size_c, scan_idx_c, 2);
1070 if (lc->tu.cross_pf) {
1071 ptrdiff_t stride = s->frame->linesize[2];
1072 int hshift = s->ps.sps->hshift[2];
1073 int vshift = s->ps.sps->vshift[2];
1074 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1075 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1076 int size = 1 << log2_trafo_size_c;
1078 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1079 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1080 for (i = 0; i < (size * size); i++) {
1081 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1083 s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1086 } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
1087 int trafo_size_h = 1 << (log2_trafo_size + 1);
1088 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1089 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1090 if (lc->cu.pred_mode == MODE_INTRA) {
1091 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1092 trafo_size_h, trafo_size_v);
1093 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1096 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1097 log2_trafo_size, scan_idx_c, 1);
1099 for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1100 if (lc->cu.pred_mode == MODE_INTRA) {
1101 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1102 trafo_size_h, trafo_size_v);
1103 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1106 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1107 log2_trafo_size, scan_idx_c, 2);
1110 } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1111 if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) {
1112 int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1113 int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1114 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1115 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1116 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1117 if (s->ps.sps->chroma_format_idc == 2) {
1118 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1119 trafo_size_h, trafo_size_v);
1120 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1121 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1123 } else if (blk_idx == 3) {
1124 int trafo_size_h = 1 << (log2_trafo_size + 1);
1125 int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1126 ff_hevc_set_neighbour_available(s, xBase, yBase,
1127 trafo_size_h, trafo_size_v);
1128 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1129 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1130 if (s->ps.sps->chroma_format_idc == 2) {
1131 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1132 trafo_size_h, trafo_size_v);
1133 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1134 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1142 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1144 int cb_size = 1 << log2_cb_size;
1145 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1147 int min_pu_width = s->ps.sps->min_pu_width;
1148 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1149 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1152 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1153 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1154 s->is_pcm[i + j * min_pu_width] = 2;
1157 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1158 int xBase, int yBase, int cb_xBase, int cb_yBase,
1159 int log2_cb_size, int log2_trafo_size,
1160 int trafo_depth, int blk_idx,
1161 const int *base_cbf_cb, const int *base_cbf_cr)
1163 HEVCLocalContext *lc = s->HEVClc;
1164 uint8_t split_transform_flag;
1169 cbf_cb[0] = base_cbf_cb[0];
1170 cbf_cb[1] = base_cbf_cb[1];
1171 cbf_cr[0] = base_cbf_cr[0];
1172 cbf_cr[1] = base_cbf_cr[1];
1174 if (lc->cu.intra_split_flag) {
1175 if (trafo_depth == 1) {
1176 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1177 if (s->ps.sps->chroma_format_idc == 3) {
1178 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1179 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1181 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1182 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1186 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1187 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1188 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1191 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1192 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1193 trafo_depth < lc->cu.max_trafo_depth &&
1194 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1195 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1197 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1198 lc->cu.pred_mode == MODE_INTER &&
1199 lc->cu.part_mode != PART_2Nx2N &&
1202 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1203 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1207 if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1208 if (trafo_depth == 0 || cbf_cb[0]) {
1209 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1210 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1211 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1215 if (trafo_depth == 0 || cbf_cr[0]) {
1216 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1217 if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1218 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1223 if (split_transform_flag) {
1224 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1225 const int x1 = x0 + trafo_size_split;
1226 const int y1 = y0 + trafo_size_split;
1228 #define SUBDIVIDE(x, y, idx) \
1230 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1231 log2_trafo_size - 1, trafo_depth + 1, idx, \
1237 SUBDIVIDE(x0, y0, 0);
1238 SUBDIVIDE(x1, y0, 1);
1239 SUBDIVIDE(x0, y1, 2);
1240 SUBDIVIDE(x1, y1, 3);
1244 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1245 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1246 int min_tu_width = s->ps.sps->min_tb_width;
1249 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1250 cbf_cb[0] || cbf_cr[0] ||
1251 (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1252 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1255 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1256 log2_cb_size, log2_trafo_size,
1257 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1260 // TODO: store cbf_luma somewhere else
1263 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1264 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1265 int x_tu = (x0 + j) >> log2_min_tu_size;
1266 int y_tu = (y0 + i) >> log2_min_tu_size;
1267 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1270 if (!s->sh.disable_deblocking_filter_flag) {
1271 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1272 if (s->ps.pps->transquant_bypass_enable_flag &&
1273 lc->cu.cu_transquant_bypass_flag)
1274 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1280 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1282 HEVCLocalContext *lc = s->HEVClc;
1284 int cb_size = 1 << log2_cb_size;
1285 ptrdiff_t stride0 = s->frame->linesize[0];
1286 ptrdiff_t stride1 = s->frame->linesize[1];
1287 ptrdiff_t stride2 = s->frame->linesize[2];
1288 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1289 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)];
1290 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)];
1292 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
1293 (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) +
1294 ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) *
1295 s->ps.sps->pcm.bit_depth_chroma;
1296 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1299 if (!s->sh.disable_deblocking_filter_flag)
1300 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1302 ret = init_get_bits(&gb, pcm, length);
1306 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1307 if (s->ps.sps->chroma_format_idc) {
1308 s->hevcdsp.put_pcm(dst1, stride1,
1309 cb_size >> s->ps.sps->hshift[1],
1310 cb_size >> s->ps.sps->vshift[1],
1311 &gb, s->ps.sps->pcm.bit_depth_chroma);
1312 s->hevcdsp.put_pcm(dst2, stride2,
1313 cb_size >> s->ps.sps->hshift[2],
1314 cb_size >> s->ps.sps->vshift[2],
1315 &gb, s->ps.sps->pcm.bit_depth_chroma);
1322 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1324 * @param s HEVC decoding context
1325 * @param dst target buffer for block data at block position
1326 * @param dststride stride of the dst buffer
1327 * @param ref reference picture buffer at origin (0, 0)
1328 * @param mv motion vector (relative to block position) to get pixel data from
1329 * @param x_off horizontal position of block from origin (0, 0)
1330 * @param y_off vertical position of block from origin (0, 0)
1331 * @param block_w width of block
1332 * @param block_h height of block
1333 * @param luma_weight weighting factor applied to the luma prediction
1334 * @param luma_offset additive offset applied to the luma prediction value
1337 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1338 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1339 int block_w, int block_h, int luma_weight, int luma_offset)
1341 HEVCLocalContext *lc = s->HEVClc;
1342 uint8_t *src = ref->data[0];
1343 ptrdiff_t srcstride = ref->linesize[0];
1344 int pic_width = s->ps.sps->width;
1345 int pic_height = s->ps.sps->height;
1348 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1349 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1350 int idx = ff_hevc_pel_weight[block_w];
1352 x_off += mv->x >> 2;
1353 y_off += mv->y >> 2;
1354 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1356 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1357 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1358 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1359 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1360 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1361 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1363 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1364 edge_emu_stride, srcstride,
1365 block_w + QPEL_EXTRA,
1366 block_h + QPEL_EXTRA,
1367 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1368 pic_width, pic_height);
1369 src = lc->edge_emu_buffer + buf_offset;
1370 srcstride = edge_emu_stride;
1374 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1375 block_h, mx, my, block_w);
1377 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1378 block_h, s->sh.luma_log2_weight_denom,
1379 luma_weight, luma_offset, mx, my, block_w);
1383 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1385 * @param s HEVC decoding context
1386 * @param dst target buffer for block data at block position
1387 * @param dststride stride of the dst buffer
1388 * @param ref0 reference picture0 buffer at origin (0, 0)
1389 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1390 * @param x_off horizontal position of block from origin (0, 0)
1391 * @param y_off vertical position of block from origin (0, 0)
1392 * @param block_w width of block
1393 * @param block_h height of block
1394 * @param ref1 reference picture1 buffer at origin (0, 0)
1395 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1396 * @param current_mv current motion vector structure
1398 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1399 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1400 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1402 HEVCLocalContext *lc = s->HEVClc;
1403 ptrdiff_t src0stride = ref0->linesize[0];
1404 ptrdiff_t src1stride = ref1->linesize[0];
1405 int pic_width = s->ps.sps->width;
1406 int pic_height = s->ps.sps->height;
1407 int mx0 = mv0->x & 3;
1408 int my0 = mv0->y & 3;
1409 int mx1 = mv1->x & 3;
1410 int my1 = mv1->y & 3;
1411 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1412 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1413 int x_off0 = x_off + (mv0->x >> 2);
1414 int y_off0 = y_off + (mv0->y >> 2);
1415 int x_off1 = x_off + (mv1->x >> 2);
1416 int y_off1 = y_off + (mv1->y >> 2);
1417 int idx = ff_hevc_pel_weight[block_w];
1419 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1420 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1422 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1423 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1424 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1425 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1426 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1427 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1429 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1430 edge_emu_stride, src0stride,
1431 block_w + QPEL_EXTRA,
1432 block_h + QPEL_EXTRA,
1433 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1434 pic_width, pic_height);
1435 src0 = lc->edge_emu_buffer + buf_offset;
1436 src0stride = edge_emu_stride;
1439 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1440 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1441 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1442 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1443 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1444 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1446 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1447 edge_emu_stride, src1stride,
1448 block_w + QPEL_EXTRA,
1449 block_h + QPEL_EXTRA,
1450 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1451 pic_width, pic_height);
1452 src1 = lc->edge_emu_buffer2 + buf_offset;
1453 src1stride = edge_emu_stride;
1456 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1457 block_h, mx0, my0, block_w);
1459 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1460 block_h, mx1, my1, block_w);
1462 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1463 block_h, s->sh.luma_log2_weight_denom,
1464 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1465 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1466 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1467 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1473 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1475 * @param s HEVC decoding context
1476 * @param dst1 target buffer for block data at block position (U plane)
1477 * @param dst2 target buffer for block data at block position (V plane)
1478 * @param dststride stride of the dst1 and dst2 buffers
1479 * @param ref reference picture buffer at origin (0, 0)
1480 * @param mv motion vector (relative to block position) to get pixel data from
1481 * @param x_off horizontal position of block from origin (0, 0)
1482 * @param y_off vertical position of block from origin (0, 0)
1483 * @param block_w width of block
1484 * @param block_h height of block
1485 * @param chroma_weight weighting factor applied to the chroma prediction
1486 * @param chroma_offset additive offset applied to the chroma prediction value
1489 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1490 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1491 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1493 HEVCLocalContext *lc = s->HEVClc;
1494 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1495 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1496 const Mv *mv = ¤t_mv->mv[reflist];
1497 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1498 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1499 int idx = ff_hevc_pel_weight[block_w];
1500 int hshift = s->ps.sps->hshift[1];
1501 int vshift = s->ps.sps->vshift[1];
1502 intptr_t mx = av_mod_uintp2(mv->x, 2 + hshift);
1503 intptr_t my = av_mod_uintp2(mv->y, 2 + vshift);
1504 intptr_t _mx = mx << (1 - hshift);
1505 intptr_t _my = my << (1 - vshift);
1507 x_off += mv->x >> (2 + hshift);
1508 y_off += mv->y >> (2 + vshift);
1509 src0 += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1511 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1512 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1513 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1514 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1515 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift));
1516 int buf_offset0 = EPEL_EXTRA_BEFORE *
1517 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1518 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1519 edge_emu_stride, srcstride,
1520 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1521 x_off - EPEL_EXTRA_BEFORE,
1522 y_off - EPEL_EXTRA_BEFORE,
1523 pic_width, pic_height);
1525 src0 = lc->edge_emu_buffer + buf_offset0;
1526 srcstride = edge_emu_stride;
1529 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1530 block_h, _mx, _my, block_w);
1532 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1533 block_h, s->sh.chroma_log2_weight_denom,
1534 chroma_weight, chroma_offset, _mx, _my, block_w);
1538 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1540 * @param s HEVC decoding context
1541 * @param dst target buffer for block data at block position
1542 * @param dststride stride of the dst buffer
1543 * @param ref0 reference picture0 buffer at origin (0, 0)
1544 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1545 * @param x_off horizontal position of block from origin (0, 0)
1546 * @param y_off vertical position of block from origin (0, 0)
1547 * @param block_w width of block
1548 * @param block_h height of block
1549 * @param ref1 reference picture1 buffer at origin (0, 0)
1550 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1551 * @param current_mv current motion vector structure
1552 * @param cidx chroma component(cb, cr)
1554 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1555 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1557 HEVCLocalContext *lc = s->HEVClc;
1558 uint8_t *src1 = ref0->data[cidx+1];
1559 uint8_t *src2 = ref1->data[cidx+1];
1560 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1561 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1562 int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1563 (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
1564 int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1565 int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1566 Mv *mv0 = ¤t_mv->mv[0];
1567 Mv *mv1 = ¤t_mv->mv[1];
1568 int hshift = s->ps.sps->hshift[1];
1569 int vshift = s->ps.sps->vshift[1];
1571 intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1572 intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1573 intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1574 intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1575 intptr_t _mx0 = mx0 << (1 - hshift);
1576 intptr_t _my0 = my0 << (1 - vshift);
1577 intptr_t _mx1 = mx1 << (1 - hshift);
1578 intptr_t _my1 = my1 << (1 - vshift);
1580 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1581 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1582 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1583 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1584 int idx = ff_hevc_pel_weight[block_w];
1585 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1586 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1588 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1589 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1590 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1591 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1592 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1593 int buf_offset1 = EPEL_EXTRA_BEFORE *
1594 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1596 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1597 edge_emu_stride, src1stride,
1598 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1599 x_off0 - EPEL_EXTRA_BEFORE,
1600 y_off0 - EPEL_EXTRA_BEFORE,
1601 pic_width, pic_height);
1603 src1 = lc->edge_emu_buffer + buf_offset1;
1604 src1stride = edge_emu_stride;
1607 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1608 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1609 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1610 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1611 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1612 int buf_offset1 = EPEL_EXTRA_BEFORE *
1613 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1615 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1616 edge_emu_stride, src2stride,
1617 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1618 x_off1 - EPEL_EXTRA_BEFORE,
1619 y_off1 - EPEL_EXTRA_BEFORE,
1620 pic_width, pic_height);
1622 src2 = lc->edge_emu_buffer2 + buf_offset1;
1623 src2stride = edge_emu_stride;
1626 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1627 block_h, _mx0, _my0, block_w);
1629 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1630 src2, src2stride, lc->tmp,
1631 block_h, _mx1, _my1, block_w);
1633 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1634 src2, src2stride, lc->tmp,
1636 s->sh.chroma_log2_weight_denom,
1637 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1638 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1639 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1640 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1641 _mx1, _my1, block_w);
1644 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1645 const Mv *mv, int y0, int height)
1647 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1649 if (s->threads_type == FF_THREAD_FRAME )
1650 ff_thread_await_progress(&ref->tf, y, 0);
1653 static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
1654 int nPbH, int log2_cb_size, int part_idx,
1655 int merge_idx, MvField *mv)
1657 HEVCLocalContext *lc = s->HEVClc;
1658 enum InterPredIdc inter_pred_idc = PRED_L0;
1661 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1663 if (s->sh.slice_type == HEVC_SLICE_B)
1664 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1666 if (inter_pred_idc != PRED_L1) {
1667 if (s->sh.nb_refs[L0])
1668 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1670 mv->pred_flag = PF_L0;
1671 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1672 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1673 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1674 part_idx, merge_idx, mv, mvp_flag, 0);
1675 mv->mv[0].x += lc->pu.mvd.x;
1676 mv->mv[0].y += lc->pu.mvd.y;
1679 if (inter_pred_idc != PRED_L0) {
1680 if (s->sh.nb_refs[L1])
1681 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1683 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1684 AV_ZERO32(&lc->pu.mvd);
1686 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1689 mv->pred_flag += PF_L1;
1690 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1691 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1692 part_idx, merge_idx, mv, mvp_flag, 1);
1693 mv->mv[1].x += lc->pu.mvd.x;
1694 mv->mv[1].y += lc->pu.mvd.y;
1698 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1700 int log2_cb_size, int partIdx, int idx)
1702 #define POS(c_idx, x, y) \
1703 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1704 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1705 HEVCLocalContext *lc = s->HEVClc;
1707 struct MvField current_mv = {{{ 0 }}};
1709 int min_pu_width = s->ps.sps->min_pu_width;
1711 MvField *tab_mvf = s->ref->tab_mvf;
1712 RefPicList *refPicList = s->ref->refPicList;
1713 HEVCFrame *ref0 = NULL, *ref1 = NULL;
1714 uint8_t *dst0 = POS(0, x0, y0);
1715 uint8_t *dst1 = POS(1, x0, y0);
1716 uint8_t *dst2 = POS(2, x0, y0);
1717 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1718 int min_cb_width = s->ps.sps->min_cb_width;
1719 int x_cb = x0 >> log2_min_cb_size;
1720 int y_cb = y0 >> log2_min_cb_size;
1724 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1727 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1729 if (skip_flag || lc->pu.merge_flag) {
1730 if (s->sh.max_num_merge_cand > 1)
1731 merge_idx = ff_hevc_merge_idx_decode(s);
1735 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1736 partIdx, merge_idx, ¤t_mv);
1738 hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1739 partIdx, merge_idx, ¤t_mv);
1742 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1743 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1745 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1746 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1747 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1749 if (current_mv.pred_flag & PF_L0) {
1750 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1753 hevc_await_progress(s, ref0, ¤t_mv.mv[0], y0, nPbH);
1755 if (current_mv.pred_flag & PF_L1) {
1756 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1759 hevc_await_progress(s, ref1, ¤t_mv.mv[1], y0, nPbH);
1762 if (current_mv.pred_flag == PF_L0) {
1763 int x0_c = x0 >> s->ps.sps->hshift[1];
1764 int y0_c = y0 >> s->ps.sps->vshift[1];
1765 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1766 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1768 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1769 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1770 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1771 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1773 if (s->ps.sps->chroma_format_idc) {
1774 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1775 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1776 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1777 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1778 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1779 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1781 } else if (current_mv.pred_flag == PF_L1) {
1782 int x0_c = x0 >> s->ps.sps->hshift[1];
1783 int y0_c = y0 >> s->ps.sps->vshift[1];
1784 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1785 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1787 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1788 ¤t_mv.mv[1], x0, y0, nPbW, nPbH,
1789 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1790 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1792 if (s->ps.sps->chroma_format_idc) {
1793 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1794 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1795 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1797 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1798 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv,
1799 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1801 } else if (current_mv.pred_flag == PF_BI) {
1802 int x0_c = x0 >> s->ps.sps->hshift[1];
1803 int y0_c = y0 >> s->ps.sps->vshift[1];
1804 int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1805 int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1807 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1808 ¤t_mv.mv[0], x0, y0, nPbW, nPbH,
1809 ref1->frame, ¤t_mv.mv[1], ¤t_mv);
1811 if (s->ps.sps->chroma_format_idc) {
1812 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1813 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 0);
1815 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1816 x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, 1);
1824 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1825 int prev_intra_luma_pred_flag)
1827 HEVCLocalContext *lc = s->HEVClc;
1828 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1829 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1830 int min_pu_width = s->ps.sps->min_pu_width;
1831 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1832 int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
1833 int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
1835 int cand_up = (lc->ctb_up_flag || y0b) ?
1836 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1837 int cand_left = (lc->ctb_left_flag || x0b) ?
1838 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1840 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1842 MvField *tab_mvf = s->ref->tab_mvf;
1843 int intra_pred_mode;
1847 // intra_pred_mode prediction does not cross vertical CTB boundaries
1848 if ((y0 - 1) < y_ctb)
1851 if (cand_left == cand_up) {
1852 if (cand_left < 2) {
1853 candidate[0] = INTRA_PLANAR;
1854 candidate[1] = INTRA_DC;
1855 candidate[2] = INTRA_ANGULAR_26;
1857 candidate[0] = cand_left;
1858 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1859 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1862 candidate[0] = cand_left;
1863 candidate[1] = cand_up;
1864 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1865 candidate[2] = INTRA_PLANAR;
1866 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1867 candidate[2] = INTRA_DC;
1869 candidate[2] = INTRA_ANGULAR_26;
1873 if (prev_intra_luma_pred_flag) {
1874 intra_pred_mode = candidate[lc->pu.mpm_idx];
1876 if (candidate[0] > candidate[1])
1877 FFSWAP(uint8_t, candidate[0], candidate[1]);
1878 if (candidate[0] > candidate[2])
1879 FFSWAP(uint8_t, candidate[0], candidate[2]);
1880 if (candidate[1] > candidate[2])
1881 FFSWAP(uint8_t, candidate[1], candidate[2]);
1883 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1884 for (i = 0; i < 3; i++)
1885 if (intra_pred_mode >= candidate[i])
1889 /* write the intra prediction units into the mv array */
1892 for (i = 0; i < size_in_pus; i++) {
1893 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1894 intra_pred_mode, size_in_pus);
1896 for (j = 0; j < size_in_pus; j++) {
1897 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1901 return intra_pred_mode;
1904 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1905 int log2_cb_size, int ct_depth)
1907 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1908 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
1909 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
1912 for (y = 0; y < length; y++)
1913 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
1917 static const uint8_t tab_mode_idx[] = {
1918 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1919 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1921 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1924 HEVCLocalContext *lc = s->HEVClc;
1925 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1926 uint8_t prev_intra_luma_pred_flag[4];
1927 int split = lc->cu.part_mode == PART_NxN;
1928 int pb_size = (1 << log2_cb_size) >> split;
1929 int side = split + 1;
1933 for (i = 0; i < side; i++)
1934 for (j = 0; j < side; j++)
1935 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1937 for (i = 0; i < side; i++) {
1938 for (j = 0; j < side; j++) {
1939 if (prev_intra_luma_pred_flag[2 * i + j])
1940 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1942 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1944 lc->pu.intra_pred_mode[2 * i + j] =
1945 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1946 prev_intra_luma_pred_flag[2 * i + j]);
1950 if (s->ps.sps->chroma_format_idc == 3) {
1951 for (i = 0; i < side; i++) {
1952 for (j = 0; j < side; j++) {
1953 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1954 if (chroma_mode != 4) {
1955 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1956 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1958 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1960 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1964 } else if (s->ps.sps->chroma_format_idc == 2) {
1966 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1967 if (chroma_mode != 4) {
1968 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1971 mode_idx = intra_chroma_table[chroma_mode];
1973 mode_idx = lc->pu.intra_pred_mode[0];
1975 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1976 } else if (s->ps.sps->chroma_format_idc != 0) {
1977 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1978 if (chroma_mode != 4) {
1979 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1980 lc->pu.intra_pred_mode_c[0] = 34;
1982 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1984 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1989 static void intra_prediction_unit_default_value(HEVCContext *s,
1993 HEVCLocalContext *lc = s->HEVClc;
1994 int pb_size = 1 << log2_cb_size;
1995 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
1996 int min_pu_width = s->ps.sps->min_pu_width;
1997 MvField *tab_mvf = s->ref->tab_mvf;
1998 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1999 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2002 if (size_in_pus == 0)
2004 for (j = 0; j < size_in_pus; j++)
2005 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2006 if (lc->cu.pred_mode == MODE_INTRA)
2007 for (j = 0; j < size_in_pus; j++)
2008 for (k = 0; k < size_in_pus; k++)
2009 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2012 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2014 int cb_size = 1 << log2_cb_size;
2015 HEVCLocalContext *lc = s->HEVClc;
2016 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2017 int length = cb_size >> log2_min_cb_size;
2018 int min_cb_width = s->ps.sps->min_cb_width;
2019 int x_cb = x0 >> log2_min_cb_size;
2020 int y_cb = y0 >> log2_min_cb_size;
2021 int idx = log2_cb_size - 2;
2022 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2027 lc->cu.pred_mode = MODE_INTRA;
2028 lc->cu.part_mode = PART_2Nx2N;
2029 lc->cu.intra_split_flag = 0;
2031 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2032 for (x = 0; x < 4; x++)
2033 lc->pu.intra_pred_mode[x] = 1;
2034 if (s->ps.pps->transquant_bypass_enable_flag) {
2035 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2036 if (lc->cu.cu_transquant_bypass_flag)
2037 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2039 lc->cu.cu_transquant_bypass_flag = 0;
2041 if (s->sh.slice_type != HEVC_SLICE_I) {
2042 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2044 x = y_cb * min_cb_width + x_cb;
2045 for (y = 0; y < length; y++) {
2046 memset(&s->skip_flag[x], skip_flag, length);
2049 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2051 x = y_cb * min_cb_width + x_cb;
2052 for (y = 0; y < length; y++) {
2053 memset(&s->skip_flag[x], 0, length);
2058 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2059 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2060 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2062 if (!s->sh.disable_deblocking_filter_flag)
2063 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2067 if (s->sh.slice_type != HEVC_SLICE_I)
2068 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2069 if (lc->cu.pred_mode != MODE_INTRA ||
2070 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2071 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2072 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2073 lc->cu.pred_mode == MODE_INTRA;
2076 if (lc->cu.pred_mode == MODE_INTRA) {
2077 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2078 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2079 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2080 pcm_flag = ff_hevc_pcm_flag_decode(s);
2083 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2084 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2085 if (s->ps.sps->pcm.loop_filter_disable_flag)
2086 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2091 intra_prediction_unit(s, x0, y0, log2_cb_size);
2094 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2095 switch (lc->cu.part_mode) {
2097 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2100 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2101 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2104 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2105 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2108 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2109 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2112 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2113 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2116 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2117 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2120 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2121 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2124 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2125 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2126 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2127 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2133 int rqt_root_cbf = 1;
2135 if (lc->cu.pred_mode != MODE_INTRA &&
2136 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2137 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2140 const static int cbf[2] = { 0 };
2141 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2142 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2143 s->ps.sps->max_transform_hierarchy_depth_inter;
2144 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2146 log2_cb_size, 0, 0, cbf, cbf);
2150 if (!s->sh.disable_deblocking_filter_flag)
2151 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2156 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2157 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2159 x = y_cb * min_cb_width + x_cb;
2160 for (y = 0; y < length; y++) {
2161 memset(&s->qp_y_tab[x], lc->qp_y, length);
2165 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2166 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2167 lc->qPy_pred = lc->qp_y;
2170 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2175 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2176 int log2_cb_size, int cb_depth)
2178 HEVCLocalContext *lc = s->HEVClc;
2179 const int cb_size = 1 << log2_cb_size;
2183 lc->ct_depth = cb_depth;
2184 if (x0 + cb_size <= s->ps.sps->width &&
2185 y0 + cb_size <= s->ps.sps->height &&
2186 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2187 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2189 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2191 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2192 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2193 lc->tu.is_cu_qp_delta_coded = 0;
2194 lc->tu.cu_qp_delta = 0;
2197 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2198 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2199 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2203 int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2204 const int cb_size_split = cb_size >> 1;
2205 const int x1 = x0 + cb_size_split;
2206 const int y1 = y0 + cb_size_split;
2210 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2214 if (more_data && x1 < s->ps.sps->width) {
2215 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2219 if (more_data && y1 < s->ps.sps->height) {
2220 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2224 if (more_data && x1 < s->ps.sps->width &&
2225 y1 < s->ps.sps->height) {
2226 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2231 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2232 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2233 lc->qPy_pred = lc->qp_y;
2236 return ((x1 + cb_size_split) < s->ps.sps->width ||
2237 (y1 + cb_size_split) < s->ps.sps->height);
2241 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2244 if ((!((x0 + cb_size) %
2245 (1 << (s->ps.sps->log2_ctb_size))) ||
2246 (x0 + cb_size >= s->ps.sps->width)) &&
2248 (1 << (s->ps.sps->log2_ctb_size))) ||
2249 (y0 + cb_size >= s->ps.sps->height))) {
2250 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2251 return !end_of_slice_flag;
2260 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2263 HEVCLocalContext *lc = s->HEVClc;
2264 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2265 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2266 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2268 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2270 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2271 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2272 lc->first_qp_group = 1;
2273 lc->end_of_tiles_x = s->ps.sps->width;
2274 } else if (s->ps.pps->tiles_enabled_flag) {
2275 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2276 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2277 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2278 lc->first_qp_group = 1;
2281 lc->end_of_tiles_x = s->ps.sps->width;
2284 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2286 lc->boundary_flags = 0;
2287 if (s->ps.pps->tiles_enabled_flag) {
2288 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]])
2289 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2290 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2291 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2292 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]])
2293 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2294 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2295 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2297 if (ctb_addr_in_slice <= 0)
2298 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2299 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2300 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2303 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2304 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2305 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]]));
2306 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]]));
2309 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2311 HEVCContext *s = avctxt->priv_data;
2312 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2316 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2318 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2319 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2320 return AVERROR_INVALIDDATA;
2323 if (s->sh.dependent_slice_segment_flag) {
2324 int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2325 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2326 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2327 return AVERROR_INVALIDDATA;
2331 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2332 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2334 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2335 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2336 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2338 ff_hevc_cabac_init(s, ctb_addr_ts);
2340 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2342 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2343 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2344 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2346 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2347 if (more_data < 0) {
2348 s->tab_slice_address[ctb_addr_rs] = -1;
2354 ff_hevc_save_states(s, ctb_addr_ts);
2355 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2358 if (x_ctb + ctb_size >= s->ps.sps->width &&
2359 y_ctb + ctb_size >= s->ps.sps->height)
2360 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2365 static int hls_slice_data(HEVCContext *s)
2373 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2376 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2378 HEVCContext *s1 = avctxt->priv_data, *s;
2379 HEVCLocalContext *lc;
2380 int ctb_size = 1<< s1->ps.sps->log2_ctb_size;
2382 int *ctb_row_p = input_ctb_row;
2383 int ctb_row = ctb_row_p[job];
2384 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);
2385 int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2386 int thread = ctb_row % s1->threads_number;
2389 s = s1->sList[self_id];
2393 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2397 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2400 while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2401 int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2402 int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2404 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2406 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2408 if (atomic_load(&s1->wpp_err)) {
2409 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2413 ff_hevc_cabac_init(s, ctb_addr_ts);
2414 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2415 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2417 if (more_data < 0) {
2418 s->tab_slice_address[ctb_addr_rs] = -1;
2419 atomic_store(&s1->wpp_err, 1);
2420 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2426 ff_hevc_save_states(s, ctb_addr_ts);
2427 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2428 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2430 if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2431 atomic_store(&s1->wpp_err, 1);
2432 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2436 if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) {
2437 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2438 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2441 ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2444 if(x_ctb >= s->ps.sps->width) {
2448 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2453 static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
2455 const uint8_t *data = nal->data;
2456 int length = nal->size;
2457 HEVCLocalContext *lc = s->HEVClc;
2458 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2459 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2461 int64_t startheader, cmpt = 0;
2467 return AVERROR(ENOMEM);
2470 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) {
2471 av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2472 s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets,
2473 s->ps.sps->ctb_width, s->ps.sps->ctb_height
2475 res = AVERROR_INVALIDDATA;
2479 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2482 for (i = 1; i < s->threads_number; i++) {
2483 s->sList[i] = av_malloc(sizeof(HEVCContext));
2484 memcpy(s->sList[i], s, sizeof(HEVCContext));
2485 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2486 s->sList[i]->HEVClc = s->HEVClcList[i];
2490 offset = (lc->gb.index >> 3);
2492 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2493 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2499 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2500 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2501 for (j = 0, cmpt = 0, startheader = offset
2502 + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2503 if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2508 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2509 s->sh.offset[i - 1] = offset;
2512 if (s->sh.num_entry_point_offsets != 0) {
2513 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2514 if (length < offset) {
2515 av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2516 res = AVERROR_INVALIDDATA;
2519 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2520 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2525 for (i = 1; i < s->threads_number; i++) {
2526 s->sList[i]->HEVClc->first_qp_group = 1;
2527 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2528 memcpy(s->sList[i], s, sizeof(HEVCContext));
2529 s->sList[i]->HEVClc = s->HEVClcList[i];
2532 atomic_store(&s->wpp_err, 0);
2533 ff_reset_entries(s->avctx);
2535 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2540 if (s->ps.pps->entropy_coding_sync_enabled_flag)
2541 s->avctx->execute2(s->avctx, hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2543 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2551 static int set_side_data(HEVCContext *s)
2553 AVFrame *out = s->ref->frame;
2555 if (s->sei_frame_packing_present &&
2556 s->frame_packing_arrangement_type >= 3 &&
2557 s->frame_packing_arrangement_type <= 5 &&
2558 s->content_interpretation_type > 0 &&
2559 s->content_interpretation_type < 3) {
2560 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2562 return AVERROR(ENOMEM);
2564 switch (s->frame_packing_arrangement_type) {
2566 if (s->quincunx_subsampling)
2567 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2569 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2572 stereo->type = AV_STEREO3D_TOPBOTTOM;
2575 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2579 if (s->content_interpretation_type == 2)
2580 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2583 if (s->sei_display_orientation_present &&
2584 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2585 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2586 AVFrameSideData *rotation = av_frame_new_side_data(out,
2587 AV_FRAME_DATA_DISPLAYMATRIX,
2588 sizeof(int32_t) * 9);
2590 return AVERROR(ENOMEM);
2592 av_display_rotation_set((int32_t *)rotation->data, angle);
2593 av_display_matrix_flip((int32_t *)rotation->data,
2594 s->sei_hflip, s->sei_vflip);
2597 // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2598 // so the side data persists for the entire coded video sequence.
2599 if (s->sei_mastering_display_info_present > 0 &&
2600 IS_IRAP(s) && s->no_rasl_output_flag) {
2601 s->sei_mastering_display_info_present--;
2603 if (s->sei_mastering_display_info_present) {
2604 // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
2605 const int mapping[3] = {2, 0, 1};
2606 const int chroma_den = 50000;
2607 const int luma_den = 10000;
2609 AVMasteringDisplayMetadata *metadata =
2610 av_mastering_display_metadata_create_side_data(out);
2612 return AVERROR(ENOMEM);
2614 for (i = 0; i < 3; i++) {
2615 const int j = mapping[i];
2616 metadata->display_primaries[i][0].num = s->display_primaries[j][0];
2617 metadata->display_primaries[i][0].den = chroma_den;
2618 metadata->display_primaries[i][1].num = s->display_primaries[j][1];
2619 metadata->display_primaries[i][1].den = chroma_den;
2621 metadata->white_point[0].num = s->white_point[0];
2622 metadata->white_point[0].den = chroma_den;
2623 metadata->white_point[1].num = s->white_point[1];
2624 metadata->white_point[1].den = chroma_den;
2626 metadata->max_luminance.num = s->max_mastering_luminance;
2627 metadata->max_luminance.den = luma_den;
2628 metadata->min_luminance.num = s->min_mastering_luminance;
2629 metadata->min_luminance.den = luma_den;
2630 metadata->has_luminance = 1;
2631 metadata->has_primaries = 1;
2633 av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n");
2634 av_log(s->avctx, AV_LOG_DEBUG,
2635 "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2636 av_q2d(metadata->display_primaries[0][0]),
2637 av_q2d(metadata->display_primaries[0][1]),
2638 av_q2d(metadata->display_primaries[1][0]),
2639 av_q2d(metadata->display_primaries[1][1]),
2640 av_q2d(metadata->display_primaries[2][0]),
2641 av_q2d(metadata->display_primaries[2][1]),
2642 av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]));
2643 av_log(s->avctx, AV_LOG_DEBUG,
2644 "min_luminance=%f, max_luminance=%f\n",
2645 av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
2648 if (s->a53_caption) {
2649 AVFrameSideData* sd = av_frame_new_side_data(out,
2650 AV_FRAME_DATA_A53_CC,
2651 s->a53_caption_size);
2653 memcpy(sd->data, s->a53_caption, s->a53_caption_size);
2654 av_freep(&s->a53_caption);
2655 s->a53_caption_size = 0;
2656 s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2662 static int hevc_frame_start(HEVCContext *s)
2664 HEVCLocalContext *lc = s->HEVClc;
2665 int pic_size_in_ctb = ((s->ps.sps->width >> s->ps.sps->log2_min_cb_size) + 1) *
2666 ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1);
2669 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2670 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2671 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2672 memset(s->is_pcm, 0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1));
2673 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2676 s->first_nal_type = s->nal_unit_type;
2678 s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos);
2680 if (s->ps.pps->tiles_enabled_flag)
2681 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2683 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2687 ret = ff_hevc_frame_rps(s);
2689 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2693 s->ref->frame->key_frame = IS_IRAP(s);
2695 ret = set_side_data(s);
2699 s->frame->pict_type = 3 - s->sh.slice_type;
2702 ff_hevc_bump_frame(s);
2704 av_frame_unref(s->output_frame);
2705 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2709 if (!s->avctx->hwaccel)
2710 ff_thread_finish_setup(s->avctx);
2716 ff_hevc_unref_frame(s, s->ref, ~0);
2721 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2723 HEVCLocalContext *lc = s->HEVClc;
2724 GetBitContext *gb = &lc->gb;
2725 int ctb_addr_ts, ret;
2728 s->nal_unit_type = nal->type;
2729 s->temporal_id = nal->temporal_id;
2731 switch (s->nal_unit_type) {
2733 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2738 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2739 s->apply_defdispwin);
2744 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2748 case HEVC_NAL_SEI_PREFIX:
2749 case HEVC_NAL_SEI_SUFFIX:
2750 ret = ff_hevc_decode_nal_sei(s);
2754 case HEVC_NAL_TRAIL_R:
2755 case HEVC_NAL_TRAIL_N:
2756 case HEVC_NAL_TSA_N:
2757 case HEVC_NAL_TSA_R:
2758 case HEVC_NAL_STSA_N:
2759 case HEVC_NAL_STSA_R:
2760 case HEVC_NAL_BLA_W_LP:
2761 case HEVC_NAL_BLA_W_RADL:
2762 case HEVC_NAL_BLA_N_LP:
2763 case HEVC_NAL_IDR_W_RADL:
2764 case HEVC_NAL_IDR_N_LP:
2765 case HEVC_NAL_CRA_NUT:
2766 case HEVC_NAL_RADL_N:
2767 case HEVC_NAL_RADL_R:
2768 case HEVC_NAL_RASL_N:
2769 case HEVC_NAL_RASL_R:
2770 ret = hls_slice_header(s);
2774 if (s->max_ra == INT_MAX) {
2775 if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
2779 s->max_ra = INT_MIN;
2783 if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
2784 s->poc <= s->max_ra) {
2788 if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
2789 s->max_ra = INT_MIN;
2792 if (s->sh.first_slice_in_pic_flag) {
2793 ret = hevc_frame_start(s);
2796 } else if (!s->ref) {
2797 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2801 if (s->nal_unit_type != s->first_nal_type) {
2802 av_log(s->avctx, AV_LOG_ERROR,
2803 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2804 s->first_nal_type, s->nal_unit_type);
2805 return AVERROR_INVALIDDATA;
2808 if (!s->sh.dependent_slice_segment_flag &&
2809 s->sh.slice_type != HEVC_SLICE_I) {
2810 ret = ff_hevc_slice_rpl(s);
2812 av_log(s->avctx, AV_LOG_WARNING,
2813 "Error constructing the reference lists for the current slice.\n");
2818 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2819 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2824 if (s->avctx->hwaccel) {
2825 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2829 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2830 ctb_addr_ts = hls_slice_data_wpp(s, nal);
2832 ctb_addr_ts = hls_slice_data(s);
2833 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2837 if (ctb_addr_ts < 0) {
2843 case HEVC_NAL_EOS_NUT:
2844 case HEVC_NAL_EOB_NUT:
2845 s->seq_decode = (s->seq_decode + 1) & 0xff;
2846 s->max_ra = INT_MAX;
2849 case HEVC_NAL_FD_NUT:
2852 av_log(s->avctx, AV_LOG_INFO,
2853 "Skipping NAL unit %d\n", s->nal_unit_type);
2858 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2863 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2868 s->last_eos = s->eos;
2871 /* split the input packet into NAL units, so we know the upper bound on the
2872 * number of slices in the frame */
2873 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
2874 s->nal_length_size, s->avctx->codec_id, 1);
2876 av_log(s->avctx, AV_LOG_ERROR,
2877 "Error splitting the input into NAL units.\n");
2881 for (i = 0; i < s->pkt.nb_nals; i++) {
2882 if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
2883 s->pkt.nals[i].type == HEVC_NAL_EOS_NUT)
2887 /* decode the NAL units */
2888 for (i = 0; i < s->pkt.nb_nals; i++) {
2889 ret = decode_nal_unit(s, &s->pkt.nals[i]);
2891 av_log(s->avctx, AV_LOG_WARNING,
2892 "Error parsing NAL unit #%d.\n", i);
2898 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2899 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2904 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2907 for (i = 0; i < 16; i++)
2908 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2911 static int verify_md5(HEVCContext *s, AVFrame *frame)
2913 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2918 return AVERROR(EINVAL);
2920 pixel_shift = desc->comp[0].depth > 8;
2922 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2925 /* the checksums are LE, so we have to byteswap for >8bpp formats
2928 if (pixel_shift && !s->checksum_buf) {
2929 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2930 FFMAX3(frame->linesize[0], frame->linesize[1],
2931 frame->linesize[2]));
2932 if (!s->checksum_buf)
2933 return AVERROR(ENOMEM);
2937 for (i = 0; frame->data[i]; i++) {
2938 int width = s->avctx->coded_width;
2939 int height = s->avctx->coded_height;
2940 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2941 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2944 av_md5_init(s->md5_ctx);
2945 for (j = 0; j < h; j++) {
2946 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2949 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2950 (const uint16_t *) src, w);
2951 src = s->checksum_buf;
2954 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2956 av_md5_final(s->md5_ctx, md5);
2958 if (!memcmp(md5, s->md5[i], 16)) {
2959 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2960 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2961 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2963 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2964 print_md5(s->avctx, AV_LOG_ERROR, md5);
2965 av_log (s->avctx, AV_LOG_ERROR, " != ");
2966 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2967 av_log (s->avctx, AV_LOG_ERROR, "\n");
2968 return AVERROR_INVALIDDATA;
2972 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2977 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length)
2979 AVCodecContext *avctx = s->avctx;
2983 bytestream2_init(&gb, buf, length);
2985 if (length > 3 && (buf[0] || buf[1] || buf[2] > 1)) {
2986 /* It seems the extradata is encoded as hvcC format.
2987 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
2988 * is finalized. When finalized, configurationVersion will be 1 and we
2989 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
2990 int i, j, num_arrays, nal_len_size;
2994 bytestream2_skip(&gb, 21);
2995 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
2996 num_arrays = bytestream2_get_byte(&gb);
2998 /* nal units in the hvcC always have length coded with 2 bytes,
2999 * so put a fake nal_length_size = 2 while parsing them */
3000 s->nal_length_size = 2;
3002 /* Decode nal units from hvcC. */
3003 for (i = 0; i < num_arrays; i++) {
3004 int type = bytestream2_get_byte(&gb) & 0x3f;
3005 int cnt = bytestream2_get_be16(&gb);
3007 for (j = 0; j < cnt; j++) {
3008 // +2 for the nal size field
3009 int nalsize = bytestream2_peek_be16(&gb) + 2;
3010 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3011 av_log(s->avctx, AV_LOG_ERROR,
3012 "Invalid NAL unit size in extradata.\n");
3013 return AVERROR_INVALIDDATA;
3016 ret = decode_nal_units(s, gb.buffer, nalsize);
3018 av_log(avctx, AV_LOG_ERROR,
3019 "Decoding nal unit %d %d from hvcC failed\n",
3023 bytestream2_skip(&gb, nalsize);
3027 /* Now store right nal length size, that will be used to parse
3029 s->nal_length_size = nal_len_size;
3032 ret = decode_nal_units(s, buf, length);
3037 /* export stream parameters from the first SPS */
3038 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3039 if (s->ps.sps_list[i]) {
3040 const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3041 export_stream_params(s->avctx, &s->ps, sps);
3049 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3053 int new_extradata_size;
3054 uint8_t *new_extradata;
3055 HEVCContext *s = avctx->priv_data;
3058 ret = ff_hevc_output_frame(s, data, 1);
3066 new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
3067 &new_extradata_size);
3068 if (new_extradata && new_extradata_size > 0) {
3069 ret = hevc_decode_extradata(s, new_extradata, new_extradata_size);
3075 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3079 if (avctx->hwaccel) {
3080 if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) {
3081 av_log(avctx, AV_LOG_ERROR,
3082 "hardware accelerator failed to decode picture\n");
3083 ff_hevc_unref_frame(s, s->ref, ~0);
3087 /* verify the SEI checksum */
3088 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3090 ret = verify_md5(s, s->ref->frame);
3091 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3092 ff_hevc_unref_frame(s, s->ref, ~0);
3099 if (s->is_decoded) {
3100 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3104 if (s->output_frame->buf[0]) {
3105 av_frame_move_ref(data, s->output_frame);
3112 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3116 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3120 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3121 if (!dst->tab_mvf_buf)
3123 dst->tab_mvf = src->tab_mvf;
3125 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3126 if (!dst->rpl_tab_buf)
3128 dst->rpl_tab = src->rpl_tab;
3130 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3134 dst->poc = src->poc;
3135 dst->ctb_count = src->ctb_count;
3136 dst->window = src->window;
3137 dst->flags = src->flags;
3138 dst->sequence = src->sequence;
3140 if (src->hwaccel_picture_private) {
3141 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3142 if (!dst->hwaccel_priv_buf)
3144 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3149 ff_hevc_unref_frame(s, dst, ~0);
3150 return AVERROR(ENOMEM);
3153 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3155 HEVCContext *s = avctx->priv_data;
3160 av_freep(&s->md5_ctx);
3162 av_freep(&s->cabac_state);
3164 for (i = 0; i < 3; i++) {
3165 av_freep(&s->sao_pixel_buffer_h[i]);
3166 av_freep(&s->sao_pixel_buffer_v[i]);
3168 av_frame_free(&s->output_frame);
3170 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3171 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3172 av_frame_free(&s->DPB[i].frame);
3175 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
3176 av_buffer_unref(&s->ps.vps_list[i]);
3177 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
3178 av_buffer_unref(&s->ps.sps_list[i]);
3179 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
3180 av_buffer_unref(&s->ps.pps_list[i]);
3185 av_freep(&s->sh.entry_point_offset);
3186 av_freep(&s->sh.offset);
3187 av_freep(&s->sh.size);
3189 for (i = 1; i < s->threads_number; i++) {
3190 HEVCLocalContext *lc = s->HEVClcList[i];
3192 av_freep(&s->HEVClcList[i]);
3193 av_freep(&s->sList[i]);
3196 if (s->HEVClc == s->HEVClcList[0])
3198 av_freep(&s->HEVClcList[0]);
3200 ff_h2645_packet_uninit(&s->pkt);
3205 static av_cold int hevc_init_context(AVCodecContext *avctx)
3207 HEVCContext *s = avctx->priv_data;
3212 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3215 s->HEVClcList[0] = s->HEVClc;
3218 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3219 if (!s->cabac_state)
3222 s->output_frame = av_frame_alloc();
3223 if (!s->output_frame)
3226 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3227 s->DPB[i].frame = av_frame_alloc();
3228 if (!s->DPB[i].frame)
3230 s->DPB[i].tf.f = s->DPB[i].frame;
3233 s->max_ra = INT_MAX;
3235 s->md5_ctx = av_md5_alloc();
3239 ff_bswapdsp_init(&s->bdsp);
3241 s->context_initialized = 1;
3244 ff_hevc_reset_sei(s);
3249 hevc_decode_free(avctx);
3250 return AVERROR(ENOMEM);
3253 static int hevc_update_thread_context(AVCodecContext *dst,
3254 const AVCodecContext *src)
3256 HEVCContext *s = dst->priv_data;
3257 HEVCContext *s0 = src->priv_data;
3260 if (!s->context_initialized) {
3261 ret = hevc_init_context(dst);
3266 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3267 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3268 if (s0->DPB[i].frame->buf[0]) {
3269 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3275 if (s->ps.sps != s0->ps.sps)
3277 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
3278 av_buffer_unref(&s->ps.vps_list[i]);
3279 if (s0->ps.vps_list[i]) {
3280 s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
3281 if (!s->ps.vps_list[i])
3282 return AVERROR(ENOMEM);
3286 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3287 av_buffer_unref(&s->ps.sps_list[i]);
3288 if (s0->ps.sps_list[i]) {
3289 s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
3290 if (!s->ps.sps_list[i])
3291 return AVERROR(ENOMEM);
3295 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
3296 av_buffer_unref(&s->ps.pps_list[i]);
3297 if (s0->ps.pps_list[i]) {
3298 s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
3299 if (!s->ps.pps_list[i])
3300 return AVERROR(ENOMEM);
3304 if (s->ps.sps != s0->ps.sps)
3305 if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
3308 s->seq_decode = s0->seq_decode;
3309 s->seq_output = s0->seq_output;
3310 s->pocTid0 = s0->pocTid0;
3311 s->max_ra = s0->max_ra;
3313 s->no_rasl_output_flag = s0->no_rasl_output_flag;
3315 s->is_nalff = s0->is_nalff;
3316 s->nal_length_size = s0->nal_length_size;
3318 s->threads_number = s0->threads_number;
3319 s->threads_type = s0->threads_type;
3322 s->seq_decode = (s->seq_decode + 1) & 0xff;
3323 s->max_ra = INT_MAX;
3329 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3331 HEVCContext *s = avctx->priv_data;
3334 avctx->internal->allocate_progress = 1;
3336 ret = hevc_init_context(avctx);
3340 s->enable_parallel_tiles = 0;
3341 s->picture_struct = 0;
3344 atomic_init(&s->wpp_err, 0);
3346 if(avctx->active_thread_type & FF_THREAD_SLICE)
3347 s->threads_number = avctx->thread_count;
3349 s->threads_number = 1;
3351 if (avctx->extradata_size > 0 && avctx->extradata) {
3352 ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size);
3354 hevc_decode_free(avctx);
3359 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3360 s->threads_type = FF_THREAD_FRAME;
3362 s->threads_type = FF_THREAD_SLICE;
3367 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3369 HEVCContext *s = avctx->priv_data;
3372 memset(s, 0, sizeof(*s));
3374 ret = hevc_init_context(avctx);
3381 static void hevc_decode_flush(AVCodecContext *avctx)
3383 HEVCContext *s = avctx->priv_data;
3384 ff_hevc_flush_dpb(s);
3385 s->max_ra = INT_MAX;
3389 #define OFFSET(x) offsetof(HEVCContext, x)
3390 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3392 static const AVOption options[] = {
3393 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3394 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3395 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3396 AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3400 static const AVClass hevc_decoder_class = {
3401 .class_name = "HEVC decoder",
3402 .item_name = av_default_item_name,
3404 .version = LIBAVUTIL_VERSION_INT,
3407 AVCodec ff_hevc_decoder = {
3409 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3410 .type = AVMEDIA_TYPE_VIDEO,
3411 .id = AV_CODEC_ID_HEVC,
3412 .priv_data_size = sizeof(HEVCContext),
3413 .priv_class = &hevc_decoder_class,
3414 .init = hevc_decode_init,
3415 .close = hevc_decode_free,
3416 .decode = hevc_decode_frame,
3417 .flush = hevc_decode_flush,
3418 .update_thread_context = hevc_update_thread_context,
3419 .init_thread_copy = hevc_init_thread_copy,
3420 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3421 AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
3422 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
3423 .profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),