Merge commit '1f80742f49a9a4e846c9f099387881abc87150b2'
[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 hls_prediction_unit(HEVCContext *s, int x0, int y0,
1580                                 int nPbW, int nPbH,
1581                                 int log2_cb_size, int partIdx, int idx)
1582 {
1583 #define POS(c_idx, x, y)                                                              \
1584     &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1585                            (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1586     HEVCLocalContext *lc = s->HEVClc;
1587     int merge_idx = 0;
1588     struct MvField current_mv = {{{ 0 }}};
1589
1590     int min_pu_width = s->sps->min_pu_width;
1591
1592     MvField *tab_mvf = s->ref->tab_mvf;
1593     RefPicList  *refPicList = s->ref->refPicList;
1594     HEVCFrame *ref0, *ref1;
1595     uint8_t *dst0 = POS(0, x0, y0);
1596     uint8_t *dst1 = POS(1, x0, y0);
1597     uint8_t *dst2 = POS(2, x0, y0);
1598     int log2_min_cb_size = s->sps->log2_min_cb_size;
1599     int min_cb_width     = s->sps->min_cb_width;
1600     int x_cb             = x0 >> log2_min_cb_size;
1601     int y_cb             = y0 >> log2_min_cb_size;
1602     int x_pu, y_pu;
1603     int i, j;
1604
1605     int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1606
1607     if (!skip_flag)
1608         lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1609
1610     if (skip_flag || lc->pu.merge_flag) {
1611         if (s->sh.max_num_merge_cand > 1)
1612             merge_idx = ff_hevc_merge_idx_decode(s);
1613         else
1614             merge_idx = 0;
1615
1616         ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1617                                    partIdx, merge_idx, &current_mv);
1618     } else {
1619         enum InterPredIdc inter_pred_idc = PRED_L0;
1620         int mvp_flag;
1621
1622         ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1623         current_mv.pred_flag = 0;
1624         if (s->sh.slice_type == B_SLICE)
1625             inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1626
1627         if (inter_pred_idc != PRED_L1) {
1628             if (s->sh.nb_refs[L0]) {
1629                 current_mv.ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1630             }
1631             current_mv.pred_flag = PF_L0;
1632             ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1633             mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1634             ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1635                                      partIdx, merge_idx, &current_mv,
1636                                      mvp_flag, 0);
1637             current_mv.mv[0].x += lc->pu.mvd.x;
1638             current_mv.mv[0].y += lc->pu.mvd.y;
1639         }
1640
1641         if (inter_pred_idc != PRED_L0) {
1642             if (s->sh.nb_refs[L1]) {
1643                 current_mv.ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1644             }
1645
1646             if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1647                 AV_ZERO32(&lc->pu.mvd);
1648             } else {
1649                 ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1650             }
1651
1652             current_mv.pred_flag += PF_L1;
1653             mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1654             ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1655                                      partIdx, merge_idx, &current_mv,
1656                                      mvp_flag, 1);
1657             current_mv.mv[1].x += lc->pu.mvd.x;
1658             current_mv.mv[1].y += lc->pu.mvd.y;
1659         }
1660     }
1661
1662     x_pu = x0 >> s->sps->log2_min_pu_size;
1663     y_pu = y0 >> s->sps->log2_min_pu_size;
1664
1665     for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1666         for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1667             tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1668
1669     if (current_mv.pred_flag & PF_L0) {
1670         ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1671         if (!ref0)
1672             return;
1673         hevc_await_progress(s, ref0, &current_mv.mv[0], y0, nPbH);
1674     }
1675     if (current_mv.pred_flag & PF_L1) {
1676         ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1677         if (!ref1)
1678             return;
1679         hevc_await_progress(s, ref1, &current_mv.mv[1], y0, nPbH);
1680     }
1681
1682     if (current_mv.pred_flag == PF_L0) {
1683         int x0_c = x0 >> s->sps->hshift[1];
1684         int y0_c = y0 >> s->sps->vshift[1];
1685         int nPbW_c = nPbW >> s->sps->hshift[1];
1686         int nPbH_c = nPbH >> s->sps->vshift[1];
1687
1688         luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1689                     &current_mv.mv[0], x0, y0, nPbW, nPbH,
1690                     s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1691                     s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1692
1693         chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1694                       0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1695                       s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1696         chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1697                       0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1698                       s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1699     } else if (current_mv.pred_flag == PF_L1) {
1700         int x0_c = x0 >> s->sps->hshift[1];
1701         int y0_c = y0 >> s->sps->vshift[1];
1702         int nPbW_c = nPbW >> s->sps->hshift[1];
1703         int nPbH_c = nPbH >> s->sps->vshift[1];
1704
1705         luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1706                     &current_mv.mv[1], x0, y0, nPbW, nPbH,
1707                     s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1708                     s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1709
1710         chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1711                       1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1712                       s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1713
1714         chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1715                       1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1716                       s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1717     } else if (current_mv.pred_flag == PF_BI) {
1718         int x0_c = x0 >> s->sps->hshift[1];
1719         int y0_c = y0 >> s->sps->vshift[1];
1720         int nPbW_c = nPbW >> s->sps->hshift[1];
1721         int nPbH_c = nPbH >> s->sps->vshift[1];
1722
1723         luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1724                    &current_mv.mv[0], x0, y0, nPbW, nPbH,
1725                    ref1->frame, &current_mv.mv[1], &current_mv);
1726
1727         chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1728                      x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 0);
1729
1730         chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1731                      x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 1);
1732     }
1733 }
1734
1735 /**
1736  * 8.4.1
1737  */
1738 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1739                                 int prev_intra_luma_pred_flag)
1740 {
1741     HEVCLocalContext *lc = s->HEVClc;
1742     int x_pu             = x0 >> s->sps->log2_min_pu_size;
1743     int y_pu             = y0 >> s->sps->log2_min_pu_size;
1744     int min_pu_width     = s->sps->min_pu_width;
1745     int size_in_pus      = pu_size >> s->sps->log2_min_pu_size;
1746     int x0b              = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1747     int y0b              = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1748
1749     int cand_up   = (lc->ctb_up_flag || y0b) ?
1750                     s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1751     int cand_left = (lc->ctb_left_flag || x0b) ?
1752                     s->tab_ipm[y_pu * min_pu_width + x_pu - 1]   : INTRA_DC;
1753
1754     int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1755
1756     MvField *tab_mvf = s->ref->tab_mvf;
1757     int intra_pred_mode;
1758     int candidate[3];
1759     int i, j;
1760
1761     // intra_pred_mode prediction does not cross vertical CTB boundaries
1762     if ((y0 - 1) < y_ctb)
1763         cand_up = INTRA_DC;
1764
1765     if (cand_left == cand_up) {
1766         if (cand_left < 2) {
1767             candidate[0] = INTRA_PLANAR;
1768             candidate[1] = INTRA_DC;
1769             candidate[2] = INTRA_ANGULAR_26;
1770         } else {
1771             candidate[0] = cand_left;
1772             candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1773             candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1774         }
1775     } else {
1776         candidate[0] = cand_left;
1777         candidate[1] = cand_up;
1778         if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1779             candidate[2] = INTRA_PLANAR;
1780         } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1781             candidate[2] = INTRA_DC;
1782         } else {
1783             candidate[2] = INTRA_ANGULAR_26;
1784         }
1785     }
1786
1787     if (prev_intra_luma_pred_flag) {
1788         intra_pred_mode = candidate[lc->pu.mpm_idx];
1789     } else {
1790         if (candidate[0] > candidate[1])
1791             FFSWAP(uint8_t, candidate[0], candidate[1]);
1792         if (candidate[0] > candidate[2])
1793             FFSWAP(uint8_t, candidate[0], candidate[2]);
1794         if (candidate[1] > candidate[2])
1795             FFSWAP(uint8_t, candidate[1], candidate[2]);
1796
1797         intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1798         for (i = 0; i < 3; i++)
1799             if (intra_pred_mode >= candidate[i])
1800                 intra_pred_mode++;
1801     }
1802
1803     /* write the intra prediction units into the mv array */
1804     if (!size_in_pus)
1805         size_in_pus = 1;
1806     for (i = 0; i < size_in_pus; i++) {
1807         memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1808                intra_pred_mode, size_in_pus);
1809
1810         for (j = 0; j < size_in_pus; j++) {
1811             tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1812         }
1813     }
1814
1815     return intra_pred_mode;
1816 }
1817
1818 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1819                                           int log2_cb_size, int ct_depth)
1820 {
1821     int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1822     int x_cb   = x0 >> s->sps->log2_min_cb_size;
1823     int y_cb   = y0 >> s->sps->log2_min_cb_size;
1824     int y;
1825
1826     for (y = 0; y < length; y++)
1827         memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1828                ct_depth, length);
1829 }
1830
1831 static const uint8_t tab_mode_idx[] = {
1832      0,  1,  2,  2,  2,  2,  3,  5,  7,  8, 10, 12, 13, 15, 17, 18, 19, 20,
1833     21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1834
1835 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1836                                   int log2_cb_size)
1837 {
1838     HEVCLocalContext *lc = s->HEVClc;
1839     static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1840     uint8_t prev_intra_luma_pred_flag[4];
1841     int split   = lc->cu.part_mode == PART_NxN;
1842     int pb_size = (1 << log2_cb_size) >> split;
1843     int side    = split + 1;
1844     int chroma_mode;
1845     int i, j;
1846
1847     for (i = 0; i < side; i++)
1848         for (j = 0; j < side; j++)
1849             prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1850
1851     for (i = 0; i < side; i++) {
1852         for (j = 0; j < side; j++) {
1853             if (prev_intra_luma_pred_flag[2 * i + j])
1854                 lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1855             else
1856                 lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1857
1858             lc->pu.intra_pred_mode[2 * i + j] =
1859                 luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1860                                      prev_intra_luma_pred_flag[2 * i + j]);
1861         }
1862     }
1863
1864     if (s->sps->chroma_format_idc == 3) {
1865         for (i = 0; i < side; i++) {
1866             for (j = 0; j < side; j++) {
1867                 lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1868                 if (chroma_mode != 4) {
1869                     if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1870                         lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1871                     else
1872                         lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1873                 } else {
1874                     lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1875                 }
1876             }
1877         }
1878     } else if (s->sps->chroma_format_idc == 2) {
1879         int mode_idx;
1880         lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1881         if (chroma_mode != 4) {
1882             if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1883                 mode_idx = 34;
1884             else
1885                 mode_idx = intra_chroma_table[chroma_mode];
1886         } else {
1887             mode_idx = lc->pu.intra_pred_mode[0];
1888         }
1889         lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1890     } else if (s->sps->chroma_format_idc != 0) {
1891         chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1892         if (chroma_mode != 4) {
1893             if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1894                 lc->pu.intra_pred_mode_c[0] = 34;
1895             else
1896                 lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1897         } else {
1898             lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1899         }
1900     }
1901 }
1902
1903 static void intra_prediction_unit_default_value(HEVCContext *s,
1904                                                 int x0, int y0,
1905                                                 int log2_cb_size)
1906 {
1907     HEVCLocalContext *lc = s->HEVClc;
1908     int pb_size          = 1 << log2_cb_size;
1909     int size_in_pus      = pb_size >> s->sps->log2_min_pu_size;
1910     int min_pu_width     = s->sps->min_pu_width;
1911     MvField *tab_mvf     = s->ref->tab_mvf;
1912     int x_pu             = x0 >> s->sps->log2_min_pu_size;
1913     int y_pu             = y0 >> s->sps->log2_min_pu_size;
1914     int j, k;
1915
1916     if (size_in_pus == 0)
1917         size_in_pus = 1;
1918     for (j = 0; j < size_in_pus; j++)
1919         memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1920     if (lc->cu.pred_mode == MODE_INTRA)
1921         for (j = 0; j < size_in_pus; j++)
1922             for (k = 0; k < size_in_pus; k++)
1923                 tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1924 }
1925
1926 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1927 {
1928     int cb_size          = 1 << log2_cb_size;
1929     HEVCLocalContext *lc = s->HEVClc;
1930     int log2_min_cb_size = s->sps->log2_min_cb_size;
1931     int length           = cb_size >> log2_min_cb_size;
1932     int min_cb_width     = s->sps->min_cb_width;
1933     int x_cb             = x0 >> log2_min_cb_size;
1934     int y_cb             = y0 >> log2_min_cb_size;
1935     int idx              = log2_cb_size - 2;
1936     int qp_block_mask    = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1937     int x, y, ret;
1938
1939     lc->cu.x                = x0;
1940     lc->cu.y                = y0;
1941     lc->cu.pred_mode        = MODE_INTRA;
1942     lc->cu.part_mode        = PART_2Nx2N;
1943     lc->cu.intra_split_flag = 0;
1944
1945     SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
1946     for (x = 0; x < 4; x++)
1947         lc->pu.intra_pred_mode[x] = 1;
1948     if (s->pps->transquant_bypass_enable_flag) {
1949         lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
1950         if (lc->cu.cu_transquant_bypass_flag)
1951             set_deblocking_bypass(s, x0, y0, log2_cb_size);
1952     } else
1953         lc->cu.cu_transquant_bypass_flag = 0;
1954
1955     if (s->sh.slice_type != I_SLICE) {
1956         uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
1957
1958         x = y_cb * min_cb_width + x_cb;
1959         for (y = 0; y < length; y++) {
1960             memset(&s->skip_flag[x], skip_flag, length);
1961             x += min_cb_width;
1962         }
1963         lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
1964     } else {
1965         x = y_cb * min_cb_width + x_cb;
1966         for (y = 0; y < length; y++) {
1967             memset(&s->skip_flag[x], 0, length);
1968             x += min_cb_width;
1969         }
1970     }
1971
1972     if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
1973         hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
1974         intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
1975
1976         if (!s->sh.disable_deblocking_filter_flag)
1977             ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1978     } else {
1979         int pcm_flag = 0;
1980
1981         if (s->sh.slice_type != I_SLICE)
1982             lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
1983         if (lc->cu.pred_mode != MODE_INTRA ||
1984             log2_cb_size == s->sps->log2_min_cb_size) {
1985             lc->cu.part_mode        = ff_hevc_part_mode_decode(s, log2_cb_size);
1986             lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
1987                                       lc->cu.pred_mode == MODE_INTRA;
1988         }
1989
1990         if (lc->cu.pred_mode == MODE_INTRA) {
1991             if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
1992                 log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
1993                 log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
1994                 pcm_flag = ff_hevc_pcm_flag_decode(s);
1995             }
1996             if (pcm_flag) {
1997                 intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
1998                 ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
1999                 if (s->sps->pcm.loop_filter_disable_flag)
2000                     set_deblocking_bypass(s, x0, y0, log2_cb_size);
2001
2002                 if (ret < 0)
2003                     return ret;
2004             } else {
2005                 intra_prediction_unit(s, x0, y0, log2_cb_size);
2006             }
2007         } else {
2008             intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2009             switch (lc->cu.part_mode) {
2010             case PART_2Nx2N:
2011                 hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2012                 break;
2013             case PART_2NxN:
2014                 hls_prediction_unit(s, x0, y0,               cb_size, cb_size / 2, log2_cb_size, 0, idx);
2015                 hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2016                 break;
2017             case PART_Nx2N:
2018                 hls_prediction_unit(s, x0,               y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2019                 hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2020                 break;
2021             case PART_2NxnU:
2022                 hls_prediction_unit(s, x0, y0,               cb_size, cb_size     / 4, log2_cb_size, 0, idx);
2023                 hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2024                 break;
2025             case PART_2NxnD:
2026                 hls_prediction_unit(s, x0, y0,                   cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2027                 hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size     / 4, log2_cb_size, 1, idx);
2028                 break;
2029             case PART_nLx2N:
2030                 hls_prediction_unit(s, x0,               y0, cb_size     / 4, cb_size, log2_cb_size, 0, idx - 2);
2031                 hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2032                 break;
2033             case PART_nRx2N:
2034                 hls_prediction_unit(s, x0,                   y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2035                 hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size     / 4, cb_size, log2_cb_size, 1, idx - 2);
2036                 break;
2037             case PART_NxN:
2038                 hls_prediction_unit(s, x0,               y0,               cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2039                 hls_prediction_unit(s, x0 + cb_size / 2, y0,               cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2040                 hls_prediction_unit(s, x0,               y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2041                 hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2042                 break;
2043             }
2044         }
2045
2046         if (!pcm_flag) {
2047             int rqt_root_cbf = 1;
2048
2049             if (lc->cu.pred_mode != MODE_INTRA &&
2050                 !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2051                 rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2052             }
2053             if (rqt_root_cbf) {
2054                 const static int cbf[2] = { 0 };
2055                 lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2056                                          s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2057                                          s->sps->max_transform_hierarchy_depth_inter;
2058                 ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2059                                          log2_cb_size,
2060                                          log2_cb_size, 0, 0, cbf, cbf);
2061                 if (ret < 0)
2062                     return ret;
2063             } else {
2064                 if (!s->sh.disable_deblocking_filter_flag)
2065                     ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2066             }
2067         }
2068     }
2069
2070     if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2071         ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2072
2073     x = y_cb * min_cb_width + x_cb;
2074     for (y = 0; y < length; y++) {
2075         memset(&s->qp_y_tab[x], lc->qp_y, length);
2076         x += min_cb_width;
2077     }
2078
2079     if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2080        ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2081         lc->qPy_pred = lc->qp_y;
2082     }
2083
2084     set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2085
2086     return 0;
2087 }
2088
2089 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2090                                int log2_cb_size, int cb_depth)
2091 {
2092     HEVCLocalContext *lc = s->HEVClc;
2093     const int cb_size    = 1 << log2_cb_size;
2094     int ret;
2095     int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2096     int split_cu;
2097
2098     lc->ct_depth = cb_depth;
2099     if (x0 + cb_size <= s->sps->width  &&
2100         y0 + cb_size <= s->sps->height &&
2101         log2_cb_size > s->sps->log2_min_cb_size) {
2102         split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2103     } else {
2104         split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2105     }
2106     if (s->pps->cu_qp_delta_enabled_flag &&
2107         log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2108         lc->tu.is_cu_qp_delta_coded = 0;
2109         lc->tu.cu_qp_delta          = 0;
2110     }
2111
2112     if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2113         log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2114         lc->tu.is_cu_chroma_qp_offset_coded = 0;
2115     }
2116
2117     if (split_cu) {
2118         const int cb_size_split = cb_size >> 1;
2119         const int x1 = x0 + cb_size_split;
2120         const int y1 = y0 + cb_size_split;
2121
2122         int more_data = 0;
2123
2124         more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2125         if (more_data < 0)
2126             return more_data;
2127
2128         if (more_data && x1 < s->sps->width) {
2129             more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2130             if (more_data < 0)
2131                 return more_data;
2132         }
2133         if (more_data && y1 < s->sps->height) {
2134             more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2135             if (more_data < 0)
2136                 return more_data;
2137         }
2138         if (more_data && x1 < s->sps->width &&
2139             y1 < s->sps->height) {
2140             more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2141             if (more_data < 0)
2142                 return more_data;
2143         }
2144
2145         if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2146             ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2147             lc->qPy_pred = lc->qp_y;
2148
2149         if (more_data)
2150             return ((x1 + cb_size_split) < s->sps->width ||
2151                     (y1 + cb_size_split) < s->sps->height);
2152         else
2153             return 0;
2154     } else {
2155         ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2156         if (ret < 0)
2157             return ret;
2158         if ((!((x0 + cb_size) %
2159                (1 << (s->sps->log2_ctb_size))) ||
2160              (x0 + cb_size >= s->sps->width)) &&
2161             (!((y0 + cb_size) %
2162                (1 << (s->sps->log2_ctb_size))) ||
2163              (y0 + cb_size >= s->sps->height))) {
2164             int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2165             return !end_of_slice_flag;
2166         } else {
2167             return 1;
2168         }
2169     }
2170
2171     return 0;
2172 }
2173
2174 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2175                                  int ctb_addr_ts)
2176 {
2177     HEVCLocalContext *lc  = s->HEVClc;
2178     int ctb_size          = 1 << s->sps->log2_ctb_size;
2179     int ctb_addr_rs       = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2180     int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2181
2182     s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2183
2184     if (s->pps->entropy_coding_sync_enabled_flag) {
2185         if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2186             lc->first_qp_group = 1;
2187         lc->end_of_tiles_x = s->sps->width;
2188     } else if (s->pps->tiles_enabled_flag) {
2189         if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2190             int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2191             lc->end_of_tiles_x   = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2192             lc->first_qp_group   = 1;
2193         }
2194     } else {
2195         lc->end_of_tiles_x = s->sps->width;
2196     }
2197
2198     lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2199
2200     lc->boundary_flags = 0;
2201     if (s->pps->tiles_enabled_flag) {
2202         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]])
2203             lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2204         if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2205             lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2206         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]])
2207             lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2208         if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2209             lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2210     } else {
2211         if (!ctb_addr_in_slice > 0)
2212             lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2213         if (ctb_addr_in_slice < s->sps->ctb_width)
2214             lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2215     }
2216
2217     lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2218     lc->ctb_up_flag   = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2219     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]]));
2220     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]]));
2221 }
2222
2223 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2224 {
2225     HEVCContext *s  = avctxt->priv_data;
2226     int ctb_size    = 1 << s->sps->log2_ctb_size;
2227     int more_data   = 1;
2228     int x_ctb       = 0;
2229     int y_ctb       = 0;
2230     int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2231
2232     if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2233         av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2234         return AVERROR_INVALIDDATA;
2235     }
2236
2237     if (s->sh.dependent_slice_segment_flag) {
2238         int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2239         if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2240             av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2241             return AVERROR_INVALIDDATA;
2242         }
2243     }
2244
2245     while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2246         int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2247
2248         x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2249         y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2250         hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2251
2252         ff_hevc_cabac_init(s, ctb_addr_ts);
2253
2254         hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2255
2256         s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2257         s->deblock[ctb_addr_rs].tc_offset   = s->sh.tc_offset;
2258         s->filter_slice_edges[ctb_addr_rs]  = s->sh.slice_loop_filter_across_slices_enabled_flag;
2259
2260         more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2261         if (more_data < 0) {
2262             s->tab_slice_address[ctb_addr_rs] = -1;
2263             return more_data;
2264         }
2265
2266
2267         ctb_addr_ts++;
2268         ff_hevc_save_states(s, ctb_addr_ts);
2269         ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2270     }
2271
2272     if (x_ctb + ctb_size >= s->sps->width &&
2273         y_ctb + ctb_size >= s->sps->height)
2274         ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2275
2276     return ctb_addr_ts;
2277 }
2278
2279 static int hls_slice_data(HEVCContext *s)
2280 {
2281     int arg[2];
2282     int ret[2];
2283
2284     arg[0] = 0;
2285     arg[1] = 1;
2286
2287     s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2288     return ret[0];
2289 }
2290 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2291 {
2292     HEVCContext *s1  = avctxt->priv_data, *s;
2293     HEVCLocalContext *lc;
2294     int ctb_size    = 1<< s1->sps->log2_ctb_size;
2295     int more_data   = 1;
2296     int *ctb_row_p    = input_ctb_row;
2297     int ctb_row = ctb_row_p[job];
2298     int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2299     int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2300     int thread = ctb_row % s1->threads_number;
2301     int ret;
2302
2303     s = s1->sList[self_id];
2304     lc = s->HEVClc;
2305
2306     if(ctb_row) {
2307         ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2308
2309         if (ret < 0)
2310             return ret;
2311         ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2312     }
2313
2314     while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2315         int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2316         int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2317
2318         hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2319
2320         ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2321
2322         if (avpriv_atomic_int_get(&s1->wpp_err)){
2323             ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2324             return 0;
2325         }
2326
2327         ff_hevc_cabac_init(s, ctb_addr_ts);
2328         hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2329         more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2330
2331         if (more_data < 0) {
2332             s->tab_slice_address[ctb_addr_rs] = -1;
2333             return more_data;
2334         }
2335
2336         ctb_addr_ts++;
2337
2338         ff_hevc_save_states(s, ctb_addr_ts);
2339         ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2340         ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2341
2342         if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2343             avpriv_atomic_int_set(&s1->wpp_err,  1);
2344             ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2345             return 0;
2346         }
2347
2348         if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2349             ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2350             ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2351             return ctb_addr_ts;
2352         }
2353         ctb_addr_rs       = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2354         x_ctb+=ctb_size;
2355
2356         if(x_ctb >= s->sps->width) {
2357             break;
2358         }
2359     }
2360     ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2361
2362     return 0;
2363 }
2364
2365 static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2366 {
2367     HEVCLocalContext *lc = s->HEVClc;
2368     int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2369     int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2370     int offset;
2371     int startheader, cmpt = 0;
2372     int i, j, res = 0;
2373
2374
2375     if (!s->sList[1]) {
2376         ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2377
2378
2379         for (i = 1; i < s->threads_number; i++) {
2380             s->sList[i] = av_malloc(sizeof(HEVCContext));
2381             memcpy(s->sList[i], s, sizeof(HEVCContext));
2382             s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2383             s->sList[i]->HEVClc = s->HEVClcList[i];
2384         }
2385     }
2386
2387     offset = (lc->gb.index >> 3);
2388
2389     for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2390         if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2391             startheader--;
2392             cmpt++;
2393         }
2394     }
2395
2396     for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2397         offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2398         for (j = 0, cmpt = 0, startheader = offset
2399              + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2400             if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2401                 startheader--;
2402                 cmpt++;
2403             }
2404         }
2405         s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2406         s->sh.offset[i - 1] = offset;
2407
2408     }
2409     if (s->sh.num_entry_point_offsets != 0) {
2410         offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2411         s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2412         s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2413
2414     }
2415     s->data = nal;
2416
2417     for (i = 1; i < s->threads_number; i++) {
2418         s->sList[i]->HEVClc->first_qp_group = 1;
2419         s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2420         memcpy(s->sList[i], s, sizeof(HEVCContext));
2421         s->sList[i]->HEVClc = s->HEVClcList[i];
2422     }
2423
2424     avpriv_atomic_int_set(&s->wpp_err, 0);
2425     ff_reset_entries(s->avctx);
2426
2427     for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2428         arg[i] = i;
2429         ret[i] = 0;
2430     }
2431
2432     if (s->pps->entropy_coding_sync_enabled_flag)
2433         s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2434
2435     for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2436         res += ret[i];
2437     av_free(ret);
2438     av_free(arg);
2439     return res;
2440 }
2441
2442 /**
2443  * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2444  * 0 if the unit should be skipped, 1 otherwise
2445  */
2446 static int hls_nal_unit(HEVCContext *s)
2447 {
2448     GetBitContext *gb = &s->HEVClc->gb;
2449     int nuh_layer_id;
2450
2451     if (get_bits1(gb) != 0)
2452         return AVERROR_INVALIDDATA;
2453
2454     s->nal_unit_type = get_bits(gb, 6);
2455
2456     nuh_layer_id   = get_bits(gb, 6);
2457     s->temporal_id = get_bits(gb, 3) - 1;
2458     if (s->temporal_id < 0)
2459         return AVERROR_INVALIDDATA;
2460
2461     av_log(s->avctx, AV_LOG_DEBUG,
2462            "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2463            s->nal_unit_type, nuh_layer_id, s->temporal_id);
2464
2465     return nuh_layer_id == 0;
2466 }
2467
2468 static int set_side_data(HEVCContext *s)
2469 {
2470     AVFrame *out = s->ref->frame;
2471
2472     if (s->sei_frame_packing_present &&
2473         s->frame_packing_arrangement_type >= 3 &&
2474         s->frame_packing_arrangement_type <= 5 &&
2475         s->content_interpretation_type > 0 &&
2476         s->content_interpretation_type < 3) {
2477         AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2478         if (!stereo)
2479             return AVERROR(ENOMEM);
2480
2481         switch (s->frame_packing_arrangement_type) {
2482         case 3:
2483             if (s->quincunx_subsampling)
2484                 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2485             else
2486                 stereo->type = AV_STEREO3D_SIDEBYSIDE;
2487             break;
2488         case 4:
2489             stereo->type = AV_STEREO3D_TOPBOTTOM;
2490             break;
2491         case 5:
2492             stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2493             break;
2494         }
2495
2496         if (s->content_interpretation_type == 2)
2497             stereo->flags = AV_STEREO3D_FLAG_INVERT;
2498     }
2499
2500     if (s->sei_display_orientation_present &&
2501         (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2502         double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2503         AVFrameSideData *rotation = av_frame_new_side_data(out,
2504                                                            AV_FRAME_DATA_DISPLAYMATRIX,
2505                                                            sizeof(int32_t) * 9);
2506         if (!rotation)
2507             return AVERROR(ENOMEM);
2508
2509         av_display_rotation_set((int32_t *)rotation->data, angle);
2510         av_display_matrix_flip((int32_t *)rotation->data,
2511                                s->sei_hflip, s->sei_vflip);
2512     }
2513
2514     return 0;
2515 }
2516
2517 static int hevc_frame_start(HEVCContext *s)
2518 {
2519     HEVCLocalContext *lc = s->HEVClc;
2520     int pic_size_in_ctb  = ((s->sps->width  >> s->sps->log2_min_cb_size) + 1) *
2521                            ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2522     int ret;
2523
2524     memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2525     memset(s->vertical_bs,   0, s->bs_width * s->bs_height);
2526     memset(s->cbf_luma,      0, s->sps->min_tb_width * s->sps->min_tb_height);
2527     memset(s->is_pcm,        0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2528     memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2529
2530     s->is_decoded        = 0;
2531     s->first_nal_type    = s->nal_unit_type;
2532
2533     if (s->pps->tiles_enabled_flag)
2534         lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2535
2536     ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2537     if (ret < 0)
2538         goto fail;
2539
2540     ret = ff_hevc_frame_rps(s);
2541     if (ret < 0) {
2542         av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2543         goto fail;
2544     }
2545
2546     s->ref->frame->key_frame = IS_IRAP(s);
2547
2548     ret = set_side_data(s);
2549     if (ret < 0)
2550         goto fail;
2551
2552     s->frame->pict_type = 3 - s->sh.slice_type;
2553
2554     if (!IS_IRAP(s))
2555         ff_hevc_bump_frame(s);
2556
2557     av_frame_unref(s->output_frame);
2558     ret = ff_hevc_output_frame(s, s->output_frame, 0);
2559     if (ret < 0)
2560         goto fail;
2561
2562     ff_thread_finish_setup(s->avctx);
2563
2564     return 0;
2565
2566 fail:
2567     if (s->ref && s->threads_type == FF_THREAD_FRAME)
2568         ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2569     s->ref = NULL;
2570     return ret;
2571 }
2572
2573 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2574 {
2575     HEVCLocalContext *lc = s->HEVClc;
2576     GetBitContext *gb    = &lc->gb;
2577     int ctb_addr_ts, ret;
2578
2579     ret = init_get_bits8(gb, nal, length);
2580     if (ret < 0)
2581         return ret;
2582
2583     ret = hls_nal_unit(s);
2584     if (ret < 0) {
2585         av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2586                s->nal_unit_type);
2587         goto fail;
2588     } else if (!ret)
2589         return 0;
2590
2591     switch (s->nal_unit_type) {
2592     case NAL_VPS:
2593         ret = ff_hevc_decode_nal_vps(s);
2594         if (ret < 0)
2595             goto fail;
2596         break;
2597     case NAL_SPS:
2598         ret = ff_hevc_decode_nal_sps(s);
2599         if (ret < 0)
2600             goto fail;
2601         break;
2602     case NAL_PPS:
2603         ret = ff_hevc_decode_nal_pps(s);
2604         if (ret < 0)
2605             goto fail;
2606         break;
2607     case NAL_SEI_PREFIX:
2608     case NAL_SEI_SUFFIX:
2609         ret = ff_hevc_decode_nal_sei(s);
2610         if (ret < 0)
2611             goto fail;
2612         break;
2613     case NAL_TRAIL_R:
2614     case NAL_TRAIL_N:
2615     case NAL_TSA_N:
2616     case NAL_TSA_R:
2617     case NAL_STSA_N:
2618     case NAL_STSA_R:
2619     case NAL_BLA_W_LP:
2620     case NAL_BLA_W_RADL:
2621     case NAL_BLA_N_LP:
2622     case NAL_IDR_W_RADL:
2623     case NAL_IDR_N_LP:
2624     case NAL_CRA_NUT:
2625     case NAL_RADL_N:
2626     case NAL_RADL_R:
2627     case NAL_RASL_N:
2628     case NAL_RASL_R:
2629         ret = hls_slice_header(s);
2630         if (ret < 0)
2631             return ret;
2632
2633         if (s->max_ra == INT_MAX) {
2634             if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2635                 s->max_ra = s->poc;
2636             } else {
2637                 if (IS_IDR(s))
2638                     s->max_ra = INT_MIN;
2639             }
2640         }
2641
2642         if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2643             s->poc <= s->max_ra) {
2644             s->is_decoded = 0;
2645             break;
2646         } else {
2647             if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2648                 s->max_ra = INT_MIN;
2649         }
2650
2651         if (s->sh.first_slice_in_pic_flag) {
2652             ret = hevc_frame_start(s);
2653             if (ret < 0)
2654                 return ret;
2655         } else if (!s->ref) {
2656             av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2657             goto fail;
2658         }
2659
2660         if (s->nal_unit_type != s->first_nal_type) {
2661             av_log(s->avctx, AV_LOG_ERROR,
2662                    "Non-matching NAL types of the VCL NALUs: %d %d\n",
2663                    s->first_nal_type, s->nal_unit_type);
2664             return AVERROR_INVALIDDATA;
2665         }
2666
2667         if (!s->sh.dependent_slice_segment_flag &&
2668             s->sh.slice_type != I_SLICE) {
2669             ret = ff_hevc_slice_rpl(s);
2670             if (ret < 0) {
2671                 av_log(s->avctx, AV_LOG_WARNING,
2672                        "Error constructing the reference lists for the current slice.\n");
2673                 goto fail;
2674             }
2675         }
2676
2677         if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2678             ctb_addr_ts = hls_slice_data_wpp(s, nal, length);
2679         else
2680             ctb_addr_ts = hls_slice_data(s);
2681         if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2682             s->is_decoded = 1;
2683         }
2684
2685         if (ctb_addr_ts < 0) {
2686             ret = ctb_addr_ts;
2687             goto fail;
2688         }
2689         break;
2690     case NAL_EOS_NUT:
2691     case NAL_EOB_NUT:
2692         s->seq_decode = (s->seq_decode + 1) & 0xff;
2693         s->max_ra     = INT_MAX;
2694         break;
2695     case NAL_AUD:
2696     case NAL_FD_NUT:
2697         break;
2698     default:
2699         av_log(s->avctx, AV_LOG_INFO,
2700                "Skipping NAL unit %d\n", s->nal_unit_type);
2701     }
2702
2703     return 0;
2704 fail:
2705     if (s->avctx->err_recognition & AV_EF_EXPLODE)
2706         return ret;
2707     return 0;
2708 }
2709
2710 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2711  * between these functions would be nice. */
2712 int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2713                          HEVCNAL *nal)
2714 {
2715     int i, si, di;
2716     uint8_t *dst;
2717
2718     s->skipped_bytes = 0;
2719 #define STARTCODE_TEST                                                  \
2720         if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) {     \
2721             if (src[i + 2] != 3) {                                      \
2722                 /* startcode, so we must be past the end */             \
2723                 length = i;                                             \
2724             }                                                           \
2725             break;                                                      \
2726         }
2727 #if HAVE_FAST_UNALIGNED
2728 #define FIND_FIRST_ZERO                                                 \
2729         if (i > 0 && !src[i])                                           \
2730             i--;                                                        \
2731         while (src[i])                                                  \
2732             i++
2733 #if HAVE_FAST_64BIT
2734     for (i = 0; i + 1 < length; i += 9) {
2735         if (!((~AV_RN64A(src + i) &
2736                (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2737               0x8000800080008080ULL))
2738             continue;
2739         FIND_FIRST_ZERO;
2740         STARTCODE_TEST;
2741         i -= 7;
2742     }
2743 #else
2744     for (i = 0; i + 1 < length; i += 5) {
2745         if (!((~AV_RN32A(src + i) &
2746                (AV_RN32A(src + i) - 0x01000101U)) &
2747               0x80008080U))
2748             continue;
2749         FIND_FIRST_ZERO;
2750         STARTCODE_TEST;
2751         i -= 3;
2752     }
2753 #endif /* HAVE_FAST_64BIT */
2754 #else
2755     for (i = 0; i + 1 < length; i += 2) {
2756         if (src[i])
2757             continue;
2758         if (i > 0 && src[i - 1] == 0)
2759             i--;
2760         STARTCODE_TEST;
2761     }
2762 #endif /* HAVE_FAST_UNALIGNED */
2763
2764     if (i >= length - 1) { // no escaped 0
2765         nal->data = src;
2766         nal->size = length;
2767         return length;
2768     }
2769
2770     av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2771                    length + FF_INPUT_BUFFER_PADDING_SIZE);
2772     if (!nal->rbsp_buffer)
2773         return AVERROR(ENOMEM);
2774
2775     dst = nal->rbsp_buffer;
2776
2777     memcpy(dst, src, i);
2778     si = di = i;
2779     while (si + 2 < length) {
2780         // remove escapes (very rare 1:2^22)
2781         if (src[si + 2] > 3) {
2782             dst[di++] = src[si++];
2783             dst[di++] = src[si++];
2784         } else if (src[si] == 0 && src[si + 1] == 0) {
2785             if (src[si + 2] == 3) { // escape
2786                 dst[di++] = 0;
2787                 dst[di++] = 0;
2788                 si       += 3;
2789
2790                 s->skipped_bytes++;
2791                 if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2792                     s->skipped_bytes_pos_size *= 2;
2793                     av_reallocp_array(&s->skipped_bytes_pos,
2794                             s->skipped_bytes_pos_size,
2795                             sizeof(*s->skipped_bytes_pos));
2796                     if (!s->skipped_bytes_pos)
2797                         return AVERROR(ENOMEM);
2798                 }
2799                 if (s->skipped_bytes_pos)
2800                     s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2801                 continue;
2802             } else // next start code
2803                 goto nsc;
2804         }
2805
2806         dst[di++] = src[si++];
2807     }
2808     while (si < length)
2809         dst[di++] = src[si++];
2810
2811 nsc:
2812     memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2813
2814     nal->data = dst;
2815     nal->size = di;
2816     return si;
2817 }
2818
2819 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2820 {
2821     int i, consumed, ret = 0;
2822
2823     s->ref = NULL;
2824     s->last_eos = s->eos;
2825     s->eos = 0;
2826
2827     /* split the input packet into NAL units, so we know the upper bound on the
2828      * number of slices in the frame */
2829     s->nb_nals = 0;
2830     while (length >= 4) {
2831         HEVCNAL *nal;
2832         int extract_length = 0;
2833
2834         if (s->is_nalff) {
2835             int i;
2836             for (i = 0; i < s->nal_length_size; i++)
2837                 extract_length = (extract_length << 8) | buf[i];
2838             buf    += s->nal_length_size;
2839             length -= s->nal_length_size;
2840
2841             if (extract_length > length) {
2842                 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2843                 ret = AVERROR_INVALIDDATA;
2844                 goto fail;
2845             }
2846         } else {
2847             /* search start code */
2848             while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2849                 ++buf;
2850                 --length;
2851                 if (length < 4) {
2852                     av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2853                     ret = AVERROR_INVALIDDATA;
2854                     goto fail;
2855                 }
2856             }
2857
2858             buf           += 3;
2859             length        -= 3;
2860         }
2861
2862         if (!s->is_nalff)
2863             extract_length = length;
2864
2865         if (s->nals_allocated < s->nb_nals + 1) {
2866             int new_size = s->nals_allocated + 1;
2867             HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2868             if (!tmp) {
2869                 ret = AVERROR(ENOMEM);
2870                 goto fail;
2871             }
2872             s->nals = tmp;
2873             memset(s->nals + s->nals_allocated, 0,
2874                    (new_size - s->nals_allocated) * sizeof(*tmp));
2875             av_reallocp_array(&s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2876             av_reallocp_array(&s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2877             av_reallocp_array(&s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2878             s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2879             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));
2880             s->nals_allocated = new_size;
2881         }
2882         s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2883         s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2884         nal = &s->nals[s->nb_nals];
2885
2886         consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2887
2888         s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2889         s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2890         s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2891
2892
2893         if (consumed < 0) {
2894             ret = consumed;
2895             goto fail;
2896         }
2897
2898         ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2899         if (ret < 0)
2900             goto fail;
2901         hls_nal_unit(s);
2902
2903         if (s->nal_unit_type == NAL_EOB_NUT ||
2904             s->nal_unit_type == NAL_EOS_NUT)
2905             s->eos = 1;
2906
2907         buf    += consumed;
2908         length -= consumed;
2909     }
2910
2911     /* parse the NAL units */
2912     for (i = 0; i < s->nb_nals; i++) {
2913         int ret;
2914         s->skipped_bytes = s->skipped_bytes_nal[i];
2915         s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
2916
2917         ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2918         if (ret < 0) {
2919             av_log(s->avctx, AV_LOG_WARNING,
2920                    "Error parsing NAL unit #%d.\n", i);
2921             goto fail;
2922         }
2923     }
2924
2925 fail:
2926     if (s->ref && s->threads_type == FF_THREAD_FRAME)
2927         ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2928
2929     return ret;
2930 }
2931
2932 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2933 {
2934     int i;
2935     for (i = 0; i < 16; i++)
2936         av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2937 }
2938
2939 static int verify_md5(HEVCContext *s, AVFrame *frame)
2940 {
2941     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2942     int pixel_shift;
2943     int i, j;
2944
2945     if (!desc)
2946         return AVERROR(EINVAL);
2947
2948     pixel_shift = desc->comp[0].depth_minus1 > 7;
2949
2950     av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2951            s->poc);
2952
2953     /* the checksums are LE, so we have to byteswap for >8bpp formats
2954      * on BE arches */
2955 #if HAVE_BIGENDIAN
2956     if (pixel_shift && !s->checksum_buf) {
2957         av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2958                        FFMAX3(frame->linesize[0], frame->linesize[1],
2959                               frame->linesize[2]));
2960         if (!s->checksum_buf)
2961             return AVERROR(ENOMEM);
2962     }
2963 #endif
2964
2965     for (i = 0; frame->data[i]; i++) {
2966         int width  = s->avctx->coded_width;
2967         int height = s->avctx->coded_height;
2968         int w = (i == 1 || i == 2) ? (width  >> desc->log2_chroma_w) : width;
2969         int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2970         uint8_t md5[16];
2971
2972         av_md5_init(s->md5_ctx);
2973         for (j = 0; j < h; j++) {
2974             const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2975 #if HAVE_BIGENDIAN
2976             if (pixel_shift) {
2977                 s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2978                                     (const uint16_t *) src, w);
2979                 src = s->checksum_buf;
2980             }
2981 #endif
2982             av_md5_update(s->md5_ctx, src, w << pixel_shift);
2983         }
2984         av_md5_final(s->md5_ctx, md5);
2985
2986         if (!memcmp(md5, s->md5[i], 16)) {
2987             av_log   (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2988             print_md5(s->avctx, AV_LOG_DEBUG, md5);
2989             av_log   (s->avctx, AV_LOG_DEBUG, "; ");
2990         } else {
2991             av_log   (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2992             print_md5(s->avctx, AV_LOG_ERROR, md5);
2993             av_log   (s->avctx, AV_LOG_ERROR, " != ");
2994             print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2995             av_log   (s->avctx, AV_LOG_ERROR, "\n");
2996             return AVERROR_INVALIDDATA;
2997         }
2998     }
2999
3000     av_log(s->avctx, AV_LOG_DEBUG, "\n");
3001
3002     return 0;
3003 }
3004
3005 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3006                              AVPacket *avpkt)
3007 {
3008     int ret;
3009     HEVCContext *s = avctx->priv_data;
3010
3011     if (!avpkt->size) {
3012         ret = ff_hevc_output_frame(s, data, 1);
3013         if (ret < 0)
3014             return ret;
3015
3016         *got_output = ret;
3017         return 0;
3018     }
3019
3020     s->ref = NULL;
3021     ret    = decode_nal_units(s, avpkt->data, avpkt->size);
3022     if (ret < 0)
3023         return ret;
3024
3025     /* verify the SEI checksum */
3026     if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3027         s->is_md5) {
3028         ret = verify_md5(s, s->ref->frame);
3029         if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3030             ff_hevc_unref_frame(s, s->ref, ~0);
3031             return ret;
3032         }
3033     }
3034     s->is_md5 = 0;
3035
3036     if (s->is_decoded) {
3037         av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3038         s->is_decoded = 0;
3039     }
3040
3041     if (s->output_frame->buf[0]) {
3042         av_frame_move_ref(data, s->output_frame);
3043         *got_output = 1;
3044     }
3045
3046     return avpkt->size;
3047 }
3048
3049 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3050 {
3051     int ret;
3052
3053     ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3054     if (ret < 0)
3055         return ret;
3056
3057     dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3058     if (!dst->tab_mvf_buf)
3059         goto fail;
3060     dst->tab_mvf = src->tab_mvf;
3061
3062     dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3063     if (!dst->rpl_tab_buf)
3064         goto fail;
3065     dst->rpl_tab = src->rpl_tab;
3066
3067     dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3068     if (!dst->rpl_buf)
3069         goto fail;
3070
3071     dst->poc        = src->poc;
3072     dst->ctb_count  = src->ctb_count;
3073     dst->window     = src->window;
3074     dst->flags      = src->flags;
3075     dst->sequence   = src->sequence;
3076
3077     return 0;
3078 fail:
3079     ff_hevc_unref_frame(s, dst, ~0);
3080     return AVERROR(ENOMEM);
3081 }
3082
3083 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3084 {
3085     HEVCContext       *s = avctx->priv_data;
3086     int i;
3087
3088     pic_arrays_free(s);
3089
3090     av_freep(&s->md5_ctx);
3091
3092     for(i=0; i < s->nals_allocated; i++) {
3093         av_freep(&s->skipped_bytes_pos_nal[i]);
3094     }
3095     av_freep(&s->skipped_bytes_pos_size_nal);
3096     av_freep(&s->skipped_bytes_nal);
3097     av_freep(&s->skipped_bytes_pos_nal);
3098
3099     av_freep(&s->cabac_state);
3100
3101     av_frame_free(&s->tmp_frame);
3102     av_frame_free(&s->output_frame);
3103
3104     for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3105         ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3106         av_frame_free(&s->DPB[i].frame);
3107     }
3108
3109     for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3110         av_buffer_unref(&s->vps_list[i]);
3111     for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3112         av_buffer_unref(&s->sps_list[i]);
3113     for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3114         av_buffer_unref(&s->pps_list[i]);
3115     s->sps = NULL;
3116     s->pps = NULL;
3117     s->vps = NULL;
3118
3119     av_buffer_unref(&s->current_sps);
3120
3121     av_freep(&s->sh.entry_point_offset);
3122     av_freep(&s->sh.offset);
3123     av_freep(&s->sh.size);
3124
3125     for (i = 1; i < s->threads_number; i++) {
3126         HEVCLocalContext *lc = s->HEVClcList[i];
3127         if (lc) {
3128             av_freep(&s->HEVClcList[i]);
3129             av_freep(&s->sList[i]);
3130         }
3131     }
3132     if (s->HEVClc == s->HEVClcList[0])
3133         s->HEVClc = NULL;
3134     av_freep(&s->HEVClcList[0]);
3135
3136     for (i = 0; i < s->nals_allocated; i++)
3137         av_freep(&s->nals[i].rbsp_buffer);
3138     av_freep(&s->nals);
3139     s->nals_allocated = 0;
3140
3141     return 0;
3142 }
3143
3144 static av_cold int hevc_init_context(AVCodecContext *avctx)
3145 {
3146     HEVCContext *s = avctx->priv_data;
3147     int i;
3148
3149     s->avctx = avctx;
3150
3151     s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3152     if (!s->HEVClc)
3153         goto fail;
3154     s->HEVClcList[0] = s->HEVClc;
3155     s->sList[0] = s;
3156
3157     s->cabac_state = av_malloc(HEVC_CONTEXTS);
3158     if (!s->cabac_state)
3159         goto fail;
3160
3161     s->tmp_frame = av_frame_alloc();
3162     if (!s->tmp_frame)
3163         goto fail;
3164
3165     s->output_frame = av_frame_alloc();
3166     if (!s->output_frame)
3167         goto fail;
3168
3169     for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3170         s->DPB[i].frame = av_frame_alloc();
3171         if (!s->DPB[i].frame)
3172             goto fail;
3173         s->DPB[i].tf.f = s->DPB[i].frame;
3174     }
3175
3176     s->max_ra = INT_MAX;
3177
3178     s->md5_ctx = av_md5_alloc();
3179     if (!s->md5_ctx)
3180         goto fail;
3181
3182     ff_bswapdsp_init(&s->bdsp);
3183
3184     s->context_initialized = 1;
3185     s->eos = 0;
3186
3187     return 0;
3188
3189 fail:
3190     hevc_decode_free(avctx);
3191     return AVERROR(ENOMEM);
3192 }
3193
3194 static int hevc_update_thread_context(AVCodecContext *dst,
3195                                       const AVCodecContext *src)
3196 {
3197     HEVCContext *s  = dst->priv_data;
3198     HEVCContext *s0 = src->priv_data;
3199     int i, ret;
3200
3201     if (!s->context_initialized) {
3202         ret = hevc_init_context(dst);
3203         if (ret < 0)
3204             return ret;
3205     }
3206
3207     for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3208         ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3209         if (s0->DPB[i].frame->buf[0]) {
3210             ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3211             if (ret < 0)
3212                 return ret;
3213         }
3214     }
3215
3216     if (s->sps != s0->sps)
3217         s->sps = NULL;
3218     for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3219         av_buffer_unref(&s->vps_list[i]);
3220         if (s0->vps_list[i]) {
3221             s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3222             if (!s->vps_list[i])
3223                 return AVERROR(ENOMEM);
3224         }
3225     }
3226
3227     for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3228         av_buffer_unref(&s->sps_list[i]);
3229         if (s0->sps_list[i]) {
3230             s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3231             if (!s->sps_list[i])
3232                 return AVERROR(ENOMEM);
3233         }
3234     }
3235
3236     for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3237         av_buffer_unref(&s->pps_list[i]);
3238         if (s0->pps_list[i]) {
3239             s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3240             if (!s->pps_list[i])
3241                 return AVERROR(ENOMEM);
3242         }
3243     }
3244
3245     av_buffer_unref(&s->current_sps);
3246     if (s0->current_sps) {
3247         s->current_sps = av_buffer_ref(s0->current_sps);
3248         if (!s->current_sps)
3249             return AVERROR(ENOMEM);
3250     }
3251
3252     if (s->sps != s0->sps)
3253         if ((ret = set_sps(s, s0->sps)) < 0)
3254             return ret;
3255
3256     s->seq_decode = s0->seq_decode;
3257     s->seq_output = s0->seq_output;
3258     s->pocTid0    = s0->pocTid0;
3259     s->max_ra     = s0->max_ra;
3260     s->eos        = s0->eos;
3261
3262     s->is_nalff        = s0->is_nalff;
3263     s->nal_length_size = s0->nal_length_size;
3264
3265     s->threads_number      = s0->threads_number;
3266     s->threads_type        = s0->threads_type;
3267
3268     if (s0->eos) {
3269         s->seq_decode = (s->seq_decode + 1) & 0xff;
3270         s->max_ra = INT_MAX;
3271     }
3272
3273     return 0;
3274 }
3275
3276 static int hevc_decode_extradata(HEVCContext *s)
3277 {
3278     AVCodecContext *avctx = s->avctx;
3279     GetByteContext gb;
3280     int ret;
3281
3282     bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3283
3284     if (avctx->extradata_size > 3 &&
3285         (avctx->extradata[0] || avctx->extradata[1] ||
3286          avctx->extradata[2] > 1)) {
3287         /* It seems the extradata is encoded as hvcC format.
3288          * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3289          * is finalized. When finalized, configurationVersion will be 1 and we
3290          * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3291         int i, j, num_arrays, nal_len_size;
3292
3293         s->is_nalff = 1;
3294
3295         bytestream2_skip(&gb, 21);
3296         nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3297         num_arrays   = bytestream2_get_byte(&gb);
3298
3299         /* nal units in the hvcC always have length coded with 2 bytes,
3300          * so put a fake nal_length_size = 2 while parsing them */
3301         s->nal_length_size = 2;
3302
3303         /* Decode nal units from hvcC. */
3304         for (i = 0; i < num_arrays; i++) {
3305             int type = bytestream2_get_byte(&gb) & 0x3f;
3306             int cnt  = bytestream2_get_be16(&gb);
3307
3308             for (j = 0; j < cnt; j++) {
3309                 // +2 for the nal size field
3310                 int nalsize = bytestream2_peek_be16(&gb) + 2;
3311                 if (bytestream2_get_bytes_left(&gb) < nalsize) {
3312                     av_log(s->avctx, AV_LOG_ERROR,
3313                            "Invalid NAL unit size in extradata.\n");
3314                     return AVERROR_INVALIDDATA;
3315                 }
3316
3317                 ret = decode_nal_units(s, gb.buffer, nalsize);
3318                 if (ret < 0) {
3319                     av_log(avctx, AV_LOG_ERROR,
3320                            "Decoding nal unit %d %d from hvcC failed\n",
3321                            type, i);
3322                     return ret;
3323                 }
3324                 bytestream2_skip(&gb, nalsize);
3325             }
3326         }
3327
3328         /* Now store right nal length size, that will be used to parse
3329          * all other nals */
3330         s->nal_length_size = nal_len_size;
3331     } else {
3332         s->is_nalff = 0;
3333         ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3334         if (ret < 0)
3335             return ret;
3336     }
3337     return 0;
3338 }
3339
3340 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3341 {
3342     HEVCContext *s = avctx->priv_data;
3343     int ret;
3344
3345     ff_init_cabac_states();
3346
3347     avctx->internal->allocate_progress = 1;
3348
3349     ret = hevc_init_context(avctx);
3350     if (ret < 0)
3351         return ret;
3352
3353     s->enable_parallel_tiles = 0;
3354     s->picture_struct = 0;
3355
3356     if(avctx->active_thread_type & FF_THREAD_SLICE)
3357         s->threads_number = avctx->thread_count;
3358     else
3359         s->threads_number = 1;
3360
3361     if (avctx->extradata_size > 0 && avctx->extradata) {
3362         ret = hevc_decode_extradata(s);
3363         if (ret < 0) {
3364             hevc_decode_free(avctx);
3365             return ret;
3366         }
3367     }
3368
3369     if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3370             s->threads_type = FF_THREAD_FRAME;
3371         else
3372             s->threads_type = FF_THREAD_SLICE;
3373
3374     return 0;
3375 }
3376
3377 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3378 {
3379     HEVCContext *s = avctx->priv_data;
3380     int ret;
3381
3382     memset(s, 0, sizeof(*s));
3383
3384     ret = hevc_init_context(avctx);
3385     if (ret < 0)
3386         return ret;
3387
3388     return 0;
3389 }
3390
3391 static void hevc_decode_flush(AVCodecContext *avctx)
3392 {
3393     HEVCContext *s = avctx->priv_data;
3394     ff_hevc_flush_dpb(s);
3395     s->max_ra = INT_MAX;
3396 }
3397
3398 #define OFFSET(x) offsetof(HEVCContext, x)
3399 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3400
3401 static const AVProfile profiles[] = {
3402     { FF_PROFILE_HEVC_MAIN,                 "Main"                },
3403     { FF_PROFILE_HEVC_MAIN_10,              "Main 10"             },
3404     { FF_PROFILE_HEVC_MAIN_STILL_PICTURE,   "Main Still Picture"  },
3405     { FF_PROFILE_HEVC_REXT,                 "Rext"  },
3406     { FF_PROFILE_UNKNOWN },
3407 };
3408
3409 static const AVOption options[] = {
3410     { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3411         AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3412     { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3413         AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3414     { NULL },
3415 };
3416
3417 static const AVClass hevc_decoder_class = {
3418     .class_name = "HEVC decoder",
3419     .item_name  = av_default_item_name,
3420     .option     = options,
3421     .version    = LIBAVUTIL_VERSION_INT,
3422 };
3423
3424 AVCodec ff_hevc_decoder = {
3425     .name                  = "hevc",
3426     .long_name             = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3427     .type                  = AVMEDIA_TYPE_VIDEO,
3428     .id                    = AV_CODEC_ID_HEVC,
3429     .priv_data_size        = sizeof(HEVCContext),
3430     .priv_class            = &hevc_decoder_class,
3431     .init                  = hevc_decode_init,
3432     .close                 = hevc_decode_free,
3433     .decode                = hevc_decode_frame,
3434     .flush                 = hevc_decode_flush,
3435     .update_thread_context = hevc_update_thread_context,
3436     .init_thread_copy      = hevc_init_thread_copy,
3437     .capabilities          = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3438                              CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3439     .profiles              = NULL_IF_CONFIG_SMALL(profiles),
3440 };