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