path: root/libavcodec/hevcdec.c (plain)
blob: f9e8ff0c9f2af826df419846b2c51f22a2039f9d

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