Merge commit '4abe3b049d987420eb891f74a35af2cebbf52144'
[ffmpeg.git] / libavcodec / hevcdec.c
1 /*
2  * HEVC video Decoder
3  *
4  * Copyright (C) 2012 - 2013 Guillaume Martres
5  * Copyright (C) 2012 - 2013 Mickael Raulet
6  * Copyright (C) 2012 - 2013 Gildas Cocherel
7  * Copyright (C) 2012 - 2013 Wassim Hamidouche
8  *
9  * This file is part of 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 "hevcdec.h"
41 #include "profiles.h"
42
43 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 };
44
45 /**
46  * NOTE: Each function hls_foo correspond to the function foo in the
47  * specification (HLS stands for High Level Syntax).
48  */
49
50 /**
51  * Section 5.7
52  */
53
54 /* free everything allocated  by pic_arrays_init() */
55 static void pic_arrays_free(HEVCContext *s)
56 {
57     av_freep(&s->sao);
58     av_freep(&s->deblock);
59
60     av_freep(&s->skip_flag);
61     av_freep(&s->tab_ct_depth);
62
63     av_freep(&s->tab_ipm);
64     av_freep(&s->cbf_luma);
65     av_freep(&s->is_pcm);
66
67     av_freep(&s->qp_y_tab);
68     av_freep(&s->tab_slice_address);
69     av_freep(&s->filter_slice_edges);
70
71     av_freep(&s->horizontal_bs);
72     av_freep(&s->vertical_bs);
73
74     av_freep(&s->sh.entry_point_offset);
75     av_freep(&s->sh.size);
76     av_freep(&s->sh.offset);
77
78     av_buffer_pool_uninit(&s->tab_mvf_pool);
79     av_buffer_pool_uninit(&s->rpl_tab_pool);
80 }
81
82 /* allocate arrays that depend on frame dimensions */
83 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
84 {
85     int log2_min_cb_size = sps->log2_min_cb_size;
86     int width            = sps->width;
87     int height           = sps->height;
88     int pic_size_in_ctb  = ((width  >> log2_min_cb_size) + 1) *
89                            ((height >> log2_min_cb_size) + 1);
90     int ctb_count        = sps->ctb_width * sps->ctb_height;
91     int min_pu_size      = sps->min_pu_width * sps->min_pu_height;
92
93     s->bs_width  = (width  >> 2) + 1;
94     s->bs_height = (height >> 2) + 1;
95
96     s->sao           = av_mallocz_array(ctb_count, sizeof(*s->sao));
97     s->deblock       = av_mallocz_array(ctb_count, sizeof(*s->deblock));
98     if (!s->sao || !s->deblock)
99         goto fail;
100
101     s->skip_flag    = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
102     s->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
103     if (!s->skip_flag || !s->tab_ct_depth)
104         goto fail;
105
106     s->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
107     s->tab_ipm  = av_mallocz(min_pu_size);
108     s->is_pcm   = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
109     if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
110         goto fail;
111
112     s->filter_slice_edges = av_mallocz(ctb_count);
113     s->tab_slice_address  = av_malloc_array(pic_size_in_ctb,
114                                       sizeof(*s->tab_slice_address));
115     s->qp_y_tab           = av_malloc_array(pic_size_in_ctb,
116                                       sizeof(*s->qp_y_tab));
117     if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
118         goto fail;
119
120     s->horizontal_bs = av_mallocz_array(s->bs_width, s->bs_height);
121     s->vertical_bs   = av_mallocz_array(s->bs_width, s->bs_height);
122     if (!s->horizontal_bs || !s->vertical_bs)
123         goto fail;
124
125     s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
126                                           av_buffer_allocz);
127     s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
128                                           av_buffer_allocz);
129     if (!s->tab_mvf_pool || !s->rpl_tab_pool)
130         goto fail;
131
132     return 0;
133
134 fail:
135     pic_arrays_free(s);
136     return AVERROR(ENOMEM);
137 }
138
139 static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
140 {
141     int i = 0;
142     int j = 0;
143     uint8_t luma_weight_l0_flag[16];
144     uint8_t chroma_weight_l0_flag[16];
145     uint8_t luma_weight_l1_flag[16];
146     uint8_t chroma_weight_l1_flag[16];
147     int luma_log2_weight_denom;
148
149     luma_log2_weight_denom = get_ue_golomb_long(gb);
150     if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7)
151         av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
152     s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
153     if (s->ps.sps->chroma_format_idc != 0) {
154         int delta = get_se_golomb(gb);
155         s->sh.chroma_log2_weight_denom = av_clip_uintp2(s->sh.luma_log2_weight_denom + delta, 3);
156     }
157
158     for (i = 0; i < s->sh.nb_refs[L0]; i++) {
159         luma_weight_l0_flag[i] = get_bits1(gb);
160         if (!luma_weight_l0_flag[i]) {
161             s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
162             s->sh.luma_offset_l0[i] = 0;
163         }
164     }
165     if (s->ps.sps->chroma_format_idc != 0) {
166         for (i = 0; i < s->sh.nb_refs[L0]; i++)
167             chroma_weight_l0_flag[i] = get_bits1(gb);
168     } else {
169         for (i = 0; i < s->sh.nb_refs[L0]; i++)
170             chroma_weight_l0_flag[i] = 0;
171     }
172     for (i = 0; i < s->sh.nb_refs[L0]; i++) {
173         if (luma_weight_l0_flag[i]) {
174             int delta_luma_weight_l0 = get_se_golomb(gb);
175             s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
176             s->sh.luma_offset_l0[i] = get_se_golomb(gb);
177         }
178         if (chroma_weight_l0_flag[i]) {
179             for (j = 0; j < 2; j++) {
180                 int delta_chroma_weight_l0 = get_se_golomb(gb);
181                 int delta_chroma_offset_l0 = get_se_golomb(gb);
182                 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
183                 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
184                                                                                     >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
185             }
186         } else {
187             s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
188             s->sh.chroma_offset_l0[i][0] = 0;
189             s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
190             s->sh.chroma_offset_l0[i][1] = 0;
191         }
192     }
193     if (s->sh.slice_type == B_SLICE) {
194         for (i = 0; i < s->sh.nb_refs[L1]; i++) {
195             luma_weight_l1_flag[i] = get_bits1(gb);
196             if (!luma_weight_l1_flag[i]) {
197                 s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
198                 s->sh.luma_offset_l1[i] = 0;
199             }
200         }
201         if (s->ps.sps->chroma_format_idc != 0) {
202             for (i = 0; i < s->sh.nb_refs[L1]; i++)
203                 chroma_weight_l1_flag[i] = get_bits1(gb);
204         } else {
205             for (i = 0; i < s->sh.nb_refs[L1]; i++)
206                 chroma_weight_l1_flag[i] = 0;
207         }
208         for (i = 0; i < s->sh.nb_refs[L1]; i++) {
209             if (luma_weight_l1_flag[i]) {
210                 int delta_luma_weight_l1 = get_se_golomb(gb);
211                 s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
212                 s->sh.luma_offset_l1[i] = get_se_golomb(gb);
213             }
214             if (chroma_weight_l1_flag[i]) {
215                 for (j = 0; j < 2; j++) {
216                     int delta_chroma_weight_l1 = get_se_golomb(gb);
217                     int delta_chroma_offset_l1 = get_se_golomb(gb);
218                     s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
219                     s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
220                                                                                         >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
221                 }
222             } else {
223                 s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
224                 s->sh.chroma_offset_l1[i][0] = 0;
225                 s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
226                 s->sh.chroma_offset_l1[i][1] = 0;
227             }
228         }
229     }
230 }
231
232 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
233 {
234     const HEVCSPS *sps = s->ps.sps;
235     int max_poc_lsb    = 1 << sps->log2_max_poc_lsb;
236     int prev_delta_msb = 0;
237     unsigned int nb_sps = 0, nb_sh;
238     int i;
239
240     rps->nb_refs = 0;
241     if (!sps->long_term_ref_pics_present_flag)
242         return 0;
243
244     if (sps->num_long_term_ref_pics_sps > 0)
245         nb_sps = get_ue_golomb_long(gb);
246     nb_sh = get_ue_golomb_long(gb);
247
248     if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
249         return AVERROR_INVALIDDATA;
250
251     rps->nb_refs = nb_sh + nb_sps;
252
253     for (i = 0; i < rps->nb_refs; i++) {
254         uint8_t delta_poc_msb_present;
255
256         if (i < nb_sps) {
257             uint8_t lt_idx_sps = 0;
258
259             if (sps->num_long_term_ref_pics_sps > 1)
260                 lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
261
262             rps->poc[i]  = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
263             rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
264         } else {
265             rps->poc[i]  = get_bits(gb, sps->log2_max_poc_lsb);
266             rps->used[i] = get_bits1(gb);
267         }
268
269         delta_poc_msb_present = get_bits1(gb);
270         if (delta_poc_msb_present) {
271             int delta = get_ue_golomb_long(gb);
272
273             if (i && i != nb_sps)
274                 delta += prev_delta_msb;
275
276             rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
277             prev_delta_msb = delta;
278         }
279     }
280
281     return 0;
282 }
283
284 static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
285                                  const HEVCSPS *sps)
286 {
287     const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
288     unsigned int num = 0, den = 0;
289
290     avctx->pix_fmt             = sps->pix_fmt;
291     avctx->coded_width         = sps->width;
292     avctx->coded_height        = sps->height;
293     avctx->width               = sps->output_width;
294     avctx->height              = sps->output_height;
295     avctx->has_b_frames        = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
296     avctx->profile             = sps->ptl.general_ptl.profile_idc;
297     avctx->level               = sps->ptl.general_ptl.level_idc;
298
299     ff_set_sar(avctx, sps->vui.sar);
300
301     if (sps->vui.video_signal_type_present_flag)
302         avctx->color_range = sps->vui.video_full_range_flag ? AVCOL_RANGE_JPEG
303                                                             : AVCOL_RANGE_MPEG;
304     else
305         avctx->color_range = AVCOL_RANGE_MPEG;
306
307     if (sps->vui.colour_description_present_flag) {
308         avctx->color_primaries = sps->vui.colour_primaries;
309         avctx->color_trc       = sps->vui.transfer_characteristic;
310         avctx->colorspace      = sps->vui.matrix_coeffs;
311     } else {
312         avctx->color_primaries = AVCOL_PRI_UNSPECIFIED;
313         avctx->color_trc       = AVCOL_TRC_UNSPECIFIED;
314         avctx->colorspace      = AVCOL_SPC_UNSPECIFIED;
315     }
316
317     if (vps->vps_timing_info_present_flag) {
318         num = vps->vps_num_units_in_tick;
319         den = vps->vps_time_scale;
320     } else if (sps->vui.vui_timing_info_present_flag) {
321         num = sps->vui.vui_num_units_in_tick;
322         den = sps->vui.vui_time_scale;
323     }
324
325     if (num != 0 && den != 0)
326         av_reduce(&avctx->framerate.den, &avctx->framerate.num,
327                   num, den, 1 << 30);
328 }
329
330 static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fmt)
331 {
332     #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VAAPI_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
333     enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
334     int ret, i;
335
336     pic_arrays_free(s);
337     s->ps.sps = NULL;
338     s->ps.vps = NULL;
339
340     if (!sps)
341         return 0;
342
343     ret = pic_arrays_init(s, sps);
344     if (ret < 0)
345         goto fail;
346
347     export_stream_params(s->avctx, &s->ps, sps);
348
349     switch (sps->pix_fmt) {
350     case AV_PIX_FMT_YUV420P:
351     case AV_PIX_FMT_YUVJ420P:
352 #if CONFIG_HEVC_DXVA2_HWACCEL
353         *fmt++ = AV_PIX_FMT_DXVA2_VLD;
354 #endif
355 #if CONFIG_HEVC_D3D11VA_HWACCEL
356         *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
357 #endif
358 #if CONFIG_HEVC_VAAPI_HWACCEL
359         *fmt++ = AV_PIX_FMT_VAAPI;
360 #endif
361 #if CONFIG_HEVC_VDPAU_HWACCEL
362         *fmt++ = AV_PIX_FMT_VDPAU;
363 #endif
364         break;
365     case AV_PIX_FMT_YUV420P10:
366 #if CONFIG_HEVC_DXVA2_HWACCEL
367         *fmt++ = AV_PIX_FMT_DXVA2_VLD;
368 #endif
369 #if CONFIG_HEVC_D3D11VA_HWACCEL
370         *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
371 #endif
372 #if CONFIG_HEVC_VAAPI_HWACCEL
373         *fmt++ = AV_PIX_FMT_VAAPI;
374 #endif
375         break;
376     }
377
378     if (pix_fmt == AV_PIX_FMT_NONE) {
379         *fmt++ = sps->pix_fmt;
380         *fmt = AV_PIX_FMT_NONE;
381
382         ret = ff_thread_get_format(s->avctx, pix_fmts);
383         if (ret < 0)
384             goto fail;
385         s->avctx->pix_fmt = ret;
386     }
387     else {
388         s->avctx->pix_fmt = pix_fmt;
389     }
390
391     ff_hevc_pred_init(&s->hpc,     sps->bit_depth);
392     ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
393     ff_videodsp_init (&s->vdsp,    sps->bit_depth);
394
395     for (i = 0; i < 3; i++) {
396         av_freep(&s->sao_pixel_buffer_h[i]);
397         av_freep(&s->sao_pixel_buffer_v[i]);
398     }
399
400     if (sps->sao_enabled && !s->avctx->hwaccel) {
401         int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
402         int c_idx;
403
404         for(c_idx = 0; c_idx < c_count; c_idx++) {
405             int w = sps->width >> sps->hshift[c_idx];
406             int h = sps->height >> sps->vshift[c_idx];
407             s->sao_pixel_buffer_h[c_idx] =
408                 av_malloc((w * 2 * sps->ctb_height) <<
409                           sps->pixel_shift);
410             s->sao_pixel_buffer_v[c_idx] =
411                 av_malloc((h * 2 * sps->ctb_width) <<
412                           sps->pixel_shift);
413         }
414     }
415
416     s->ps.sps = sps;
417     s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
418
419     return 0;
420
421 fail:
422     pic_arrays_free(s);
423     s->ps.sps = NULL;
424     return ret;
425 }
426
427 static int hls_slice_header(HEVCContext *s)
428 {
429     GetBitContext *gb = &s->HEVClc->gb;
430     SliceHeader *sh   = &s->sh;
431     int i, ret;
432
433     // Coded parameters
434     sh->first_slice_in_pic_flag = get_bits1(gb);
435     if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
436         s->seq_decode = (s->seq_decode + 1) & 0xff;
437         s->max_ra     = INT_MAX;
438         if (IS_IDR(s))
439             ff_hevc_clear_refs(s);
440     }
441     sh->no_output_of_prior_pics_flag = 0;
442     if (IS_IRAP(s))
443         sh->no_output_of_prior_pics_flag = get_bits1(gb);
444
445     sh->pps_id = get_ue_golomb_long(gb);
446     if (sh->pps_id >= MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
447         av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
448         return AVERROR_INVALIDDATA;
449     }
450     if (!sh->first_slice_in_pic_flag &&
451         s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
452         av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
453         return AVERROR_INVALIDDATA;
454     }
455     s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
456     if (s->nal_unit_type == NAL_CRA_NUT && s->last_eos == 1)
457         sh->no_output_of_prior_pics_flag = 1;
458
459     if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
460         const HEVCSPS* last_sps = s->ps.sps;
461         s->ps.sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
462         if (last_sps && IS_IRAP(s) && s->nal_unit_type != NAL_CRA_NUT) {
463             if (s->ps.sps->width !=  last_sps->width || s->ps.sps->height != last_sps->height ||
464                 s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering !=
465                 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
466                 sh->no_output_of_prior_pics_flag = 0;
467         }
468         ff_hevc_clear_refs(s);
469         ret = set_sps(s, s->ps.sps, AV_PIX_FMT_NONE);
470         if (ret < 0)
471             return ret;
472
473         s->seq_decode = (s->seq_decode + 1) & 0xff;
474         s->max_ra     = INT_MAX;
475     }
476
477     sh->dependent_slice_segment_flag = 0;
478     if (!sh->first_slice_in_pic_flag) {
479         int slice_address_length;
480
481         if (s->ps.pps->dependent_slice_segments_enabled_flag)
482             sh->dependent_slice_segment_flag = get_bits1(gb);
483
484         slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
485                                             s->ps.sps->ctb_height);
486         sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
487         if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
488             av_log(s->avctx, AV_LOG_ERROR,
489                    "Invalid slice segment address: %u.\n",
490                    sh->slice_segment_addr);
491             return AVERROR_INVALIDDATA;
492         }
493
494         if (!sh->dependent_slice_segment_flag) {
495             sh->slice_addr = sh->slice_segment_addr;
496             s->slice_idx++;
497         }
498     } else {
499         sh->slice_segment_addr = sh->slice_addr = 0;
500         s->slice_idx           = 0;
501         s->slice_initialized   = 0;
502     }
503
504     if (!sh->dependent_slice_segment_flag) {
505         s->slice_initialized = 0;
506
507         for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
508             skip_bits(gb, 1);  // slice_reserved_undetermined_flag[]
509
510         sh->slice_type = get_ue_golomb_long(gb);
511         if (!(sh->slice_type == I_SLICE ||
512               sh->slice_type == P_SLICE ||
513               sh->slice_type == B_SLICE)) {
514             av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
515                    sh->slice_type);
516             return AVERROR_INVALIDDATA;
517         }
518         if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
519             av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
520             return AVERROR_INVALIDDATA;
521         }
522
523         // when flag is not present, picture is inferred to be output
524         sh->pic_output_flag = 1;
525         if (s->ps.pps->output_flag_present_flag)
526             sh->pic_output_flag = get_bits1(gb);
527
528         if (s->ps.sps->separate_colour_plane_flag)
529             sh->colour_plane_id = get_bits(gb, 2);
530
531         if (!IS_IDR(s)) {
532             int poc, pos;
533
534             sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
535             poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
536             if (!sh->first_slice_in_pic_flag && poc != s->poc) {
537                 av_log(s->avctx, AV_LOG_WARNING,
538                        "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
539                 if (s->avctx->err_recognition & AV_EF_EXPLODE)
540                     return AVERROR_INVALIDDATA;
541                 poc = s->poc;
542             }
543             s->poc = poc;
544
545             sh->short_term_ref_pic_set_sps_flag = get_bits1(gb);
546             pos = get_bits_left(gb);
547             if (!sh->short_term_ref_pic_set_sps_flag) {
548                 ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
549                 if (ret < 0)
550                     return ret;
551
552                 sh->short_term_rps = &sh->slice_rps;
553             } else {
554                 int numbits, rps_idx;
555
556                 if (!s->ps.sps->nb_st_rps) {
557                     av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
558                     return AVERROR_INVALIDDATA;
559                 }
560
561                 numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
562                 rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
563                 sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
564             }
565             sh->short_term_ref_pic_set_size = pos - get_bits_left(gb);
566
567             pos = get_bits_left(gb);
568             ret = decode_lt_rps(s, &sh->long_term_rps, gb);
569             if (ret < 0) {
570                 av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
571                 if (s->avctx->err_recognition & AV_EF_EXPLODE)
572                     return AVERROR_INVALIDDATA;
573             }
574             sh->long_term_ref_pic_set_size = pos - get_bits_left(gb);
575
576             if (s->ps.sps->sps_temporal_mvp_enabled_flag)
577                 sh->slice_temporal_mvp_enabled_flag = get_bits1(gb);
578             else
579                 sh->slice_temporal_mvp_enabled_flag = 0;
580         } else {
581             s->sh.short_term_rps = NULL;
582             s->poc               = 0;
583         }
584
585         /* 8.3.1 */
586         if (s->temporal_id == 0 &&
587             s->nal_unit_type != NAL_TRAIL_N &&
588             s->nal_unit_type != NAL_TSA_N   &&
589             s->nal_unit_type != NAL_STSA_N  &&
590             s->nal_unit_type != NAL_RADL_N  &&
591             s->nal_unit_type != NAL_RADL_R  &&
592             s->nal_unit_type != NAL_RASL_N  &&
593             s->nal_unit_type != NAL_RASL_R)
594             s->pocTid0 = s->poc;
595
596         if (s->ps.sps->sao_enabled) {
597             sh->slice_sample_adaptive_offset_flag[0] = get_bits1(gb);
598             if (s->ps.sps->chroma_format_idc) {
599                 sh->slice_sample_adaptive_offset_flag[1] =
600                 sh->slice_sample_adaptive_offset_flag[2] = get_bits1(gb);
601             }
602         } else {
603             sh->slice_sample_adaptive_offset_flag[0] = 0;
604             sh->slice_sample_adaptive_offset_flag[1] = 0;
605             sh->slice_sample_adaptive_offset_flag[2] = 0;
606         }
607
608         sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
609         if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
610             int nb_refs;
611
612             sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
613             if (sh->slice_type == B_SLICE)
614                 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
615
616             if (get_bits1(gb)) { // num_ref_idx_active_override_flag
617                 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
618                 if (sh->slice_type == B_SLICE)
619                     sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
620             }
621             if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
622                 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
623                        sh->nb_refs[L0], sh->nb_refs[L1]);
624                 return AVERROR_INVALIDDATA;
625             }
626
627             sh->rpl_modification_flag[0] = 0;
628             sh->rpl_modification_flag[1] = 0;
629             nb_refs = ff_hevc_frame_nb_refs(s);
630             if (!nb_refs) {
631                 av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
632                 return AVERROR_INVALIDDATA;
633             }
634
635             if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
636                 sh->rpl_modification_flag[0] = get_bits1(gb);
637                 if (sh->rpl_modification_flag[0]) {
638                     for (i = 0; i < sh->nb_refs[L0]; i++)
639                         sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
640                 }
641
642                 if (sh->slice_type == B_SLICE) {
643                     sh->rpl_modification_flag[1] = get_bits1(gb);
644                     if (sh->rpl_modification_flag[1] == 1)
645                         for (i = 0; i < sh->nb_refs[L1]; i++)
646                             sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
647                 }
648             }
649
650             if (sh->slice_type == B_SLICE)
651                 sh->mvd_l1_zero_flag = get_bits1(gb);
652
653             if (s->ps.pps->cabac_init_present_flag)
654                 sh->cabac_init_flag = get_bits1(gb);
655             else
656                 sh->cabac_init_flag = 0;
657
658             sh->collocated_ref_idx = 0;
659             if (sh->slice_temporal_mvp_enabled_flag) {
660                 sh->collocated_list = L0;
661                 if (sh->slice_type == B_SLICE)
662                     sh->collocated_list = !get_bits1(gb);
663
664                 if (sh->nb_refs[sh->collocated_list] > 1) {
665                     sh->collocated_ref_idx = get_ue_golomb_long(gb);
666                     if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
667                         av_log(s->avctx, AV_LOG_ERROR,
668                                "Invalid collocated_ref_idx: %d.\n",
669                                sh->collocated_ref_idx);
670                         return AVERROR_INVALIDDATA;
671                     }
672                 }
673             }
674
675             if ((s->ps.pps->weighted_pred_flag   && sh->slice_type == P_SLICE) ||
676                 (s->ps.pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
677                 pred_weight_table(s, gb);
678             }
679
680             sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
681             if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
682                 av_log(s->avctx, AV_LOG_ERROR,
683                        "Invalid number of merging MVP candidates: %d.\n",
684                        sh->max_num_merge_cand);
685                 return AVERROR_INVALIDDATA;
686             }
687         }
688
689         sh->slice_qp_delta = get_se_golomb(gb);
690
691         if (s->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag) {
692             sh->slice_cb_qp_offset = get_se_golomb(gb);
693             sh->slice_cr_qp_offset = get_se_golomb(gb);
694         } else {
695             sh->slice_cb_qp_offset = 0;
696             sh->slice_cr_qp_offset = 0;
697         }
698
699         if (s->ps.pps->chroma_qp_offset_list_enabled_flag)
700             sh->cu_chroma_qp_offset_enabled_flag = get_bits1(gb);
701         else
702             sh->cu_chroma_qp_offset_enabled_flag = 0;
703
704         if (s->ps.pps->deblocking_filter_control_present_flag) {
705             int deblocking_filter_override_flag = 0;
706
707             if (s->ps.pps->deblocking_filter_override_enabled_flag)
708                 deblocking_filter_override_flag = get_bits1(gb);
709
710             if (deblocking_filter_override_flag) {
711                 sh->disable_deblocking_filter_flag = get_bits1(gb);
712                 if (!sh->disable_deblocking_filter_flag) {
713                     sh->beta_offset = get_se_golomb(gb) * 2;
714                     sh->tc_offset   = get_se_golomb(gb) * 2;
715                 }
716             } else {
717                 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
718                 sh->beta_offset                    = s->ps.pps->beta_offset;
719                 sh->tc_offset                      = s->ps.pps->tc_offset;
720             }
721         } else {
722             sh->disable_deblocking_filter_flag = 0;
723             sh->beta_offset                    = 0;
724             sh->tc_offset                      = 0;
725         }
726
727         if (s->ps.pps->seq_loop_filter_across_slices_enabled_flag &&
728             (sh->slice_sample_adaptive_offset_flag[0] ||
729              sh->slice_sample_adaptive_offset_flag[1] ||
730              !sh->disable_deblocking_filter_flag)) {
731             sh->slice_loop_filter_across_slices_enabled_flag = get_bits1(gb);
732         } else {
733             sh->slice_loop_filter_across_slices_enabled_flag = s->ps.pps->seq_loop_filter_across_slices_enabled_flag;
734         }
735     } else if (!s->slice_initialized) {
736         av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
737         return AVERROR_INVALIDDATA;
738     }
739
740     sh->num_entry_point_offsets = 0;
741     if (s->ps.pps->tiles_enabled_flag || s->ps.pps->entropy_coding_sync_enabled_flag) {
742         unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
743         // It would be possible to bound this tighter but this here is simpler
744         if (num_entry_point_offsets > get_bits_left(gb)) {
745             av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
746             return AVERROR_INVALIDDATA;
747         }
748
749         sh->num_entry_point_offsets = num_entry_point_offsets;
750         if (sh->num_entry_point_offsets > 0) {
751             int offset_len = get_ue_golomb_long(gb) + 1;
752
753             if (offset_len < 1 || offset_len > 32) {
754                 sh->num_entry_point_offsets = 0;
755                 av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
756                 return AVERROR_INVALIDDATA;
757             }
758
759             av_freep(&sh->entry_point_offset);
760             av_freep(&sh->offset);
761             av_freep(&sh->size);
762             sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
763             sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
764             sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
765             if (!sh->entry_point_offset || !sh->offset || !sh->size) {
766                 sh->num_entry_point_offsets = 0;
767                 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
768                 return AVERROR(ENOMEM);
769             }
770             for (i = 0; i < sh->num_entry_point_offsets; i++) {
771                 unsigned val = get_bits_long(gb, offset_len);
772                 sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
773             }
774             if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
775                 s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
776                 s->threads_number = 1;
777             } else
778                 s->enable_parallel_tiles = 0;
779         } else
780             s->enable_parallel_tiles = 0;
781     }
782
783     if (s->ps.pps->slice_header_extension_present_flag) {
784         unsigned int length = get_ue_golomb_long(gb);
785         if (length*8LL > get_bits_left(gb)) {
786             av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
787             return AVERROR_INVALIDDATA;
788         }
789         for (i = 0; i < length; i++)
790             skip_bits(gb, 8);  // slice_header_extension_data_byte
791     }
792
793     // Inferred parameters
794     sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
795     if (sh->slice_qp > 51 ||
796         sh->slice_qp < -s->ps.sps->qp_bd_offset) {
797         av_log(s->avctx, AV_LOG_ERROR,
798                "The slice_qp %d is outside the valid range "
799                "[%d, 51].\n",
800                sh->slice_qp,
801                -s->ps.sps->qp_bd_offset);
802         return AVERROR_INVALIDDATA;
803     }
804
805     sh->slice_ctb_addr_rs = sh->slice_segment_addr;
806
807     if (!s->sh.slice_ctb_addr_rs && s->sh.dependent_slice_segment_flag) {
808         av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
809         return AVERROR_INVALIDDATA;
810     }
811
812     if (get_bits_left(gb) < 0) {
813         av_log(s->avctx, AV_LOG_ERROR,
814                "Overread slice header by %d bits\n", -get_bits_left(gb));
815         return AVERROR_INVALIDDATA;
816     }
817
818     s->HEVClc->first_qp_group = !s->sh.dependent_slice_segment_flag;
819
820     if (!s->ps.pps->cu_qp_delta_enabled_flag)
821         s->HEVClc->qp_y = s->sh.slice_qp;
822
823     s->slice_initialized = 1;
824     s->HEVClc->tu.cu_qp_offset_cb = 0;
825     s->HEVClc->tu.cu_qp_offset_cr = 0;
826
827     s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == NAL_CRA_NUT && s->last_eos);
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 == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1349                            (s->sh.slice_type == B_SLICE && 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 == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1412                            (s->sh.slice_type == B_SLICE && 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 == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1498                            (s->sh.slice_type == B_SLICE && 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 == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1563                            (s->sh.slice_type == B_SLICE && 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 == B_SLICE)
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 != I_SLICE) {
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 != I_SLICE)
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     if (s->ps.pps->tiles_enabled_flag)
2679         lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2680
2681     ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2682     if (ret < 0)
2683         goto fail;
2684
2685     ret = ff_hevc_frame_rps(s);
2686     if (ret < 0) {
2687         av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2688         goto fail;
2689     }
2690
2691     s->ref->frame->key_frame = IS_IRAP(s);
2692
2693     ret = set_side_data(s);
2694     if (ret < 0)
2695         goto fail;
2696
2697     s->frame->pict_type = 3 - s->sh.slice_type;
2698
2699     if (!IS_IRAP(s))
2700         ff_hevc_bump_frame(s);
2701
2702     av_frame_unref(s->output_frame);
2703     ret = ff_hevc_output_frame(s, s->output_frame, 0);
2704     if (ret < 0)
2705         goto fail;
2706
2707     if (!s->avctx->hwaccel)
2708         ff_thread_finish_setup(s->avctx);
2709
2710     return 0;
2711
2712 fail:
2713     if (s->ref)
2714         ff_hevc_unref_frame(s, s->ref, ~0);
2715     s->ref = NULL;
2716     return ret;
2717 }
2718
2719 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2720 {
2721     HEVCLocalContext *lc = s->HEVClc;
2722     GetBitContext *gb    = &lc->gb;
2723     int ctb_addr_ts, ret;
2724
2725     *gb              = nal->gb;
2726     s->nal_unit_type = nal->type;
2727     s->temporal_id   = nal->temporal_id;
2728
2729     switch (s->nal_unit_type) {
2730     case NAL_VPS:
2731         ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2732         if (ret < 0)
2733             goto fail;
2734         break;
2735     case NAL_SPS:
2736         ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2737                                      s->apply_defdispwin);
2738         if (ret < 0)
2739             goto fail;
2740         break;
2741     case NAL_PPS:
2742         ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2743         if (ret < 0)
2744             goto fail;
2745         break;
2746     case NAL_SEI_PREFIX:
2747     case NAL_SEI_SUFFIX:
2748         ret = ff_hevc_decode_nal_sei(s);
2749         if (ret < 0)
2750             goto fail;
2751         break;
2752     case NAL_TRAIL_R:
2753     case NAL_TRAIL_N:
2754     case NAL_TSA_N:
2755     case NAL_TSA_R:
2756     case NAL_STSA_N:
2757     case NAL_STSA_R:
2758     case NAL_BLA_W_LP:
2759     case NAL_BLA_W_RADL:
2760     case NAL_BLA_N_LP:
2761     case NAL_IDR_W_RADL:
2762     case NAL_IDR_N_LP:
2763     case NAL_CRA_NUT:
2764     case NAL_RADL_N:
2765     case NAL_RADL_R:
2766     case NAL_RASL_N:
2767     case NAL_RASL_R:
2768         ret = hls_slice_header(s);
2769         if (ret < 0)
2770             return ret;
2771
2772         if (s->max_ra == INT_MAX) {
2773             if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2774                 s->max_ra = s->poc;
2775             } else {
2776                 if (IS_IDR(s))
2777                     s->max_ra = INT_MIN;
2778             }
2779         }
2780
2781         if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2782             s->poc <= s->max_ra) {
2783             s->is_decoded = 0;
2784             break;
2785         } else {
2786             if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2787                 s->max_ra = INT_MIN;
2788         }
2789
2790         if (s->sh.first_slice_in_pic_flag) {
2791             ret = hevc_frame_start(s);
2792             if (ret < 0)
2793                 return ret;
2794         } else if (!s->ref) {
2795             av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2796             goto fail;
2797         }
2798
2799         if (s->nal_unit_type != s->first_nal_type) {
2800             av_log(s->avctx, AV_LOG_ERROR,
2801                    "Non-matching NAL types of the VCL NALUs: %d %d\n",
2802                    s->first_nal_type, s->nal_unit_type);
2803             return AVERROR_INVALIDDATA;
2804         }
2805
2806         if (!s->sh.dependent_slice_segment_flag &&
2807             s->sh.slice_type != I_SLICE) {
2808             ret = ff_hevc_slice_rpl(s);
2809             if (ret < 0) {
2810                 av_log(s->avctx, AV_LOG_WARNING,
2811                        "Error constructing the reference lists for the current slice.\n");
2812                 goto fail;
2813             }
2814         }
2815
2816         if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2817             ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2818             if (ret < 0)
2819                 goto fail;
2820         }
2821
2822         if (s->avctx->hwaccel) {
2823             ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2824             if (ret < 0)
2825                 goto fail;
2826         } else {
2827             if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2828                 ctb_addr_ts = hls_slice_data_wpp(s, nal);
2829             else
2830                 ctb_addr_ts = hls_slice_data(s);
2831             if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2832                 s->is_decoded = 1;
2833             }
2834
2835             if (ctb_addr_ts < 0) {
2836                 ret = ctb_addr_ts;
2837                 goto fail;
2838             }
2839         }
2840         break;
2841     case NAL_EOS_NUT:
2842     case NAL_EOB_NUT:
2843         s->seq_decode = (s->seq_decode + 1) & 0xff;
2844         s->max_ra     = INT_MAX;
2845         break;
2846     case NAL_AUD:
2847     case NAL_FD_NUT:
2848         break;
2849     default:
2850         av_log(s->avctx, AV_LOG_INFO,
2851                "Skipping NAL unit %d\n", s->nal_unit_type);
2852     }
2853
2854     return 0;
2855 fail:
2856     if (s->avctx->err_recognition & AV_EF_EXPLODE)
2857         return ret;
2858     return 0;
2859 }
2860
2861 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2862 {
2863     int i, ret = 0;
2864
2865     s->ref = NULL;
2866     s->last_eos = s->eos;
2867     s->eos = 0;
2868
2869     /* split the input packet into NAL units, so we know the upper bound on the
2870      * number of slices in the frame */
2871     ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
2872                                 s->nal_length_size, s->avctx->codec_id, 1);
2873     if (ret < 0) {
2874         av_log(s->avctx, AV_LOG_ERROR,
2875                "Error splitting the input into NAL units.\n");
2876         return ret;
2877     }
2878
2879     for (i = 0; i < s->pkt.nb_nals; i++) {
2880         if (s->pkt.nals[i].type == NAL_EOB_NUT ||
2881             s->pkt.nals[i].type == NAL_EOS_NUT)
2882             s->eos = 1;
2883     }
2884
2885     /* decode the NAL units */
2886     for (i = 0; i < s->pkt.nb_nals; i++) {
2887         ret = decode_nal_unit(s, &s->pkt.nals[i]);
2888         if (ret < 0) {
2889             av_log(s->avctx, AV_LOG_WARNING,
2890                    "Error parsing NAL unit #%d.\n", i);
2891             goto fail;
2892         }
2893     }
2894
2895 fail:
2896     if (s->ref && s->threads_type == FF_THREAD_FRAME)
2897         ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2898
2899     return ret;
2900 }
2901
2902 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2903 {
2904     int i;
2905     for (i = 0; i < 16; i++)
2906         av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2907 }
2908
2909 static int verify_md5(HEVCContext *s, AVFrame *frame)
2910 {
2911     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2912     int pixel_shift;
2913     int i, j;
2914
2915     if (!desc)
2916         return AVERROR(EINVAL);
2917
2918     pixel_shift = desc->comp[0].depth > 8;
2919
2920     av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2921            s->poc);
2922
2923     /* the checksums are LE, so we have to byteswap for >8bpp formats
2924      * on BE arches */
2925 #if HAVE_BIGENDIAN
2926     if (pixel_shift && !s->checksum_buf) {
2927         av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2928                        FFMAX3(frame->linesize[0], frame->linesize[1],
2929                               frame->linesize[2]));
2930         if (!s->checksum_buf)
2931             return AVERROR(ENOMEM);
2932     }
2933 #endif
2934
2935     for (i = 0; frame->data[i]; i++) {
2936         int width  = s->avctx->coded_width;
2937         int height = s->avctx->coded_height;
2938         int w = (i == 1 || i == 2) ? (width  >> desc->log2_chroma_w) : width;
2939         int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2940         uint8_t md5[16];
2941
2942         av_md5_init(s->md5_ctx);
2943         for (j = 0; j < h; j++) {
2944             const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2945 #if HAVE_BIGENDIAN
2946             if (pixel_shift) {
2947                 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2948                                     (const uint16_t *) src, w);
2949                 src = s->checksum_buf;
2950             }
2951 #endif
2952             av_md5_update(s->md5_ctx, src, w << pixel_shift);
2953         }
2954         av_md5_final(s->md5_ctx, md5);
2955
2956         if (!memcmp(md5, s->md5[i], 16)) {
2957             av_log   (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2958             print_md5(s->avctx, AV_LOG_DEBUG, md5);
2959             av_log   (s->avctx, AV_LOG_DEBUG, "; ");
2960         } else {
2961             av_log   (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2962             print_md5(s->avctx, AV_LOG_ERROR, md5);
2963             av_log   (s->avctx, AV_LOG_ERROR, " != ");
2964             print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2965             av_log   (s->avctx, AV_LOG_ERROR, "\n");
2966             return AVERROR_INVALIDDATA;
2967         }
2968     }
2969
2970     av_log(s->avctx, AV_LOG_DEBUG, "\n");
2971
2972     return 0;
2973 }
2974
2975 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length)
2976 {
2977     AVCodecContext *avctx = s->avctx;
2978     GetByteContext gb;
2979     int ret, i;
2980
2981     bytestream2_init(&gb, buf, length);
2982
2983     if (length > 3 && (buf[0] || buf[1] || buf[2] > 1)) {
2984         /* It seems the extradata is encoded as hvcC format.
2985          * Temporarily, we support configurationVersion==0 until 14496-15 3rd
2986          * is finalized. When finalized, configurationVersion will be 1 and we
2987          * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
2988         int i, j, num_arrays, nal_len_size;
2989
2990         s->is_nalff = 1;
2991
2992         bytestream2_skip(&gb, 21);
2993         nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
2994         num_arrays   = bytestream2_get_byte(&gb);
2995
2996         /* nal units in the hvcC always have length coded with 2 bytes,
2997          * so put a fake nal_length_size = 2 while parsing them */
2998         s->nal_length_size = 2;
2999
3000         /* Decode nal units from hvcC. */
3001         for (i = 0; i < num_arrays; i++) {
3002             int type = bytestream2_get_byte(&gb) & 0x3f;
3003             int cnt  = bytestream2_get_be16(&gb);
3004
3005             for (j = 0; j < cnt; j++) {
3006                 // +2 for the nal size field
3007                 int nalsize = bytestream2_peek_be16(&gb) + 2;
3008                 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3009                     av_log(s->avctx, AV_LOG_ERROR,
3010                            "Invalid NAL unit size in extradata.\n");
3011                     return AVERROR_INVALIDDATA;
3012                 }
3013
3014                 ret = decode_nal_units(s, gb.buffer, nalsize);
3015                 if (ret < 0) {
3016                     av_log(avctx, AV_LOG_ERROR,
3017                            "Decoding nal unit %d %d from hvcC failed\n",
3018                            type, i);
3019                     return ret;
3020                 }
3021                 bytestream2_skip(&gb, nalsize);
3022             }
3023         }
3024
3025         /* Now store right nal length size, that will be used to parse
3026          * all other nals */
3027         s->nal_length_size = nal_len_size;
3028     } else {
3029         s->is_nalff = 0;
3030         ret = decode_nal_units(s, buf, length);
3031         if (ret < 0)
3032             return ret;
3033     }
3034
3035     /* export stream parameters from the first SPS */
3036     for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3037         if (s->ps.sps_list[i]) {
3038             const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3039             export_stream_params(s->avctx, &s->ps, sps);
3040             break;
3041         }
3042     }
3043
3044     return 0;
3045 }
3046
3047 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3048                              AVPacket *avpkt)
3049 {
3050     int ret;
3051     int new_extradata_size;
3052     uint8_t *new_extradata;
3053     HEVCContext *s = avctx->priv_data;
3054
3055     if (!avpkt->size) {
3056         ret = ff_hevc_output_frame(s, data, 1);
3057         if (ret < 0)
3058             return ret;
3059
3060         *got_output = ret;
3061         return 0;
3062     }
3063
3064     new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
3065                                             &new_extradata_size);
3066     if (new_extradata && new_extradata_size > 0) {
3067         ret = hevc_decode_extradata(s, new_extradata, new_extradata_size);
3068         if (ret < 0)
3069             return ret;
3070     }
3071
3072     s->ref = NULL;
3073     ret    = decode_nal_units(s, avpkt->data, avpkt->size);
3074     if (ret < 0)
3075         return ret;
3076
3077     if (avctx->hwaccel) {
3078         if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) {
3079             av_log(avctx, AV_LOG_ERROR,
3080                    "hardware accelerator failed to decode picture\n");
3081             ff_hevc_unref_frame(s, s->ref, ~0);
3082             return ret;
3083         }
3084     } else {
3085         /* verify the SEI checksum */
3086         if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3087             s->is_md5) {
3088             ret = verify_md5(s, s->ref->frame);
3089             if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3090                 ff_hevc_unref_frame(s, s->ref, ~0);
3091                 return ret;
3092             }
3093         }
3094     }
3095     s->is_md5 = 0;
3096
3097     if (s->is_decoded) {
3098         av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3099         s->is_decoded = 0;
3100     }
3101
3102     if (s->output_frame->buf[0]) {
3103         av_frame_move_ref(data, s->output_frame);
3104         *got_output = 1;
3105     }
3106
3107     return avpkt->size;
3108 }
3109
3110 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3111 {
3112     int ret;
3113
3114     ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3115     if (ret < 0)
3116         return ret;
3117
3118     dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3119     if (!dst->tab_mvf_buf)
3120         goto fail;
3121     dst->tab_mvf = src->tab_mvf;
3122
3123     dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3124     if (!dst->rpl_tab_buf)
3125         goto fail;
3126     dst->rpl_tab = src->rpl_tab;
3127
3128     dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3129     if (!dst->rpl_buf)
3130         goto fail;
3131
3132     dst->poc        = src->poc;
3133     dst->ctb_count  = src->ctb_count;
3134     dst->window     = src->window;
3135     dst->flags      = src->flags;
3136     dst->sequence   = src->sequence;
3137
3138     if (src->hwaccel_picture_private) {
3139         dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
3140         if (!dst->hwaccel_priv_buf)
3141             goto fail;
3142         dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
3143     }
3144
3145     return 0;
3146 fail:
3147     ff_hevc_unref_frame(s, dst, ~0);
3148     return AVERROR(ENOMEM);
3149 }
3150
3151 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3152 {
3153     HEVCContext       *s = avctx->priv_data;
3154     int i;
3155
3156     pic_arrays_free(s);
3157
3158     av_freep(&s->md5_ctx);
3159
3160     av_freep(&s->cabac_state);
3161
3162     for (i = 0; i < 3; i++) {
3163         av_freep(&s->sao_pixel_buffer_h[i]);
3164         av_freep(&s->sao_pixel_buffer_v[i]);
3165     }
3166     av_frame_free(&s->output_frame);
3167
3168     for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3169         ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3170         av_frame_free(&s->DPB[i].frame);
3171     }
3172
3173     for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
3174         av_buffer_unref(&s->ps.vps_list[i]);
3175     for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
3176         av_buffer_unref(&s->ps.sps_list[i]);
3177     for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
3178         av_buffer_unref(&s->ps.pps_list[i]);
3179     s->ps.sps = NULL;
3180     s->ps.pps = NULL;
3181     s->ps.vps = NULL;
3182
3183     av_freep(&s->sh.entry_point_offset);
3184     av_freep(&s->sh.offset);
3185     av_freep(&s->sh.size);
3186
3187     for (i = 1; i < s->threads_number; i++) {
3188         HEVCLocalContext *lc = s->HEVClcList[i];
3189         if (lc) {
3190             av_freep(&s->HEVClcList[i]);
3191             av_freep(&s->sList[i]);
3192         }
3193     }
3194     if (s->HEVClc == s->HEVClcList[0])
3195         s->HEVClc = NULL;
3196     av_freep(&s->HEVClcList[0]);
3197
3198     ff_h2645_packet_uninit(&s->pkt);
3199
3200     return 0;
3201 }
3202
3203 static av_cold int hevc_init_context(AVCodecContext *avctx)
3204 {
3205     HEVCContext *s = avctx->priv_data;
3206     int i;
3207
3208     s->avctx = avctx;
3209
3210     s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3211     if (!s->HEVClc)
3212         goto fail;
3213     s->HEVClcList[0] = s->HEVClc;
3214     s->sList[0] = s;
3215
3216     s->cabac_state = av_malloc(HEVC_CONTEXTS);
3217     if (!s->cabac_state)
3218         goto fail;
3219
3220     s->output_frame = av_frame_alloc();
3221     if (!s->output_frame)
3222         goto fail;
3223
3224     for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3225         s->DPB[i].frame = av_frame_alloc();
3226         if (!s->DPB[i].frame)
3227             goto fail;
3228         s->DPB[i].tf.f = s->DPB[i].frame;
3229     }
3230
3231     s->max_ra = INT_MAX;
3232
3233     s->md5_ctx = av_md5_alloc();
3234     if (!s->md5_ctx)
3235         goto fail;
3236
3237     ff_bswapdsp_init(&s->bdsp);
3238
3239     s->context_initialized = 1;
3240     s->eos = 0;
3241
3242     ff_hevc_reset_sei(s);
3243
3244     return 0;
3245
3246 fail:
3247     hevc_decode_free(avctx);
3248     return AVERROR(ENOMEM);
3249 }
3250
3251 static int hevc_update_thread_context(AVCodecContext *dst,
3252                                       const AVCodecContext *src)
3253 {
3254     HEVCContext *s  = dst->priv_data;
3255     HEVCContext *s0 = src->priv_data;
3256     int i, ret;
3257
3258     if (!s->context_initialized) {
3259         ret = hevc_init_context(dst);
3260         if (ret < 0)
3261             return ret;
3262     }
3263
3264     for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3265         ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3266         if (s0->DPB[i].frame->buf[0]) {
3267             ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3268             if (ret < 0)
3269                 return ret;
3270         }
3271     }
3272
3273     if (s->ps.sps != s0->ps.sps)
3274         s->ps.sps = NULL;
3275     for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
3276         av_buffer_unref(&s->ps.vps_list[i]);
3277         if (s0->ps.vps_list[i]) {
3278             s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
3279             if (!s->ps.vps_list[i])
3280                 return AVERROR(ENOMEM);
3281         }
3282     }
3283
3284     for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3285         av_buffer_unref(&s->ps.sps_list[i]);
3286         if (s0->ps.sps_list[i]) {
3287             s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
3288             if (!s->ps.sps_list[i])
3289                 return AVERROR(ENOMEM);
3290         }
3291     }
3292
3293     for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
3294         av_buffer_unref(&s->ps.pps_list[i]);
3295         if (s0->ps.pps_list[i]) {
3296             s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
3297             if (!s->ps.pps_list[i])
3298                 return AVERROR(ENOMEM);
3299         }
3300     }
3301
3302     if (s->ps.sps != s0->ps.sps)
3303         if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
3304             return ret;
3305
3306     s->seq_decode = s0->seq_decode;
3307     s->seq_output = s0->seq_output;
3308     s->pocTid0    = s0->pocTid0;
3309     s->max_ra     = s0->max_ra;
3310     s->eos        = s0->eos;
3311     s->no_rasl_output_flag = s0->no_rasl_output_flag;
3312
3313     s->is_nalff        = s0->is_nalff;
3314     s->nal_length_size = s0->nal_length_size;
3315
3316     s->threads_number      = s0->threads_number;
3317     s->threads_type        = s0->threads_type;
3318
3319     if (s0->eos) {
3320         s->seq_decode = (s->seq_decode + 1) & 0xff;
3321         s->max_ra = INT_MAX;
3322     }
3323
3324     return 0;
3325 }
3326
3327 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3328 {
3329     HEVCContext *s = avctx->priv_data;
3330     int ret;
3331
3332     avctx->internal->allocate_progress = 1;
3333
3334     ret = hevc_init_context(avctx);
3335     if (ret < 0)
3336         return ret;
3337
3338     s->enable_parallel_tiles = 0;
3339     s->picture_struct = 0;
3340     s->eos = 1;
3341
3342     atomic_init(&s->wpp_err, 0);
3343
3344     if(avctx->active_thread_type & FF_THREAD_SLICE)
3345         s->threads_number = avctx->thread_count;
3346     else
3347         s->threads_number = 1;
3348
3349     if (avctx->extradata_size > 0 && avctx->extradata) {
3350         ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size);
3351         if (ret < 0) {
3352             hevc_decode_free(avctx);
3353             return ret;
3354         }
3355     }
3356
3357     if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3358             s->threads_type = FF_THREAD_FRAME;
3359         else
3360             s->threads_type = FF_THREAD_SLICE;
3361
3362     return 0;
3363 }
3364
3365 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3366 {
3367     HEVCContext *s = avctx->priv_data;
3368     int ret;
3369
3370     memset(s, 0, sizeof(*s));
3371
3372     ret = hevc_init_context(avctx);
3373     if (ret < 0)
3374         return ret;
3375
3376     return 0;
3377 }
3378
3379 static void hevc_decode_flush(AVCodecContext *avctx)
3380 {
3381     HEVCContext *s = avctx->priv_data;
3382     ff_hevc_flush_dpb(s);
3383     s->max_ra = INT_MAX;
3384     s->eos = 1;
3385 }
3386
3387 #define OFFSET(x) offsetof(HEVCContext, x)
3388 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3389
3390 static const AVOption options[] = {
3391     { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3392         AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3393     { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3394         AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3395     { NULL },
3396 };
3397
3398 static const AVClass hevc_decoder_class = {
3399     .class_name = "HEVC decoder",
3400     .item_name  = av_default_item_name,
3401     .option     = options,
3402     .version    = LIBAVUTIL_VERSION_INT,
3403 };
3404
3405 AVCodec ff_hevc_decoder = {
3406     .name                  = "hevc",
3407     .long_name             = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3408     .type                  = AVMEDIA_TYPE_VIDEO,
3409     .id                    = AV_CODEC_ID_HEVC,
3410     .priv_data_size        = sizeof(HEVCContext),
3411     .priv_class            = &hevc_decoder_class,
3412     .init                  = hevc_decode_init,
3413     .close               &n