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