repositories / deb_ffmpeg.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Debian version 2.5.0~trusty1.1
[deb_ffmpeg.git] / ffmpeg / libavcodec / hevc.c
CommitLineData
2ba45a60
DM		 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
42const 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() */
54static 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 */
82static 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
133fail:
134 pic_arrays_free(s);
135 return AVERROR(ENOMEM);
136}
137
138static 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
227static 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
279static 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
297static 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)
f6fa7814 354 av_reduce(&s->avctx->framerate.den, &s->avctx->framerate.num,
2ba45a60
DM		 355 num, den, 1 << 30);
356
357 return 0;
358
359fail:
360 pic_arrays_free(s);
361 s->sps = NULL;
362 return ret;
363}
364
365static 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*8LL > 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) \
764do { \
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
775static 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
849static 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
865static 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,
f6fa7814 868 int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
2ba45a60
DM		 869{
870 HEVCLocalContext *lc = s->HEVClc;
871 const int log2_trafo_size_c = log2_trafo_size - s->sps->hshift[1];
872 int i;
873
874 if (lc->cu.pred_mode == MODE_INTRA) {
875 int trafo_size = 1 << log2_trafo_size;
876 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
877
878 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
879 }
880
881 if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
882 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
883 int scan_idx = SCAN_DIAG;
884 int scan_idx_c = SCAN_DIAG;
885 int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
886 (s->sps->chroma_format_idc == 2 &&
887 (cbf_cb[1] || cbf_cr[1]));
888
889 if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
890 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
891 if (lc->tu.cu_qp_delta != 0)
892 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
893 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
894 lc->tu.is_cu_qp_delta_coded = 1;
895
896 if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
897 lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
898 av_log(s->avctx, AV_LOG_ERROR,
899 "The cu_qp_delta %d is outside the valid range "
900 "[%d, %d].\n",
901 lc->tu.cu_qp_delta,
902 -(26 + s->sps->qp_bd_offset / 2),
903 (25 + s->sps->qp_bd_offset / 2));
904 return AVERROR_INVALIDDATA;
905 }
906
907 ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
908 }
909
910 if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
911 !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
912 int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
913 if (cu_chroma_qp_offset_flag) {
914 int cu_chroma_qp_offset_idx = 0;
915 if (s->pps->chroma_qp_offset_list_len_minus1 > 0) {
916 cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
917 av_log(s->avctx, AV_LOG_ERROR,
918 "cu_chroma_qp_offset_idx not yet tested.\n");
919 }
920 lc->tu.cu_qp_offset_cb = s->pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
921 lc->tu.cu_qp_offset_cr = s->pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
922 } else {
923 lc->tu.cu_qp_offset_cb = 0;
924 lc->tu.cu_qp_offset_cr = 0;
925 }
926 lc->tu.is_cu_chroma_qp_offset_coded = 1;
927 }
928
929 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
930 if (lc->tu.intra_pred_mode >= 6 &&
931 lc->tu.intra_pred_mode <= 14) {
932 scan_idx = SCAN_VERT;
933 } else if (lc->tu.intra_pred_mode >= 22 &&
934 lc->tu.intra_pred_mode <= 30) {
935 scan_idx = SCAN_HORIZ;
936 }
937
938 if (lc->tu.intra_pred_mode_c >= 6 &&
939 lc->tu.intra_pred_mode_c <= 14) {
940 scan_idx_c = SCAN_VERT;
941 } else if (lc->tu.intra_pred_mode_c >= 22 &&
942 lc->tu.intra_pred_mode_c <= 30) {
943 scan_idx_c = SCAN_HORIZ;
944 }
945 }
946
947 lc->tu.cross_pf = 0;
948
949 if (cbf_luma)
950 ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
951 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
952 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
953 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
954 lc->tu.cross_pf = (s->pps->cross_component_prediction_enabled_flag && cbf_luma &&
955 (lc->cu.pred_mode == MODE_INTER ||
956 (lc->tu.chroma_mode_c == 4)));
957
958 if (lc->tu.cross_pf) {
959 hls_cross_component_pred(s, 0);
960 }
961 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
962 if (lc->cu.pred_mode == MODE_INTRA) {
963 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
964 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
965 }
966 if (cbf_cb[i])
967 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
968 log2_trafo_size_c, scan_idx_c, 1);
969 else
970 if (lc->tu.cross_pf) {
971 ptrdiff_t stride = s->frame->linesize[1];
972 int hshift = s->sps->hshift[1];
973 int vshift = s->sps->vshift[1];
f6fa7814
DM		 974 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
975 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
2ba45a60
DM		 976 int size = 1 << log2_trafo_size_c;
977
978 uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
979 ((x0 >> hshift) << s->sps->pixel_shift)];
980 for (i = 0; i < (size * size); i++) {
981 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
982 }
983 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
984 }
985 }
986
987 if (lc->tu.cross_pf) {
988 hls_cross_component_pred(s, 1);
989 }
990 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
991 if (lc->cu.pred_mode == MODE_INTRA) {
992 ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
993 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
994 }
995 if (cbf_cr[i])
996 ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
997 log2_trafo_size_c, scan_idx_c, 2);
998 else
999 if (lc->tu.cross_pf) {
1000 ptrdiff_t stride = s->frame->linesize[2];
1001 int hshift = s->sps->hshift[2];
1002 int vshift = s->sps->vshift[2];
f6fa7814
DM		 1003 int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1004 int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
2ba45a60
DM		 1005 int size = 1 << log2_trafo_size_c;
1006
1007 uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1008 ((x0 >> hshift) << s->sps->pixel_shift)];
1009 for (i = 0; i < (size * size); i++) {
1010 coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1011 }
1012 s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1013 }
1014 }
1015 } else if (blk_idx == 3) {
1016 int trafo_size_h = 1 << (log2_trafo_size + 1);
1017 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1018 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1019 if (lc->cu.pred_mode == MODE_INTRA) {
1020 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1021 trafo_size_h, trafo_size_v);
1022 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1023 }
1024 if (cbf_cb[i])
1025 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1026 log2_trafo_size, scan_idx_c, 1);
1027 }
1028 for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1029 if (lc->cu.pred_mode == MODE_INTRA) {
1030 ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1031 trafo_size_h, trafo_size_v);
1032 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1033 }
1034 if (cbf_cr[i])
1035 ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1036 log2_trafo_size, scan_idx_c, 2);
1037 }
1038 }
1039 } else if (lc->cu.pred_mode == MODE_INTRA) {
1040 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1041 int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
1042 int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
1043 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1044 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1045 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1046 if (s->sps->chroma_format_idc == 2) {
1047 ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1048 trafo_size_h, trafo_size_v);
1049 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1050 s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1051 }
1052 } else if (blk_idx == 3) {
1053 int trafo_size_h = 1 << (log2_trafo_size + 1);
1054 int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1055 ff_hevc_set_neighbour_available(s, xBase, yBase,
1056 trafo_size_h, trafo_size_v);
1057 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1058 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1059 if (s->sps->chroma_format_idc == 2) {
1060 ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1061 trafo_size_h, trafo_size_v);
1062 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1063 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1064 }
1065 }
1066 }
1067
1068 return 0;
1069}
1070
1071static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1072{
1073 int cb_size = 1 << log2_cb_size;
1074 int log2_min_pu_size = s->sps->log2_min_pu_size;
1075
1076 int min_pu_width = s->sps->min_pu_width;
1077 int x_end = FFMIN(x0 + cb_size, s->sps->width);
1078 int y_end = FFMIN(y0 + cb_size, s->sps->height);
1079 int i, j;
1080
1081 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1082 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1083 s->is_pcm[i + j * min_pu_width] = 2;
1084}
1085
1086static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1087 int xBase, int yBase, int cb_xBase, int cb_yBase,
1088 int log2_cb_size, int log2_trafo_size,
1089 int trafo_depth, int blk_idx,
1090 const int *base_cbf_cb, const int *base_cbf_cr)
1091{
1092 HEVCLocalContext *lc = s->HEVClc;
1093 uint8_t split_transform_flag;
1094 int cbf_cb[2];
1095 int cbf_cr[2];
1096 int ret;
1097
1098 cbf_cb[0] = base_cbf_cb[0];
1099 cbf_cb[1] = base_cbf_cb[1];
1100 cbf_cr[0] = base_cbf_cr[0];
1101 cbf_cr[1] = base_cbf_cr[1];
1102
1103 if (lc->cu.intra_split_flag) {
1104 if (trafo_depth == 1) {
1105 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1106 if (s->sps->chroma_format_idc == 3) {
1107 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1108 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1109 } else {
1110 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1111 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1112 }
1113 }
1114 } else {
1115 lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1116 lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1117 lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1118 }
1119
1120 if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1121 log2_trafo_size > s->sps->log2_min_tb_size &&
1122 trafo_depth < lc->cu.max_trafo_depth &&
1123 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1124 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1125 } else {
1126 int inter_split = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1127 lc->cu.pred_mode == MODE_INTER &&
1128 lc->cu.part_mode != PART_2Nx2N &&
1129 trafo_depth == 0;
1130
1131 split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1132 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1133 inter_split;
1134 }
1135
1136 if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1137 if (trafo_depth == 0 || cbf_cb[0]) {
1138 cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1139 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1140 cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1141 }
1142 }
1143
1144 if (trafo_depth == 0 || cbf_cr[0]) {
1145 cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1146 if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1147 cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1148 }
1149 }
1150 }
1151
1152 if (split_transform_flag) {
1153 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1154 const int x1 = x0 + trafo_size_split;
1155 const int y1 = y0 + trafo_size_split;
1156
1157#define SUBDIVIDE(x, y, idx) \
1158do { \
1159 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1160 log2_trafo_size - 1, trafo_depth + 1, idx, \
1161 cbf_cb, cbf_cr); \
1162 if (ret < 0) \
1163 return ret; \
1164} while (0)
1165
1166 SUBDIVIDE(x0, y0, 0);
1167 SUBDIVIDE(x1, y0, 1);
1168 SUBDIVIDE(x0, y1, 2);
1169 SUBDIVIDE(x1, y1, 3);
1170
1171#undef SUBDIVIDE
1172 } else {
1173 int min_tu_size = 1 << s->sps->log2_min_tb_size;
1174 int log2_min_tu_size = s->sps->log2_min_tb_size;
1175 int min_tu_width = s->sps->min_tb_width;
1176 int cbf_luma = 1;
1177
1178 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1179 cbf_cb[0] || cbf_cr[0] ||
1180 (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1181 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1182 }
1183
1184 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
f6fa7814 1185 log2_cb_size, log2_trafo_size,
2ba45a60
DM		 1186 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1187 if (ret < 0)
1188 return ret;
1189 // TODO: store cbf_luma somewhere else
1190 if (cbf_luma) {
1191 int i, j;
1192 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1193 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1194 int x_tu = (x0 + j) >> log2_min_tu_size;
1195 int y_tu = (y0 + i) >> log2_min_tu_size;
1196 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1197 }
1198 }
1199 if (!s->sh.disable_deblocking_filter_flag) {
1200 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1201 if (s->pps->transquant_bypass_enable_flag &&
1202 lc->cu.cu_transquant_bypass_flag)
1203 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1204 }
1205 }
1206 return 0;
1207}
1208
1209static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1210{
1211 HEVCLocalContext *lc = s->HEVClc;
1212 GetBitContext gb;
1213 int cb_size = 1 << log2_cb_size;
1214 int stride0 = s->frame->linesize[0];
1215 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1216 int stride1 = s->frame->linesize[1];
1217 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1218 int stride2 = s->frame->linesize[2];
1219 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1220
1221 int length = cb_size * cb_size * s->sps->pcm.bit_depth +
1222 (((cb_size >> s->sps->hshift[1]) * (cb_size >> s->sps->vshift[1])) +
1223 ((cb_size >> s->sps->hshift[2]) * (cb_size >> s->sps->vshift[2]))) *
1224 s->sps->pcm.bit_depth_chroma;
1225 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1226 int ret;
1227
1228 if (!s->sh.disable_deblocking_filter_flag)
1229 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1230
1231 ret = init_get_bits(&gb, pcm, length);
1232 if (ret < 0)
1233 return ret;
1234
1235 s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->sps->pcm.bit_depth);
1236 s->hevcdsp.put_pcm(dst1, stride1,
1237 cb_size >> s->sps->hshift[1],
1238 cb_size >> s->sps->vshift[1],
1239 &gb, s->sps->pcm.bit_depth_chroma);
1240 s->hevcdsp.put_pcm(dst2, stride2,
1241 cb_size >> s->sps->hshift[2],
1242 cb_size >> s->sps->vshift[2],
1243 &gb, s->sps->pcm.bit_depth_chroma);
1244 return 0;
1245}
1246
1247/**
1248 * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1249 *
1250 * @param s HEVC decoding context
1251 * @param dst target buffer for block data at block position
1252 * @param dststride stride of the dst buffer
1253 * @param ref reference picture buffer at origin (0, 0)
1254 * @param mv motion vector (relative to block position) to get pixel data from
1255 * @param x_off horizontal position of block from origin (0, 0)
1256 * @param y_off vertical position of block from origin (0, 0)
1257 * @param block_w width of block
1258 * @param block_h height of block
1259 * @param luma_weight weighting factor applied to the luma prediction
1260 * @param luma_offset additive offset applied to the luma prediction value
1261 */
1262
1263static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1264 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1265 int block_w, int block_h, int luma_weight, int luma_offset)
1266{
1267 HEVCLocalContext *lc = s->HEVClc;
1268 uint8_t *src = ref->data[0];
1269 ptrdiff_t srcstride = ref->linesize[0];
1270 int pic_width = s->sps->width;
1271 int pic_height = s->sps->height;
1272 int mx = mv->x & 3;
1273 int my = mv->y & 3;
1274 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1275 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1276 int idx = ff_hevc_pel_weight[block_w];
1277
1278 x_off += mv->x >> 2;
1279 y_off += mv->y >> 2;
1280 src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1281
1282 if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1283 x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1284 y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1285 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1286 int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1287 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1288
1289 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1290 edge_emu_stride, srcstride,
1291 block_w + QPEL_EXTRA,
1292 block_h + QPEL_EXTRA,
1293 x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1294 pic_width, pic_height);
1295 src = lc->edge_emu_buffer + buf_offset;
1296 srcstride = edge_emu_stride;
1297 }
1298
1299 if (!weight_flag)
1300 s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1301 block_h, mx, my, block_w);
1302 else
1303 s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1304 block_h, s->sh.luma_log2_weight_denom,
1305 luma_weight, luma_offset, mx, my, block_w);
1306}
1307
1308/**
1309 * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1310 *
1311 * @param s HEVC decoding context
1312 * @param dst target buffer for block data at block position
1313 * @param dststride stride of the dst buffer
1314 * @param ref0 reference picture0 buffer at origin (0, 0)
1315 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1316 * @param x_off horizontal position of block from origin (0, 0)
1317 * @param y_off vertical position of block from origin (0, 0)
1318 * @param block_w width of block
1319 * @param block_h height of block
1320 * @param ref1 reference picture1 buffer at origin (0, 0)
1321 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1322 * @param current_mv current motion vector structure
1323 */
1324 static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1325 AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1326 int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1327{
1328 HEVCLocalContext *lc = s->HEVClc;
2ba45a60
DM		 1329 ptrdiff_t src0stride = ref0->linesize[0];
1330 ptrdiff_t src1stride = ref1->linesize[0];
1331 int pic_width = s->sps->width;
1332 int pic_height = s->sps->height;
1333 int mx0 = mv0->x & 3;
1334 int my0 = mv0->y & 3;
1335 int mx1 = mv1->x & 3;
1336 int my1 = mv1->y & 3;
1337 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1338 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1339 int x_off0 = x_off + (mv0->x >> 2);
1340 int y_off0 = y_off + (mv0->y >> 2);
1341 int x_off1 = x_off + (mv1->x >> 2);
1342 int y_off1 = y_off + (mv1->y >> 2);
1343 int idx = ff_hevc_pel_weight[block_w];
1344
1345 uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1346 uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1347
1348 if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1349 x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1350 y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1351 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1352 int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1353 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1354
1355 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1356 edge_emu_stride, src0stride,
1357 block_w + QPEL_EXTRA,
1358 block_h + QPEL_EXTRA,
1359 x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1360 pic_width, pic_height);
1361 src0 = lc->edge_emu_buffer + buf_offset;
1362 src0stride = edge_emu_stride;
1363 }
1364
1365 if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1366 x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1367 y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1368 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1369 int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1370 int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1371
1372 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1373 edge_emu_stride, src1stride,
1374 block_w + QPEL_EXTRA,
1375 block_h + QPEL_EXTRA,
1376 x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1377 pic_width, pic_height);
1378 src1 = lc->edge_emu_buffer2 + buf_offset;
1379 src1stride = edge_emu_stride;
1380 }
1381
f6fa7814 1382 s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
2ba45a60
DM		 1383 block_h, mx0, my0, block_w);
1384 if (!weight_flag)
f6fa7814 1385 s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
2ba45a60
DM		 1386 block_h, mx1, my1, block_w);
1387 else
f6fa7814 1388 s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
2ba45a60
DM		 1389 block_h, s->sh.luma_log2_weight_denom,
1390 s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1391 s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1392 s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1393 s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1394 mx1, my1, block_w);
1395
1396}
1397
1398/**
1399 * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1400 *
1401 * @param s HEVC decoding context
1402 * @param dst1 target buffer for block data at block position (U plane)
1403 * @param dst2 target buffer for block data at block position (V plane)
1404 * @param dststride stride of the dst1 and dst2 buffers
1405 * @param ref reference picture buffer at origin (0, 0)
1406 * @param mv motion vector (relative to block position) to get pixel data from
1407 * @param x_off horizontal position of block from origin (0, 0)
1408 * @param y_off vertical position of block from origin (0, 0)
1409 * @param block_w width of block
1410 * @param block_h height of block
1411 * @param chroma_weight weighting factor applied to the chroma prediction
1412 * @param chroma_offset additive offset applied to the chroma prediction value
1413 */
1414
1415static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1416 ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1417 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1418{
1419 HEVCLocalContext *lc = s->HEVClc;
1420 int pic_width = s->sps->width >> s->sps->hshift[1];
1421 int pic_height = s->sps->height >> s->sps->vshift[1];
1422 const Mv *mv = &current_mv->mv[reflist];
1423 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1424 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1425 int idx = ff_hevc_pel_weight[block_w];
1426 int hshift = s->sps->hshift[1];
1427 int vshift = s->sps->vshift[1];
1428 intptr_t mx = mv->x & ((1 << (2 + hshift)) - 1);
1429 intptr_t my = mv->y & ((1 << (2 + vshift)) - 1);
1430 intptr_t _mx = mx << (1 - hshift);
1431 intptr_t _my = my << (1 - vshift);
1432
1433 x_off += mv->x >> (2 + hshift);
1434 y_off += mv->y >> (2 + vshift);
1435 src0 += y_off * srcstride + (x_off << s->sps->pixel_shift);
1436
1437 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1438 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1439 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1440 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1441 int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->sps->pixel_shift));
1442 int buf_offset0 = EPEL_EXTRA_BEFORE *
1443 (edge_emu_stride + (1 << s->sps->pixel_shift));
1444 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1445 edge_emu_stride, srcstride,
1446 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1447 x_off - EPEL_EXTRA_BEFORE,
1448 y_off - EPEL_EXTRA_BEFORE,
1449 pic_width, pic_height);
1450
1451 src0 = lc->edge_emu_buffer + buf_offset0;
1452 srcstride = edge_emu_stride;
1453 }
1454 if (!weight_flag)
1455 s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1456 block_h, _mx, _my, block_w);
1457 else
1458 s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1459 block_h, s->sh.chroma_log2_weight_denom,
1460 chroma_weight, chroma_offset, _mx, _my, block_w);
1461}
1462
1463/**
1464 * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1465 *
1466 * @param s HEVC decoding context
1467 * @param dst target buffer for block data at block position
1468 * @param dststride stride of the dst buffer
1469 * @param ref0 reference picture0 buffer at origin (0, 0)
1470 * @param mv0 motion vector0 (relative to block position) to get pixel data from
1471 * @param x_off horizontal position of block from origin (0, 0)
1472 * @param y_off vertical position of block from origin (0, 0)
1473 * @param block_w width of block
1474 * @param block_h height of block
1475 * @param ref1 reference picture1 buffer at origin (0, 0)
1476 * @param mv1 motion vector1 (relative to block position) to get pixel data from
1477 * @param current_mv current motion vector structure
1478 * @param cidx chroma component(cb, cr)
1479 */
1480static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1481 int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1482{
2ba45a60
DM		 1483 HEVCLocalContext *lc = s->HEVClc;
1484 uint8_t *src1 = ref0->data[cidx+1];
1485 uint8_t *src2 = ref1->data[cidx+1];
1486 ptrdiff_t src1stride = ref0->linesize[cidx+1];
1487 ptrdiff_t src2stride = ref1->linesize[cidx+1];
1488 int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1489 (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1490 int pic_width = s->sps->width >> s->sps->hshift[1];
1491 int pic_height = s->sps->height >> s->sps->vshift[1];
1492 Mv *mv0 = &current_mv->mv[0];
1493 Mv *mv1 = &current_mv->mv[1];
1494 int hshift = s->sps->hshift[1];
1495 int vshift = s->sps->vshift[1];
1496
1497 intptr_t mx0 = mv0->x & ((1 << (2 + hshift)) - 1);
1498 intptr_t my0 = mv0->y & ((1 << (2 + vshift)) - 1);
1499 intptr_t mx1 = mv1->x & ((1 << (2 + hshift)) - 1);
1500 intptr_t my1 = mv1->y & ((1 << (2 + vshift)) - 1);
1501 intptr_t _mx0 = mx0 << (1 - hshift);
1502 intptr_t _my0 = my0 << (1 - vshift);
1503 intptr_t _mx1 = mx1 << (1 - hshift);
1504 intptr_t _my1 = my1 << (1 - vshift);
1505
1506 int x_off0 = x_off + (mv0->x >> (2 + hshift));
1507 int y_off0 = y_off + (mv0->y >> (2 + vshift));
1508 int x_off1 = x_off + (mv1->x >> (2 + hshift));
1509 int y_off1 = y_off + (mv1->y >> (2 + vshift));
1510 int idx = ff_hevc_pel_weight[block_w];
1511 src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1512 src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1513
1514 if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1515 x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1516 y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1517 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1518 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1519 int buf_offset1 = EPEL_EXTRA_BEFORE *
1520 (edge_emu_stride + (1 << s->sps->pixel_shift));
1521
1522 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1523 edge_emu_stride, src1stride,
1524 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1525 x_off0 - EPEL_EXTRA_BEFORE,
1526 y_off0 - EPEL_EXTRA_BEFORE,
1527 pic_width, pic_height);
1528
1529 src1 = lc->edge_emu_buffer + buf_offset1;
1530 src1stride = edge_emu_stride;
1531 }
1532
1533 if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1534 x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1535 y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1536 const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1537 int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1538 int buf_offset1 = EPEL_EXTRA_BEFORE *
1539 (edge_emu_stride + (1 << s->sps->pixel_shift));
1540
1541 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1542 edge_emu_stride, src2stride,
1543 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1544 x_off1 - EPEL_EXTRA_BEFORE,
1545 y_off1 - EPEL_EXTRA_BEFORE,
1546 pic_width, pic_height);
1547
1548 src2 = lc->edge_emu_buffer2 + buf_offset1;
1549 src2stride = edge_emu_stride;
1550 }
1551
f6fa7814 1552 s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
2ba45a60
DM		 1553 block_h, _mx0, _my0, block_w);
1554 if (!weight_flag)
1555 s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
f6fa7814 1556 src2, src2stride, lc->tmp,
2ba45a60
DM		 1557 block_h, _mx1, _my1, block_w);
1558 else
1559 s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
f6fa7814 1560 src2, src2stride, lc->tmp,
2ba45a60
DM		 1561 block_h,
1562 s->sh.chroma_log2_weight_denom,
1563 s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1564 s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1565 s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1566 s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1567 _mx1, _my1, block_w);
1568}
1569
1570static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1571 const Mv *mv, int y0, int height)
1572{
f6fa7814 1573 int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
2ba45a60
DM		 1574
1575 if (s->threads_type == FF_THREAD_FRAME )
1576 ff_thread_await_progress(&ref->tf, y, 0);
1577}
1578
f6fa7814
DM		 1579static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1580 int nPbH, int log2_cb_size, int part_idx,
1581 int merge_idx, MvField *mv)
1582{
1583 HEVCLocalContext *lc = s->HEVClc;
1584 enum InterPredIdc inter_pred_idc = PRED_L0;
1585 int mvp_flag;
1586
1587 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1588 mv->pred_flag = 0;
1589 if (s->sh.slice_type == B_SLICE)
1590 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1591
1592 if (inter_pred_idc != PRED_L1) {
1593 if (s->sh.nb_refs[L0])
1594 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1595
1596 mv->pred_flag = PF_L0;
1597 ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1598 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1599 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1600 part_idx, merge_idx, mv, mvp_flag, 0);
1601 mv->mv[0].x += lc->pu.mvd.x;
1602 mv->mv[0].y += lc->pu.mvd.y;
1603 }
1604
1605 if (inter_pred_idc != PRED_L0) {
1606 if (s->sh.nb_refs[L1])
1607 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1608
1609 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1610 AV_ZERO32(&lc->pu.mvd);
1611 } else {
1612 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1613 }
1614
1615 mv->pred_flag += PF_L1;
1616 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1617 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1618 part_idx, merge_idx, mv, mvp_flag, 1);
1619 mv->mv[1].x += lc->pu.mvd.x;
1620 mv->mv[1].y += lc->pu.mvd.y;
1621 }
1622}
1623
2ba45a60
DM		 1624static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1625 int nPbW, int nPbH,
1626 int log2_cb_size, int partIdx, int idx)
1627{
1628#define POS(c_idx, x, y) \
1629 &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1630 (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1631 HEVCLocalContext *lc = s->HEVClc;
1632 int merge_idx = 0;
1633 struct MvField current_mv = {{{ 0 }}};
1634
1635 int min_pu_width = s->sps->min_pu_width;
1636
1637 MvField *tab_mvf = s->ref->tab_mvf;
1638 RefPicList *refPicList = s->ref->refPicList;
1639 HEVCFrame *ref0, *ref1;
1640 uint8_t *dst0 = POS(0, x0, y0);
1641 uint8_t *dst1 = POS(1, x0, y0);
1642 uint8_t *dst2 = POS(2, x0, y0);
1643 int log2_min_cb_size = s->sps->log2_min_cb_size;
1644 int min_cb_width = s->sps->min_cb_width;
1645 int x_cb = x0 >> log2_min_cb_size;
1646 int y_cb = y0 >> log2_min_cb_size;
2ba45a60
DM		 1647 int x_pu, y_pu;
1648 int i, j;
1649
f6fa7814
DM		 1650 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1651
1652 if (!skip_flag)
1653 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1654
1655 if (skip_flag || lc->pu.merge_flag) {
2ba45a60
DM		 1656 if (s->sh.max_num_merge_cand > 1)
1657 merge_idx = ff_hevc_merge_idx_decode(s);
1658 else
1659 merge_idx = 0;
1660
f6fa7814
DM		 1661 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1662 partIdx, merge_idx, &current_mv);
1663 } else {
1664 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1665 partIdx, merge_idx, &current_mv);
1666 }
2ba45a60 1667
f6fa7814
DM		 1668 x_pu = x0 >> s->sps->log2_min_pu_size;
1669 y_pu = y0 >> s->sps->log2_min_pu_size;
2ba45a60 1670
f6fa7814
DM		 1671 for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1672 for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1673 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
2ba45a60
DM		 1674
1675 if (current_mv.pred_flag & PF_L0) {
1676 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1677 if (!ref0)
1678 return;
1679 hevc_await_progress(s, ref0, &current_mv.mv[0], y0, nPbH);
1680 }
1681 if (current_mv.pred_flag & PF_L1) {
1682 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1683 if (!ref1)
1684 return;
1685 hevc_await_progress(s, ref1, &current_mv.mv[1], y0, nPbH);
1686 }
1687
1688 if (current_mv.pred_flag == PF_L0) {
1689 int x0_c = x0 >> s->sps->hshift[1];
1690 int y0_c = y0 >> s->sps->vshift[1];
1691 int nPbW_c = nPbW >> s->sps->hshift[1];
1692 int nPbH_c = nPbH >> s->sps->vshift[1];
1693
1694 luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1695 &current_mv.mv[0], x0, y0, nPbW, nPbH,
1696 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1697 s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1698
1699 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1700 0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1701 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1702 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1703 0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1704 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1705 } else if (current_mv.pred_flag == PF_L1) {
1706 int x0_c = x0 >> s->sps->hshift[1];
1707 int y0_c = y0 >> s->sps->vshift[1];
1708 int nPbW_c = nPbW >> s->sps->hshift[1];
1709 int nPbH_c = nPbH >> s->sps->vshift[1];
1710
1711 luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1712 &current_mv.mv[1], x0, y0, nPbW, nPbH,
1713 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1714 s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1715
1716 chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1717 1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1718 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1719
1720 chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1721 1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1722 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1723 } else if (current_mv.pred_flag == PF_BI) {
1724 int x0_c = x0 >> s->sps->hshift[1];
1725 int y0_c = y0 >> s->sps->vshift[1];
1726 int nPbW_c = nPbW >> s->sps->hshift[1];
1727 int nPbH_c = nPbH >> s->sps->vshift[1];
1728
1729 luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1730 &current_mv.mv[0], x0, y0, nPbW, nPbH,
1731 ref1->frame, &current_mv.mv[1], &current_mv);
1732
1733 chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1734 x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 0);
1735
1736 chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1737 x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 1);
1738 }
1739}
1740
1741/**
1742 * 8.4.1
1743 */
1744static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1745 int prev_intra_luma_pred_flag)
1746{
1747 HEVCLocalContext *lc = s->HEVClc;
1748 int x_pu = x0 >> s->sps->log2_min_pu_size;
1749 int y_pu = y0 >> s->sps->log2_min_pu_size;
1750 int min_pu_width = s->sps->min_pu_width;
1751 int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1752 int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1753 int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1754
1755 int cand_up = (lc->ctb_up_flag || y0b) ?
1756 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1757 int cand_left = (lc->ctb_left_flag || x0b) ?
1758 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1759
1760 int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1761
1762 MvField *tab_mvf = s->ref->tab_mvf;
1763 int intra_pred_mode;
1764 int candidate[3];
1765 int i, j;
1766
1767 // intra_pred_mode prediction does not cross vertical CTB boundaries
1768 if ((y0 - 1) < y_ctb)
1769 cand_up = INTRA_DC;
1770
1771 if (cand_left == cand_up) {
1772 if (cand_left < 2) {
1773 candidate[0] = INTRA_PLANAR;
1774 candidate[1] = INTRA_DC;
1775 candidate[2] = INTRA_ANGULAR_26;
1776 } else {
1777 candidate[0] = cand_left;
1778 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1779 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1780 }
1781 } else {
1782 candidate[0] = cand_left;
1783 candidate[1] = cand_up;
1784 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1785 candidate[2] = INTRA_PLANAR;
1786 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1787 candidate[2] = INTRA_DC;
1788 } else {
1789 candidate[2] = INTRA_ANGULAR_26;
1790 }
1791 }
1792
1793 if (prev_intra_luma_pred_flag) {
1794 intra_pred_mode = candidate[lc->pu.mpm_idx];
1795 } else {
1796 if (candidate[0] > candidate[1])
1797 FFSWAP(uint8_t, candidate[0], candidate[1]);
1798 if (candidate[0] > candidate[2])
1799 FFSWAP(uint8_t, candidate[0], candidate[2]);
1800 if (candidate[1] > candidate[2])
1801 FFSWAP(uint8_t, candidate[1], candidate[2]);
1802
1803 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1804 for (i = 0; i < 3; i++)
1805 if (intra_pred_mode >= candidate[i])
1806 intra_pred_mode++;
1807 }
1808
1809 /* write the intra prediction units into the mv array */
1810 if (!size_in_pus)
1811 size_in_pus = 1;
1812 for (i = 0; i < size_in_pus; i++) {
1813 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1814 intra_pred_mode, size_in_pus);
1815
1816 for (j = 0; j < size_in_pus; j++) {
1817 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1818 }
1819 }
1820
1821 return intra_pred_mode;
1822}
1823
1824static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1825 int log2_cb_size, int ct_depth)
1826{
1827 int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1828 int x_cb = x0 >> s->sps->log2_min_cb_size;
1829 int y_cb = y0 >> s->sps->log2_min_cb_size;
1830 int y;
1831
1832 for (y = 0; y < length; y++)
1833 memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1834 ct_depth, length);
1835}
1836
1837static const uint8_t tab_mode_idx[] = {
1838 0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1839 21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1840
1841static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1842 int log2_cb_size)
1843{
1844 HEVCLocalContext *lc = s->HEVClc;
1845 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1846 uint8_t prev_intra_luma_pred_flag[4];
1847 int split = lc->cu.part_mode == PART_NxN;
1848 int pb_size = (1 << log2_cb_size) >> split;
1849 int side = split + 1;
1850 int chroma_mode;
1851 int i, j;
1852
1853 for (i = 0; i < side; i++)
1854 for (j = 0; j < side; j++)
1855 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1856
1857 for (i = 0; i < side; i++) {
1858 for (j = 0; j < side; j++) {
1859 if (prev_intra_luma_pred_flag[2 * i + j])
1860 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1861 else
1862 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1863
1864 lc->pu.intra_pred_mode[2 * i + j] =
1865 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1866 prev_intra_luma_pred_flag[2 * i + j]);
1867 }
1868 }
1869
1870 if (s->sps->chroma_format_idc == 3) {
1871 for (i = 0; i < side; i++) {
1872 for (j = 0; j < side; j++) {
1873 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1874 if (chroma_mode != 4) {
1875 if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1876 lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1877 else
1878 lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1879 } else {
1880 lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1881 }
1882 }
1883 }
1884 } else if (s->sps->chroma_format_idc == 2) {
1885 int mode_idx;
1886 lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1887 if (chroma_mode != 4) {
1888 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1889 mode_idx = 34;
1890 else
1891 mode_idx = intra_chroma_table[chroma_mode];
1892 } else {
1893 mode_idx = lc->pu.intra_pred_mode[0];
1894 }
1895 lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1896 } else if (s->sps->chroma_format_idc != 0) {
1897 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1898 if (chroma_mode != 4) {
1899 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1900 lc->pu.intra_pred_mode_c[0] = 34;
1901 else
1902 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1903 } else {
1904 lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1905 }
1906 }
1907}
1908
1909static void intra_prediction_unit_default_value(HEVCContext *s,
1910 int x0, int y0,
1911 int log2_cb_size)
1912{
1913 HEVCLocalContext *lc = s->HEVClc;
1914 int pb_size = 1 << log2_cb_size;
1915 int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1916 int min_pu_width = s->sps->min_pu_width;
1917 MvField *tab_mvf = s->ref->tab_mvf;
1918 int x_pu = x0 >> s->sps->log2_min_pu_size;
1919 int y_pu = y0 >> s->sps->log2_min_pu_size;
1920 int j, k;
1921
1922 if (size_in_pus == 0)
1923 size_in_pus = 1;
1924 for (j = 0; j < size_in_pus; j++)
1925 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1926 if (lc->cu.pred_mode == MODE_INTRA)
1927 for (j = 0; j < size_in_pus; j++)
1928 for (k = 0; k < size_in_pus; k++)
1929 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1930}
1931
1932static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1933{
1934 int cb_size = 1 << log2_cb_size;
1935 HEVCLocalContext *lc = s->HEVClc;
1936 int log2_min_cb_size = s->sps->log2_min_cb_size;
1937 int length = cb_size >> log2_min_cb_size;
1938 int min_cb_width = s->sps->min_cb_width;
1939 int x_cb = x0 >> log2_min_cb_size;
1940 int y_cb = y0 >> log2_min_cb_size;
1941 int idx = log2_cb_size - 2;
1942 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1943 int x, y, ret;
1944
1945 lc->cu.x = x0;
1946 lc->cu.y = y0;
2ba45a60
DM		 1947 lc->cu.pred_mode = MODE_INTRA;
1948 lc->cu.part_mode = PART_2Nx2N;
1949 lc->cu.intra_split_flag = 0;
2ba45a60
DM		 1950
1951 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
1952 for (x = 0; x < 4; x++)
1953 lc->pu.intra_pred_mode[x] = 1;
1954 if (s->pps->transquant_bypass_enable_flag) {
1955 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
1956 if (lc->cu.cu_transquant_bypass_flag)
1957 set_deblocking_bypass(s, x0, y0, log2_cb_size);
1958 } else
1959 lc->cu.cu_transquant_bypass_flag = 0;
1960
1961 if (s->sh.slice_type != I_SLICE) {
1962 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
1963
1964 x = y_cb * min_cb_width + x_cb;
1965 for (y = 0; y < length; y++) {
1966 memset(&s->skip_flag[x], skip_flag, length);
1967 x += min_cb_width;
1968 }
1969 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
1970 } else {
1971 x = y_cb * min_cb_width + x_cb;
1972 for (y = 0; y < length; y++) {
1973 memset(&s->skip_flag[x], 0, length);
1974 x += min_cb_width;
1975 }
1976 }
1977
1978 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
1979 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
1980 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
1981
1982 if (!s->sh.disable_deblocking_filter_flag)
1983 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1984 } else {
f6fa7814
DM		 1985 int pcm_flag = 0;
1986
2ba45a60
DM		 1987 if (s->sh.slice_type != I_SLICE)
1988 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
1989 if (lc->cu.pred_mode != MODE_INTRA ||
1990 log2_cb_size == s->sps->log2_min_cb_size) {
1991 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
1992 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
1993 lc->cu.pred_mode == MODE_INTRA;
1994 }
1995
1996 if (lc->cu.pred_mode == MODE_INTRA) {
1997 if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
1998 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
1999 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
f6fa7814 2000 pcm_flag = ff_hevc_pcm_flag_decode(s);
2ba45a60 2001 }
f6fa7814 2002 if (pcm_flag) {
2ba45a60
DM		 2003 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2004 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2005 if (s->sps->pcm.loop_filter_disable_flag)
2006 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2007
2008 if (ret < 0)
2009 return ret;
2010 } else {
2011 intra_prediction_unit(s, x0, y0, log2_cb_size);
2012 }
2013 } else {
2014 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2015 switch (lc->cu.part_mode) {
2016 case PART_2Nx2N:
2017 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2018 break;
2019 case PART_2NxN:
2020 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2021 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2022 break;
2023 case PART_Nx2N:
2024 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2025 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2026 break;
2027 case PART_2NxnU:
2028 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2029 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2030 break;
2031 case PART_2NxnD:
2032 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2033 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2034 break;
2035 case PART_nLx2N:
2036 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2037 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2038 break;
2039 case PART_nRx2N:
2040 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2041 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2042 break;
2043 case PART_NxN:
2044 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2045 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2046 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2047 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2048 break;
2049 }
2050 }
2051
f6fa7814
DM		 2052 if (!pcm_flag) {
2053 int rqt_root_cbf = 1;
2054
2ba45a60
DM		 2055 if (lc->cu.pred_mode != MODE_INTRA &&
2056 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
f6fa7814 2057 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2ba45a60 2058 }
f6fa7814 2059 if (rqt_root_cbf) {
2ba45a60
DM		 2060 const static int cbf[2] = { 0 };
2061 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2062 s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2063 s->sps->max_transform_hierarchy_depth_inter;
2064 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2065 log2_cb_size,
2066 log2_cb_size, 0, 0, cbf, cbf);
2067 if (ret < 0)
2068 return ret;
2069 } else {
2070 if (!s->sh.disable_deblocking_filter_flag)
2071 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2072 }
2073 }
2074 }
2075
2076 if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2077 ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2078
2079 x = y_cb * min_cb_width + x_cb;
2080 for (y = 0; y < length; y++) {
2081 memset(&s->qp_y_tab[x], lc->qp_y, length);
2082 x += min_cb_width;
2083 }
2084
2085 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2086 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2087 lc->qPy_pred = lc->qp_y;
2088 }
2089
f6fa7814 2090 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2ba45a60
DM		 2091
2092 return 0;
2093}
2094
2095static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2096 int log2_cb_size, int cb_depth)
2097{
2098 HEVCLocalContext *lc = s->HEVClc;
2099 const int cb_size = 1 << log2_cb_size;
2100 int ret;
2101 int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2102 int split_cu;
2103
f6fa7814 2104 lc->ct_depth = cb_depth;
2ba45a60
DM		 2105 if (x0 + cb_size <= s->sps->width &&
2106 y0 + cb_size <= s->sps->height &&
2107 log2_cb_size > s->sps->log2_min_cb_size) {
2108 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2109 } else {
2110 split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2111 }
2112 if (s->pps->cu_qp_delta_enabled_flag &&
2113 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2114 lc->tu.is_cu_qp_delta_coded = 0;
2115 lc->tu.cu_qp_delta = 0;
2116 }
2117
2118 if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2119 log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2120 lc->tu.is_cu_chroma_qp_offset_coded = 0;
2121 }
2122
2123 if (split_cu) {
2124 const int cb_size_split = cb_size >> 1;
2125 const int x1 = x0 + cb_size_split;
2126 const int y1 = y0 + cb_size_split;
2127
2128 int more_data = 0;
2129
2130 more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2131 if (more_data < 0)
2132 return more_data;
2133
2134 if (more_data && x1 < s->sps->width) {
2135 more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2136 if (more_data < 0)
2137 return more_data;
2138 }
2139 if (more_data && y1 < s->sps->height) {
2140 more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2141 if (more_data < 0)
2142 return more_data;
2143 }
2144 if (more_data && x1 < s->sps->width &&
2145 y1 < s->sps->height) {
2146 more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2147 if (more_data < 0)
2148 return more_data;
2149 }
2150
2151 if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2152 ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2153 lc->qPy_pred = lc->qp_y;
2154
2155 if (more_data)
2156 return ((x1 + cb_size_split) < s->sps->width ||
2157 (y1 + cb_size_split) < s->sps->height);
2158 else
2159 return 0;
2160 } else {
2161 ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2162 if (ret < 0)
2163 return ret;
2164 if ((!((x0 + cb_size) %
2165 (1 << (s->sps->log2_ctb_size))) ||
2166 (x0 + cb_size >= s->sps->width)) &&
2167 (!((y0 + cb_size) %
2168 (1 << (s->sps->log2_ctb_size))) ||
2169 (y0 + cb_size >= s->sps->height))) {
2170 int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2171 return !end_of_slice_flag;
2172 } else {
2173 return 1;
2174 }
2175 }
2176
2177 return 0;
2178}
2179
2180static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2181 int ctb_addr_ts)
2182{
2183 HEVCLocalContext *lc = s->HEVClc;
2184 int ctb_size = 1 << s->sps->log2_ctb_size;
2185 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2186 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2187
2188 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2189
2190 if (s->pps->entropy_coding_sync_enabled_flag) {
2191 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2192 lc->first_qp_group = 1;
2193 lc->end_of_tiles_x = s->sps->width;
2194 } else if (s->pps->tiles_enabled_flag) {
2195 if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2196 int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2197 lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2198 lc->first_qp_group = 1;
2199 }
2200 } else {
2201 lc->end_of_tiles_x = s->sps->width;
2202 }
2203
2204 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2205
2206 lc->boundary_flags = 0;
2207 if (s->pps->tiles_enabled_flag) {
2208 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]])
2209 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2210 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2211 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2212 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]])
2213 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2214 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2215 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2216 } else {
2217 if (!ctb_addr_in_slice > 0)
2218 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2219 if (ctb_addr_in_slice < s->sps->ctb_width)
2220 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2221 }
2222
2223 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2224 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2225 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]]));
2226 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]]));
2227}
2228
2229static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2230{
2231 HEVCContext *s = avctxt->priv_data;
2232 int ctb_size = 1 << s->sps->log2_ctb_size;
2233 int more_data = 1;
2234 int x_ctb = 0;
2235 int y_ctb = 0;
2236 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2237
2238 if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2239 av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2240 return AVERROR_INVALIDDATA;
2241 }
2242
2243 if (s->sh.dependent_slice_segment_flag) {
2244 int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2245 if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2246 av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2247 return AVERROR_INVALIDDATA;
2248 }
2249 }
2250
2251 while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2252 int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2253
2254 x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2255 y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2256 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2257
2258 ff_hevc_cabac_init(s, ctb_addr_ts);
2259
2260 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2261
2262 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2263 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2264 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2265
2266 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2267 if (more_data < 0) {
2268 s->tab_slice_address[ctb_addr_rs] = -1;
2269 return more_data;
2270 }
2271
2272
2273 ctb_addr_ts++;
2274 ff_hevc_save_states(s, ctb_addr_ts);
2275 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2276 }
2277
2278 if (x_ctb + ctb_size >= s->sps->width &&
2279 y_ctb + ctb_size >= s->sps->height)
2280 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2281
2282 return ctb_addr_ts;
2283}
2284
2285static int hls_slice_data(HEVCContext *s)
2286{
2287 int arg[2];
2288 int ret[2];
2289
2290 arg[0] = 0;
2291 arg[1] = 1;
2292
2293 s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2294 return ret[0];
2295}
2296static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2297{
2298 HEVCContext *s1 = avctxt->priv_data, *s;
2299 HEVCLocalContext *lc;
2300 int ctb_size = 1<< s1->sps->log2_ctb_size;
2301 int more_data = 1;
2302 int *ctb_row_p = input_ctb_row;
2303 int ctb_row = ctb_row_p[job];
2304 int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2305 int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2306 int thread = ctb_row % s1->threads_number;
2307 int ret;
2308
2309 s = s1->sList[self_id];
2310 lc = s->HEVClc;
2311
2312 if(ctb_row) {
2313 ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2314
2315 if (ret < 0)
2316 return ret;
2317 ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2318 }
2319
2320 while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2321 int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2322 int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2323
2324 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2325
2326 ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2327
2328 if (avpriv_atomic_int_get(&s1->wpp_err)){
2329 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2330 return 0;
2331 }
2332
2333 ff_hevc_cabac_init(s, ctb_addr_ts);
2334 hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2335 more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2336
2337 if (more_data < 0) {
2338 s->tab_slice_address[ctb_addr_rs] = -1;
2339 return more_data;
2340 }
2341
2342 ctb_addr_ts++;
2343
2344 ff_hevc_save_states(s, ctb_addr_ts);
2345 ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2346 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2347
2348 if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2349 avpriv_atomic_int_set(&s1->wpp_err, 1);
2350 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2351 return 0;
2352 }
2353
2354 if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2355 ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2356 ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2357 return ctb_addr_ts;
2358 }
2359 ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2360 x_ctb+=ctb_size;
2361
2362 if(x_ctb >= s->sps->width) {
2363 break;
2364 }
2365 }
2366 ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2367
2368 return 0;
2369}
2370
2371static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2372{
2373 HEVCLocalContext *lc = s->HEVClc;
2374 int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2375 int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2376 int offset;
2377 int startheader, cmpt = 0;
2378 int i, j, res = 0;
2379
2380
2381 if (!s->sList[1]) {
2382 ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2383
2384
2385 for (i = 1; i < s->threads_number; i++) {
2386 s->sList[i] = av_malloc(sizeof(HEVCContext));
2387 memcpy(s->sList[i], s, sizeof(HEVCContext));
2388 s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2389 s->sList[i]->HEVClc = s->HEVClcList[i];
2390 }
2391 }
2392
2393 offset = (lc->gb.index >> 3);
2394
2395 for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2396 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2397 startheader--;
2398 cmpt++;
2399 }
2400 }
2401
2402 for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2403 offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2404 for (j = 0, cmpt = 0, startheader = offset
2405 + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2406 if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2407 startheader--;
2408 cmpt++;
2409 }
2410 }
2411 s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2412 s->sh.offset[i - 1] = offset;
2413
2414 }
2415 if (s->sh.num_entry_point_offsets != 0) {
2416 offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2417 s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2418 s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2419
2420 }
2421 s->data = nal;
2422
2423 for (i = 1; i < s->threads_number; i++) {
2424 s->sList[i]->HEVClc->first_qp_group = 1;
2425 s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2426 memcpy(s->sList[i], s, sizeof(HEVCContext));
2427 s->sList[i]->HEVClc = s->HEVClcList[i];
2428 }
2429
2430 avpriv_atomic_int_set(&s->wpp_err, 0);
2431 ff_reset_entries(s->avctx);
2432
2433 for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2434 arg[i] = i;
2435 ret[i] = 0;
2436 }
2437
2438 if (s->pps->entropy_coding_sync_enabled_flag)
2439 s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2440
2441 for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2442 res += ret[i];
2443 av_free(ret);
2444 av_free(arg);
2445 return res;
2446}
2447
2448/**
2449 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2450 * 0 if the unit should be skipped, 1 otherwise
2451 */
2452static int hls_nal_unit(HEVCContext *s)
2453{
2454 GetBitContext *gb = &s->HEVClc->gb;
2455 int nuh_layer_id;
2456
2457 if (get_bits1(gb) != 0)
2458 return AVERROR_INVALIDDATA;
2459
2460 s->nal_unit_type = get_bits(gb, 6);
2461
2462 nuh_layer_id = get_bits(gb, 6);
2463 s->temporal_id = get_bits(gb, 3) - 1;
2464 if (s->temporal_id < 0)
2465 return AVERROR_INVALIDDATA;
2466
2467 av_log(s->avctx, AV_LOG_DEBUG,
2468 "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2469 s->nal_unit_type, nuh_layer_id, s->temporal_id);
2470
2471 return nuh_layer_id == 0;
2472}
2473
2474static int set_side_data(HEVCContext *s)
2475{
2476 AVFrame *out = s->ref->frame;
2477
2478 if (s->sei_frame_packing_present &&
2479 s->frame_packing_arrangement_type >= 3 &&
2480 s->frame_packing_arrangement_type <= 5 &&
2481 s->content_interpretation_type > 0 &&
2482 s->content_interpretation_type < 3) {
2483 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2484 if (!stereo)
2485 return AVERROR(ENOMEM);
2486
2487 switch (s->frame_packing_arrangement_type) {
2488 case 3:
2489 if (s->quincunx_subsampling)
2490 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2491 else
2492 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2493 break;
2494 case 4:
2495 stereo->type = AV_STEREO3D_TOPBOTTOM;
2496 break;
2497 case 5:
2498 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2499 break;
2500 }
2501
2502 if (s->content_interpretation_type == 2)
2503 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2504 }
2505
2506 if (s->sei_display_orientation_present &&
2507 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2508 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2509 AVFrameSideData *rotation = av_frame_new_side_data(out,
2510 AV_FRAME_DATA_DISPLAYMATRIX,
2511 sizeof(int32_t) * 9);
2512 if (!rotation)
2513 return AVERROR(ENOMEM);
2514
2515 av_display_rotation_set((int32_t *)rotation->data, angle);
2516 av_display_matrix_flip((int32_t *)rotation->data,
f6fa7814 2517 s->sei_hflip, s->sei_vflip);
2ba45a60
DM		 2518 }
2519
2520 return 0;
2521}
2522
2523static int hevc_frame_start(HEVCContext *s)
2524{
2525 HEVCLocalContext *lc = s->HEVClc;
2526 int pic_size_in_ctb = ((s->sps->width >> s->sps->log2_min_cb_size) + 1) *
2527 ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2528 int ret;
2529
2530 memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2531 memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2532 memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2533 memset(s->is_pcm, 0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2534 memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2535
2536 s->is_decoded = 0;
2537 s->first_nal_type = s->nal_unit_type;
2538
2539 if (s->pps->tiles_enabled_flag)
2540 lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2541
2542 ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2543 if (ret < 0)
2544 goto fail;
2545
2546 ret = ff_hevc_frame_rps(s);
2547 if (ret < 0) {
2548 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2549 goto fail;
2550 }
2551
2552 s->ref->frame->key_frame = IS_IRAP(s);
2553
2554 ret = set_side_data(s);
2555 if (ret < 0)
2556 goto fail;
2557
2558 s->frame->pict_type = 3 - s->sh.slice_type;
2559
2560 if (!IS_IRAP(s))
2561 ff_hevc_bump_frame(s);
2562
2563 av_frame_unref(s->output_frame);
2564 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2565 if (ret < 0)
2566 goto fail;
2567
2568 ff_thread_finish_setup(s->avctx);
2569
2570 return 0;
2571
2572fail:
2573 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2574 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2575 s->ref = NULL;
2576 return ret;
2577}
2578
2579static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2580{
2581 HEVCLocalContext *lc = s->HEVClc;
2582 GetBitContext *gb = &lc->gb;
2583 int ctb_addr_ts, ret;
2584
2585 ret = init_get_bits8(gb, nal, length);
2586 if (ret < 0)
2587 return ret;
2588
2589 ret = hls_nal_unit(s);
2590 if (ret < 0) {
2591 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2592 s->nal_unit_type);
2593 goto fail;
2594 } else if (!ret)
2595 return 0;
2596
2597 switch (s->nal_unit_type) {
2598 case NAL_VPS:
2599 ret = ff_hevc_decode_nal_vps(s);
2600 if (ret < 0)
2601 goto fail;
2602 break;
2603 case NAL_SPS:
2604 ret = ff_hevc_decode_nal_sps(s);
2605 if (ret < 0)
2606 goto fail;
2607 break;
2608 case NAL_PPS:
2609 ret = ff_hevc_decode_nal_pps(s);
2610 if (ret < 0)
2611 goto fail;
2612 break;
2613 case NAL_SEI_PREFIX:
2614 case NAL_SEI_SUFFIX:
2615 ret = ff_hevc_decode_nal_sei(s);
2616 if (ret < 0)
2617 goto fail;
2618 break;
2619 case NAL_TRAIL_R:
2620 case NAL_TRAIL_N:
2621 case NAL_TSA_N:
2622 case NAL_TSA_R:
2623 case NAL_STSA_N:
2624 case NAL_STSA_R:
2625 case NAL_BLA_W_LP:
2626 case NAL_BLA_W_RADL:
2627 case NAL_BLA_N_LP:
2628 case NAL_IDR_W_RADL:
2629 case NAL_IDR_N_LP:
2630 case NAL_CRA_NUT:
2631 case NAL_RADL_N:
2632 case NAL_RADL_R:
2633 case NAL_RASL_N:
2634 case NAL_RASL_R:
2635 ret = hls_slice_header(s);
2636 if (ret < 0)
2637 return ret;
2638
2639 if (s->max_ra == INT_MAX) {
2640 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2641 s->max_ra = s->poc;
2642 } else {
2643 if (IS_IDR(s))
2644 s->max_ra = INT_MIN;
2645 }
2646 }
2647
2648 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2649 s->poc <= s->max_ra) {
2650 s->is_decoded = 0;
2651 break;
2652 } else {
2653 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2654 s->max_ra = INT_MIN;
2655 }
2656
2657 if (s->sh.first_slice_in_pic_flag) {
2658 ret = hevc_frame_start(s);
2659 if (ret < 0)
2660 return ret;
2661 } else if (!s->ref) {
2662 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2663 goto fail;
2664 }
2665
2666 if (s->nal_unit_type != s->first_nal_type) {
2667 av_log(s->avctx, AV_LOG_ERROR,
2668 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2669 s->first_nal_type, s->nal_unit_type);
2670 return AVERROR_INVALIDDATA;
2671 }
2672
2673 if (!s->sh.dependent_slice_segment_flag &&
2674 s->sh.slice_type != I_SLICE) {
2675 ret = ff_hevc_slice_rpl(s);
2676 if (ret < 0) {
2677 av_log(s->avctx, AV_LOG_WARNING,
2678 "Error constructing the reference lists for the current slice.\n");
2679 goto fail;
2680 }
2681 }
2682
2683 if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2684 ctb_addr_ts = hls_slice_data_wpp(s, nal, length);
2685 else
2686 ctb_addr_ts = hls_slice_data(s);
2687 if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2688 s->is_decoded = 1;
2689 }
2690
2691 if (ctb_addr_ts < 0) {
2692 ret = ctb_addr_ts;
2693 goto fail;
2694 }
2695 break;
2696 case NAL_EOS_NUT:
2697 case NAL_EOB_NUT:
2698 s->seq_decode = (s->seq_decode + 1) & 0xff;
2699 s->max_ra = INT_MAX;
2700 break;
2701 case NAL_AUD:
2702 case NAL_FD_NUT:
2703 break;
2704 default:
2705 av_log(s->avctx, AV_LOG_INFO,
2706 "Skipping NAL unit %d\n", s->nal_unit_type);
2707 }
2708
2709 return 0;
2710fail:
2711 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2712 return ret;
2713 return 0;
2714}
2715
2716/* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2717 * between these functions would be nice. */
2718int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2719 HEVCNAL *nal)
2720{
2721 int i, si, di;
2722 uint8_t *dst;
2723
2724 s->skipped_bytes = 0;
2725#define STARTCODE_TEST \
2726 if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2727 if (src[i + 2] != 3) { \
2728 /* startcode, so we must be past the end */ \
2729 length = i; \
2730 } \
2731 break; \
2732 }
2733#if HAVE_FAST_UNALIGNED
2734#define FIND_FIRST_ZERO \
2735 if (i > 0 && !src[i]) \
2736 i--; \
2737 while (src[i]) \
2738 i++
2739#if HAVE_FAST_64BIT
2740 for (i = 0; i + 1 < length; i += 9) {
2741 if (!((~AV_RN64A(src + i) &
2742 (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2743 0x8000800080008080ULL))
2744 continue;
2745 FIND_FIRST_ZERO;
2746 STARTCODE_TEST;
2747 i -= 7;
2748 }
2749#else
2750 for (i = 0; i + 1 < length; i += 5) {
2751 if (!((~AV_RN32A(src + i) &
2752 (AV_RN32A(src + i) - 0x01000101U)) &
2753 0x80008080U))
2754 continue;
2755 FIND_FIRST_ZERO;
2756 STARTCODE_TEST;
2757 i -= 3;
2758 }
2759#endif /* HAVE_FAST_64BIT */
2760#else
2761 for (i = 0; i + 1 < length; i += 2) {
2762 if (src[i])
2763 continue;
2764 if (i > 0 && src[i - 1] == 0)
2765 i--;
2766 STARTCODE_TEST;
2767 }
2768#endif /* HAVE_FAST_UNALIGNED */
2769
2770 if (i >= length - 1) { // no escaped 0
2771 nal->data = src;
2772 nal->size = length;
2773 return length;
2774 }
2775
2776 av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2777 length + FF_INPUT_BUFFER_PADDING_SIZE);
2778 if (!nal->rbsp_buffer)
2779 return AVERROR(ENOMEM);
2780
2781 dst = nal->rbsp_buffer;
2782
2783 memcpy(dst, src, i);
2784 si = di = i;
2785 while (si + 2 < length) {
2786 // remove escapes (very rare 1:2^22)
2787 if (src[si + 2] > 3) {
2788 dst[di++] = src[si++];
2789 dst[di++] = src[si++];
2790 } else if (src[si] == 0 && src[si + 1] == 0) {
2791 if (src[si + 2] == 3) { // escape
2792 dst[di++] = 0;
2793 dst[di++] = 0;
2794 si += 3;
2795
2796 s->skipped_bytes++;
2797 if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2798 s->skipped_bytes_pos_size *= 2;
2799 av_reallocp_array(&s->skipped_bytes_pos,
2800 s->skipped_bytes_pos_size,
2801 sizeof(*s->skipped_bytes_pos));
2802 if (!s->skipped_bytes_pos)
2803 return AVERROR(ENOMEM);
2804 }
2805 if (s->skipped_bytes_pos)
2806 s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2807 continue;
2808 } else // next start code
2809 goto nsc;
2810 }
2811
2812 dst[di++] = src[si++];
2813 }
2814 while (si < length)
2815 dst[di++] = src[si++];
2816
2817nsc:
2818 memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2819
2820 nal->data = dst;
2821 nal->size = di;
2822 return si;
2823}
2824
2825static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2826{
2827 int i, consumed, ret = 0;
2828
2829 s->ref = NULL;
2830 s->last_eos = s->eos;
2831 s->eos = 0;
2832
2833 /* split the input packet into NAL units, so we know the upper bound on the
2834 * number of slices in the frame */
2835 s->nb_nals = 0;
2836 while (length >= 4) {
2837 HEVCNAL *nal;
2838 int extract_length = 0;
2839
2840 if (s->is_nalff) {
2841 int i;
2842 for (i = 0; i < s->nal_length_size; i++)
2843 extract_length = (extract_length << 8) | buf[i];
2844 buf += s->nal_length_size;
2845 length -= s->nal_length_size;
2846
2847 if (extract_length > length) {
2848 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2849 ret = AVERROR_INVALIDDATA;
2850 goto fail;
2851 }
2852 } else {
2853 /* search start code */
2854 while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2855 ++buf;
2856 --length;
2857 if (length < 4) {
2858 av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2859 ret = AVERROR_INVALIDDATA;
2860 goto fail;
2861 }
2862 }
2863
2864 buf += 3;
2865 length -= 3;
2866 }
2867
2868 if (!s->is_nalff)
2869 extract_length = length;
2870
2871 if (s->nals_allocated < s->nb_nals + 1) {
2872 int new_size = s->nals_allocated + 1;
2873 HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2874 if (!tmp) {
2875 ret = AVERROR(ENOMEM);
2876 goto fail;
2877 }
2878 s->nals = tmp;
2879 memset(s->nals + s->nals_allocated, 0,
2880 (new_size - s->nals_allocated) * sizeof(*tmp));
2881 av_reallocp_array(&s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2882 av_reallocp_array(&s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2883 av_reallocp_array(&s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2884 s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2885 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));
2886 s->nals_allocated = new_size;
2887 }
2888 s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2889 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2890 nal = &s->nals[s->nb_nals];
2891
2892 consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2893
2894 s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2895 s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2896 s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2897
2898
2899 if (consumed < 0) {
2900 ret = consumed;
2901 goto fail;
2902 }
2903
2904 ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2905 if (ret < 0)
2906 goto fail;
2907 hls_nal_unit(s);
2908
2909 if (s->nal_unit_type == NAL_EOB_NUT ||
2910 s->nal_unit_type == NAL_EOS_NUT)
2911 s->eos = 1;
2912
2913 buf += consumed;
2914 length -= consumed;
2915 }
2916
2917 /* parse the NAL units */
2918 for (i = 0; i < s->nb_nals; i++) {
2919 int ret;
2920 s->skipped_bytes = s->skipped_bytes_nal[i];
2921 s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
2922
2923 ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2924 if (ret < 0) {
2925 av_log(s->avctx, AV_LOG_WARNING,
2926 "Error parsing NAL unit #%d.\n", i);
2927 goto fail;
2928 }
2929 }
2930
2931fail:
2932 if (s->ref && s->threads_type == FF_THREAD_FRAME)
2933 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2934
2935 return ret;
2936}
2937
2938static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2939{
2940 int i;
2941 for (i = 0; i < 16; i++)
2942 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2943}
2944
2945static int verify_md5(HEVCContext *s, AVFrame *frame)
2946{
2947 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2948 int pixel_shift;
2949 int i, j;
2950
2951 if (!desc)
2952 return AVERROR(EINVAL);
2953
2954 pixel_shift = desc->comp[0].depth_minus1 > 7;
2955
2956 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2957 s->poc);
2958
2959 /* the checksums are LE, so we have to byteswap for >8bpp formats
2960 * on BE arches */
2961#if HAVE_BIGENDIAN
2962 if (pixel_shift && !s->checksum_buf) {
2963 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2964 FFMAX3(frame->linesize[0], frame->linesize[1],
2965 frame->linesize[2]));
2966 if (!s->checksum_buf)
2967 return AVERROR(ENOMEM);
2968 }
2969#endif
2970
2971 for (i = 0; frame->data[i]; i++) {
2972 int width = s->avctx->coded_width;
2973 int height = s->avctx->coded_height;
2974 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2975 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2976 uint8_t md5[16];
2977
2978 av_md5_init(s->md5_ctx);
2979 for (j = 0; j < h; j++) {
2980 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2981#if HAVE_BIGENDIAN
2982 if (pixel_shift) {
2983 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2984 (const uint16_t *) src, w);
2985 src = s->checksum_buf;
2986 }
2987#endif
2988 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2989 }
2990 av_md5_final(s->md5_ctx, md5);
2991
2992 if (!memcmp(md5, s->md5[i], 16)) {
2993 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2994 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2995 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2996 } else {
2997 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2998 print_md5(s->avctx, AV_LOG_ERROR, md5);
2999 av_log (s->avctx, AV_LOG_ERROR, " != ");
3000 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
3001 av_log (s->avctx, AV_LOG_ERROR, "\n");
3002 return AVERROR_INVALIDDATA;
3003 }
3004 }
3005
3006 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3007
3008 return 0;
3009}
3010
3011static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3012 AVPacket *avpkt)
3013{
3014 int ret;
3015 HEVCContext *s = avctx->priv_data;
3016
3017 if (!avpkt->size) {
3018 ret = ff_hevc_output_frame(s, data, 1);
3019 if (ret < 0)
3020 return ret;
3021
3022 *got_output = ret;
3023 return 0;
3024 }
3025
3026 s->ref = NULL;
3027 ret = decode_nal_units(s, avpkt->data, avpkt->size);
3028 if (ret < 0)
3029 return ret;
3030
3031 /* verify the SEI checksum */
3032 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3033 s->is_md5) {
3034 ret = verify_md5(s, s->ref->frame);
3035 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3036 ff_hevc_unref_frame(s, s->ref, ~0);
3037 return ret;
3038 }
3039 }
3040 s->is_md5 = 0;
3041
3042 if (s->is_decoded) {
3043 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3044 s->is_decoded = 0;
3045 }
3046
3047 if (s->output_frame->buf[0]) {
3048 av_frame_move_ref(data, s->output_frame);
3049 *got_output = 1;
3050 }
3051
3052 return avpkt->size;
3053}
3054
3055static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3056{
3057 int ret;
3058
3059 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3060 if (ret < 0)
3061 return ret;
3062
3063 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3064 if (!dst->tab_mvf_buf)
3065 goto fail;
3066 dst->tab_mvf = src->tab_mvf;
3067
3068 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3069 if (!dst->rpl_tab_buf)
3070 goto fail;
3071 dst->rpl_tab = src->rpl_tab;
3072
3073 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3074 if (!dst->rpl_buf)
3075 goto fail;
3076
3077 dst->poc = src->poc;
3078 dst->ctb_count = src->ctb_count;
3079 dst->window = src->window;
3080 dst->flags = src->flags;
3081 dst->sequence = src->sequence;
3082
3083 return 0;
3084fail:
3085 ff_hevc_unref_frame(s, dst, ~0);
3086 return AVERROR(ENOMEM);
3087}
3088
3089static av_cold int hevc_decode_free(AVCodecContext *avctx)
3090{
3091 HEVCContext *s = avctx->priv_data;
3092 int i;
3093
3094 pic_arrays_free(s);
3095
3096 av_freep(&s->md5_ctx);
3097
3098 for(i=0; i < s->nals_allocated; i++) {
3099 av_freep(&s->skipped_bytes_pos_nal[i]);
3100 }
3101 av_freep(&s->skipped_bytes_pos_size_nal);
3102 av_freep(&s->skipped_bytes_nal);
3103 av_freep(&s->skipped_bytes_pos_nal);
3104
3105 av_freep(&s->cabac_state);
3106
3107 av_frame_free(&s->tmp_frame);
3108 av_frame_free(&s->output_frame);
3109
3110 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3111 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3112 av_frame_free(&s->DPB[i].frame);
3113 }
3114
3115 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3116 av_buffer_unref(&s->vps_list[i]);
3117 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3118 av_buffer_unref(&s->sps_list[i]);
3119 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3120 av_buffer_unref(&s->pps_list[i]);
3121 s->sps = NULL;
3122 s->pps = NULL;
3123 s->vps = NULL;
3124
3125 av_buffer_unref(&s->current_sps);
3126
3127 av_freep(&s->sh.entry_point_offset);
3128 av_freep(&s->sh.offset);
3129 av_freep(&s->sh.size);
3130
3131 for (i = 1; i < s->threads_number; i++) {
3132 HEVCLocalContext *lc = s->HEVClcList[i];
3133 if (lc) {
3134 av_freep(&s->HEVClcList[i]);
3135 av_freep(&s->sList[i]);
3136 }
3137 }
3138 if (s->HEVClc == s->HEVClcList[0])
3139 s->HEVClc = NULL;
3140 av_freep(&s->HEVClcList[0]);
3141
3142 for (i = 0; i < s->nals_allocated; i++)
3143 av_freep(&s->nals[i].rbsp_buffer);
3144 av_freep(&s->nals);
3145 s->nals_allocated = 0;
3146
3147 return 0;
3148}
3149
3150static av_cold int hevc_init_context(AVCodecContext *avctx)
3151{
3152 HEVCContext *s = avctx->priv_data;
3153 int i;
3154
3155 s->avctx = avctx;
3156
3157 s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3158 if (!s->HEVClc)
3159 goto fail;
3160 s->HEVClcList[0] = s->HEVClc;
3161 s->sList[0] = s;
3162
3163 s->cabac_state = av_malloc(HEVC_CONTEXTS);
3164 if (!s->cabac_state)
3165 goto fail;
3166
3167 s->tmp_frame = av_frame_alloc();
3168 if (!s->tmp_frame)
3169 goto fail;
3170
3171 s->output_frame = av_frame_alloc();
3172 if (!s->output_frame)
3173 goto fail;
3174
3175 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3176 s->DPB[i].frame = av_frame_alloc();
3177 if (!s->DPB[i].frame)
3178 goto fail;
3179 s->DPB[i].tf.f = s->DPB[i].frame;
3180 }
3181
3182 s->max_ra = INT_MAX;
3183
3184 s->md5_ctx = av_md5_alloc();
3185 if (!s->md5_ctx)
3186 goto fail;
3187
3188 ff_bswapdsp_init(&s->bdsp);
3189
3190 s->context_initialized = 1;
3191 s->eos = 0;
3192
3193 return 0;
3194
3195fail:
3196 hevc_decode_free(avctx);
3197 return AVERROR(ENOMEM);
3198}
3199
3200static int hevc_update_thread_context(AVCodecContext *dst,
3201 const AVCodecContext *src)
3202{
3203 HEVCContext *s = dst->priv_data;
3204 HEVCContext *s0 = src->priv_data;
3205 int i, ret;
3206
3207 if (!s->context_initialized) {
3208 ret = hevc_init_context(dst);
3209 if (ret < 0)
3210 return ret;
3211 }
3212
3213 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3214 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3215 if (s0->DPB[i].frame->buf[0]) {
3216 ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3217 if (ret < 0)
3218 return ret;
3219 }
3220 }
3221
3222 if (s->sps != s0->sps)
3223 s->sps = NULL;
3224 for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3225 av_buffer_unref(&s->vps_list[i]);
3226 if (s0->vps_list[i]) {
3227 s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3228 if (!s->vps_list[i])
3229 return AVERROR(ENOMEM);
3230 }
3231 }
3232
3233 for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3234 av_buffer_unref(&s->sps_list[i]);
3235 if (s0->sps_list[i]) {
3236 s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3237 if (!s->sps_list[i])
3238 return AVERROR(ENOMEM);
3239 }
3240 }
3241
3242 for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3243 av_buffer_unref(&s->pps_list[i]);
3244 if (s0->pps_list[i]) {
3245 s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3246 if (!s->pps_list[i])
3247 return AVERROR(ENOMEM);
3248 }
3249 }
3250
3251 av_buffer_unref(&s->current_sps);
3252 if (s0->current_sps) {
3253 s->current_sps = av_buffer_ref(s0->current_sps);
3254 if (!s->current_sps)
3255 return AVERROR(ENOMEM);
3256 }
3257
3258 if (s->sps != s0->sps)
3259 if ((ret = set_sps(s, s0->sps)) < 0)
3260 return ret;
3261
3262 s->seq_decode = s0->seq_decode;
3263 s->seq_output = s0->seq_output;
3264 s->pocTid0 = s0->pocTid0;
3265 s->max_ra = s0->max_ra;
3266 s->eos = s0->eos;
3267
3268 s->is_nalff = s0->is_nalff;
3269 s->nal_length_size = s0->nal_length_size;
3270
3271 s->threads_number = s0->threads_number;
3272 s->threads_type = s0->threads_type;
3273
3274 if (s0->eos) {
3275 s->seq_decode = (s->seq_decode + 1) & 0xff;
3276 s->max_ra = INT_MAX;
3277 }
3278
3279 return 0;
3280}
3281
3282static int hevc_decode_extradata(HEVCContext *s)
3283{
3284 AVCodecContext *avctx = s->avctx;
3285 GetByteContext gb;
3286 int ret;
3287
3288 bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3289
3290 if (avctx->extradata_size > 3 &&
3291 (avctx->extradata[0] || avctx->extradata[1] ||
3292 avctx->extradata[2] > 1)) {
3293 /* It seems the extradata is encoded as hvcC format.
3294 * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3295 * is finalized. When finalized, configurationVersion will be 1 and we
3296 * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3297 int i, j, num_arrays, nal_len_size;
3298
3299 s->is_nalff = 1;
3300
3301 bytestream2_skip(&gb, 21);
3302 nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3303 num_arrays = bytestream2_get_byte(&gb);
3304
3305 /* nal units in the hvcC always have length coded with 2 bytes,
3306 * so put a fake nal_length_size = 2 while parsing them */
3307 s->nal_length_size = 2;
3308
3309 /* Decode nal units from hvcC. */
3310 for (i = 0; i < num_arrays; i++) {
3311 int type = bytestream2_get_byte(&gb) & 0x3f;
3312 int cnt = bytestream2_get_be16(&gb);
3313
3314 for (j = 0; j < cnt; j++) {
3315 // +2 for the nal size field
3316 int nalsize = bytestream2_peek_be16(&gb) + 2;
3317 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3318 av_log(s->avctx, AV_LOG_ERROR,
3319 "Invalid NAL unit size in extradata.\n");
3320 return AVERROR_INVALIDDATA;
3321 }
3322
3323 ret = decode_nal_units(s, gb.buffer, nalsize);
3324 if (ret < 0) {
3325 av_log(avctx, AV_LOG_ERROR,
3326 "Decoding nal unit %d %d from hvcC failed\n",
3327 type, i);
3328 return ret;
3329 }
3330 bytestream2_skip(&gb, nalsize);
3331 }
3332 }
3333
3334 /* Now store right nal length size, that will be used to parse
3335 * all other nals */
3336 s->nal_length_size = nal_len_size;
3337 } else {
3338 s->is_nalff = 0;
3339 ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3340 if (ret < 0)
3341 return ret;
3342 }
3343 return 0;
3344}
3345
3346static av_cold int hevc_decode_init(AVCodecContext *avctx)
3347{
3348 HEVCContext *s = avctx->priv_data;
3349 int ret;
3350
3351 ff_init_cabac_states();
3352
3353 avctx->internal->allocate_progress = 1;
3354
3355 ret = hevc_init_context(avctx);
3356 if (ret < 0)
3357 return ret;
3358
3359 s->enable_parallel_tiles = 0;
3360 s->picture_struct = 0;
3361
3362 if(avctx->active_thread_type & FF_THREAD_SLICE)
3363 s->threads_number = avctx->thread_count;
3364 else
3365 s->threads_number = 1;
3366
3367 if (avctx->extradata_size > 0 && avctx->extradata) {
3368 ret = hevc_decode_extradata(s);
3369 if (ret < 0) {
3370 hevc_decode_free(avctx);
3371 return ret;
3372 }
3373 }
3374
3375 if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3376 s->threads_type = FF_THREAD_FRAME;
3377 else
3378 s->threads_type = FF_THREAD_SLICE;
3379
3380 return 0;
3381}
3382
3383static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3384{
3385 HEVCContext *s = avctx->priv_data;
3386 int ret;
3387
3388 memset(s, 0, sizeof(*s));
3389
3390 ret = hevc_init_context(avctx);
3391 if (ret < 0)
3392 return ret;
3393
3394 return 0;
3395}
3396
3397static void hevc_decode_flush(AVCodecContext *avctx)
3398{
3399 HEVCContext *s = avctx->priv_data;
3400 ff_hevc_flush_dpb(s);
3401 s->max_ra = INT_MAX;
3402}
3403
3404#define OFFSET(x) offsetof(HEVCContext, x)
3405#define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3406
3407static const AVProfile profiles[] = {
3408 { FF_PROFILE_HEVC_MAIN, "Main" },
3409 { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3410 { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3411 { FF_PROFILE_HEVC_REXT, "Rext" },
3412 { FF_PROFILE_UNKNOWN },
3413};
3414
3415static const AVOption options[] = {
3416 { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3417 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3418 { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3419 AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3420 { NULL },
3421};
3422
3423static const AVClass hevc_decoder_class = {
3424 .class_name = "HEVC decoder",
3425 .item_name = av_default_item_name,
3426 .option = options,
3427 .version = LIBAVUTIL_VERSION_INT,
3428};
3429
3430AVCodec ff_hevc_decoder = {
3431 .name = "hevc",
3432 .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3433 .type = AVMEDIA_TYPE_VIDEO,
3434 .id = AV_CODEC_ID_HEVC,
3435 .priv_data_size = sizeof(HEVCContext),
3436 .priv_class = &hevc_decoder_class,
3437 .init = hevc_decode_init,
3438 .close = hevc_decode_free,
3439 .decode = hevc_decode_frame,
3440 .flush = hevc_decode_flush,
3441 .update_thread_context = hevc_update_thread_context,
3442 .init_thread_copy = hevc_init_thread_copy,
3443 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3444 CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3445 .profiles = NULL_IF_CONFIG_SMALL(profiles),
3446};
ffmpeg Piment Noir Debian package repository