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