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