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