hevc: Change type of array stride parameters to ptrdiff_t
[libav.git] / libavcodec / hevc.c
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 Libav.
10 *
11 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 */
25
26 #include "libavutil/attributes.h"
27 #include "libavutil/common.h"
28 #include "libavutil/display.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/md5.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/stereo3d.h"
34
35 #include "bswapdsp.h"
36 #include "bytestream.h"
37 #include "cabac_functions.h"
38 #include "golomb.h"
39 #include "hevc.h"
40 #include "profiles.h"
41
42 const uint8_t ff_hevc_qpel_extra_before[4] = { 0, 3, 3, 3 };
43 const uint8_t ff_hevc_qpel_extra_after[4] = { 0, 4, 4, 4 };
44 const uint8_t ff_hevc_qpel_extra[4] = { 0, 7, 7, 7 };
45
46 static const uint8_t scan_1x1[1] = { 0 };
47
48 static const uint8_t horiz_scan2x2_x[4] = { 0, 1, 0, 1 };
49
50 static const uint8_t horiz_scan2x2_y[4] = { 0, 0, 1, 1 };
51
52 static const uint8_t horiz_scan4x4_x[16] = {
53 0, 1, 2, 3,
54 0, 1, 2, 3,
55 0, 1, 2, 3,
56 0, 1, 2, 3,
57 };
58
59 static const uint8_t horiz_scan4x4_y[16] = {
60 0, 0, 0, 0,
61 1, 1, 1, 1,
62 2, 2, 2, 2,
63 3, 3, 3, 3,
64 };
65
66 static const uint8_t horiz_scan8x8_inv[8][8] = {
67 { 0, 1, 2, 3, 16, 17, 18, 19, },
68 { 4, 5, 6, 7, 20, 21, 22, 23, },
69 { 8, 9, 10, 11, 24, 25, 26, 27, },
70 { 12, 13, 14, 15, 28, 29, 30, 31, },
71 { 32, 33, 34, 35, 48, 49, 50, 51, },
72 { 36, 37, 38, 39, 52, 53, 54, 55, },
73 { 40, 41, 42, 43, 56, 57, 58, 59, },
74 { 44, 45, 46, 47, 60, 61, 62, 63, },
75 };
76
77 static const uint8_t diag_scan2x2_x[4] = { 0, 0, 1, 1 };
78
79 static const uint8_t diag_scan2x2_y[4] = { 0, 1, 0, 1 };
80
81 static const uint8_t diag_scan2x2_inv[2][2] = {
82 { 0, 2, },
83 { 1, 3, },
84 };
85
86 static const uint8_t diag_scan4x4_inv[4][4] = {
87 { 0, 2, 5, 9, },
88 { 1, 4, 8, 12, },
89 { 3, 7, 11, 14, },
90 { 6, 10, 13, 15, },
91 };
92
93 static const uint8_t diag_scan8x8_inv[8][8] = {
94 { 0, 2, 5, 9, 14, 20, 27, 35, },
95 { 1, 4, 8, 13, 19, 26, 34, 42, },
96 { 3, 7, 12, 18, 25, 33, 41, 48, },
97 { 6, 11, 17, 24, 32, 40, 47, 53, },
98 { 10, 16, 23, 31, 39, 46, 52, 57, },
99 { 15, 22, 30, 38, 45, 51, 56, 60, },
100 { 21, 29, 37, 44, 50, 55, 59, 62, },
101 { 28, 36, 43, 49, 54, 58, 61, 63, },
102 };
103
104 /**
105 * NOTE: Each function hls_foo correspond to the function foo in the
106 * specification (HLS stands for High Level Syntax).
107 */
108
109 /**
110 * Section 5.7
111 */
112
113 /* free everything allocated by pic_arrays_init() */
114 static void pic_arrays_free(HEVCContext *s)
115 {
116 av_freep(&s->sao);
117 av_freep(&s->deblock);
118
119 av_freep(&s->skip_flag);
120 av_freep(&s->tab_ct_depth);
121
122 av_freep(&s->tab_ipm);
123 av_freep(&s->cbf_luma);
124 av_freep(&s->is_pcm);
125
126 av_freep(&s->qp_y_tab);
127 av_freep(&s->tab_slice_address);
128 av_freep(&s->filter_slice_edges);
129
130 av_freep(&s->horizontal_bs);
131 av_freep(&s->vertical_bs);
132
133 av_buffer_pool_uninit(&s->tab_mvf_pool);
134 av_buffer_pool_uninit(&s->rpl_tab_pool);
135 }
136
137 /* allocate arrays that depend on frame dimensions */
138 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
139 {
140 int log2_min_cb_size = sps->log2_min_cb_size;
141 int width = sps->width;
142 int height = sps->height;
143 int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
144 ((height >> log2_min_cb_size) + 1);
145 int ctb_count = sps->ctb_width * sps->ctb_height;
146 int min_pu_size = sps->min_pu_width * sps->min_pu_height;
147
148 s->bs_width = width >> 3;
149 s->bs_height = height >> 3;
150
151 s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
152 s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
153 if (!s->sao || !s->deblock)
154 goto fail;
155
156 s->skip_flag = av_malloc(pic_size_in_ctb);
157 s->tab_ct_depth = av_malloc(sps->min_cb_height * sps->min_cb_width);
158 if (!s->skip_flag || !s->tab_ct_depth)
159 goto fail;
160
161 s->cbf_luma = av_malloc(sps->min_tb_width * sps->min_tb_height);
162 s->tab_ipm = av_mallocz(min_pu_size);
163 s->is_pcm = av_malloc(min_pu_size);
164 if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
165 goto fail;
166
167 s->filter_slice_edges = av_malloc(ctb_count);
168 s->tab_slice_address = av_malloc(pic_size_in_ctb *
169 sizeof(*s->tab_slice_address));
170 s->qp_y_tab = av_malloc(pic_size_in_ctb *
171 sizeof(*s->qp_y_tab));
172 if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
173 goto fail;
174
175 s->horizontal_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
176 s->vertical_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
177 if (!s->horizontal_bs || !s->vertical_bs)
178 goto fail;
179
180 s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
181 av_buffer_alloc);
182 s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
183 av_buffer_allocz);
184 if (!s->tab_mvf_pool || !s->rpl_tab_pool)
185 goto fail;
186
187 return 0;
188
189 fail:
190 pic_arrays_free(s);
191 return AVERROR(ENOMEM);
192 }
193
194 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
195 {
196 int i = 0;
197 int j = 0;
198 uint8_t luma_weight_l0_flag[16];
199 uint8_t chroma_weight_l0_flag[16];
200 uint8_t luma_weight_l1_flag[16];
201 uint8_t chroma_weight_l1_flag[16];
202
203 s->sh.luma_log2_weight_denom = av_clip(get_ue_golomb_long(gb), 0, 7);
204 if (s->ps.sps->chroma_format_idc != 0) {
205 int delta = get_se_golomb(gb);
206 s->sh.chroma_log2_weight_denom = av_clip(s->sh.luma_log2_weight_denom + delta, 0, 7);
207 }
208
209 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
210 luma_weight_l0_flag[i] = get_bits1(gb);
211 if (!luma_weight_l0_flag[i]) {
212 s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
213 s->sh.luma_offset_l0[i] = 0;
214 }
215 }
216 if (s->ps.sps->chroma_format_idc != 0) { // FIXME: invert "if" and "for"
217 for (i = 0; i < s->sh.nb_refs[L0]; i++)
218 chroma_weight_l0_flag[i] = get_bits1(gb);
219 } else {
220 for (i = 0; i < s->sh.nb_refs[L0]; i++)
221 chroma_weight_l0_flag[i] = 0;
222 }
223 for (i = 0; i < s->sh.nb_refs[L0]; i++) {
224 if (luma_weight_l0_flag[i]) {
225 int delta_luma_weight_l0 = get_se_golomb(gb);
226 s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
227 s->sh.luma_offset_l0[i] = get_se_golomb(gb);
228 }
229 if (chroma_weight_l0_flag[i]) {
230 for (j = 0; j < 2; j++) {
231 int delta_chroma_weight_l0 = get_se_golomb(gb);
232 int delta_chroma_offset_l0 = get_se_golomb(gb);
233 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
234 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
235 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
236 }
237 } else {
238 s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
239 s->sh.chroma_offset_l0[i][0] = 0;
240 s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
241 s->sh.chroma_offset_l0[i][1] = 0;
242 }
243 }
244 if (s->sh.slice_type == B_SLICE) {
245 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
246 luma_weight_l1_flag[i] = get_bits1(gb);
247 if (!luma_weight_l1_flag[i]) {
248 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
249 s->sh.luma_offset_l1[i] = 0;
250 }
251 }
252 if (s->ps.sps->chroma_format_idc != 0) {
253 for (i = 0; i < s->sh.nb_refs[L1]; i++)
254 chroma_weight_l1_flag[i] = get_bits1(gb);
255 } else {
256 for (i = 0; i < s->sh.nb_refs[L1]; i++)
257 chroma_weight_l1_flag[i] = 0;
258 }
259 for (i = 0; i < s->sh.nb_refs[L1]; i++) {
260 if (luma_weight_l1_flag[i]) {
261 int delta_luma_weight_l1 = get_se_golomb(gb);
262 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
263 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
264 }
265 if (chroma_weight_l1_flag[i]) {
266 for (j = 0; j < 2; j++) {
267 int delta_chroma_weight_l1 = get_se_golomb(gb);
268 int delta_chroma_offset_l1 = get_se_golomb(gb);
269 s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
270 s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
271 >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
272 }
273 } else {
274 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
275 s->sh.chroma_offset_l1[i][0] = 0;
276 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
277 s->sh.chroma_offset_l1[i][1] = 0;
278 }
279 }
280 }
281 }
282
283 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
284 {
285 const HEVCSPS *sps = s->ps.sps;
286 int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
287 int prev_delta_msb = 0;
288 unsigned int nb_sps = 0, nb_sh;
289 int i;
290
291 rps->nb_refs = 0;
292 if (!sps->long_term_ref_pics_present_flag)
293 return 0;
294
295 if (sps->num_long_term_ref_pics_sps > 0)
296 nb_sps = get_ue_golomb_long(gb);
297 nb_sh = get_ue_golomb_long(gb);
298
299 if (nb_sh + nb_sps > FF_ARRAY_ELEMS(rps->poc))
300 return AVERROR_INVALIDDATA;
301
302 rps->nb_refs = nb_sh + nb_sps;
303
304 for (i = 0; i < rps->nb_refs; i++) {
305 uint8_t delta_poc_msb_present;
306
307 if (i < nb_sps) {
308 uint8_t lt_idx_sps = 0;
309
310 if (sps->num_long_term_ref_pics_sps > 1)
311 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
312
313 rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
314 rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
315 } else {
316 rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
317 rps->used[i] = get_bits1(gb);
318 }
319
320 delta_poc_msb_present = get_bits1(gb);
321 if (delta_poc_msb_present) {
322 int delta = get_ue_golomb_long(gb);
323
324 if (i && i != nb_sps)
325 delta += prev_delta_msb;
326
327 rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
328 prev_delta_msb = delta;
329 }
330 }
331
332 return 0;
333 }
334
335 static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
336 const HEVCSPS *sps)
337 {
338 const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
339 unsigned int num = 0, den = 0;
340
341 avctx->pix_fmt = sps->pix_fmt;
342 avctx->coded_width = sps->width;
343 avctx->coded_height = sps->height;
344 avctx->width = sps->output_width;
345 avctx->height = sps->output_height;
346 avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
347 avctx->profile = sps->ptl.general_ptl.profile_idc;
348 avctx->level = sps->ptl.general_ptl.level_idc;
349
350 ff_set_sar(avctx, sps->vui.sar);
351
352 if (sps->vui.video_signal_type_present_flag)
353 avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
354 : AVCOL_RANGE_MPEG;
355 else
356 avctx->color_range = AVCOL_RANGE_MPEG;
357
358 if (sps->vui.colour_description_present_flag) {
359 avctx->color_primaries = sps->vui.colour_primaries;
360 avctx->color_trc = sps->vui.transfer_characteristic;
361 avctx->colorspace = sps->vui.matrix_coeffs;
362 } else {
363 avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
364 avctx->color_trc = AVCOL_TRC_UNSPECIFIED;
365 avctx->colorspace = AVCOL_SPC_UNSPECIFIED;
366 }
367
368 if (vps->vps_timing_info_present_flag) {
369 num = vps->vps_num_units_in_tick;
370 den = vps->vps_time_scale;
371 } else if (sps->vui.vui_timing_info_present_flag) {
372 num = sps->vui.vui_num_units_in_tick;
373 den = sps->vui.vui_time_scale;
374 }
375
376 if (num != 0 && den != 0)
377 av_reduce(&avctx->framerate.den, &avctx->framerate.num,
378 num, den, 1 << 30);
379 }
380
381 static int set_sps(HEVCContext *s, const HEVCSPS *sps)
382 {
383 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
384 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
385 int ret;
386
387 pic_arrays_free(s);
388 s->ps.sps = NULL;
389 s->ps.vps = NULL;
390
391 if (!sps)
392 return 0;
393
394 ret = pic_arrays_init(s, sps);
395 if (ret < 0)
396 goto fail;
397
398 export_stream_params(s->avctx, &s->ps, sps);
399
400 if (sps->pix_fmt == AV_PIX_FMT_YUV420P || sps->pix_fmt == AV_PIX_FMT_YUVJ420P ||
401 sps->pix_fmt == AV_PIX_FMT_YUV420P10) {
402 #if CONFIG_HEVC_DXVA2_HWACCEL
403 *fmt++ = AV_PIX_FMT_DXVA2_VLD;
404 #endif
405 }
406 if (sps->pix_fmt == AV_PIX_FMT_YUV420P || sps->pix_fmt == AV_PIX_FMT_YUVJ420P) {
407 #if CONFIG_HEVC_D3D11VA_HWACCEL
408 *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
409 #endif
410 #if CONFIG_HEVC_VDPAU_HWACCEL
411 *fmt++ = AV_PIX_FMT_VDPAU;
412 #endif
413 }
414
415 *fmt++ = sps->pix_fmt;
416 *fmt = AV_PIX_FMT_NONE;
417
418 ret = ff_get_format(s->avctx, pix_fmts);
419 if (ret < 0)
420 goto fail;
421 s->avctx->pix_fmt = ret;
422
423 ff_hevc_pred_init(&s->hpc, sps->bit_depth);
424 ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
425 ff_videodsp_init (&s->vdsp, sps->bit_depth);
426
427 if (sps->sao_enabled && !s->avctx->hwaccel) {
428 av_frame_unref(s->tmp_frame);
429 ret = ff_get_buffer(s->avctx, s->tmp_frame, AV_GET_BUFFER_FLAG_REF);
430 if (ret < 0)
431 goto fail;
432 s->frame = s->tmp_frame;
433 }
434
435 s->ps.sps = sps;
436 s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
437
438 return 0;
439
440 fail:
441 pic_arrays_free(s);
442 s->ps.sps = NULL;
443 return ret;
444 }
445
446 static int hls_slice_header(HEVCContext *s)
447 {
448 GetBitContext *gb = &s->HEVClc.gb;
449 SliceHeader *sh = &s->sh;
450 int i, ret;
451
452 // Coded parameters
453 sh->first_slice_in_pic_flag = get_bits1(gb);
454 if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
455 s->seq_decode = (s->seq_decode + 1) & 0xff;
456 s->max_ra = INT_MAX;
457 if (IS_IDR(s))
458 ff_hevc_clear_refs(s);
459 }
460 if (IS_IRAP(s))
461 sh->no_output_of_prior_pics_flag = get_bits1(gb);
462
463 sh->pps_id = get_ue_golomb_long(gb);
464 if (sh->pps_id >= MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
465 av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
466 return AVERROR_INVALIDDATA;
467 }
468 if (!sh->first_slice_in_pic_flag &&
469 s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
470 av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
471 return AVERROR_INVALIDDATA;
472 }
473 s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
474
475 if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
476 s->ps.sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
477
478 ff_hevc_clear_refs(s);
479 ret = set_sps(s, s->ps.sps);
480 if (ret < 0)
481 return ret;
482
483 s->seq_decode = (s->seq_decode + 1) & 0xff;
484 s->max_ra = INT_MAX;
485 }
486
487 sh->dependent_slice_segment_flag = 0;
488 if (!sh->first_slice_in_pic_flag) {
489 int slice_address_length;
490
491 if (s->ps.pps->dependent_slice_segments_enabled_flag)
492 sh->dependent_slice_segment_flag = get_bits1(gb);
493
494 slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
495 s->ps.sps->ctb_height);
496 sh->slice_segment_addr = slice_address_length ? get_bits(gb, slice_address_length) : 0;
497 if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
498 av_log(s->avctx, AV_LOG_ERROR,
499 "Invalid slice segment address: %u.\n",
500 sh->slice_segment_addr);
501 return AVERROR_INVALIDDATA;
502 }
503
504 if (!sh->dependent_slice_segment_flag) {
505 sh->slice_addr = sh->slice_segment_addr;
506 s->slice_idx++;
507 }
508 } else {
509 sh->slice_segment_addr = sh->slice_addr = 0;
510 s->slice_idx = 0;
511 s->slice_initialized = 0;
512 }
513
514 if (!sh->dependent_slice_segment_flag) {
515 s->slice_initialized = 0;
516
517 for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
518 skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
519
520 sh->slice_type = get_ue_golomb_long(gb);
521 if (!(sh->slice_type == I_SLICE ||
522 sh->slice_type == P_SLICE ||
523 sh->slice_type == B_SLICE)) {
524 av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
525 sh->slice_type);
526 return AVERROR_INVALIDDATA;
527 }
528 if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
529 av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
530 return AVERROR_INVALIDDATA;
531 }
532
533 // when flag is not present, picture is inferred to be output
534 sh->pic_output_flag = 1;
535 if (s->ps.pps->output_flag_present_flag)
536 sh->pic_output_flag = get_bits1(gb);
537
538 if (s->ps.sps->separate_colour_plane_flag)
539 sh->colour_plane_id = get_bits(gb, 2);
540
541 if (!IS_IDR(s)) {
542 int poc, pos;
543
544 sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
545 poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
546 if (!sh->first_slice_in_pic_flag && poc != s->poc) {
547 av_log(s->avctx, AV_LOG_WARNING,
548 "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
549 if (s->avctx->err_recognition & AV_EF_EXPLODE)
550 return AVERROR_INVALIDDATA;
551 poc = s->poc;
552 }
553 s->poc = poc;
554
555 sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
556 pos = get_bits_left(gb);
557 if (!sh->short_term_ref_pic_set_sps_flag) {
558 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
559 if (ret < 0)
560 return ret;
561
562 sh->short_term_rps = &sh->slice_rps;
563 } else {
564 int numbits, rps_idx;
565
566 if (!s->ps.sps->nb_st_rps) {
567 av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
568 return AVERROR_INVALIDDATA;
569 }
570
571 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
572 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
573 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
574 }
575 sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
576
577 pos = get_bits_left(gb);
578 ret = decode_lt_rps(s, &sh->long_term_rps, gb);
579 if (ret < 0) {
580 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
581 if (s->avctx->err_recognition & AV_EF_EXPLODE)
582 return AVERROR_INVALIDDATA;
583 }
584 sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
585
586 if (s->ps.sps->sps_temporal_mvp_enabled_flag)
587 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
588 else
589 sh->slice_temporal_mvp_enabled_flag = 0;
590 } else {
591 s->sh.short_term_rps = NULL;
592 s->poc = 0;
593 }
594
595 /* 8.3.1 */
596 if (s->temporal_id == 0 &&
597 s->nal_unit_type != NAL_TRAIL_N &&
598 s->nal_unit_type != NAL_TSA_N &&
599 s->nal_unit_type != NAL_STSA_N &&
600 s->nal_unit_type != NAL_RADL_N &&
601 s->nal_unit_type != NAL_RADL_R &&
602 s->nal_unit_type != NAL_RASL_N &&
603 s->nal_unit_type != NAL_RASL_R)
604 s->pocTid0 = s->poc;
605
606 if (s->ps.sps->sao_enabled) {
607 sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
608 sh->slice_sample_adaptive_offset_flag[1] =
609 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
610 } else {
611 sh->slice_sample_adaptive_offset_flag[0] = 0;
612 sh->slice_sample_adaptive_offset_flag[1] = 0;
613 sh->slice_sample_adaptive_offset_flag[2] = 0;
614 }
615
616 sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
617 if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
618 int nb_refs;
619
620 sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
621 if (sh->slice_type == B_SLICE)
622 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
623
624 if (get_bits1(gb)) { // num_ref_idx_active_override_flag
625 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
626 if (sh->slice_type == B_SLICE)
627 sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
628 }
629 if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
630 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
631 sh->nb_refs[L0], sh->nb_refs[L1]);
632 return AVERROR_INVALIDDATA;
633 }
634
635 sh->rpl_modification_flag[0] = 0;
636 sh->rpl_modification_flag[1] = 0;
637 nb_refs = ff_hevc_frame_nb_refs(s);
638 if (!nb_refs) {
639 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
640 return AVERROR_INVALIDDATA;
641 }
642
643 if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
644 sh->rpl_modification_flag[0] = get_bits1(gb);
645 if (sh->rpl_modification_flag[0]) {
646 for (i = 0; i < sh->nb_refs[L0]; i++)
647 sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
648 }
649
650 if (sh->slice_type == B_SLICE) {
651 sh->rpl_modification_flag[1] = get_bits1(gb);
652 if (sh->rpl_modification_flag[1] == 1)
653 for (i = 0; i < sh->nb_refs[L1]; i++)
654 sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
655 }
656 }
657
658 if (sh->slice_type == B_SLICE)
659 sh->mvd_l1_zero_flag = get_bits1(gb);
660
661 if (s->ps.pps->cabac_init_present_flag)
662 sh->cabac_init_flag = get_bits1(gb);
663 else
664 sh->cabac_init_flag = 0;
665
666 sh->collocated_ref_idx = 0;
667 if (sh->slice_temporal_mvp_enabled_flag) {
668 sh->collocated_list = L0;
669 if (sh->slice_type == B_SLICE)
670 sh->collocated_list = !get_bits1(gb);
671
672 if (sh->nb_refs[sh->collocated_list] > 1) {
673 sh->collocated_ref_idx = get_ue_golomb_long(gb);
674 if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
675 av_log(s->avctx, AV_LOG_ERROR,
676 "Invalid collocated_ref_idx: %d.\n",
677 sh->collocated_ref_idx);
678 return AVERROR_INVALIDDATA;
679 }
680 }
681 }
682
683 if ((s->ps.pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
684 (s->ps.pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
685 pred_weight_table(s, gb);
686 }
687
688 sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
689 if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
690 av_log(s->avctx, AV_LOG_ERROR,
691 "Invalid number of merging MVP candidates: %d.\n",
692 sh->max_num_merge_cand);
693 return AVERROR_INVALIDDATA;
694 }
695 }
696
697 sh->slice_qp_delta = get_se_golomb(gb);
698
699 if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
700 sh->slice_cb_qp_offset = get_se_golomb(gb);
701 sh->slice_cr_qp_offset = get_se_golomb(gb);
702 } else {
703 sh->slice_cb_qp_offset = 0;
704 sh->slice_cr_qp_offset = 0;
705 }
706
707 if (s->ps.pps->deblocking_filter_control_present_flag) {
708 int deblocking_filter_override_flag = 0;
709
710 if (s->ps.pps->deblocking_filter_override_enabled_flag)
711 deblocking_filter_override_flag = get_bits1(gb);
712
713 if (deblocking_filter_override_flag) {
714 sh->disable_deblocking_filter_flag = get_bits1(gb);
715 if (!sh->disable_deblocking_filter_flag) {
716 sh->beta_offset = get_se_golomb(gb) * 2;
717 sh->tc_offset = get_se_golomb(gb) * 2;
718 }
719 } else {
720 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
721 sh->beta_offset = s->ps.pps->beta_offset;
722 sh->tc_offset = s->ps.pps->tc_offset;
723 }
724 } else {
725 sh->disable_deblocking_filter_flag = 0;
726 sh->beta_offset = 0;
727 sh->tc_offset = 0;
728 }
729
730 if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
731 (sh->slice_sample_adaptive_offset_flag[0] ||
732 sh->slice_sample_adaptive_offset_flag[1] ||
733 !sh->disable_deblocking_filter_flag)) {
734 sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
735 } else {
736 sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
737 }
738 } else if (!s->slice_initialized) {
739 av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
740 return AVERROR_INVALIDDATA;
741 }
742
743 sh->num_entry_point_offsets = 0;
744 if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
745 sh->num_entry_point_offsets = get_ue_golomb_long(gb);
746 if (sh->num_entry_point_offsets > 0) {
747 int offset_len = get_ue_golomb_long(gb) + 1;
748
749 for (i = 0; i < sh->num_entry_point_offsets; i++)
750 skip_bits(gb, offset_len);
751 }
752 }
753
754 if (s->ps.pps->slice_header_extension_present_flag) {
755 unsigned int length = get_ue_golomb_long(gb);
756 for (i = 0; i < length; i++)
757 skip_bits(gb, 8); // slice_header_extension_data_byte
758 }
759
760 // Inferred parameters
761 sh->slice_qp = 26 + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
762 if (sh->slice_qp > 51 ||
763 sh->slice_qp < -s->ps.sps->qp_bd_offset) {
764 av_log(s->avctx, AV_LOG_ERROR,
765 "The slice_qp %d is outside the valid range "
766 "[%d, 51].\n",
767 sh->slice_qp,
768 -s->ps.sps->qp_bd_offset);
769 return AVERROR_INVALIDDATA;
770 }
771
772 sh->slice_ctb_addr_rs = sh->slice_segment_addr;
773
774 if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
775 av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
776 return AVERROR_INVALIDDATA;
777 }
778
779 s->HEVClc.first_qp_group = !s->sh.dependent_slice_segment_flag;
780
781 if (!s->ps.pps->cu_qp_delta_enabled_flag)
782 s->HEVClc.qp_y = FFUMOD(s->sh.slice_qp + 52 + 2 * s->ps.sps->qp_bd_offset,
783 52 + s->ps.sps->qp_bd_offset) - s->ps.sps->qp_bd_offset;
784
785 s->slice_initialized = 1;
786
787 return 0;
788 }
789
790 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
791
792 #define SET_SAO(elem, value) \
793 do { \
794 if (!sao_merge_up_flag && !sao_merge_left_flag) \
795 sao->elem = value; \
796 else if (sao_merge_left_flag) \
797 sao->elem = CTB(s->sao, rx-1, ry).elem; \
798 else if (sao_merge_up_flag) \
799 sao->elem = CTB(s->sao, rx, ry-1).elem; \
800 else \
801 sao->elem = 0; \
802 } while (0)
803
804 static void hls_sao_param(HEVCContext *s, int rx, int ry)
805 {
806 HEVCLocalContext *lc = &s->HEVClc;
807 int sao_merge_left_flag = 0;
808 int sao_merge_up_flag = 0;
809 int shift = s->ps.sps->bit_depth - FFMIN(s->ps.sps->bit_depth, 10);
810 SAOParams *sao = &CTB(s->sao, rx, ry);
811 int c_idx, i;
812
813 if (s->sh.slice_sample_adaptive_offset_flag[0] ||
814 s->sh.slice_sample_adaptive_offset_flag[1]) {
815 if (rx > 0) {
816 if (lc->ctb_left_flag)
817 sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
818 }
819 if (ry > 0 && !sao_merge_left_flag) {
820 if (lc->ctb_up_flag)
821 sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
822 }
823 }
824
825 for (c_idx = 0; c_idx < 3; c_idx++) {
826 if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
827 sao->type_idx[c_idx] = SAO_NOT_APPLIED;
828 continue;
829 }
830
831 if (c_idx == 2) {
832 sao->type_idx[2] = sao->type_idx[1];
833 sao->eo_class[2] = sao->eo_class[1];
834 } else {
835 SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
836 }
837
838 if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
839 continue;
840
841 for (i = 0; i < 4; i++)
842 SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
843
844 if (sao->type_idx[c_idx] == SAO_BAND) {
845 for (i = 0; i < 4; i++) {
846 if (sao->offset_abs[c_idx][i]) {
847 SET_SAO(offset_sign[c_idx][i],
848 ff_hevc_sao_offset_sign_decode(s));
849 } else {
850 sao->offset_sign[c_idx][i] = 0;
851 }
852 }
853 SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
854 } else if (c_idx != 2) {
855 SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
856 }
857
858 // Inferred parameters
859 sao->offset_val[c_idx][0] = 0;
860 for (i = 0; i < 4; i++) {
861 sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i] << shift;
862 if (sao->type_idx[c_idx] == SAO_EDGE) {
863 if (i > 1)
864 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
865 } else if (sao->offset_sign[c_idx][i]) {
866 sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
867 }
868 }
869 }
870 }
871
872 #undef SET_SAO
873 #undef CTB
874
875 static void hls_residual_coding(HEVCContext *s, int x0, int y0,
876 int log2_trafo_size, enum ScanType scan_idx,
877 int c_idx)
878 {
879 #define GET_COORD(offset, n) \
880 do { \
881 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
882 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
883 } while (0)
884 HEVCLocalContext *lc = &s->HEVClc;
885 int transform_skip_flag = 0;
886
887 int last_significant_coeff_x, last_significant_coeff_y;
888 int last_scan_pos;
889 int n_end;
890 int num_coeff = 0;
891 int greater1_ctx = 1;
892
893 int num_last_subset;
894 int x_cg_last_sig, y_cg_last_sig;
895
896 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
897
898 ptrdiff_t stride = s->frame->linesize[c_idx];
899 int hshift = s->ps.sps->hshift[c_idx];
900 int vshift = s->ps.sps->vshift[c_idx];
901 uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
902 ((x0 >> hshift) << s->ps.sps->pixel_shift)];
903 DECLARE_ALIGNED(32, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = { 0 };
904 DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = { { 0 } };
905
906 int trafo_size = 1 << log2_trafo_size;
907 int i, qp, shift, add, scale, scale_m;
908 static const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
909 const uint8_t *scale_matrix;
910 uint8_t dc_scale;
911
912 // Derive QP for dequant
913 if (!lc->cu.cu_transquant_bypass_flag) {
914 static const int qp_c[] = {
915 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37
916 };
917
918 static const uint8_t rem6[51 + 2 * 6 + 1] = {
919 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
920 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
921 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
922 };
923
924 static const uint8_t div6[51 + 2 * 6 + 1] = {
925 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
926 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
927 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
928 };
929 int qp_y = lc->qp_y;
930
931 if (c_idx == 0) {
932 qp = qp_y + s->ps.sps->qp_bd_offset;
933 } else {
934 int qp_i, offset;
935
936 if (c_idx == 1)
937 offset = s->ps.pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
938 else
939 offset = s->ps.pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
940
941 qp_i = av_clip(qp_y + offset, -s->ps.sps->qp_bd_offset, 57);
942 if (qp_i < 30)
943 qp = qp_i;
944 else if (qp_i > 43)
945 qp = qp_i - 6;
946 else
947 qp = qp_c[qp_i - 30];
948
949 qp += s->ps.sps->qp_bd_offset;
950 }
951
952 shift = s->ps.sps->bit_depth + log2_trafo_size - 5;
953 add = 1 << (shift - 1);
954 scale = level_scale[rem6[qp]] << (div6[qp]);
955 scale_m = 16; // default when no custom scaling lists.
956 dc_scale = 16;
957
958 if (s->ps.sps->scaling_list_enable_flag) {
959 const ScalingList *sl = s->ps.pps->scaling_list_data_present_flag ?
960 &s->ps.pps->scaling_list : &s->ps.sps->scaling_list;
961 int matrix_id = lc->cu.pred_mode != MODE_INTRA;
962
963 if (log2_trafo_size != 5)
964 matrix_id = 3 * matrix_id + c_idx;
965
966 scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
967 if (log2_trafo_size >= 4)
968 dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
969 }
970 }
971
972 if (s->ps.pps->transform_skip_enabled_flag &&
973 !lc->cu.cu_transquant_bypass_flag &&
974 log2_trafo_size == 2) {
975 transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
976 }
977
978 last_significant_coeff_x =
979 ff_hevc_last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
980 last_significant_coeff_y =
981 ff_hevc_last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
982
983 if (last_significant_coeff_x > 3) {
984 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
985 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
986 (2 + (last_significant_coeff_x & 1)) +
987 suffix;
988 }
989
990 if (last_significant_coeff_y > 3) {
991 int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
992 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
993 (2 + (last_significant_coeff_y & 1)) +
994 suffix;
995 }
996
997 if (scan_idx == SCAN_VERT)
998 FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
999
1000 x_cg_last_sig = last_significant_coeff_x >> 2;
1001 y_cg_last_sig = last_significant_coeff_y >> 2;
1002
1003 switch (scan_idx) {
1004 case SCAN_DIAG: {
1005 int last_x_c = last_significant_coeff_x & 3;
1006 int last_y_c = last_significant_coeff_y & 3;
1007
1008 scan_x_off = ff_hevc_diag_scan4x4_x;
1009 scan_y_off = ff_hevc_diag_scan4x4_y;
1010 num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1011 if (trafo_size == 4) {
1012 scan_x_cg = scan_1x1;
1013 scan_y_cg = scan_1x1;
1014 } else if (trafo_size == 8) {
1015 num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1016 scan_x_cg = diag_scan2x2_x;
1017 scan_y_cg = diag_scan2x2_y;
1018 } else if (trafo_size == 16) {
1019 num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1020 scan_x_cg = ff_hevc_diag_scan4x4_x;
1021 scan_y_cg = ff_hevc_diag_scan4x4_y;
1022 } else { // trafo_size == 32
1023 num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1024 scan_x_cg = ff_hevc_diag_scan8x8_x;
1025 scan_y_cg = ff_hevc_diag_scan8x8_y;
1026 }
1027 break;
1028 }
1029 case SCAN_HORIZ:
1030 scan_x_cg = horiz_scan2x2_x;
1031 scan_y_cg = horiz_scan2x2_y;
1032 scan_x_off = horiz_scan4x4_x;
1033 scan_y_off = horiz_scan4x4_y;
1034 num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1035 break;
1036 default: //SCAN_VERT
1037 scan_x_cg = horiz_scan2x2_y;
1038 scan_y_cg = horiz_scan2x2_x;
1039 scan_x_off = horiz_scan4x4_y;
1040 scan_y_off = horiz_scan4x4_x;
1041 num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1042 break;
1043 }
1044 num_coeff++;
1045 num_last_subset = (num_coeff - 1) >> 4;
1046
1047 for (i = num_last_subset; i >= 0; i--) {
1048 int n, m;
1049 int x_cg, y_cg, x_c, y_c;
1050 int implicit_non_zero_coeff = 0;
1051 int64_t trans_coeff_level;
1052 int prev_sig = 0;
1053 int offset = i << 4;
1054
1055 uint8_t significant_coeff_flag_idx[16];
1056 uint8_t nb_significant_coeff_flag = 0;
1057
1058 x_cg = scan_x_cg[i];
1059 y_cg = scan_y_cg[i];
1060
1061 if (i < num_last_subset && i > 0) {
1062 int ctx_cg = 0;
1063 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1064 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1065 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1066 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1067
1068 significant_coeff_group_flag[x_cg][y_cg] =
1069 ff_hevc_significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
1070 implicit_non_zero_coeff = 1;
1071 } else {
1072 significant_coeff_group_flag[x_cg][y_cg] =
1073 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1074 (x_cg == 0 && y_cg == 0));
1075 }
1076
1077 last_scan_pos = num_coeff - offset - 1;
1078
1079 if (i == num_last_subset) {
1080 n_end = last_scan_pos - 1;
1081 significant_coeff_flag_idx[0] = last_scan_pos;
1082 nb_significant_coeff_flag = 1;
1083 } else {
1084 n_end = 15;
1085 }
1086
1087 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1088 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1089 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1090 prev_sig += significant_coeff_group_flag[x_cg][y_cg + 1] << 1;
1091
1092 for (n = n_end; n >= 0; n--) {
1093 GET_COORD(offset, n);
1094
1095 if (significant_coeff_group_flag[x_cg][y_cg] &&
1096 (n > 0 || implicit_non_zero_coeff == 0)) {
1097 if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c,
1098 log2_trafo_size,
1099 scan_idx,
1100 prev_sig) == 1) {
1101 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1102 nb_significant_coeff_flag++;
1103 implicit_non_zero_coeff = 0;
1104 }
1105 } else {
1106 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1107 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1108 significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1109 nb_significant_coeff_flag++;
1110 }
1111 }
1112 }
1113
1114 n_end = nb_significant_coeff_flag;
1115
1116 if (n_end) {
1117 int first_nz_pos_in_cg = 16;
1118 int last_nz_pos_in_cg = -1;
1119 int c_rice_param = 0;
1120 int first_greater1_coeff_idx = -1;
1121 uint8_t coeff_abs_level_greater1_flag[16] = { 0 };
1122 uint16_t coeff_sign_flag;
1123 int sum_abs = 0;
1124 int sign_hidden = 0;
1125
1126 // initialize first elem of coeff_bas_level_greater1_flag
1127 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1128
1129 if (!(i == num_last_subset) && greater1_ctx == 0)
1130 ctx_set++;
1131 greater1_ctx = 1;
1132 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1133
1134 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1135 int n_idx = significant_coeff_flag_idx[m];
1136 int inc = (ctx_set << 2) + greater1_ctx;
1137 coeff_abs_level_greater1_flag[n_idx] =
1138 ff_hevc_coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
1139 if (coeff_abs_level_greater1_flag[n_idx]) {
1140 greater1_ctx = 0;
1141 } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1142 greater1_ctx++;
1143 }
1144
1145 if (coeff_abs_level_greater1_flag[n_idx] &&
1146 first_greater1_coeff_idx == -1)
1147 first_greater1_coeff_idx = n_idx;
1148 }
1149 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1150 sign_hidden = last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1151 !lc->cu.cu_transquant_bypass_flag;
1152
1153 if (first_greater1_coeff_idx != -1) {
1154 coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1155 }
1156 if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden) {
1157 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1158 } else {
1159 coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1160 }
1161
1162 for (m = 0; m < n_end; m++) {
1163 n = significant_coeff_flag_idx[m];
1164 GET_COORD(offset, n);
1165 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1166 if (trans_coeff_level == ((m < 8) ?
1167 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1168 int last_coeff_abs_level_remaining = ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param);
1169
1170 trans_coeff_level += last_coeff_abs_level_remaining;
1171 if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1172 c_rice_param = FFMIN(c_rice_param + 1, 4);
1173 }
1174 if (s->ps.pps->sign_data_hiding_flag && sign_hidden) {
1175 sum_abs += trans_coeff_level;
1176 if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1177 trans_coeff_level = -trans_coeff_level;
1178 }
1179 if (coeff_sign_flag >> 15)
1180 trans_coeff_level = -trans_coeff_level;
1181 coeff_sign_flag <<= 1;
1182 if (!lc->cu.cu_transquant_bypass_flag) {
1183 if (s->ps.sps->scaling_list_enable_flag) {
1184 if (y_c || x_c || log2_trafo_size < 4) {
1185 int pos;
1186 switch (log2_trafo_size) {
1187 case 3: pos = (y_c << 3) + x_c; break;
1188 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1189 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1190 default: pos = (y_c << 2) + x_c;
1191 }
1192 scale_m = scale_matrix[pos];
1193 } else {
1194 scale_m = dc_scale;
1195 }
1196 }
1197 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1198 if(trans_coeff_level < 0) {
1199 if((~trans_coeff_level) & 0xFffffffffff8000)
1200 trans_coeff_level = -32768;
1201 } else {
1202 if (trans_coeff_level & 0xffffffffffff8000)
1203 trans_coeff_level = 32767;
1204 }
1205 }
1206 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1207 }
1208 }
1209 }
1210
1211 if (!lc->cu.cu_transquant_bypass_flag) {
1212 if (transform_skip_flag)
1213 s->hevcdsp.dequant(coeffs);
1214 else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 &&
1215 log2_trafo_size == 2)
1216 s->hevcdsp.transform_4x4_luma(coeffs);
1217 else {
1218 int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
1219 if (max_xy == 0)
1220 s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
1221 else {
1222 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
1223 if (max_xy < 4)
1224 col_limit = FFMIN(4, col_limit);
1225 else if (max_xy < 8)
1226 col_limit = FFMIN(8, col_limit);
1227 else if (max_xy < 12)
1228 col_limit = FFMIN(24, col_limit);
1229 s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
1230 }
1231 }
1232 }
1233 s->hevcdsp.add_residual[log2_trafo_size - 2](dst, coeffs, stride);
1234 }
1235
1236 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1237 int xBase, int yBase, int cb_xBase, int cb_yBase,
1238 int log2_cb_size, int log2_trafo_size,
1239 int blk_idx, int cbf_luma, int cbf_cb, int cbf_cr)
1240 {
1241 HEVCLocalContext *lc = &s->HEVClc;
1242
1243 if (lc->cu.pred_mode == MODE_INTRA) {
1244 int trafo_size = 1 << log2_trafo_size;
1245 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1246
1247 s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
1248 if (log2_trafo_size > 2) {
1249 trafo_size = trafo_size << (s->ps.sps->hshift[1] - 1);
1250 ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1251 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 1);
1252 s->hpc.intra_pred[log2_trafo_size - 3](s, x0, y0, 2);
1253 } else if (blk_idx == 3) {
1254 trafo_size = trafo_size << s->ps.sps->hshift[1];
1255 ff_hevc_set_neighbour_available(s, xBase, yBase,
1256 trafo_size, trafo_size);
1257 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1258 s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1259 }
1260 }
1261
1262 if (cbf_luma || cbf_cb || cbf_cr) {
1263 int scan_idx = SCAN_DIAG;
1264 int scan_idx_c = SCAN_DIAG;
1265
1266 if (s->ps.pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1267 lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
1268 if (lc->tu.cu_qp_delta != 0)
1269 if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1270 lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1271 lc->tu.is_cu_qp_delta_coded = 1;
1272
1273 if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
1274 lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
1275 av_log(s->avctx, AV_LOG_ERROR,
1276 "The cu_qp_delta %d is outside the valid range "
1277 "[%d, %d].\n",
1278 lc->tu.cu_qp_delta,
1279 -(26 + s->ps.sps->qp_bd_offset / 2),
1280 (25 + s->ps.sps->qp_bd_offset / 2));
1281 return AVERROR_INVALIDDATA;
1282 }
1283
1284 ff_hevc_set_qPy(s, x0, y0, cb_xBase, cb_yBase, log2_cb_size);
1285 }
1286
1287 if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1288 if (lc->tu.cur_intra_pred_mode >= 6 &&
1289 lc->tu.cur_intra_pred_mode <= 14) {
1290 scan_idx = SCAN_VERT;
1291 } else if (lc->tu.cur_intra_pred_mode >= 22 &&
1292 lc->tu.cur_intra_pred_mode <= 30) {
1293 scan_idx = SCAN_HORIZ;
1294 }
1295
1296 if (lc->pu.intra_pred_mode_c >= 6 &&
1297 lc->pu.intra_pred_mode_c <= 14) {
1298 scan_idx_c = SCAN_VERT;
1299 } else if (lc->pu.intra_pred_mode_c >= 22 &&
1300 lc->pu.intra_pred_mode_c <= 30) {
1301 scan_idx_c = SCAN_HORIZ;
1302 }
1303 }
1304
1305 if (cbf_luma)
1306 hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1307 if (log2_trafo_size > 2) {
1308 if (cbf_cb)
1309 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 1);
1310 if (cbf_cr)
1311 hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 2);
1312 } else if (blk_idx == 3) {
1313 if (cbf_cb)
1314 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 1);
1315 if (cbf_cr)
1316 hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 2);
1317 }
1318 }
1319 return 0;
1320 }
1321
1322 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1323 {
1324 int cb_size = 1 << log2_cb_size;
1325 int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1326
1327 int min_pu_width = s->ps.sps->min_pu_width;
1328 int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1329 int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1330 int i, j;
1331
1332 for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1333 for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1334 s->is_pcm[i + j * min_pu_width] = 2;
1335 }
1336
1337 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1338 int xBase, int yBase, int cb_xBase, int cb_yBase,
1339 int log2_cb_size, int log2_trafo_size,
1340 int trafo_depth, int blk_idx,
1341 int cbf_cb, int cbf_cr)
1342 {
1343 HEVCLocalContext *lc = &s->HEVClc;
1344 uint8_t split_transform_flag;
1345 int ret;
1346
1347 if (lc->cu.intra_split_flag) {
1348 if (trafo_depth == 1)
1349 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1350 } else {
1351 lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[0];
1352 }
1353
1354 if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1355 log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1356 trafo_depth < lc->cu.max_trafo_depth &&
1357 !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1358 split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1359 } else {
1360 int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1361 lc->cu.pred_mode == MODE_INTER &&
1362 lc->cu.part_mode != PART_2Nx2N &&
1363 trafo_depth == 0;
1364
1365 split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1366 (lc->cu.intra_split_flag && trafo_depth == 0) ||
1367 inter_split;
1368 }
1369
1370 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cb))
1371 cbf_cb = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1372 else if (log2_trafo_size > 2 || trafo_depth == 0)
1373 cbf_cb = 0;
1374 if (log2_trafo_size > 2 && (trafo_depth == 0 || cbf_cr))
1375 cbf_cr = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1376 else if (log2_trafo_size > 2 || trafo_depth == 0)
1377 cbf_cr = 0;
1378
1379 if (split_transform_flag) {
1380 const int trafo_size_split = 1 << (log2_trafo_size - 1);
1381 const int x1 = x0 + trafo_size_split;
1382 const int y1 = y0 + trafo_size_split;
1383
1384 #define SUBDIVIDE(x, y, idx) \
1385 do { \
1386 ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1387 log2_trafo_size - 1, trafo_depth + 1, idx, \
1388 cbf_cb, cbf_cr); \
1389 if (ret < 0) \
1390 return ret; \
1391 } while (0)
1392
1393 SUBDIVIDE(x0, y0, 0);
1394 SUBDIVIDE(x1, y0, 1);
1395 SUBDIVIDE(x0, y1, 2);
1396 SUBDIVIDE(x1, y1, 3);
1397
1398 #undef SUBDIVIDE
1399 } else {
1400 int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1401 int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1402 int min_tu_width = s->ps.sps->min_tb_width;
1403 int cbf_luma = 1;
1404
1405 if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1406 cbf_cb || cbf_cr)
1407 cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1408
1409 ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1410 log2_cb_size, log2_trafo_size,
1411 blk_idx, cbf_luma, cbf_cb, cbf_cr);
1412 if (ret < 0)
1413 return ret;
1414 // TODO: store cbf_luma somewhere else
1415 if (cbf_luma) {
1416 int i, j;
1417 for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1418 for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1419 int x_tu = (x0 + j) >> log2_min_tu_size;
1420 int y_tu = (y0 + i) >> log2_min_tu_size;
1421 s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1422 }
1423 }
1424 if (!s->sh.disable_deblocking_filter_flag) {
1425 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1426 if (s->ps.pps->transquant_bypass_enable_flag &&
1427 lc->cu.cu_transquant_bypass_flag)
1428 set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1429 }
1430 }
1431 return 0;
1432 }
1433
1434 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1435 {
1436 //TODO: non-4:2:0 support
1437 HEVCLocalContext *lc = &s->HEVClc;
1438 GetBitContext gb;
1439 int cb_size = 1 << log2_cb_size;
1440 ptrdiff_t stride0 = s->frame->linesize[0];
1441 ptrdiff_t stride1 = s->frame->linesize[1];
1442 ptrdiff_t stride2 = s->frame->linesize[2];
1443 uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1444 uint8_t *dst1 = &s->frame->data[1][(y0 >> s->ps.sps->vshift[1]) * stride1 + ((x0 >> s->ps.sps->hshift[1]) << s->ps.sps->pixel_shift)];
1445 uint8_t *dst2 = &s->frame->data[2][(y0 >> s->ps.sps->vshift[2]) * stride2 + ((x0 >> s->ps.sps->hshift[2]) << s->ps.sps->pixel_shift)];
1446
1447 int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth + ((cb_size * cb_size) >> 1) * s->ps.sps->pcm.bit_depth_chroma;
1448 const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1449 int ret;
1450
1451 if (!s->sh.disable_deblocking_filter_flag)
1452 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1453
1454 ret = init_get_bits(&gb, pcm, length);
1455 if (ret < 0)
1456 return ret;
1457
1458 s->hevcdsp.put_pcm(dst0, stride0, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1459 s->hevcdsp.put_pcm(dst1, stride1, cb_size / 2, &gb, s->ps.sps->pcm.bit_depth_chroma);
1460 s->hevcdsp.put_pcm(dst2, stride2, cb_size / 2, &gb, s->ps.sps->pcm.bit_depth_chroma);
1461 return 0;
1462 }
1463
1464 static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1465 {
1466 HEVCLocalContext *lc = &s->HEVClc;
1467 int x = ff_hevc_abs_mvd_greater0_flag_decode(s);
1468 int y = ff_hevc_abs_mvd_greater0_flag_decode(s);
1469
1470 if (x)
1471 x += ff_hevc_abs_mvd_greater1_flag_decode(s);
1472 if (y)
1473 y += ff_hevc_abs_mvd_greater1_flag_decode(s);
1474
1475 switch (x) {
1476 case 2: lc->pu.mvd.x = ff_hevc_mvd_decode(s); break;
1477 case 1: lc->pu.mvd.x = ff_hevc_mvd_sign_flag_decode(s); break;
1478 case 0: lc->pu.mvd.x = 0; break;
1479 }
1480
1481 switch (y) {
1482 case 2: lc->pu.mvd.y = ff_hevc_mvd_decode(s); break;
1483 case 1: lc->pu.mvd.y = ff_hevc_mvd_sign_flag_decode(s); break;
1484 case 0: lc->pu.mvd.y = 0; break;
1485 }
1486 }
1487
1488 /**
1489 * 8.5.3.2.2.1 Luma sample interpolation process
1490 *
1491 * @param s HEVC decoding context
1492 * @param dst target buffer for block data at block position
1493 * @param dststride stride of the dst buffer
1494 * @param ref reference picture buffer at origin (0, 0)
1495 * @param mv motion vector (relative to block position) to get pixel data from
1496 * @param x_off horizontal position of block from origin (0, 0)
1497 * @param y_off vertical position of block from origin (0, 0)
1498 * @param block_w width of block
1499 * @param block_h height of block
1500 */
1501 static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride,
1502 AVFrame *ref, const Mv *mv, int x_off, int y_off,
1503 int block_w, int block_h, int pred_idx)
1504 {
1505 HEVCLocalContext *lc = &s->HEVClc;
1506 uint8_t *src = ref->data[0];
1507 ptrdiff_t srcstride = ref->linesize[0];
1508 int pic_width = s->ps.sps->width;
1509 int pic_height = s->ps.sps->height;
1510
1511 int mx = mv->x & 3;
1512 int my = mv->y & 3;
1513 int extra_left = ff_hevc_qpel_extra_before[mx];
1514 int extra_top = ff_hevc_qpel_extra_before[my];
1515
1516 x_off += mv->x >> 2;
1517 y_off += mv->y >> 2;
1518 src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1519
1520 if (x_off < extra_left || y_off < extra_top ||
1521 x_off >= pic_width - block_w - ff_hevc_qpel_extra_after[mx] ||
1522 y_off >= pic_height - block_h - ff_hevc_qpel_extra_after[my]) {
1523 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1524 int offset = extra_top * srcstride + (extra_left << s->ps.sps->pixel_shift);
1525 int buf_offset = extra_top *
1526 edge_emu_stride + (extra_left << s->ps.sps->pixel_shift);
1527
1528 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1529 edge_emu_stride, srcstride,
1530 block_w + ff_hevc_qpel_extra[mx],
1531 block_h + ff_hevc_qpel_extra[my],
1532 x_off - extra_left, y_off - extra_top,
1533 pic_width, pic_height);
1534 src = lc->edge_emu_buffer + buf_offset;
1535 srcstride = edge_emu_stride;
1536 }
1537 s->hevcdsp.put_hevc_qpel[!!my][!!mx][pred_idx](dst, dststride, src, srcstride,
1538 block_h, mx, my, lc->mc_buffer);
1539 }
1540
1541 /**
1542 * 8.5.3.2.2.2 Chroma sample interpolation process
1543 *
1544 * @param s HEVC decoding context
1545 * @param dst1 target buffer for block data at block position (U plane)
1546 * @param dst2 target buffer for block data at block position (V plane)
1547 * @param dststride stride of the dst1 and dst2 buffers
1548 * @param ref reference picture buffer at origin (0, 0)
1549 * @param mv motion vector (relative to block position) to get pixel data from
1550 * @param x_off horizontal position of block from origin (0, 0)
1551 * @param y_off vertical position of block from origin (0, 0)
1552 * @param block_w width of block
1553 * @param block_h height of block
1554 */
1555 static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1556 ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
1557 int x_off, int y_off, int block_w, int block_h, int pred_idx)
1558 {
1559 HEVCLocalContext *lc = &s->HEVClc;
1560 uint8_t *src1 = ref->data[1];
1561 uint8_t *src2 = ref->data[2];
1562 ptrdiff_t src1stride = ref->linesize[1];
1563 ptrdiff_t src2stride = ref->linesize[2];
1564 int pic_width = s->ps.sps->width >> 1;
1565 int pic_height = s->ps.sps->height >> 1;
1566
1567 int mx = mv->x & 7;
1568 int my = mv->y & 7;
1569
1570 x_off += mv->x >> 3;
1571 y_off += mv->y >> 3;
1572 src1 += y_off * src1stride + (x_off * (1 << s->ps.sps->pixel_shift));
1573 src2 += y_off * src2stride + (x_off * (1 << s->ps.sps->pixel_shift));
1574
1575 if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1576 x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1577 y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1578 const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1579 int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1580 int buf_offset1 = EPEL_EXTRA_BEFORE *
1581 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1582 int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1583 int buf_offset2 = EPEL_EXTRA_BEFORE *
1584 (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1585
1586 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1587 edge_emu_stride, src1stride,
1588 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1589 x_off - EPEL_EXTRA_BEFORE,
1590 y_off - EPEL_EXTRA_BEFORE,
1591 pic_width, pic_height);
1592
1593 src1 = lc->edge_emu_buffer + buf_offset1;
1594 src1stride = edge_emu_stride;
1595 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst1, dststride, src1, src1stride,
1596 block_h, mx, my, lc->mc_buffer);
1597
1598 s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2,
1599 edge_emu_stride, src2stride,
1600 block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1601 x_off - EPEL_EXTRA_BEFORE,
1602 y_off - EPEL_EXTRA_BEFORE,
1603 pic_width, pic_height);
1604 src2 = lc->edge_emu_buffer + buf_offset2;
1605 src2stride = edge_emu_stride;
1606
1607 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst2, dststride, src2, src2stride,
1608 block_h, mx, my, lc->mc_buffer);
1609 } else {
1610 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst1, dststride, src1, src1stride,
1611 block_h, mx, my, lc->mc_buffer);
1612 s->hevcdsp.put_hevc_epel[!!my][!!mx][pred_idx](dst2, dststride, src2, src2stride,
1613 block_h, mx, my, lc->mc_buffer);
1614 }
1615 }
1616
1617 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1618 const Mv *mv, int y0, int height)
1619 {
1620 int y = (mv->y >> 2) + y0 + height + 9;
1621 ff_thread_await_progress(&ref->tf, y, 0);
1622 }
1623
1624 static void hevc_luma_mv_mpv_mode(HEVCContext *s, int x0, int y0, int nPbW,
1625 int nPbH, int log2_cb_size, int part_idx,
1626 int merge_idx, MvField *mv)
1627 {
1628 HEVCLocalContext *lc = &s->HEVClc;
1629 enum InterPredIdc inter_pred_idc = PRED_L0;
1630 int mvp_flag;
1631
1632 ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1633 if (s->sh.slice_type == B_SLICE)
1634 inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1635
1636 if (inter_pred_idc != PRED_L1) {
1637 if (s->sh.nb_refs[L0])
1638 mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1639
1640 mv->pred_flag[0] = 1;
1641 hls_mvd_coding(s, x0, y0, 0);
1642 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1643 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1644 part_idx, merge_idx, mv, mvp_flag, 0);
1645 mv->mv[0].x += lc->pu.mvd.x;
1646 mv->mv[0].y += lc->pu.mvd.y;
1647 }
1648
1649 if (inter_pred_idc != PRED_L0) {
1650 if (s->sh.nb_refs[L1])
1651 mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1652
1653 if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1654 AV_ZERO32(&lc->pu.mvd);
1655 } else {
1656 hls_mvd_coding(s, x0, y0, 1);
1657 }
1658
1659 mv->pred_flag[1] = 1;
1660 mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1661 ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1662 part_idx, merge_idx, mv, mvp_flag, 1);
1663 mv->mv[1].x += lc->pu.mvd.x;
1664 mv->mv[1].y += lc->pu.mvd.y;
1665 }
1666 }
1667
1668 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1669 int nPbW, int nPbH,
1670 int log2_cb_size, int partIdx)
1671 {
1672 static const int pred_indices[] = {
1673 [4] = 0, [8] = 1, [12] = 2, [16] = 3, [24] = 4, [32] = 5, [48] = 6, [64] = 7,
1674 };
1675 const int pred_idx = pred_indices[nPbW];
1676
1677 #define POS(c_idx, x, y) \
1678 &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1679 (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1680 HEVCLocalContext *lc = &s->HEVClc;
1681 int merge_idx = 0;
1682 struct MvField current_mv = {{{ 0 }}};
1683
1684 int min_pu_width = s->ps.sps->min_pu_width;
1685
1686 MvField *tab_mvf = s->ref->tab_mvf;
1687 RefPicList *refPicList = s->ref->refPicList;
1688 HEVCFrame *ref0, *ref1;
1689
1690 ptrdiff_t tmpstride = MAX_PB_SIZE * sizeof(int16_t);
1691
1692 uint8_t *dst0 = POS(0, x0, y0);
1693 uint8_t *dst1 = POS(1, x0, y0);
1694 uint8_t *dst2 = POS(2, x0, y0);
1695 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1696 int min_cb_width = s->ps.sps->min_cb_width;
1697 int x_cb = x0 >> log2_min_cb_size;
1698 int y_cb = y0 >> log2_min_cb_size;
1699 int x_pu, y_pu;
1700 int i, j;
1701
1702 int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1703
1704 if (!skip_flag)
1705 lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1706
1707 if (skip_flag || lc->pu.merge_flag) {
1708 if (s->sh.max_num_merge_cand > 1)
1709 merge_idx = ff_hevc_merge_idx_decode(s);
1710 else
1711 merge_idx = 0;
1712
1713 ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1714 partIdx, merge_idx, &current_mv);
1715 } else {
1716 hevc_luma_mv_mpv_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1717 partIdx, merge_idx, &current_mv);
1718 }
1719
1720 x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1721 y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1722
1723 for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1724 for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1725 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1726
1727 if (current_mv.pred_flag[0]) {
1728 ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1729 if (!ref0)
1730 return;
1731 hevc_await_progress(s, ref0, &current_mv.mv[0], y0, nPbH);
1732 }
1733 if (current_mv.pred_flag[1]) {
1734 ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1735 if (!ref1)
1736 return;
1737 hevc_await_progress(s, ref1, &current_mv.mv[1], y0, nPbH);
1738 }
1739
1740 if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1741 DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1742 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1743
1744 luma_mc(s, tmp, tmpstride, ref0->frame,
1745 &current_mv.mv[0], x0, y0, nPbW, nPbH, pred_idx);
1746
1747 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1748 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1749 s->hevcdsp.weighted_pred[pred_idx](s->sh.luma_log2_weight_denom,
1750 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1751 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1752 dst0, s->frame->linesize[0], tmp,
1753 tmpstride, nPbH);
1754 } else {
1755 s->hevcdsp.put_unweighted_pred[pred_idx](dst0, s->frame->linesize[0], tmp, tmpstride, nPbH);
1756 }
1757 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1758 &current_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
1759
1760 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1761 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1762 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1763 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1764 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1765 dst1, s->frame->linesize[1], tmp, tmpstride,
1766 nPbH / 2);
1767 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1768 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1769 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1770 dst2, s->frame->linesize[2], tmp2, tmpstride,
1771 nPbH / 2);
1772 } else {
1773 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst1, s->frame->linesize[1], tmp, tmpstride, nPbH / 2);
1774 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst2, s->frame->linesize[2], tmp2, tmpstride, nPbH / 2);
1775 }
1776 } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1777 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1778 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1779
1780 luma_mc(s, tmp, tmpstride, ref1->frame,
1781 &current_mv.mv[1], x0, y0, nPbW, nPbH, pred_idx);
1782
1783 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1784 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1785 s->hevcdsp.weighted_pred[pred_idx](s->sh.luma_log2_weight_denom,
1786 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1787 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1788 dst0, s->frame->linesize[0], tmp, tmpstride,
1789 nPbH);
1790 } else {
1791 s->hevcdsp.put_unweighted_pred[pred_idx](dst0, s->frame->linesize[0], tmp, tmpstride, nPbH);
1792 }
1793
1794 chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
1795 &current_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
1796
1797 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1798 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1799 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1800 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1801 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1802 dst1, s->frame->linesize[1], tmp, tmpstride, nPbH/2);
1803 s->hevcdsp.weighted_pred_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1804 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1805 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1806 dst2, s->frame->linesize[2], tmp2, tmpstride, nPbH/2);
1807 } else {
1808 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst1, s->frame->linesize[1], tmp, tmpstride, nPbH / 2);
1809 s->hevcdsp.put_unweighted_pred_chroma[pred_idx](dst2, s->frame->linesize[2], tmp2, tmpstride, nPbH / 2);
1810 }
1811 } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1812 DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1813 DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1814 DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1815 DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
1816
1817 luma_mc(s, tmp, tmpstride, ref0->frame,
1818 &current_mv.mv[0], x0, y0, nPbW, nPbH, pred_idx);
1819 luma_mc(s, tmp2, tmpstride, ref1->frame,
1820 &current_mv.mv[1], x0, y0, nPbW, nPbH, pred_idx);
1821
1822 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1823 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1824 s->hevcdsp.weighted_pred_avg[pred_idx](s->sh.luma_log2_weight_denom,
1825 s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1826 s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1827 s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1828 s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1829 dst0, s->frame->linesize[0],
1830 tmp, tmp2, tmpstride, nPbH);
1831 } else {
1832 s->hevcdsp.put_unweighted_pred_avg[pred_idx](dst0, s->frame->linesize[0],
1833 tmp, tmp2, tmpstride, nPbH);
1834 }
1835
1836 chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1837 &current_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
1838 chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
1839 &current_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2, pred_idx);
1840
1841 if ((s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1842 (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag)) {
1843 s->hevcdsp.weighted_pred_avg_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1844 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1845 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1846 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1847 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1848 dst1, s->frame->linesize[1], tmp, tmp3,
1849 tmpstride, nPbH / 2);
1850 s->hevcdsp.weighted_pred_avg_chroma[pred_idx](s->sh.chroma_log2_weight_denom,
1851 s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1852 s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1853 s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1854 s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1855 dst2, s->frame->linesize[2], tmp2, tmp4,
1856 tmpstride, nPbH / 2);
1857 } else {
1858 s->hevcdsp.put_unweighted_pred_avg_chroma[pred_idx](dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbH/2);
1859 s->hevcdsp.put_unweighted_pred_avg_chroma[pred_idx](dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbH/2);
1860 }
1861 }
1862 }
1863
1864 /**
1865 * 8.4.1
1866 */
1867 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1868 int prev_intra_luma_pred_flag)
1869 {
1870 HEVCLocalContext *lc = &s->HEVClc;
1871 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1872 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1873 int min_pu_width = s->ps.sps->min_pu_width;
1874 int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1875 int x0b = x0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
1876 int y0b = y0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
1877
1878 int cand_up = (lc->ctb_up_flag || y0b) ?
1879 s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1880 int cand_left = (lc->ctb_left_flag || x0b) ?
1881 s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1882
1883 int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1884
1885 MvField *tab_mvf = s->ref->tab_mvf;
1886 int intra_pred_mode;
1887 int candidate[3];
1888 int i, j;
1889
1890 // intra_pred_mode prediction does not cross vertical CTB boundaries
1891 if ((y0 - 1) < y_ctb)
1892 cand_up = INTRA_DC;
1893
1894 if (cand_left == cand_up) {
1895 if (cand_left < 2) {
1896 candidate[0] = INTRA_PLANAR;
1897 candidate[1] = INTRA_DC;
1898 candidate[2] = INTRA_ANGULAR_26;
1899 } else {
1900 candidate[0] = cand_left;
1901 candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1902 candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1903 }
1904 } else {
1905 candidate[0] = cand_left;
1906 candidate[1] = cand_up;
1907 if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1908 candidate[2] = INTRA_PLANAR;
1909 } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1910 candidate[2] = INTRA_DC;
1911 } else {
1912 candidate[2] = INTRA_ANGULAR_26;
1913 }
1914 }
1915
1916 if (prev_intra_luma_pred_flag) {
1917 intra_pred_mode = candidate[lc->pu.mpm_idx];
1918 } else {
1919 if (candidate[0] > candidate[1])
1920 FFSWAP(uint8_t, candidate[0], candidate[1]);
1921 if (candidate[0] > candidate[2])
1922 FFSWAP(uint8_t, candidate[0], candidate[2]);
1923 if (candidate[1] > candidate[2])
1924 FFSWAP(uint8_t, candidate[1], candidate[2]);
1925
1926 intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1927 for (i = 0; i < 3; i++)
1928 if (intra_pred_mode >= candidate[i])
1929 intra_pred_mode++;
1930 }
1931
1932 /* write the intra prediction units into the mv array */
1933 if (!size_in_pus)
1934 size_in_pus = 1;
1935 for (i = 0; i < size_in_pus; i++) {
1936 memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1937 intra_pred_mode, size_in_pus);
1938
1939 for (j = 0; j < size_in_pus; j++) {
1940 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1941 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1942 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1943 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1944 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1945 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1946 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1947 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1948 tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1949 }
1950 }
1951
1952 return intra_pred_mode;
1953 }
1954
1955 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1956 int log2_cb_size, int ct_depth)
1957 {
1958 int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1959 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
1960 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
1961 int y;
1962
1963 for (y = 0; y < length; y++)
1964 memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
1965 ct_depth, length);
1966 }
1967
1968 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1969 int log2_cb_size)
1970 {
1971 HEVCLocalContext *lc = &s->HEVClc;
1972 static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1973 uint8_t prev_intra_luma_pred_flag[4];
1974 int split = lc->cu.part_mode == PART_NxN;
1975 int pb_size = (1 << log2_cb_size) >> split;
1976 int side = split + 1;
1977 int chroma_mode;
1978 int i, j;
1979
1980 for (i = 0; i < side; i++)
1981 for (j = 0; j < side; j++)
1982 prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1983
1984 for (i = 0; i < side; i++) {
1985 for (j = 0; j < side; j++) {
1986 if (prev_intra_luma_pred_flag[2 * i + j])
1987 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1988 else
1989 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1990
1991 lc->pu.intra_pred_mode[2 * i + j] =
1992 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1993 prev_intra_luma_pred_flag[2 * i + j]);
1994 }
1995 }
1996
1997 chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1998 if (chroma_mode != 4) {
1999 if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2000 lc->pu.intra_pred_mode_c = 34;
2001 else
2002 lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
2003 } else {
2004 lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
2005 }
2006 }
2007
2008 static void intra_prediction_unit_default_value(HEVCContext *s,
2009 int x0, int y0,
2010 int log2_cb_size)
2011 {
2012 HEVCLocalContext *lc = &s->HEVClc;
2013 int pb_size = 1 << log2_cb_size;
2014 int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
2015 int min_pu_width = s->ps.sps->min_pu_width;
2016 MvField *tab_mvf = s->ref->tab_mvf;
2017 int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2018 int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2019 int j, k;
2020
2021 if (size_in_pus == 0)
2022 size_in_pus = 1;
2023 for (j = 0; j < size_in_pus; j++) {
2024 memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2025 for (k = 0; k < size_in_pus; k++)
2026 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
2027 }
2028 }
2029
2030 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2031 {
2032 int cb_size = 1 << log2_cb_size;
2033 HEVCLocalContext *lc = &s->HEVClc;
2034 int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2035 int length = cb_size >> log2_min_cb_size;
2036 int min_cb_width = s->ps.sps->min_cb_width;
2037 int x_cb = x0 >> log2_min_cb_size;
2038 int y_cb = y0 >> log2_min_cb_size;
2039 int x, y, ret;
2040
2041 lc->cu.x = x0;
2042 lc->cu.y = y0;
2043 lc->cu.pred_mode = MODE_INTRA;
2044 lc->cu.part_mode = PART_2Nx2N;
2045 lc->cu.intra_split_flag = 0;
2046
2047 SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2048 for (x = 0; x < 4; x++)
2049 lc->pu.intra_pred_mode[x] = 1;
2050 if (s->ps.pps->transquant_bypass_enable_flag) {
2051 lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
2052 if (lc->cu.cu_transquant_bypass_flag)
2053 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2054 } else
2055 lc->cu.cu_transquant_bypass_flag = 0;
2056
2057 if (s->sh.slice_type != I_SLICE) {
2058 uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2059
2060 x = y_cb * min_cb_width + x_cb;
2061 for (y = 0; y < length; y++) {
2062 memset(&s->skip_flag[x], skip_flag, length);
2063 x += min_cb_width;
2064 }
2065 lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2066 }
2067
2068 if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2069 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2070 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2071
2072 if (!s->sh.disable_deblocking_filter_flag)
2073 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2074 } else {
2075 int pcm_flag = 0;
2076
2077 if (s->sh.slice_type != I_SLICE)
2078 lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2079 if (lc->cu.pred_mode != MODE_INTRA ||
2080 log2_cb_size == s->ps.sps->log2_min_cb_size) {
2081 lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2082 lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2083 lc->cu.pred_mode == MODE_INTRA;
2084 }
2085
2086 if (lc->cu.pred_mode == MODE_INTRA) {
2087 if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2088 log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2089 log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2090 pcm_flag = ff_hevc_pcm_flag_decode(s);
2091 }
2092 if (pcm_flag) {
2093 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2094 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2095 if (s->ps.sps->pcm.loop_filter_disable_flag)
2096 set_deblocking_bypass(s, x0, y0, log2_cb_size);
2097
2098 if (ret < 0)
2099 return ret;
2100 } else {
2101 intra_prediction_unit(s, x0, y0, log2_cb_size);
2102 }
2103 } else {
2104 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2105 switch (lc->cu.part_mode) {
2106 case PART_2Nx2N:
2107 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2108 break;
2109 case PART_2NxN:
2110 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0);
2111 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1);
2112 break;
2113 case PART_Nx2N:
2114 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0);
2115 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1);
2116 break;
2117 case PART_2NxnU:
2118 hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0);
2119 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1);
2120 break;
2121 case PART_2NxnD:
2122 hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0);
2123 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1);
2124 break;
2125 case PART_nLx2N:
2126 hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0);
2127 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1);
2128 break;
2129 case PART_nRx2N:
2130 hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0);
2131 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1);
2132 break;
2133 case PART_NxN:
2134 hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0);
2135 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1);
2136 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2);
2137 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2138 break;
2139 }
2140 }
2141
2142 if (!pcm_flag) {
2143 int rqt_root_cbf = 1;
2144
2145 if (lc->cu.pred_mode != MODE_INTRA &&
2146 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2147 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2148 }
2149 if (rqt_root_cbf) {
2150 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2151 s->ps.sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2152 s->ps.sps->max_transform_hierarchy_depth_inter;
2153 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2154 log2_cb_size,
2155 log2_cb_size, 0, 0, 0, 0);
2156 if (ret < 0)
2157 return ret;
2158 } else {
2159 if (!s->sh.disable_deblocking_filter_flag)
2160 ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2161 }
2162 }
2163 }
2164
2165 if (s->ps.pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2166 ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2167
2168 x = y_cb * min_cb_width + x_cb;
2169 for (y = 0; y < length; y++) {
2170 memset(&s->qp_y_tab[x], lc->qp_y, length);
2171 x += min_cb_width;
2172 }
2173
2174 set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2175
2176 return 0;
2177 }
2178
2179 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2180 int log2_cb_size, int cb_depth)
2181 {
2182 HEVCLocalContext *lc = &s->HEVClc;
2183 const int cb_size = 1 << log2_cb_size;
2184 int split_cu;
2185
2186 lc->ct.depth = cb_depth;
2187 if (x0 + cb_size <= s->ps.sps->width &&
2188 y0 + cb_size <= s->ps.sps->height &&
2189 log2_cb_size > s->ps.sps->log2_min_cb_size) {
2190 split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2191 } else {
2192 split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2193 }
2194 if (s->ps.pps->cu_qp_delta_enabled_flag &&
2195 log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2196 lc->tu.is_cu_qp_delta_coded = 0;
2197 lc->tu.cu_qp_delta = 0;
2198 }
2199
2200 if (split_cu) {
2201 const int cb_size_split = cb_size >> 1;
2202 const int x1 = x0 + cb_size_split;
2203 const int y1 = y0 + cb_size_split;
2204
2205 log2_cb_size--;
2206 cb_depth++;
2207
2208 #define SUBDIVIDE(x, y) \
2209 do { \
2210 if (x < s->ps.sps->width && y < s->ps.sps->height) { \
2211 int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2212 if (ret < 0) \
2213 return ret; \
2214 } \
2215 } while (0)
2216
2217 SUBDIVIDE(x0, y0);
2218 SUBDIVIDE(x1, y0);
2219 SUBDIVIDE(x0, y1);
2220 SUBDIVIDE(x1, y1);
2221 } else {
2222 int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2223 if (ret < 0)
2224 return ret;
2225 }
2226
2227 return 0;
2228 }
2229
2230 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2231 int ctb_addr_ts)
2232 {
2233 HEVCLocalContext *lc = &s->HEVClc;
2234 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2235 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2236 int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2237
2238 s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2239
2240 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
2241 if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2242 lc->first_qp_group = 1;
2243 lc->end_of_tiles_x = s->ps.sps->width;
2244 } else if (s->ps.pps->tiles_enabled_flag) {
2245 if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2246 int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2247 lc->start_of_tiles_x = x_ctb;
2248 lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2249 lc->first_qp_group = 1;
2250 }
2251 } else {
2252 lc->end_of_tiles_x = s->ps.sps->width;
2253 }
2254
2255 lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2256
2257 lc->boundary_flags = 0;
2258 if (s->ps.pps->tiles_enabled_flag) {
2259 if (x_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
2260 lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2261 if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2262 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2263 if (y_ctb > 0 && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->ps.sps->ctb_width]])
2264 lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2265 if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2266 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2267 } else {
2268 if (!ctb_addr_in_slice)
2269 lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2270 if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2271 lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2272 }
2273
2274 lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2275 lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2276 lc->ctb_up_right_flag = ((y_ctb > 0) && (ctb_addr_in_slice+1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 - s->ps.sps->ctb_width]]));
2277 lc->ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0) && (ctb_addr_in_slice-1 >= s->ps.sps->ctb_width) && (s->ps.pps->tile_id[ctb_addr_ts] == s->ps.pps->tile_id[s->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 - s->ps.sps->ctb_width]]));
2278 }
2279
2280 static int hls_slice_data(HEVCContext *s)
2281 {
2282 int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2283 int more_data = 1;
2284 int x_ctb = 0;
2285 int y_ctb = 0;
2286 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2287 int ret;
2288
2289 while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2290 int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2291
2292 x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2293 y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2294 hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2295
2296 ff_hevc_cabac_init(s, ctb_addr_ts);
2297
2298 hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2299
2300 s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2301 s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2302 s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2303
2304 ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2305 if (ret < 0)
2306 return ret;
2307 more_data = !ff_hevc_end_of_slice_flag_decode(s);
2308
2309 ctb_addr_ts++;
2310 ff_hevc_save_states(s, ctb_addr_ts);
2311 ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2312 }
2313
2314 if (x_ctb + ctb_size >= s->ps.sps->width &&
2315 y_ctb + ctb_size >= s->ps.sps->height)
2316 ff_hevc_hls_filter(s, x_ctb, y_ctb);
2317
2318 return ctb_addr_ts;
2319 }
2320
2321 static void restore_tqb_pixels(HEVCContext *s)
2322 {
2323 int min_pu_size = 1 << s->ps.sps->log2_min_pu_size;
2324 int x, y, c_idx;
2325
2326 for (c_idx = 0; c_idx < 3; c_idx++) {
2327 ptrdiff_t stride = s->frame->linesize[c_idx];
2328 int hshift = s->ps.sps->hshift[c_idx];
2329 int vshift = s->ps.sps->vshift[c_idx];
2330 for (y = 0; y < s->ps.sps->min_pu_height; y++) {
2331 for (x = 0; x < s->ps.sps->min_pu_width; x++) {
2332 if (s->is_pcm[y * s->ps.sps->min_pu_width + x]) {
2333 int n;
2334 int len = min_pu_size >> hshift;
2335 uint8_t *src = &s->frame->data[c_idx][((y << s->ps.sps->log2_min_pu_size) >> vshift) * stride + (((x << s->ps.sps->log2_min_pu_size) >> hshift) << s->ps.sps->pixel_shift)];
2336 uint8_t *dst = &s->sao_frame->data[c_idx][((y << s->ps.sps->log2_min_pu_size) >> vshift) * stride + (((x << s->ps.sps->log2_min_pu_size) >> hshift) << s->ps.sps->pixel_shift)];
2337 for (n = 0; n < (min_pu_size >> vshift); n++) {
2338 memcpy(dst, src, len);
2339 src += stride;
2340 dst += stride;
2341 }
2342 }
2343 }
2344 }
2345 }
2346 }
2347
2348 static int set_side_data(HEVCContext *s)
2349 {
2350 AVFrame *out = s->ref->frame;
2351
2352 if (s->sei_frame_packing_present &&
2353 s->frame_packing_arrangement_type >= 3 &&
2354 s->frame_packing_arrangement_type <= 5 &&
2355 s->content_interpretation_type > 0 &&
2356 s->content_interpretation_type < 3) {
2357 AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2358 if (!stereo)
2359 return AVERROR(ENOMEM);
2360
2361 switch (s->frame_packing_arrangement_type) {
2362 case 3:
2363 if (s->quincunx_subsampling)
2364 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2365 else
2366 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2367 break;
2368 case 4:
2369 stereo->type = AV_STEREO3D_TOPBOTTOM;
2370 break;
2371 case 5:
2372 stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2373 break;
2374 }
2375
2376 if (s->content_interpretation_type == 2)
2377 stereo->flags = AV_STEREO3D_FLAG_INVERT;
2378 }
2379
2380 if (s->sei_display_orientation_present &&
2381 (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2382 double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2383 AVFrameSideData *rotation = av_frame_new_side_data(out,
2384 AV_FRAME_DATA_DISPLAYMATRIX,
2385 sizeof(int32_t) * 9);
2386 if (!rotation)
2387 return AVERROR(ENOMEM);
2388
2389 av_display_rotation_set((int32_t *)rotation->data, angle);
2390 av_display_matrix_flip((int32_t *)rotation->data,
2391 s->sei_hflip, s->sei_vflip);
2392 }
2393
2394 return 0;
2395 }
2396
2397 static int hevc_frame_start(HEVCContext *s)
2398 {
2399 HEVCLocalContext *lc = &s->HEVClc;
2400 int ret;
2401
2402 memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2403 memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2404 memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2405 memset(s->is_pcm, 0, s->ps.sps->min_pu_width * s->ps.sps->min_pu_height);
2406
2407 lc->start_of_tiles_x = 0;
2408 s->is_decoded = 0;
2409 s->first_nal_type = s->nal_unit_type;
2410
2411 if (s->ps.pps->tiles_enabled_flag)
2412 lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2413
2414 ret = ff_hevc_set_new_ref(s, s->ps.sps->sao_enabled ? &s->sao_frame : &s->frame,
2415 s->poc);
2416 if (ret < 0)
2417 goto fail;
2418
2419 ret = ff_hevc_frame_rps(s);
2420 if (ret < 0) {
2421 av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2422 goto fail;
2423 }
2424
2425 s->ref->frame->key_frame = IS_IRAP(s);
2426
2427 ret = set_side_data(s);
2428 if (ret < 0)
2429 goto fail;
2430
2431 av_frame_unref(s->output_frame);
2432 ret = ff_hevc_output_frame(s, s->output_frame, 0);
2433 if (ret < 0)
2434 goto fail;
2435
2436 ff_thread_finish_setup(s->avctx);
2437
2438 return 0;
2439
2440 fail:
2441 if (s->ref)
2442 ff_hevc_unref_frame(s, s->ref, ~0);
2443 s->ref = NULL;
2444 return ret;
2445 }
2446
2447 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2448 {
2449 HEVCLocalContext *lc = &s->HEVClc;
2450 GetBitContext *gb = &lc->gb;
2451 int ctb_addr_ts, ret;
2452
2453 *gb = nal->gb;
2454 s->nal_unit_type = nal->type;
2455 s->temporal_id = nal->temporal_id;
2456
2457 switch (s->nal_unit_type) {
2458 case NAL_VPS:
2459 ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2460 if (ret < 0)
2461 goto fail;
2462 break;
2463 case NAL_SPS:
2464 ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2465 s->apply_defdispwin);
2466 if (ret < 0)
2467 goto fail;
2468 break;
2469 case NAL_PPS:
2470 ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2471 if (ret < 0)
2472 goto fail;
2473 break;
2474 case NAL_SEI_PREFIX:
2475 case NAL_SEI_SUFFIX:
2476 ret = ff_hevc_decode_nal_sei(s);
2477 if (ret < 0)
2478 goto fail;
2479 break;
2480 case NAL_TRAIL_R:
2481 case NAL_TRAIL_N:
2482 case NAL_TSA_N:
2483 case NAL_TSA_R:
2484 case NAL_STSA_N:
2485 case NAL_STSA_R:
2486 case NAL_BLA_W_LP:
2487 case NAL_BLA_W_RADL:
2488 case NAL_BLA_N_LP:
2489 case NAL_IDR_W_RADL:
2490 case NAL_IDR_N_LP:
2491 case NAL_CRA_NUT:
2492 case NAL_RADL_N:
2493 case NAL_RADL_R:
2494 case NAL_RASL_N:
2495 case NAL_RASL_R:
2496 ret = hls_slice_header(s);
2497 if (ret < 0)
2498 return ret;
2499
2500 if (s->max_ra == INT_MAX) {
2501 if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2502 s->max_ra = s->poc;
2503 } else {
2504 if (IS_IDR(s))
2505 s->max_ra = INT_MIN;
2506 }
2507 }
2508
2509 if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2510 s->poc <= s->max_ra) {
2511 s->is_decoded = 0;
2512 break;
2513 } else {
2514 if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2515 s->max_ra = INT_MIN;
2516 }
2517
2518 if (s->sh.first_slice_in_pic_flag) {
2519 ret = hevc_frame_start(s);
2520 if (ret < 0)
2521 return ret;
2522 } else if (!s->ref) {
2523 av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2524 goto fail;
2525 }
2526
2527 if (s->nal_unit_type != s->first_nal_type) {
2528 av_log(s->avctx, AV_LOG_ERROR,
2529 "Non-matching NAL types of the VCL NALUs: %d %d\n",
2530 s->first_nal_type, s->nal_unit_type);
2531 return AVERROR_INVALIDDATA;
2532 }
2533
2534 if (!s->sh.dependent_slice_segment_flag &&
2535 s->sh.slice_type != I_SLICE) {
2536 ret = ff_hevc_slice_rpl(s);
2537 if (ret < 0) {
2538 av_log(s->avctx, AV_LOG_WARNING,
2539 "Error constructing the reference lists for the current slice.\n");
2540 goto fail;
2541 }
2542 }
2543
2544 if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2545 ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2546 if (ret < 0)
2547 goto fail;
2548 }
2549
2550 if (s->avctx->hwaccel) {
2551 ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2552 if (ret < 0)
2553 goto fail;
2554 } else {
2555 ctb_addr_ts = hls_slice_data(s);
2556 if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2557 s->is_decoded = 1;
2558 if ((s->ps.pps->transquant_bypass_enable_flag ||
2559 (s->ps.sps->pcm.loop_filter_disable_flag && s->ps.sps->pcm_enabled_flag)) &&
2560 s->ps.sps->sao_enabled)
2561 restore_tqb_pixels(s);
2562 }
2563
2564 if (ctb_addr_ts < 0) {
2565 ret = ctb_addr_ts;
2566 goto fail;
2567 }
2568 }
2569 break;
2570 case NAL_EOS_NUT:
2571 case NAL_EOB_NUT:
2572 s->seq_decode = (s->seq_decode + 1) & 0xff;
2573 s->max_ra = INT_MAX;
2574 break;
2575 case NAL_AUD:
2576 case NAL_FD_NUT:
2577 break;
2578 default:
2579 av_log(s->avctx, AV_LOG_INFO,
2580 "Skipping NAL unit %d\n", s->nal_unit_type);
2581 }
2582
2583 return 0;
2584 fail:
2585 if (s->avctx->err_recognition & AV_EF_EXPLODE)
2586 return ret;
2587 return 0;
2588 }
2589
2590 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2591 {
2592 int i, ret = 0;
2593
2594 s->ref = NULL;
2595 s->eos = 0;
2596
2597 /* split the input packet into NAL units, so we know the upper bound on the
2598 * number of slices in the frame */
2599 ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
2600 s->nal_length_size, s->avctx->codec_id);
2601 if (ret < 0) {
2602 av_log(s->avctx, AV_LOG_ERROR,
2603 "Error splitting the input into NAL units.\n");
2604 return ret;
2605 }
2606
2607 for (i = 0; i < s->pkt.nb_nals; i++) {
2608 if (s->pkt.nals[i].type == NAL_EOB_NUT ||
2609 s->pkt.nals[i].type == NAL_EOS_NUT)
2610 s->eos = 1;
2611 }
2612
2613 /* decode the NAL units */
2614 for (i = 0; i < s->pkt.nb_nals; i++) {
2615 ret = decode_nal_unit(s, &s->pkt.nals[i]);
2616 if (ret < 0) {
2617 av_log(s->avctx, AV_LOG_WARNING,
2618 "Error parsing NAL unit #%d.\n", i);
2619 goto fail;
2620 }
2621 }
2622
2623 fail:
2624 if (s->ref)
2625 ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2626
2627 return ret;
2628 }
2629
2630 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2631 {
2632 int i;
2633 for (i = 0; i < 16; i++)
2634 av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2635 }
2636
2637 static int verify_md5(HEVCContext *s, AVFrame *frame)
2638 {
2639 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2640 int pixel_shift;
2641 int i, j;
2642
2643 if (!desc)
2644 return AVERROR(EINVAL);
2645
2646 pixel_shift = desc->comp[0].depth > 8;
2647
2648 av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2649 s->poc);
2650
2651 /* the checksums are LE, so we have to byteswap for >8bpp formats
2652 * on BE arches */
2653 #if HAVE_BIGENDIAN
2654 if (pixel_shift && !s->checksum_buf) {
2655 av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2656 FFMAX3(frame->linesize[0], frame->linesize[1],
2657 frame->linesize[2]));
2658 if (!s->checksum_buf)
2659 return AVERROR(ENOMEM);
2660 }
2661 #endif
2662
2663 for (i = 0; frame->data[i]; i++) {
2664 int width = s->avctx->coded_width;
2665 int height = s->avctx->coded_height;
2666 int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2667 int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2668 uint8_t md5[16];
2669
2670 av_md5_init(s->md5_ctx);
2671 for (j = 0; j < h; j++) {
2672 const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2673 #if HAVE_BIGENDIAN
2674 if (pixel_shift) {
2675 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2676 (const uint16_t *) src, w);
2677 src = s->checksum_buf;
2678 }
2679 #endif
2680 av_md5_update(s->md5_ctx, src, w << pixel_shift);
2681 }
2682 av_md5_final(s->md5_ctx, md5);
2683
2684 if (!memcmp(md5, s->md5[i], 16)) {
2685 av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2686 print_md5(s->avctx, AV_LOG_DEBUG, md5);
2687 av_log (s->avctx, AV_LOG_DEBUG, "; ");
2688 } else {
2689 av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2690 print_md5(s->avctx, AV_LOG_ERROR, md5);
2691 av_log (s->avctx, AV_LOG_ERROR, " != ");
2692 print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2693 av_log (s->avctx, AV_LOG_ERROR, "\n");
2694 return AVERROR_INVALIDDATA;
2695 }
2696 }
2697
2698 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2699
2700 return 0;
2701 }
2702
2703 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2704 AVPacket *avpkt)
2705 {
2706 int ret;
2707 HEVCContext *s = avctx->priv_data;
2708
2709 if (!avpkt->size) {
2710 ret = ff_hevc_output_frame(s, data, 1);
2711 if (ret < 0)
2712 return ret;
2713
2714 *got_output = ret;
2715 return 0;
2716 }
2717
2718 s->ref = NULL;
2719 ret = decode_nal_units(s, avpkt->data, avpkt->size);
2720 if (ret < 0)
2721 return ret;
2722
2723 if (avctx->hwaccel) {
2724 if (s->ref && avctx->hwaccel->end_frame(avctx) < 0)
2725 av_log(avctx, AV_LOG_ERROR,
2726 "hardware accelerator failed to decode picture\n");
2727 } else {
2728 /* verify the SEI checksum */
2729 if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2730 s->is_md5) {
2731 ret = verify_md5(s, s->ref->frame);
2732 if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2733 ff_hevc_unref_frame(s, s->ref, ~0);
2734 return ret;
2735 }
2736 }
2737 }
2738 s->is_md5 = 0;
2739
2740 if (s->is_decoded) {
2741 av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2742 s->is_decoded = 0;
2743 }
2744
2745 if (s->output_frame->buf[0]) {
2746 av_frame_move_ref(data, s->output_frame);
2747 *got_output = 1;
2748 }
2749
2750 return avpkt->size;
2751 }
2752
2753 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2754 {
2755 int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2756 if (ret < 0)
2757 return ret;
2758
2759 dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2760 if (!dst->tab_mvf_buf)
2761 goto fail;
2762 dst->tab_mvf = src->tab_mvf;
2763
2764 dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2765 if (!dst->rpl_tab_buf)
2766 goto fail;
2767 dst->rpl_tab = src->rpl_tab;
2768
2769 dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2770 if (!dst->rpl_buf)
2771 goto fail;
2772
2773 dst->poc = src->poc;
2774 dst->ctb_count = src->ctb_count;
2775 dst->window = src->window;
2776 dst->flags = src->flags;
2777 dst->sequence = src->sequence;
2778
2779 if (src->hwaccel_picture_private) {
2780 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
2781 if (!dst->hwaccel_priv_buf)
2782 goto fail;
2783 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
2784 }
2785
2786 return 0;
2787 fail:
2788 ff_hevc_unref_frame(s, dst, ~0);
2789 return AVERROR(ENOMEM);
2790 }
2791
2792 static av_cold int hevc_decode_free(AVCodecContext *avctx)
2793 {
2794 HEVCContext *s = avctx->priv_data;
2795 int i;
2796
2797 pic_arrays_free(s);
2798
2799 av_freep(&s->md5_ctx);
2800
2801 av_frame_free(&s->tmp_frame);
2802 av_frame_free(&s->output_frame);
2803
2804 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2805 ff_hevc_unref_frame(s, &s->DPB[i], ~0);
2806 av_frame_free(&s->DPB[i].frame);
2807 }
2808
2809 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
2810 av_buffer_unref(&s->ps.vps_list[i]);
2811 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
2812 av_buffer_unref(&s->ps.sps_list[i]);
2813 for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
2814 av_buffer_unref(&s->ps.pps_list[i]);
2815
2816 ff_h2645_packet_uninit(&s->pkt);
2817
2818 return 0;
2819 }
2820
2821 static av_cold int hevc_init_context(AVCodecContext *avctx)
2822 {
2823 HEVCContext *s = avctx->priv_data;
2824 int i;
2825
2826 s->avctx = avctx;
2827
2828 s->tmp_frame = av_frame_alloc();
2829 if (!s->tmp_frame)
2830 goto fail;
2831
2832 s->output_frame = av_frame_alloc();
2833 if (!s->output_frame)
2834 goto fail;
2835
2836 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2837 s->DPB[i].frame = av_frame_alloc();
2838 if (!s->DPB[i].frame)