FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
hevc.c
Go to the documentation of this file.
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->time_base.num, &s->avctx->time_base.den,
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 trafo_depth, int blk_idx,
869  int cbf_luma, int *cbf_cb, int *cbf_cr)
870 {
871  HEVCLocalContext *lc = s->HEVClc;
872  const int log2_trafo_size_c = log2_trafo_size - s->sps->hshift[1];
873  int i;
874 
875  if (lc->cu.pred_mode == MODE_INTRA) {
876  int trafo_size = 1 << log2_trafo_size;
877  ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
878 
879  s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
880  }
881 
882  if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
883  (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
884  int scan_idx = SCAN_DIAG;
885  int scan_idx_c = SCAN_DIAG;
886  int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
887  (s->sps->chroma_format_idc == 2 &&
888  (cbf_cb[1] || cbf_cr[1]));
889 
890  if (s->pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
891  lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
892  if (lc->tu.cu_qp_delta != 0)
893  if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
894  lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
895  lc->tu.is_cu_qp_delta_coded = 1;
896 
897  if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
898  lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
899  av_log(s->avctx, AV_LOG_ERROR,
900  "The cu_qp_delta %d is outside the valid range "
901  "[%d, %d].\n",
902  lc->tu.cu_qp_delta,
903  -(26 + s->sps->qp_bd_offset / 2),
904  (25 + s->sps->qp_bd_offset / 2));
905  return AVERROR_INVALIDDATA;
906  }
907 
908  ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
909  }
910 
911  if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
912  !lc->cu.cu_transquant_bypass_flag && !lc->tu.is_cu_chroma_qp_offset_coded) {
913  int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
914  if (cu_chroma_qp_offset_flag) {
915  int cu_chroma_qp_offset_idx = 0;
916  if (s->pps->chroma_qp_offset_list_len_minus1 > 0) {
917  cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
918  av_log(s->avctx, AV_LOG_ERROR,
919  "cu_chroma_qp_offset_idx not yet tested.\n");
920  }
921  lc->tu.cu_qp_offset_cb = s->pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
922  lc->tu.cu_qp_offset_cr = s->pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
923  } else {
924  lc->tu.cu_qp_offset_cb = 0;
925  lc->tu.cu_qp_offset_cr = 0;
926  }
927  lc->tu.is_cu_chroma_qp_offset_coded = 1;
928  }
929 
930  if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
931  if (lc->tu.intra_pred_mode >= 6 &&
932  lc->tu.intra_pred_mode <= 14) {
933  scan_idx = SCAN_VERT;
934  } else if (lc->tu.intra_pred_mode >= 22 &&
935  lc->tu.intra_pred_mode <= 30) {
936  scan_idx = SCAN_HORIZ;
937  }
938 
939  if (lc->tu.intra_pred_mode_c >= 6 &&
940  lc->tu.intra_pred_mode_c <= 14) {
941  scan_idx_c = SCAN_VERT;
942  } else if (lc->tu.intra_pred_mode_c >= 22 &&
943  lc->tu.intra_pred_mode_c <= 30) {
944  scan_idx_c = SCAN_HORIZ;
945  }
946  }
947 
948  lc->tu.cross_pf = 0;
949 
950  if (cbf_luma)
951  ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
952  if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
953  int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
954  int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
955  lc->tu.cross_pf = (s->pps->cross_component_prediction_enabled_flag && cbf_luma &&
956  (lc->cu.pred_mode == MODE_INTER ||
957  (lc->tu.chroma_mode_c == 4)));
958 
959  if (lc->tu.cross_pf) {
960  hls_cross_component_pred(s, 0);
961  }
962  for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
963  if (lc->cu.pred_mode == MODE_INTRA) {
964  ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
965  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
966  }
967  if (cbf_cb[i])
968  ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
969  log2_trafo_size_c, scan_idx_c, 1);
970  else
971  if (lc->tu.cross_pf) {
972  ptrdiff_t stride = s->frame->linesize[1];
973  int hshift = s->sps->hshift[1];
974  int vshift = s->sps->vshift[1];
975  int16_t *coeffs_y = lc->tu.coeffs[0];
976  int16_t *coeffs = lc->tu.coeffs[1];
977  int size = 1 << log2_trafo_size_c;
978 
979  uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
980  ((x0 >> hshift) << s->sps->pixel_shift)];
981  for (i = 0; i < (size * size); i++) {
982  coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
983  }
984  s->hevcdsp.transform_add[log2_trafo_size-2](dst, coeffs, stride);
985  }
986  }
987 
988  if (lc->tu.cross_pf) {
989  hls_cross_component_pred(s, 1);
990  }
991  for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
992  if (lc->cu.pred_mode == MODE_INTRA) {
993  ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
994  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
995  }
996  if (cbf_cr[i])
997  ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
998  log2_trafo_size_c, scan_idx_c, 2);
999  else
1000  if (lc->tu.cross_pf) {
1001  ptrdiff_t stride = s->frame->linesize[2];
1002  int hshift = s->sps->hshift[2];
1003  int vshift = s->sps->vshift[2];
1004  int16_t *coeffs_y = lc->tu.coeffs[0];
1005  int16_t *coeffs = lc->tu.coeffs[1];
1006  int size = 1 << log2_trafo_size_c;
1007 
1008  uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1009  ((x0 >> hshift) << s->sps->pixel_shift)];
1010  for (i = 0; i < (size * size); i++) {
1011  coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1012  }
1013  s->hevcdsp.transform_add[log2_trafo_size-2](dst, coeffs, stride);
1014  }
1015  }
1016  } else if (blk_idx == 3) {
1017  int trafo_size_h = 1 << (log2_trafo_size + 1);
1018  int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1019  for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1020  if (lc->cu.pred_mode == MODE_INTRA) {
1021  ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1022  trafo_size_h, trafo_size_v);
1023  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1024  }
1025  if (cbf_cb[i])
1026  ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1027  log2_trafo_size, scan_idx_c, 1);
1028  }
1029  for (i = 0; i < (s->sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1030  if (lc->cu.pred_mode == MODE_INTRA) {
1031  ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1032  trafo_size_h, trafo_size_v);
1033  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1034  }
1035  if (cbf_cr[i])
1036  ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1037  log2_trafo_size, scan_idx_c, 2);
1038  }
1039  }
1040  } else if (lc->cu.pred_mode == MODE_INTRA) {
1041  if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1042  int trafo_size_h = 1 << (log2_trafo_size_c + s->sps->hshift[1]);
1043  int trafo_size_v = 1 << (log2_trafo_size_c + s->sps->vshift[1]);
1044  ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1045  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1046  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1047  if (s->sps->chroma_format_idc == 2) {
1048  ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1049  trafo_size_h, trafo_size_v);
1050  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1051  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1052  }
1053  } else if (blk_idx == 3) {
1054  int trafo_size_h = 1 << (log2_trafo_size + 1);
1055  int trafo_size_v = 1 << (log2_trafo_size + s->sps->vshift[1]);
1056  ff_hevc_set_neighbour_available(s, xBase, yBase,
1057  trafo_size_h, trafo_size_v);
1058  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1059  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1060  if (s->sps->chroma_format_idc == 2) {
1061  ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1062  trafo_size_h, trafo_size_v);
1063  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1064  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1065  }
1066  }
1067  }
1068 
1069  return 0;
1070 }
1071 
1072 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1073 {
1074  int cb_size = 1 << log2_cb_size;
1075  int log2_min_pu_size = s->sps->log2_min_pu_size;
1076 
1077  int min_pu_width = s->sps->min_pu_width;
1078  int x_end = FFMIN(x0 + cb_size, s->sps->width);
1079  int y_end = FFMIN(y0 + cb_size, s->sps->height);
1080  int i, j;
1081 
1082  for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1083  for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1084  s->is_pcm[i + j * min_pu_width] = 2;
1085 }
1086 
1087 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1088  int xBase, int yBase, int cb_xBase, int cb_yBase,
1089  int log2_cb_size, int log2_trafo_size,
1090  int trafo_depth, int blk_idx,
1091  const int *base_cbf_cb, const int *base_cbf_cr)
1092 {
1093  HEVCLocalContext *lc = s->HEVClc;
1094  uint8_t split_transform_flag;
1095  int cbf_cb[2];
1096  int cbf_cr[2];
1097  int ret;
1098 
1099  cbf_cb[0] = base_cbf_cb[0];
1100  cbf_cb[1] = base_cbf_cb[1];
1101  cbf_cr[0] = base_cbf_cr[0];
1102  cbf_cr[1] = base_cbf_cr[1];
1103 
1104  if (lc->cu.intra_split_flag) {
1105  if (trafo_depth == 1) {
1106  lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1107  if (s->sps->chroma_format_idc == 3) {
1108  lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1109  lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1110  } else {
1111  lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1112  lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1113  }
1114  }
1115  } else {
1116  lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1117  lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[0];
1118  lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1119  }
1120 
1121  if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1122  log2_trafo_size > s->sps->log2_min_tb_size &&
1123  trafo_depth < lc->cu.max_trafo_depth &&
1124  !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1125  split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1126  } else {
1127  int inter_split = s->sps->max_transform_hierarchy_depth_inter == 0 &&
1128  lc->cu.pred_mode == MODE_INTER &&
1129  lc->cu.part_mode != PART_2Nx2N &&
1130  trafo_depth == 0;
1131 
1132  split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1133  (lc->cu.intra_split_flag && trafo_depth == 0) ||
1134  inter_split;
1135  }
1136 
1137  if (log2_trafo_size > 2 || s->sps->chroma_format_idc == 3) {
1138  if (trafo_depth == 0 || cbf_cb[0]) {
1139  cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1140  if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1141  cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1142  }
1143  }
1144 
1145  if (trafo_depth == 0 || cbf_cr[0]) {
1146  cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1147  if (s->sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1148  cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1149  }
1150  }
1151  }
1152 
1153  if (split_transform_flag) {
1154  const int trafo_size_split = 1 << (log2_trafo_size - 1);
1155  const int x1 = x0 + trafo_size_split;
1156  const int y1 = y0 + trafo_size_split;
1157 
1158 #define SUBDIVIDE(x, y, idx) \
1159 do { \
1160  ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1161  log2_trafo_size - 1, trafo_depth + 1, idx, \
1162  cbf_cb, cbf_cr); \
1163  if (ret < 0) \
1164  return ret; \
1165 } while (0)
1166 
1167  SUBDIVIDE(x0, y0, 0);
1168  SUBDIVIDE(x1, y0, 1);
1169  SUBDIVIDE(x0, y1, 2);
1170  SUBDIVIDE(x1, y1, 3);
1171 
1172 #undef SUBDIVIDE
1173  } else {
1174  int min_tu_size = 1 << s->sps->log2_min_tb_size;
1175  int log2_min_tu_size = s->sps->log2_min_tb_size;
1176  int min_tu_width = s->sps->min_tb_width;
1177  int cbf_luma = 1;
1178 
1179  if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1180  cbf_cb[0] || cbf_cr[0] ||
1181  (s->sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1182  cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1183  }
1184 
1185  ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1186  log2_cb_size, log2_trafo_size, trafo_depth,
1187  blk_idx, cbf_luma, cbf_cb, cbf_cr);
1188  if (ret < 0)
1189  return ret;
1190  // TODO: store cbf_luma somewhere else
1191  if (cbf_luma) {
1192  int i, j;
1193  for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1194  for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1195  int x_tu = (x0 + j) >> log2_min_tu_size;
1196  int y_tu = (y0 + i) >> log2_min_tu_size;
1197  s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1198  }
1199  }
1200  if (!s->sh.disable_deblocking_filter_flag) {
1201  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1202  if (s->pps->transquant_bypass_enable_flag &&
1203  lc->cu.cu_transquant_bypass_flag)
1204  set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1205  }
1206  }
1207  return 0;
1208 }
1209 
1210 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1211 {
1212  HEVCLocalContext *lc = s->HEVClc;
1213  GetBitContext gb;
1214  int cb_size = 1 << log2_cb_size;
1215  int stride0 = s->frame->linesize[0];
1216  uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1217  int stride1 = s->frame->linesize[1];
1218  uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1219  int stride2 = s->frame->linesize[2];
1220  uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1221 
1222  int length = cb_size * cb_size * s->sps->pcm.bit_depth +
1223  (((cb_size >> s->sps->hshift[1]) * (cb_size >> s->sps->vshift[1])) +
1224  ((cb_size >> s->sps->hshift[2]) * (cb_size >> s->sps->vshift[2]))) *
1225  s->sps->pcm.bit_depth_chroma;
1226  const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1227  int ret;
1228 
1229  if (!s->sh.disable_deblocking_filter_flag)
1230  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1231 
1232  ret = init_get_bits(&gb, pcm, length);
1233  if (ret < 0)
1234  return ret;
1235 
1236  s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->sps->pcm.bit_depth);
1237  s->hevcdsp.put_pcm(dst1, stride1,
1238  cb_size >> s->sps->hshift[1],
1239  cb_size >> s->sps->vshift[1],
1240  &gb, s->sps->pcm.bit_depth_chroma);
1241  s->hevcdsp.put_pcm(dst2, stride2,
1242  cb_size >> s->sps->hshift[2],
1243  cb_size >> s->sps->vshift[2],
1244  &gb, s->sps->pcm.bit_depth_chroma);
1245  return 0;
1246 }
1247 
1248 /**
1249  * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1250  *
1251  * @param s HEVC decoding context
1252  * @param dst target buffer for block data at block position
1253  * @param dststride stride of the dst buffer
1254  * @param ref reference picture buffer at origin (0, 0)
1255  * @param mv motion vector (relative to block position) to get pixel data from
1256  * @param x_off horizontal position of block from origin (0, 0)
1257  * @param y_off vertical position of block from origin (0, 0)
1258  * @param block_w width of block
1259  * @param block_h height of block
1260  * @param luma_weight weighting factor applied to the luma prediction
1261  * @param luma_offset additive offset applied to the luma prediction value
1262  */
1263 
1264 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1265  AVFrame *ref, const Mv *mv, int x_off, int y_off,
1266  int block_w, int block_h, int luma_weight, int luma_offset)
1267 {
1268  HEVCLocalContext *lc = s->HEVClc;
1269  uint8_t *src = ref->data[0];
1270  ptrdiff_t srcstride = ref->linesize[0];
1271  int pic_width = s->sps->width;
1272  int pic_height = s->sps->height;
1273  int mx = mv->x & 3;
1274  int my = mv->y & 3;
1275  int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1276  (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1277  int idx = ff_hevc_pel_weight[block_w];
1278 
1279  x_off += mv->x >> 2;
1280  y_off += mv->y >> 2;
1281  src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1282 
1283  if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1284  x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1285  y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1286  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1287  int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1288  int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1289 
1290  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1291  edge_emu_stride, srcstride,
1292  block_w + QPEL_EXTRA,
1293  block_h + QPEL_EXTRA,
1294  x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1295  pic_width, pic_height);
1296  src = lc->edge_emu_buffer + buf_offset;
1297  srcstride = edge_emu_stride;
1298  }
1299 
1300  if (!weight_flag)
1301  s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1302  block_h, mx, my, block_w);
1303  else
1304  s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1305  block_h, s->sh.luma_log2_weight_denom,
1306  luma_weight, luma_offset, mx, my, block_w);
1307 }
1308 
1309 /**
1310  * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1311  *
1312  * @param s HEVC decoding context
1313  * @param dst target buffer for block data at block position
1314  * @param dststride stride of the dst buffer
1315  * @param ref0 reference picture0 buffer at origin (0, 0)
1316  * @param mv0 motion vector0 (relative to block position) to get pixel data from
1317  * @param x_off horizontal position of block from origin (0, 0)
1318  * @param y_off vertical position of block from origin (0, 0)
1319  * @param block_w width of block
1320  * @param block_h height of block
1321  * @param ref1 reference picture1 buffer at origin (0, 0)
1322  * @param mv1 motion vector1 (relative to block position) to get pixel data from
1323  * @param current_mv current motion vector structure
1324  */
1325  static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1326  AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1327  int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1328 {
1329  HEVCLocalContext *lc = s->HEVClc;
1330  DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1331  ptrdiff_t src0stride = ref0->linesize[0];
1332  ptrdiff_t src1stride = ref1->linesize[0];
1333  int pic_width = s->sps->width;
1334  int pic_height = s->sps->height;
1335  int mx0 = mv0->x & 3;
1336  int my0 = mv0->y & 3;
1337  int mx1 = mv1->x & 3;
1338  int my1 = mv1->y & 3;
1339  int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1340  (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1341  int x_off0 = x_off + (mv0->x >> 2);
1342  int y_off0 = y_off + (mv0->y >> 2);
1343  int x_off1 = x_off + (mv1->x >> 2);
1344  int y_off1 = y_off + (mv1->y >> 2);
1345  int idx = ff_hevc_pel_weight[block_w];
1346 
1347  uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1348  uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1349 
1350  if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1351  x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1352  y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1353  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1354  int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1355  int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1356 
1357  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1358  edge_emu_stride, src0stride,
1359  block_w + QPEL_EXTRA,
1360  block_h + QPEL_EXTRA,
1361  x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1362  pic_width, pic_height);
1363  src0 = lc->edge_emu_buffer + buf_offset;
1364  src0stride = edge_emu_stride;
1365  }
1366 
1367  if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1368  x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1369  y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1370  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1371  int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1372  int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->sps->pixel_shift);
1373 
1374  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1375  edge_emu_stride, src1stride,
1376  block_w + QPEL_EXTRA,
1377  block_h + QPEL_EXTRA,
1378  x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1379  pic_width, pic_height);
1380  src1 = lc->edge_emu_buffer2 + buf_offset;
1381  src1stride = edge_emu_stride;
1382  }
1383 
1384  s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](tmp, src0, src0stride,
1385  block_h, mx0, my0, block_w);
1386  if (!weight_flag)
1387  s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, tmp,
1388  block_h, mx1, my1, block_w);
1389  else
1390  s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, tmp,
1391  block_h, s->sh.luma_log2_weight_denom,
1392  s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1393  s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1394  s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1395  s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1396  mx1, my1, block_w);
1397 
1398 }
1399 
1400 /**
1401  * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1402  *
1403  * @param s HEVC decoding context
1404  * @param dst1 target buffer for block data at block position (U plane)
1405  * @param dst2 target buffer for block data at block position (V plane)
1406  * @param dststride stride of the dst1 and dst2 buffers
1407  * @param ref reference picture buffer at origin (0, 0)
1408  * @param mv motion vector (relative to block position) to get pixel data from
1409  * @param x_off horizontal position of block from origin (0, 0)
1410  * @param y_off vertical position of block from origin (0, 0)
1411  * @param block_w width of block
1412  * @param block_h height of block
1413  * @param chroma_weight weighting factor applied to the chroma prediction
1414  * @param chroma_offset additive offset applied to the chroma prediction value
1415  */
1416 
1417 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1418  ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1419  int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1420 {
1421  HEVCLocalContext *lc = s->HEVClc;
1422  int pic_width = s->sps->width >> s->sps->hshift[1];
1423  int pic_height = s->sps->height >> s->sps->vshift[1];
1424  const Mv *mv = &current_mv->mv[reflist];
1425  int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1426  (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1427  int idx = ff_hevc_pel_weight[block_w];
1428  int hshift = s->sps->hshift[1];
1429  int vshift = s->sps->vshift[1];
1430  intptr_t mx = mv->x & ((1 << (2 + hshift)) - 1);
1431  intptr_t my = mv->y & ((1 << (2 + vshift)) - 1);
1432  intptr_t _mx = mx << (1 - hshift);
1433  intptr_t _my = my << (1 - vshift);
1434 
1435  x_off += mv->x >> (2 + hshift);
1436  y_off += mv->y >> (2 + vshift);
1437  src0 += y_off * srcstride + (x_off << s->sps->pixel_shift);
1438 
1439  if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1440  x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1441  y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1442  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1443  int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->sps->pixel_shift));
1444  int buf_offset0 = EPEL_EXTRA_BEFORE *
1445  (edge_emu_stride + (1 << s->sps->pixel_shift));
1446  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1447  edge_emu_stride, srcstride,
1448  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1449  x_off - EPEL_EXTRA_BEFORE,
1450  y_off - EPEL_EXTRA_BEFORE,
1451  pic_width, pic_height);
1452 
1453  src0 = lc->edge_emu_buffer + buf_offset0;
1454  srcstride = edge_emu_stride;
1455  }
1456  if (!weight_flag)
1457  s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1458  block_h, _mx, _my, block_w);
1459  else
1460  s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1461  block_h, s->sh.chroma_log2_weight_denom,
1462  chroma_weight, chroma_offset, _mx, _my, block_w);
1463 }
1464 
1465 /**
1466  * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1467  *
1468  * @param s HEVC decoding context
1469  * @param dst target buffer for block data at block position
1470  * @param dststride stride of the dst buffer
1471  * @param ref0 reference picture0 buffer at origin (0, 0)
1472  * @param mv0 motion vector0 (relative to block position) to get pixel data from
1473  * @param x_off horizontal position of block from origin (0, 0)
1474  * @param y_off vertical position of block from origin (0, 0)
1475  * @param block_w width of block
1476  * @param block_h height of block
1477  * @param ref1 reference picture1 buffer at origin (0, 0)
1478  * @param mv1 motion vector1 (relative to block position) to get pixel data from
1479  * @param current_mv current motion vector structure
1480  * @param cidx chroma component(cb, cr)
1481  */
1482 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1483  int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1484 {
1485  DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1486  HEVCLocalContext *lc = s->HEVClc;
1487  uint8_t *src1 = ref0->data[cidx+1];
1488  uint8_t *src2 = ref1->data[cidx+1];
1489  ptrdiff_t src1stride = ref0->linesize[cidx+1];
1490  ptrdiff_t src2stride = ref1->linesize[cidx+1];
1491  int weight_flag = (s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1492  (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag);
1493  int pic_width = s->sps->width >> s->sps->hshift[1];
1494  int pic_height = s->sps->height >> s->sps->vshift[1];
1495  Mv *mv0 = &current_mv->mv[0];
1496  Mv *mv1 = &current_mv->mv[1];
1497  int hshift = s->sps->hshift[1];
1498  int vshift = s->sps->vshift[1];
1499 
1500  intptr_t mx0 = mv0->x & ((1 << (2 + hshift)) - 1);
1501  intptr_t my0 = mv0->y & ((1 << (2 + vshift)) - 1);
1502  intptr_t mx1 = mv1->x & ((1 << (2 + hshift)) - 1);
1503  intptr_t my1 = mv1->y & ((1 << (2 + vshift)) - 1);
1504  intptr_t _mx0 = mx0 << (1 - hshift);
1505  intptr_t _my0 = my0 << (1 - vshift);
1506  intptr_t _mx1 = mx1 << (1 - hshift);
1507  intptr_t _my1 = my1 << (1 - vshift);
1508 
1509  int x_off0 = x_off + (mv0->x >> (2 + hshift));
1510  int y_off0 = y_off + (mv0->y >> (2 + vshift));
1511  int x_off1 = x_off + (mv1->x >> (2 + hshift));
1512  int y_off1 = y_off + (mv1->y >> (2 + vshift));
1513  int idx = ff_hevc_pel_weight[block_w];
1514  src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->sps->pixel_shift);
1515  src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->sps->pixel_shift);
1516 
1517  if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1518  x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1519  y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1520  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1521  int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1522  int buf_offset1 = EPEL_EXTRA_BEFORE *
1523  (edge_emu_stride + (1 << s->sps->pixel_shift));
1524 
1525  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1526  edge_emu_stride, src1stride,
1527  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1528  x_off0 - EPEL_EXTRA_BEFORE,
1529  y_off0 - EPEL_EXTRA_BEFORE,
1530  pic_width, pic_height);
1531 
1532  src1 = lc->edge_emu_buffer + buf_offset1;
1533  src1stride = edge_emu_stride;
1534  }
1535 
1536  if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1537  x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1538  y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1539  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1540  int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1541  int buf_offset1 = EPEL_EXTRA_BEFORE *
1542  (edge_emu_stride + (1 << s->sps->pixel_shift));
1543 
1544  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1545  edge_emu_stride, src2stride,
1546  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1547  x_off1 - EPEL_EXTRA_BEFORE,
1548  y_off1 - EPEL_EXTRA_BEFORE,
1549  pic_width, pic_height);
1550 
1551  src2 = lc->edge_emu_buffer2 + buf_offset1;
1552  src2stride = edge_emu_stride;
1553  }
1554 
1555  s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](tmp, src1, src1stride,
1556  block_h, _mx0, _my0, block_w);
1557  if (!weight_flag)
1558  s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1559  src2, src2stride, tmp,
1560  block_h, _mx1, _my1, block_w);
1561  else
1562  s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1563  src2, src2stride, tmp,
1564  block_h,
1565  s->sh.chroma_log2_weight_denom,
1566  s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1567  s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1568  s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1569  s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1570  _mx1, _my1, block_w);
1571 }
1572 
1573 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
1574  const Mv *mv, int y0, int height)
1575 {
1576  int y = (mv->y >> 2) + y0 + height + 9;
1577 
1578  if (s->threads_type == FF_THREAD_FRAME )
1579  ff_thread_await_progress(&ref->tf, y, 0);
1580 }
1581 
1582 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1583  int nPbW, int nPbH,
1584  int log2_cb_size, int partIdx, int idx)
1585 {
1586 #define POS(c_idx, x, y) \
1587  &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1588  (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1589  HEVCLocalContext *lc = s->HEVClc;
1590  int merge_idx = 0;
1591  struct MvField current_mv = {{{ 0 }}};
1592 
1593  int min_pu_width = s->sps->min_pu_width;
1594 
1595  MvField *tab_mvf = s->ref->tab_mvf;
1596  RefPicList *refPicList = s->ref->refPicList;
1597  HEVCFrame *ref0, *ref1;
1598  uint8_t *dst0 = POS(0, x0, y0);
1599  uint8_t *dst1 = POS(1, x0, y0);
1600  uint8_t *dst2 = POS(2, x0, y0);
1601  int log2_min_cb_size = s->sps->log2_min_cb_size;
1602  int min_cb_width = s->sps->min_cb_width;
1603  int x_cb = x0 >> log2_min_cb_size;
1604  int y_cb = y0 >> log2_min_cb_size;
1605  int ref_idx[2];
1606  int mvp_flag[2];
1607  int x_pu, y_pu;
1608  int i, j;
1609 
1610  if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
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,
1617  1 << log2_cb_size,
1618  1 << log2_cb_size,
1619  log2_cb_size, partIdx,
1620  merge_idx, &current_mv);
1621  x_pu = x0 >> s->sps->log2_min_pu_size;
1622  y_pu = y0 >> s->sps->log2_min_pu_size;
1623 
1624  for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1625  for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1626  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1627  } else { /* MODE_INTER */
1628  lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
1629  if (lc->pu.merge_flag) {
1630  if (s->sh.max_num_merge_cand > 1)
1631  merge_idx = ff_hevc_merge_idx_decode(s);
1632  else
1633  merge_idx = 0;
1634 
1635  ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1636  partIdx, merge_idx, &current_mv);
1637  x_pu = x0 >> s->sps->log2_min_pu_size;
1638  y_pu = y0 >> s->sps->log2_min_pu_size;
1639 
1640  for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1641  for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1642  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1643  } else {
1644  enum InterPredIdc inter_pred_idc = PRED_L0;
1645  ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1646  current_mv.pred_flag = 0;
1647  if (s->sh.slice_type == B_SLICE)
1648  inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1649 
1650  if (inter_pred_idc != PRED_L1) {
1651  if (s->sh.nb_refs[L0]) {
1652  ref_idx[0] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1653  current_mv.ref_idx[0] = ref_idx[0];
1654  }
1655  current_mv.pred_flag = PF_L0;
1656  ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1657  mvp_flag[0] = ff_hevc_mvp_lx_flag_decode(s);
1658  ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1659  partIdx, merge_idx, &current_mv,
1660  mvp_flag[0], 0);
1661  current_mv.mv[0].x += lc->pu.mvd.x;
1662  current_mv.mv[0].y += lc->pu.mvd.y;
1663  }
1664 
1665  if (inter_pred_idc != PRED_L0) {
1666  if (s->sh.nb_refs[L1]) {
1667  ref_idx[1] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1668  current_mv.ref_idx[1] = ref_idx[1];
1669  }
1670 
1671  if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1672  AV_ZERO32(&lc->pu.mvd);
1673  } else {
1674  ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1675  }
1676 
1677  current_mv.pred_flag += PF_L1;
1678  mvp_flag[1] = ff_hevc_mvp_lx_flag_decode(s);
1679  ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1680  partIdx, merge_idx, &current_mv,
1681  mvp_flag[1], 1);
1682  current_mv.mv[1].x += lc->pu.mvd.x;
1683  current_mv.mv[1].y += lc->pu.mvd.y;
1684  }
1685 
1686  x_pu = x0 >> s->sps->log2_min_pu_size;
1687  y_pu = y0 >> s->sps->log2_min_pu_size;
1688 
1689  for(j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1690  for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1691  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1692  }
1693  }
1694 
1695  if (current_mv.pred_flag & PF_L0) {
1696  ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1697  if (!ref0)
1698  return;
1699  hevc_await_progress(s, ref0, &current_mv.mv[0], y0, nPbH);
1700  }
1701  if (current_mv.pred_flag & PF_L1) {
1702  ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1703  if (!ref1)
1704  return;
1705  hevc_await_progress(s, ref1, &current_mv.mv[1], y0, nPbH);
1706  }
1707 
1708  if (current_mv.pred_flag == PF_L0) {
1709  int x0_c = x0 >> s->sps->hshift[1];
1710  int y0_c = y0 >> s->sps->vshift[1];
1711  int nPbW_c = nPbW >> s->sps->hshift[1];
1712  int nPbH_c = nPbH >> s->sps->vshift[1];
1713 
1714  luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1715  &current_mv.mv[0], x0, y0, nPbW, nPbH,
1716  s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1717  s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1718 
1719  chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1720  0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1721  s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1722  chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1723  0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1724  s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1725  } else if (current_mv.pred_flag == PF_L1) {
1726  int x0_c = x0 >> s->sps->hshift[1];
1727  int y0_c = y0 >> s->sps->vshift[1];
1728  int nPbW_c = nPbW >> s->sps->hshift[1];
1729  int nPbH_c = nPbH >> s->sps->vshift[1];
1730 
1731  luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1732  &current_mv.mv[1], x0, y0, nPbW, nPbH,
1733  s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1734  s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1735 
1736  chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1737  1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1738  s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1739 
1740  chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1741  1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1742  s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1743  } else if (current_mv.pred_flag == PF_BI) {
1744  int x0_c = x0 >> s->sps->hshift[1];
1745  int y0_c = y0 >> s->sps->vshift[1];
1746  int nPbW_c = nPbW >> s->sps->hshift[1];
1747  int nPbH_c = nPbH >> s->sps->vshift[1];
1748 
1749  luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1750  &current_mv.mv[0], x0, y0, nPbW, nPbH,
1751  ref1->frame, &current_mv.mv[1], &current_mv);
1752 
1753  chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1754  x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 0);
1755 
1756  chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1757  x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 1);
1758  }
1759 }
1760 
1761 /**
1762  * 8.4.1
1763  */
1764 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1765  int prev_intra_luma_pred_flag)
1766 {
1767  HEVCLocalContext *lc = s->HEVClc;
1768  int x_pu = x0 >> s->sps->log2_min_pu_size;
1769  int y_pu = y0 >> s->sps->log2_min_pu_size;
1770  int min_pu_width = s->sps->min_pu_width;
1771  int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1772  int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1773  int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1774 
1775  int cand_up = (lc->ctb_up_flag || y0b) ?
1776  s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1777  int cand_left = (lc->ctb_left_flag || x0b) ?
1778  s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1779 
1780  int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1781 
1782  MvField *tab_mvf = s->ref->tab_mvf;
1783  int intra_pred_mode;
1784  int candidate[3];
1785  int i, j;
1786 
1787  // intra_pred_mode prediction does not cross vertical CTB boundaries
1788  if ((y0 - 1) < y_ctb)
1789  cand_up = INTRA_DC;
1790 
1791  if (cand_left == cand_up) {
1792  if (cand_left < 2) {
1793  candidate[0] = INTRA_PLANAR;
1794  candidate[1] = INTRA_DC;
1795  candidate[2] = INTRA_ANGULAR_26;
1796  } else {
1797  candidate[0] = cand_left;
1798  candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1799  candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1800  }
1801  } else {
1802  candidate[0] = cand_left;
1803  candidate[1] = cand_up;
1804  if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1805  candidate[2] = INTRA_PLANAR;
1806  } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1807  candidate[2] = INTRA_DC;
1808  } else {
1809  candidate[2] = INTRA_ANGULAR_26;
1810  }
1811  }
1812 
1813  if (prev_intra_luma_pred_flag) {
1814  intra_pred_mode = candidate[lc->pu.mpm_idx];
1815  } else {
1816  if (candidate[0] > candidate[1])
1817  FFSWAP(uint8_t, candidate[0], candidate[1]);
1818  if (candidate[0] > candidate[2])
1819  FFSWAP(uint8_t, candidate[0], candidate[2]);
1820  if (candidate[1] > candidate[2])
1821  FFSWAP(uint8_t, candidate[1], candidate[2]);
1822 
1823  intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1824  for (i = 0; i < 3; i++)
1825  if (intra_pred_mode >= candidate[i])
1826  intra_pred_mode++;
1827  }
1828 
1829  /* write the intra prediction units into the mv array */
1830  if (!size_in_pus)
1831  size_in_pus = 1;
1832  for (i = 0; i < size_in_pus; i++) {
1833  memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1834  intra_pred_mode, size_in_pus);
1835 
1836  for (j = 0; j < size_in_pus; j++) {
1837  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1838  }
1839  }
1840 
1841  return intra_pred_mode;
1842 }
1843 
1844 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1845  int log2_cb_size, int ct_depth)
1846 {
1847  int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
1848  int x_cb = x0 >> s->sps->log2_min_cb_size;
1849  int y_cb = y0 >> s->sps->log2_min_cb_size;
1850  int y;
1851 
1852  for (y = 0; y < length; y++)
1853  memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
1854  ct_depth, length);
1855 }
1856 
1857 static const uint8_t tab_mode_idx[] = {
1858  0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1859  21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1860 
1861 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1862  int log2_cb_size)
1863 {
1864  HEVCLocalContext *lc = s->HEVClc;
1865  static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1866  uint8_t prev_intra_luma_pred_flag[4];
1867  int split = lc->cu.part_mode == PART_NxN;
1868  int pb_size = (1 << log2_cb_size) >> split;
1869  int side = split + 1;
1870  int chroma_mode;
1871  int i, j;
1872 
1873  for (i = 0; i < side; i++)
1874  for (j = 0; j < side; j++)
1875  prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1876 
1877  for (i = 0; i < side; i++) {
1878  for (j = 0; j < side; j++) {
1879  if (prev_intra_luma_pred_flag[2 * i + j])
1880  lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
1881  else
1882  lc->pu.rem_intra_luma_pred_mode = ff_hevc_rem_intra_luma_pred_mode_decode(s);
1883 
1884  lc->pu.intra_pred_mode[2 * i + j] =
1885  luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1886  prev_intra_luma_pred_flag[2 * i + j]);
1887  }
1888  }
1889 
1890  if (s->sps->chroma_format_idc == 3) {
1891  for (i = 0; i < side; i++) {
1892  for (j = 0; j < side; j++) {
1893  lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1894  if (chroma_mode != 4) {
1895  if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1896  lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1897  else
1898  lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1899  } else {
1900  lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1901  }
1902  }
1903  }
1904  } else if (s->sps->chroma_format_idc == 2) {
1905  int mode_idx;
1906  lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1907  if (chroma_mode != 4) {
1908  if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1909  mode_idx = 34;
1910  else
1911  mode_idx = intra_chroma_table[chroma_mode];
1912  } else {
1913  mode_idx = lc->pu.intra_pred_mode[0];
1914  }
1915  lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1916  } else if (s->sps->chroma_format_idc != 0) {
1917  chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1918  if (chroma_mode != 4) {
1919  if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1920  lc->pu.intra_pred_mode_c[0] = 34;
1921  else
1922  lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1923  } else {
1924  lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1925  }
1926  }
1927 }
1928 
1929 static void intra_prediction_unit_default_value(HEVCContext *s,
1930  int x0, int y0,
1931  int log2_cb_size)
1932 {
1933  HEVCLocalContext *lc = s->HEVClc;
1934  int pb_size = 1 << log2_cb_size;
1935  int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
1936  int min_pu_width = s->sps->min_pu_width;
1937  MvField *tab_mvf = s->ref->tab_mvf;
1938  int x_pu = x0 >> s->sps->log2_min_pu_size;
1939  int y_pu = y0 >> s->sps->log2_min_pu_size;
1940  int j, k;
1941 
1942  if (size_in_pus == 0)
1943  size_in_pus = 1;
1944  for (j = 0; j < size_in_pus; j++)
1945  memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
1946  if (lc->cu.pred_mode == MODE_INTRA)
1947  for (j = 0; j < size_in_pus; j++)
1948  for (k = 0; k < size_in_pus; k++)
1949  tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
1950 }
1951 
1952 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
1953 {
1954  int cb_size = 1 << log2_cb_size;
1955  HEVCLocalContext *lc = s->HEVClc;
1956  int log2_min_cb_size = s->sps->log2_min_cb_size;
1957  int length = cb_size >> log2_min_cb_size;
1958  int min_cb_width = s->sps->min_cb_width;
1959  int x_cb = x0 >> log2_min_cb_size;
1960  int y_cb = y0 >> log2_min_cb_size;
1961  int idx = log2_cb_size - 2;
1962  int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
1963  int x, y, ret;
1964 
1965  lc->cu.x = x0;
1966  lc->cu.y = y0;
1967  lc->cu.rqt_root_cbf = 1;
1968  lc->cu.pred_mode = MODE_INTRA;
1969  lc->cu.part_mode = PART_2Nx2N;
1970  lc->cu.intra_split_flag = 0;
1971  lc->cu.pcm_flag = 0;
1972 
1973  SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
1974  for (x = 0; x < 4; x++)
1975  lc->pu.intra_pred_mode[x] = 1;
1976  if (s->pps->transquant_bypass_enable_flag) {
1977  lc->cu.cu_transquant_bypass_flag = ff_hevc_cu_transquant_bypass_flag_decode(s);
1978  if (lc->cu.cu_transquant_bypass_flag)
1979  set_deblocking_bypass(s, x0, y0, log2_cb_size);
1980  } else
1981  lc->cu.cu_transquant_bypass_flag = 0;
1982 
1983  if (s->sh.slice_type != I_SLICE) {
1984  uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
1985 
1986  x = y_cb * min_cb_width + x_cb;
1987  for (y = 0; y < length; y++) {
1988  memset(&s->skip_flag[x], skip_flag, length);
1989  x += min_cb_width;
1990  }
1991  lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
1992  } else {
1993  x = y_cb * min_cb_width + x_cb;
1994  for (y = 0; y < length; y++) {
1995  memset(&s->skip_flag[x], 0, length);
1996  x += min_cb_width;
1997  }
1998  }
1999 
2000  if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2001  hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2002  intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2003 
2004  if (!s->sh.disable_deblocking_filter_flag)
2005  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2006  } else {
2007  if (s->sh.slice_type != I_SLICE)
2008  lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
2009  if (lc->cu.pred_mode != MODE_INTRA ||
2010  log2_cb_size == s->sps->log2_min_cb_size) {
2011  lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2012  lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2013  lc->cu.pred_mode == MODE_INTRA;
2014  }
2015 
2016  if (lc->cu.pred_mode == MODE_INTRA) {
2017  if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2018  log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2019  log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2020  lc->cu.pcm_flag = ff_hevc_pcm_flag_decode(s);
2021  }
2022  if (lc->cu.pcm_flag) {
2023  intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2024  ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2025  if (s->sps->pcm.loop_filter_disable_flag)
2026  set_deblocking_bypass(s, x0, y0, log2_cb_size);
2027 
2028  if (ret < 0)
2029  return ret;
2030  } else {
2031  intra_prediction_unit(s, x0, y0, log2_cb_size);
2032  }
2033  } else {
2034  intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2035  switch (lc->cu.part_mode) {
2036  case PART_2Nx2N:
2037  hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2038  break;
2039  case PART_2NxN:
2040  hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2041  hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2042  break;
2043  case PART_Nx2N:
2044  hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2045  hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2046  break;
2047  case PART_2NxnU:
2048  hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2049  hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2050  break;
2051  case PART_2NxnD:
2052  hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2053  hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2054  break;
2055  case PART_nLx2N:
2056  hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2057  hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2058  break;
2059  case PART_nRx2N:
2060  hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2061  hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2062  break;
2063  case PART_NxN:
2064  hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2065  hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2066  hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2067  hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2068  break;
2069  }
2070  }
2071 
2072  if (!lc->cu.pcm_flag) {
2073  if (lc->cu.pred_mode != MODE_INTRA &&
2074  !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2075  lc->cu.rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2076  }
2077  if (lc->cu.rqt_root_cbf) {
2078  const static int cbf[2] = { 0 };
2079  lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2080  s->sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2081  s->sps->max_transform_hierarchy_depth_inter;
2082  ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2083  log2_cb_size,
2084  log2_cb_size, 0, 0, cbf, cbf);
2085  if (ret < 0)
2086  return ret;
2087  } else {
2088  if (!s->sh.disable_deblocking_filter_flag)
2089  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2090  }
2091  }
2092  }
2093 
2094  if (s->pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2095  ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2096 
2097  x = y_cb * min_cb_width + x_cb;
2098  for (y = 0; y < length; y++) {
2099  memset(&s->qp_y_tab[x], lc->qp_y, length);
2100  x += min_cb_width;
2101  }
2102 
2103  if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2104  ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2105  lc->qPy_pred = lc->qp_y;
2106  }
2107 
2108  set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2109 
2110  return 0;
2111 }
2112 
2113 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2114  int log2_cb_size, int cb_depth)
2115 {
2116  HEVCLocalContext *lc = s->HEVClc;
2117  const int cb_size = 1 << log2_cb_size;
2118  int ret;
2119  int qp_block_mask = (1<<(s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth)) - 1;
2120  int split_cu;
2121 
2122  lc->ct.depth = cb_depth;
2123  if (x0 + cb_size <= s->sps->width &&
2124  y0 + cb_size <= s->sps->height &&
2125  log2_cb_size > s->sps->log2_min_cb_size) {
2126  split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2127  } else {
2128  split_cu = (log2_cb_size > s->sps->log2_min_cb_size);
2129  }
2130  if (s->pps->cu_qp_delta_enabled_flag &&
2131  log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2132  lc->tu.is_cu_qp_delta_coded = 0;
2133  lc->tu.cu_qp_delta = 0;
2134  }
2135 
2136  if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2137  log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_chroma_qp_offset_depth) {
2138  lc->tu.is_cu_chroma_qp_offset_coded = 0;
2139  }
2140 
2141  if (split_cu) {
2142  const int cb_size_split = cb_size >> 1;
2143  const int x1 = x0 + cb_size_split;
2144  const int y1 = y0 + cb_size_split;
2145 
2146  int more_data = 0;
2147 
2148  more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2149  if (more_data < 0)
2150  return more_data;
2151 
2152  if (more_data && x1 < s->sps->width) {
2153  more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2154  if (more_data < 0)
2155  return more_data;
2156  }
2157  if (more_data && y1 < s->sps->height) {
2158  more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2159  if (more_data < 0)
2160  return more_data;
2161  }
2162  if (more_data && x1 < s->sps->width &&
2163  y1 < s->sps->height) {
2164  more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2165  if (more_data < 0)
2166  return more_data;
2167  }
2168 
2169  if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2170  ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2171  lc->qPy_pred = lc->qp_y;
2172 
2173  if (more_data)
2174  return ((x1 + cb_size_split) < s->sps->width ||
2175  (y1 + cb_size_split) < s->sps->height);
2176  else
2177  return 0;
2178  } else {
2179  ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2180  if (ret < 0)
2181  return ret;
2182  if ((!((x0 + cb_size) %
2183  (1 << (s->sps->log2_ctb_size))) ||
2184  (x0 + cb_size >= s->sps->width)) &&
2185  (!((y0 + cb_size) %
2186  (1 << (s->sps->log2_ctb_size))) ||
2187  (y0 + cb_size >= s->sps->height))) {
2188  int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2189  return !end_of_slice_flag;
2190  } else {
2191  return 1;
2192  }
2193  }
2194 
2195  return 0;
2196 }
2197 
2198 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2199  int ctb_addr_ts)
2200 {
2201  HEVCLocalContext *lc = s->HEVClc;
2202  int ctb_size = 1 << s->sps->log2_ctb_size;
2203  int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2204  int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2205 
2206  s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2207 
2208  if (s->pps->entropy_coding_sync_enabled_flag) {
2209  if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2210  lc->first_qp_group = 1;
2211  lc->end_of_tiles_x = s->sps->width;
2212  } else if (s->pps->tiles_enabled_flag) {
2213  if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2214  int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2215  lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2216  lc->first_qp_group = 1;
2217  }
2218  } else {
2219  lc->end_of_tiles_x = s->sps->width;
2220  }
2221 
2222  lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2223 
2224  lc->boundary_flags = 0;
2225  if (s->pps->tiles_enabled_flag) {
2226  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]])
2227  lc->boundary_flags |= BOUNDARY_LEFT_TILE;
2228  if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2229  lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2230  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]])
2231  lc->boundary_flags |= BOUNDARY_UPPER_TILE;
2232  if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width])
2233  lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2234  } else {
2235  if (!ctb_addr_in_slice > 0)
2236  lc->boundary_flags |= BOUNDARY_LEFT_SLICE;
2237  if (ctb_addr_in_slice < s->sps->ctb_width)
2238  lc->boundary_flags |= BOUNDARY_UPPER_SLICE;
2239  }
2240 
2241  lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2242  lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2243  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]]));
2244  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]]));
2245 }
2246 
2247 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2248 {
2249  HEVCContext *s = avctxt->priv_data;
2250  int ctb_size = 1 << s->sps->log2_ctb_size;
2251  int more_data = 1;
2252  int x_ctb = 0;
2253  int y_ctb = 0;
2254  int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2255 
2256  if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2257  av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2258  return AVERROR_INVALIDDATA;
2259  }
2260 
2261  if (s->sh.dependent_slice_segment_flag) {
2262  int prev_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2263  if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2264  av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2265  return AVERROR_INVALIDDATA;
2266  }
2267  }
2268 
2269  while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2270  int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2271 
2272  x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2273  y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2274  hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2275 
2276  ff_hevc_cabac_init(s, ctb_addr_ts);
2277 
2278  hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2279 
2280  s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2281  s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2282  s->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2283 
2284  more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2285  if (more_data < 0) {
2286  s->tab_slice_address[ctb_addr_rs] = -1;
2287  return more_data;
2288  }
2289 
2290 
2291  ctb_addr_ts++;
2292  ff_hevc_save_states(s, ctb_addr_ts);
2293  ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2294  }
2295 
2296  if (x_ctb + ctb_size >= s->sps->width &&
2297  y_ctb + ctb_size >= s->sps->height)
2298  ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2299 
2300  return ctb_addr_ts;
2301 }
2302 
2303 static int hls_slice_data(HEVCContext *s)
2304 {
2305  int arg[2];
2306  int ret[2];
2307 
2308  arg[0] = 0;
2309  arg[1] = 1;
2310 
2311  s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2312  return ret[0];
2313 }
2314 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2315 {
2316  HEVCContext *s1 = avctxt->priv_data, *s;
2317  HEVCLocalContext *lc;
2318  int ctb_size = 1<< s1->sps->log2_ctb_size;
2319  int more_data = 1;
2320  int *ctb_row_p = input_ctb_row;
2321  int ctb_row = ctb_row_p[job];
2322  int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->sps->width + ctb_size - 1) >> s1->sps->log2_ctb_size);
2323  int ctb_addr_ts = s1->pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2324  int thread = ctb_row % s1->threads_number;
2325  int ret;
2326 
2327  s = s1->sList[self_id];
2328  lc = s->HEVClc;
2329 
2330  if(ctb_row) {
2331  ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2332 
2333  if (ret < 0)
2334  return ret;
2335  ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2336  }
2337 
2338  while(more_data && ctb_addr_ts < s->sps->ctb_size) {
2339  int x_ctb = (ctb_addr_rs % s->sps->ctb_width) << s->sps->log2_ctb_size;
2340  int y_ctb = (ctb_addr_rs / s->sps->ctb_width) << s->sps->log2_ctb_size;
2341 
2342  hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2343 
2344  ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2345 
2346  if (avpriv_atomic_int_get(&s1->wpp_err)){
2347  ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2348  return 0;
2349  }
2350 
2351  ff_hevc_cabac_init(s, ctb_addr_ts);
2352  hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2353  more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2354 
2355  if (more_data < 0) {
2356  s->tab_slice_address[ctb_addr_rs] = -1;
2357  return more_data;
2358  }
2359 
2360  ctb_addr_ts++;
2361 
2362  ff_hevc_save_states(s, ctb_addr_ts);
2363  ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2364  ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2365 
2366  if (!more_data && (x_ctb+ctb_size) < s->sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2367  avpriv_atomic_int_set(&s1->wpp_err, 1);
2368  ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2369  return 0;
2370  }
2371 
2372  if ((x_ctb+ctb_size) >= s->sps->width && (y_ctb+ctb_size) >= s->sps->height ) {
2373  ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2374  ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2375  return ctb_addr_ts;
2376  }
2377  ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2378  x_ctb+=ctb_size;
2379 
2380  if(x_ctb >= s->sps->width) {
2381  break;
2382  }
2383  }
2384  ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2385 
2386  return 0;
2387 }
2388 
2389 static int hls_slice_data_wpp(HEVCContext *s, const uint8_t *nal, int length)
2390 {
2391  HEVCLocalContext *lc = s->HEVClc;
2392  int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2393  int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2394  int offset;
2395  int startheader, cmpt = 0;
2396  int i, j, res = 0;
2397 
2398 
2399  if (!s->sList[1]) {
2400  ff_alloc_entries(s->avctx, s->sh.num_entry_point_offsets + 1);
2401 
2402 
2403  for (i = 1; i < s->threads_number; i++) {
2404  s->sList[i] = av_malloc(sizeof(HEVCContext));
2405  memcpy(s->sList[i], s, sizeof(HEVCContext));
2406  s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2407  s->sList[i]->HEVClc = s->HEVClcList[i];
2408  }
2409  }
2410 
2411  offset = (lc->gb.index >> 3);
2412 
2413  for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < s->skipped_bytes; j++) {
2414  if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2415  startheader--;
2416  cmpt++;
2417  }
2418  }
2419 
2420  for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2421  offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2422  for (j = 0, cmpt = 0, startheader = offset
2423  + s->sh.entry_point_offset[i]; j < s->skipped_bytes; j++) {
2424  if (s->skipped_bytes_pos[j] >= offset && s->skipped_bytes_pos[j] < startheader) {
2425  startheader--;
2426  cmpt++;
2427  }
2428  }
2429  s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2430  s->sh.offset[i - 1] = offset;
2431 
2432  }
2433  if (s->sh.num_entry_point_offsets != 0) {
2434  offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2435  s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2436  s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2437 
2438  }
2439  s->data = nal;
2440 
2441  for (i = 1; i < s->threads_number; i++) {
2442  s->sList[i]->HEVClc->first_qp_group = 1;
2443  s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2444  memcpy(s->sList[i], s, sizeof(HEVCContext));
2445  s->sList[i]->HEVClc = s->HEVClcList[i];
2446  }
2447 
2448  avpriv_atomic_int_set(&s->wpp_err, 0);
2449  ff_reset_entries(s->avctx);
2450 
2451  for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2452  arg[i] = i;
2453  ret[i] = 0;
2454  }
2455 
2456  if (s->pps->entropy_coding_sync_enabled_flag)
2457  s->avctx->execute2(s->avctx, (void *) hls_decode_entry_wpp, arg, ret, s->sh.num_entry_point_offsets + 1);
2458 
2459  for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2460  res += ret[i];
2461  av_free(ret);
2462  av_free(arg);
2463  return res;
2464 }
2465 
2466 /**
2467  * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,
2468  * 0 if the unit should be skipped, 1 otherwise
2469  */
2470 static int hls_nal_unit(HEVCContext *s)
2471 {
2472  GetBitContext *gb = &s->HEVClc->gb;
2473  int nuh_layer_id;
2474 
2475  if (get_bits1(gb) != 0)
2476  return AVERROR_INVALIDDATA;
2477 
2478  s->nal_unit_type = get_bits(gb, 6);
2479 
2480  nuh_layer_id = get_bits(gb, 6);
2481  s->temporal_id = get_bits(gb, 3) - 1;
2482  if (s->temporal_id < 0)
2483  return AVERROR_INVALIDDATA;
2484 
2485  av_log(s->avctx, AV_LOG_DEBUG,
2486  "nal_unit_type: %d, nuh_layer_id: %d, temporal_id: %d\n",
2487  s->nal_unit_type, nuh_layer_id, s->temporal_id);
2488 
2489  return nuh_layer_id == 0;
2490 }
2491 
2492 static int set_side_data(HEVCContext *s)
2493 {
2494  AVFrame *out = s->ref->frame;
2495 
2496  if (s->sei_frame_packing_present &&
2497  s->frame_packing_arrangement_type >= 3 &&
2498  s->frame_packing_arrangement_type <= 5 &&
2499  s->content_interpretation_type > 0 &&
2500  s->content_interpretation_type < 3) {
2501  AVStereo3D *stereo = av_stereo3d_create_side_data(out);
2502  if (!stereo)
2503  return AVERROR(ENOMEM);
2504 
2505  switch (s->frame_packing_arrangement_type) {
2506  case 3:
2507  if (s->quincunx_subsampling)
2508  stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2509  else
2510  stereo->type = AV_STEREO3D_SIDEBYSIDE;
2511  break;
2512  case 4:
2513  stereo->type = AV_STEREO3D_TOPBOTTOM;
2514  break;
2515  case 5:
2516  stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2517  break;
2518  }
2519 
2520  if (s->content_interpretation_type == 2)
2521  stereo->flags = AV_STEREO3D_FLAG_INVERT;
2522  }
2523 
2524  if (s->sei_display_orientation_present &&
2525  (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2526  double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2527  AVFrameSideData *rotation = av_frame_new_side_data(out,
2528  AV_FRAME_DATA_DISPLAYMATRIX,
2529  sizeof(int32_t) * 9);
2530  if (!rotation)
2531  return AVERROR(ENOMEM);
2532 
2533  av_display_rotation_set((int32_t *)rotation->data, angle);
2534  av_display_matrix_flip((int32_t *)rotation->data,
2535  s->sei_vflip, s->sei_hflip);
2536  }
2537 
2538  return 0;
2539 }
2540 
2541 static int hevc_frame_start(HEVCContext *s)
2542 {
2543  HEVCLocalContext *lc = s->HEVClc;
2544  int pic_size_in_ctb = ((s->sps->width >> s->sps->log2_min_cb_size) + 1) *
2545  ((s->sps->height >> s->sps->log2_min_cb_size) + 1);
2546  int ret;
2547 
2548  memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2549  memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2550  memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2551  memset(s->is_pcm, 0, (s->sps->min_pu_width + 1) * (s->sps->min_pu_height + 1));
2552  memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2553 
2554  s->is_decoded = 0;
2555  s->first_nal_type = s->nal_unit_type;
2556 
2557  if (s->pps->tiles_enabled_flag)
2558  lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2559 
2560  ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2561  if (ret < 0)
2562  goto fail;
2563 
2564  ret = ff_hevc_frame_rps(s);
2565  if (ret < 0) {
2566  av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2567  goto fail;
2568  }
2569 
2570  s->ref->frame->key_frame = IS_IRAP(s);
2571 
2572  ret = set_side_data(s);
2573  if (ret < 0)
2574  goto fail;
2575 
2576  s->frame->pict_type = 3 - s->sh.slice_type;
2577 
2578  if (!IS_IRAP(s))
2579  ff_hevc_bump_frame(s);
2580 
2581  av_frame_unref(s->output_frame);
2582  ret = ff_hevc_output_frame(s, s->output_frame, 0);
2583  if (ret < 0)
2584  goto fail;
2585 
2586  ff_thread_finish_setup(s->avctx);
2587 
2588  return 0;
2589 
2590 fail:
2591  if (s->ref && s->threads_type == FF_THREAD_FRAME)
2592  ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2593  s->ref = NULL;
2594  return ret;
2595 }
2596 
2597 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2598 {
2599  HEVCLocalContext *lc = s->HEVClc;
2600  GetBitContext *gb = &lc->gb;
2601  int ctb_addr_ts, ret;
2602 
2603  ret = init_get_bits8(gb, nal, length);
2604  if (ret < 0)
2605  return ret;
2606 
2607  ret = hls_nal_unit(s);
2608  if (ret < 0) {
2609  av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2610  s->nal_unit_type);
2611  goto fail;
2612  } else if (!ret)
2613  return 0;
2614 
2615  switch (s->nal_unit_type) {
2616  case NAL_VPS:
2617  ret = ff_hevc_decode_nal_vps(s);
2618  if (ret < 0)
2619  goto fail;
2620  break;
2621  case NAL_SPS:
2622  ret = ff_hevc_decode_nal_sps(s);
2623  if (ret < 0)
2624  goto fail;
2625  break;
2626  case NAL_PPS:
2627  ret = ff_hevc_decode_nal_pps(s);
2628  if (ret < 0)
2629  goto fail;
2630  break;
2631  case NAL_SEI_PREFIX:
2632  case NAL_SEI_SUFFIX:
2633  ret = ff_hevc_decode_nal_sei(s);
2634  if (ret < 0)
2635  goto fail;
2636  break;
2637  case NAL_TRAIL_R:
2638  case NAL_TRAIL_N:
2639  case NAL_TSA_N:
2640  case NAL_TSA_R:
2641  case NAL_STSA_N:
2642  case NAL_STSA_R:
2643  case NAL_BLA_W_LP:
2644  case NAL_BLA_W_RADL:
2645  case NAL_BLA_N_LP:
2646  case NAL_IDR_W_RADL:
2647  case NAL_IDR_N_LP:
2648  case NAL_CRA_NUT:
2649  case NAL_RADL_N:
2650  case NAL_RADL_R:
2651  case NAL_RASL_N:
2652  case NAL_RASL_R:
2653  ret = hls_slice_header(s);
2654  if (ret < 0)
2655  return ret;
2656 
2657  if (s->max_ra == INT_MAX) {
2658  if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2659  s->max_ra = s->poc;
2660  } else {
2661  if (IS_IDR(s))
2662  s->max_ra = INT_MIN;
2663  }
2664  }
2665 
2666  if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2667  s->poc <= s->max_ra) {
2668  s->is_decoded = 0;
2669  break;
2670  } else {
2671  if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2672  s->max_ra = INT_MIN;
2673  }
2674 
2675  if (s->sh.first_slice_in_pic_flag) {
2676  ret = hevc_frame_start(s);
2677  if (ret < 0)
2678  return ret;
2679  } else if (!s->ref) {
2680  av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2681  goto fail;
2682  }
2683 
2684  if (s->nal_unit_type != s->first_nal_type) {
2685  av_log(s->avctx, AV_LOG_ERROR,
2686  "Non-matching NAL types of the VCL NALUs: %d %d\n",
2687  s->first_nal_type, s->nal_unit_type);
2688  return AVERROR_INVALIDDATA;
2689  }
2690 
2691  if (!s->sh.dependent_slice_segment_flag &&
2692  s->sh.slice_type != I_SLICE) {
2693  ret = ff_hevc_slice_rpl(s);
2694  if (ret < 0) {
2695  av_log(s->avctx, AV_LOG_WARNING,
2696  "Error constructing the reference lists for the current slice.\n");
2697  goto fail;
2698  }
2699  }
2700 
2701  if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2702  ctb_addr_ts = hls_slice_data_wpp(s, nal, length);
2703  else
2704  ctb_addr_ts = hls_slice_data(s);
2705  if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2706  s->is_decoded = 1;
2707  }
2708 
2709  if (ctb_addr_ts < 0) {
2710  ret = ctb_addr_ts;
2711  goto fail;
2712  }
2713  break;
2714  case NAL_EOS_NUT:
2715  case NAL_EOB_NUT:
2716  s->seq_decode = (s->seq_decode + 1) & 0xff;
2717  s->max_ra = INT_MAX;
2718  break;
2719  case NAL_AUD:
2720  case NAL_FD_NUT:
2721  break;
2722  default:
2723  av_log(s->avctx, AV_LOG_INFO,
2724  "Skipping NAL unit %d\n", s->nal_unit_type);
2725  }
2726 
2727  return 0;
2728 fail:
2729  if (s->avctx->err_recognition & AV_EF_EXPLODE)
2730  return ret;
2731  return 0;
2732 }
2733 
2734 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2735  * between these functions would be nice. */
2736 int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
2737  HEVCNAL *nal)
2738 {
2739  int i, si, di;
2740  uint8_t *dst;
2741 
2742  s->skipped_bytes = 0;
2743 #define STARTCODE_TEST \
2744  if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2745  if (src[i + 2] != 3) { \
2746  /* startcode, so we must be past the end */ \
2747  length = i; \
2748  } \
2749  break; \
2750  }
2751 #if HAVE_FAST_UNALIGNED
2752 #define FIND_FIRST_ZERO \
2753  if (i > 0 && !src[i]) \
2754  i--; \
2755  while (src[i]) \
2756  i++
2757 #if HAVE_FAST_64BIT
2758  for (i = 0; i + 1 < length; i += 9) {
2759  if (!((~AV_RN64A(src + i) &
2760  (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2761  0x8000800080008080ULL))
2762  continue;
2763  FIND_FIRST_ZERO;
2764  STARTCODE_TEST;
2765  i -= 7;
2766  }
2767 #else
2768  for (i = 0; i + 1 < length; i += 5) {
2769  if (!((~AV_RN32A(src + i) &
2770  (AV_RN32A(src + i) - 0x01000101U)) &
2771  0x80008080U))
2772  continue;
2773  FIND_FIRST_ZERO;
2774  STARTCODE_TEST;
2775  i -= 3;
2776  }
2777 #endif /* HAVE_FAST_64BIT */
2778 #else
2779  for (i = 0; i + 1 < length; i += 2) {
2780  if (src[i])
2781  continue;
2782  if (i > 0 && src[i - 1] == 0)
2783  i--;
2784  STARTCODE_TEST;
2785  }
2786 #endif /* HAVE_FAST_UNALIGNED */
2787 
2788  if (i >= length - 1) { // no escaped 0
2789  nal->data = src;
2790  nal->size = length;
2791  return length;
2792  }
2793 
2794  av_fast_malloc(&nal->rbsp_buffer, &nal->rbsp_buffer_size,
2795  length + FF_INPUT_BUFFER_PADDING_SIZE);
2796  if (!nal->rbsp_buffer)
2797  return AVERROR(ENOMEM);
2798 
2799  dst = nal->rbsp_buffer;
2800 
2801  memcpy(dst, src, i);
2802  si = di = i;
2803  while (si + 2 < length) {
2804  // remove escapes (very rare 1:2^22)
2805  if (src[si + 2] > 3) {
2806  dst[di++] = src[si++];
2807  dst[di++] = src[si++];
2808  } else if (src[si] == 0 && src[si + 1] == 0) {
2809  if (src[si + 2] == 3) { // escape
2810  dst[di++] = 0;
2811  dst[di++] = 0;
2812  si += 3;
2813 
2814  s->skipped_bytes++;
2815  if (s->skipped_bytes_pos_size < s->skipped_bytes) {
2816  s->skipped_bytes_pos_size *= 2;
2817  av_reallocp_array(&s->skipped_bytes_pos,
2818  s->skipped_bytes_pos_size,
2819  sizeof(*s->skipped_bytes_pos));
2820  if (!s->skipped_bytes_pos)
2821  return AVERROR(ENOMEM);
2822  }
2823  if (s->skipped_bytes_pos)
2824  s->skipped_bytes_pos[s->skipped_bytes-1] = di - 1;
2825  continue;
2826  } else // next start code
2827  goto nsc;
2828  }
2829 
2830  dst[di++] = src[si++];
2831  }
2832  while (si < length)
2833  dst[di++] = src[si++];
2834 
2835 nsc:
2836  memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2837 
2838  nal->data = dst;
2839  nal->size = di;
2840  return si;
2841 }
2842 
2843 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2844 {
2845  int i, consumed, ret = 0;
2846 
2847  s->ref = NULL;
2848  s->last_eos = s->eos;
2849  s->eos = 0;
2850 
2851  /* split the input packet into NAL units, so we know the upper bound on the
2852  * number of slices in the frame */
2853  s->nb_nals = 0;
2854  while (length >= 4) {
2855  HEVCNAL *nal;
2856  int extract_length = 0;
2857 
2858  if (s->is_nalff) {
2859  int i;
2860  for (i = 0; i < s->nal_length_size; i++)
2861  extract_length = (extract_length << 8) | buf[i];
2862  buf += s->nal_length_size;
2863  length -= s->nal_length_size;
2864 
2865  if (extract_length > length) {
2866  av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2867  ret = AVERROR_INVALIDDATA;
2868  goto fail;
2869  }
2870  } else {
2871  /* search start code */
2872  while (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2873  ++buf;
2874  --length;
2875  if (length < 4) {
2876  av_log(s->avctx, AV_LOG_ERROR, "No start code is found.\n");
2877  ret = AVERROR_INVALIDDATA;
2878  goto fail;
2879  }
2880  }
2881 
2882  buf += 3;
2883  length -= 3;
2884  }
2885 
2886  if (!s->is_nalff)
2887  extract_length = length;
2888 
2889  if (s->nals_allocated < s->nb_nals + 1) {
2890  int new_size = s->nals_allocated + 1;
2891  HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2892  if (!tmp) {
2893  ret = AVERROR(ENOMEM);
2894  goto fail;
2895  }
2896  s->nals = tmp;
2897  memset(s->nals + s->nals_allocated, 0,
2898  (new_size - s->nals_allocated) * sizeof(*tmp));
2899  av_reallocp_array(&s->skipped_bytes_nal, new_size, sizeof(*s->skipped_bytes_nal));
2900  av_reallocp_array(&s->skipped_bytes_pos_size_nal, new_size, sizeof(*s->skipped_bytes_pos_size_nal));
2901  av_reallocp_array(&s->skipped_bytes_pos_nal, new_size, sizeof(*s->skipped_bytes_pos_nal));
2902  s->skipped_bytes_pos_size_nal[s->nals_allocated] = 1024; // initial buffer size
2903  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));
2904  s->nals_allocated = new_size;
2905  }
2906  s->skipped_bytes_pos_size = s->skipped_bytes_pos_size_nal[s->nb_nals];
2907  s->skipped_bytes_pos = s->skipped_bytes_pos_nal[s->nb_nals];
2908  nal = &s->nals[s->nb_nals];
2909 
2910  consumed = ff_hevc_extract_rbsp(s, buf, extract_length, nal);
2911 
2912  s->skipped_bytes_nal[s->nb_nals] = s->skipped_bytes;
2913  s->skipped_bytes_pos_size_nal[s->nb_nals] = s->skipped_bytes_pos_size;
2914  s->skipped_bytes_pos_nal[s->nb_nals++] = s->skipped_bytes_pos;
2915 
2916 
2917  if (consumed < 0) {
2918  ret = consumed;
2919  goto fail;
2920  }
2921 
2922  ret = init_get_bits8(&s->HEVClc->gb, nal->data, nal->size);
2923  if (ret < 0)
2924  goto fail;
2925  hls_nal_unit(s);
2926 
2927  if (s->nal_unit_type == NAL_EOB_NUT ||
2928  s->nal_unit_type == NAL_EOS_NUT)
2929  s->eos = 1;
2930 
2931  buf += consumed;
2932  length -= consumed;
2933  }
2934 
2935  /* parse the NAL units */
2936  for (i = 0; i < s->nb_nals; i++) {
2937  int ret;
2938  s->skipped_bytes = s->skipped_bytes_nal[i];
2939  s->skipped_bytes_pos = s->skipped_bytes_pos_nal[i];
2940 
2941  ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2942  if (ret < 0) {
2943  av_log(s->avctx, AV_LOG_WARNING,
2944  "Error parsing NAL unit #%d.\n", i);
2945  goto fail;
2946  }
2947  }
2948 
2949 fail:
2950  if (s->ref && s->threads_type == FF_THREAD_FRAME)
2951  ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2952 
2953  return ret;
2954 }
2955 
2956 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2957 {
2958  int i;
2959  for (i = 0; i < 16; i++)
2960  av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2961 }
2962 
2963 static int verify_md5(HEVCContext *s, AVFrame *frame)
2964 {
2965  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2966  int pixel_shift;
2967  int i, j;
2968 
2969  if (!desc)
2970  return AVERROR(EINVAL);
2971 
2972  pixel_shift = desc->comp[0].depth_minus1 > 7;
2973 
2974  av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2975  s->poc);
2976 
2977  /* the checksums are LE, so we have to byteswap for >8bpp formats
2978  * on BE arches */
2979 #if HAVE_BIGENDIAN
2980  if (pixel_shift && !s->checksum_buf) {
2981  av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
2982  FFMAX3(frame->linesize[0], frame->linesize[1],
2983  frame->linesize[2]));
2984  if (!s->checksum_buf)
2985  return AVERROR(ENOMEM);
2986  }
2987 #endif
2988 
2989  for (i = 0; frame->data[i]; i++) {
2990  int width = s->avctx->coded_width;
2991  int height = s->avctx->coded_height;
2992  int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2993  int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2994  uint8_t md5[16];
2995 
2996  av_md5_init(s->md5_ctx);
2997  for (j = 0; j < h; j++) {
2998  const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2999 #if HAVE_BIGENDIAN
3000  if (pixel_shift) {
3001  s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3002  (const uint16_t *) src, w);
3003  src = s->checksum_buf;
3004  }
3005 #endif
3006  av_md5_update(s->md5_ctx, src, w << pixel_shift);
3007  }
3008  av_md5_final(s->md5_ctx, md5);
3009 
3010  if (!memcmp(md5, s->md5[i], 16)) {
3011  av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
3012  print_md5(s->avctx, AV_LOG_DEBUG, md5);
3013  av_log (s->avctx, AV_LOG_DEBUG, "; ");
3014  } else {
3015  av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
3016  print_md5(s->avctx, AV_LOG_ERROR, md5);
3017  av_log (s->avctx, AV_LOG_ERROR, " != ");
3018  print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
3019  av_log (s->avctx, AV_LOG_ERROR, "\n");
3020  return AVERROR_INVALIDDATA;
3021  }
3022  }
3023 
3024  av_log(s->avctx, AV_LOG_DEBUG, "\n");
3025 
3026  return 0;
3027 }
3028 
3029 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3030  AVPacket *avpkt)
3031 {
3032  int ret;
3033  HEVCContext *s = avctx->priv_data;
3034 
3035  if (!avpkt->size) {
3036  ret = ff_hevc_output_frame(s, data, 1);
3037  if (ret < 0)
3038  return ret;
3039 
3040  *got_output = ret;
3041  return 0;
3042  }
3043 
3044  s->ref = NULL;
3045  ret = decode_nal_units(s, avpkt->data, avpkt->size);
3046  if (ret < 0)
3047  return ret;
3048 
3049  /* verify the SEI checksum */
3050  if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3051  s->is_md5) {
3052  ret = verify_md5(s, s->ref->frame);
3053  if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3054  ff_hevc_unref_frame(s, s->ref, ~0);
3055  return ret;
3056  }
3057  }
3058  s->is_md5 = 0;
3059 
3060  if (s->is_decoded) {
3061  av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3062  s->is_decoded = 0;
3063  }
3064 
3065  if (s->output_frame->buf[0]) {
3066  av_frame_move_ref(data, s->output_frame);
3067  *got_output = 1;
3068  }
3069 
3070  return avpkt->size;
3071 }
3072 
3073 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
3074 {
3075  int ret;
3076 
3077  ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3078  if (ret < 0)
3079  return ret;
3080 
3081  dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3082  if (!dst->tab_mvf_buf)
3083  goto fail;
3084  dst->tab_mvf = src->tab_mvf;
3085 
3086  dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3087  if (!dst->rpl_tab_buf)
3088  goto fail;
3089  dst->rpl_tab = src->rpl_tab;
3090 
3091  dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3092  if (!dst->rpl_buf)
3093  goto fail;
3094 
3095  dst->poc = src->poc;
3096  dst->ctb_count = src->ctb_count;
3097  dst->window = src->window;
3098  dst->flags = src->flags;
3099  dst->sequence = src->sequence;
3100 
3101  return 0;
3102 fail:
3103  ff_hevc_unref_frame(s, dst, ~0);
3104  return AVERROR(ENOMEM);
3105 }
3106 
3107 static av_cold int hevc_decode_free(AVCodecContext *avctx)
3108 {
3109  HEVCContext *s = avctx->priv_data;
3110  int i;
3111 
3112  pic_arrays_free(s);
3113 
3114  av_freep(&s->md5_ctx);
3115 
3116  for(i=0; i < s->nals_allocated; i++) {
3117  av_freep(&s->skipped_bytes_pos_nal[i]);
3118  }
3119  av_freep(&s->skipped_bytes_pos_size_nal);
3120  av_freep(&s->skipped_bytes_nal);
3121  av_freep(&s->skipped_bytes_pos_nal);
3122 
3123  av_freep(&s->cabac_state);
3124 
3125  av_frame_free(&s->tmp_frame);
3126  av_frame_free(&s->output_frame);
3127 
3128  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3129  ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3130  av_frame_free(&s->DPB[i].frame);
3131  }
3132 
3133  for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3134  av_buffer_unref(&s->vps_list[i]);
3135  for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3136  av_buffer_unref(&s->sps_list[i]);
3137  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3138  av_buffer_unref(&s->pps_list[i]);
3139  s->sps = NULL;
3140  s->pps = NULL;
3141  s->vps = NULL;
3142 
3143  av_buffer_unref(&s->current_sps);
3144 
3145  av_freep(&s->sh.entry_point_offset);
3146  av_freep(&s->sh.offset);
3147  av_freep(&s->sh.size);
3148 
3149  for (i = 1; i < s->threads_number; i++) {
3150  HEVCLocalContext *lc = s->HEVClcList[i];
3151  if (lc) {
3152  av_freep(&s->HEVClcList[i]);
3153  av_freep(&s->sList[i]);
3154  }
3155  }
3156  if (s->HEVClc == s->HEVClcList[0])
3157  s->HEVClc = NULL;
3158  av_freep(&s->HEVClcList[0]);
3159 
3160  for (i = 0; i < s->nals_allocated; i++)
3161  av_freep(&s->nals[i].rbsp_buffer);
3162  av_freep(&s->nals);
3163  s->nals_allocated = 0;
3164 
3165  return 0;
3166 }
3167 
3168 static av_cold int hevc_init_context(AVCodecContext *avctx)
3169 {
3170  HEVCContext *s = avctx->priv_data;
3171  int i;
3172 
3173  s->avctx = avctx;
3174 
3175  s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3176  if (!s->HEVClc)
3177  goto fail;
3178  s->HEVClcList[0] = s->HEVClc;
3179  s->sList[0] = s;
3180 
3181  s->cabac_state = av_malloc(HEVC_CONTEXTS);
3182  if (!s->cabac_state)
3183  goto fail;
3184 
3185  s->tmp_frame = av_frame_alloc();
3186  if (!s->tmp_frame)
3187  goto fail;
3188 
3189  s->output_frame = av_frame_alloc();
3190  if (!s->output_frame)
3191  goto fail;
3192 
3193  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3194  s->DPB[i].frame = av_frame_alloc();
3195  if (!s->DPB[i].frame)
3196  goto fail;
3197  s->DPB[i].tf.f = s->DPB[i].frame;
3198  }
3199 
3200  s->max_ra = INT_MAX;
3201 
3202  s->md5_ctx = av_md5_alloc();
3203  if (!s->md5_ctx)
3204  goto fail;
3205 
3206  ff_bswapdsp_init(&s->bdsp);
3207 
3208  s->context_initialized = 1;
3209  s->eos = 0;
3210 
3211  return 0;
3212 
3213 fail:
3214  hevc_decode_free(avctx);
3215  return AVERROR(ENOMEM);
3216 }
3217 
3218 static int hevc_update_thread_context(AVCodecContext *dst,
3219  const AVCodecContext *src)
3220 {
3221  HEVCContext *s = dst->priv_data;
3222  HEVCContext *s0 = src->priv_data;
3223  int i, ret;
3224 
3225  if (!s->context_initialized) {
3226  ret = hevc_init_context(dst);
3227  if (ret < 0)
3228  return ret;
3229  }
3230 
3231  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3232  ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3233  if (s0->DPB[i].frame->buf[0]) {
3234  ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3235  if (ret < 0)
3236  return ret;
3237  }
3238  }
3239 
3240  if (s->sps != s0->sps)
3241  s->sps = NULL;
3242  for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3243  av_buffer_unref(&s->vps_list[i]);
3244  if (s0->vps_list[i]) {
3245  s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3246  if (!s->vps_list[i])
3247  return AVERROR(ENOMEM);
3248  }
3249  }
3250 
3251  for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3252  av_buffer_unref(&s->sps_list[i]);
3253  if (s0->sps_list[i]) {
3254  s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3255  if (!s->sps_list[i])
3256  return AVERROR(ENOMEM);
3257  }
3258  }
3259 
3260  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3261  av_buffer_unref(&s->pps_list[i]);
3262  if (s0->pps_list[i]) {
3263  s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3264  if (!s->pps_list[i])
3265  return AVERROR(ENOMEM);
3266  }
3267  }
3268 
3269  av_buffer_unref(&s->current_sps);
3270  if (s0->current_sps) {
3271  s->current_sps = av_buffer_ref(s0->current_sps);
3272  if (!s->current_sps)
3273  return AVERROR(ENOMEM);
3274  }
3275 
3276  if (s->sps != s0->sps)
3277  if ((ret = set_sps(s, s0->sps)) < 0)
3278  return ret;
3279 
3280  s->seq_decode = s0->seq_decode;
3281  s->seq_output = s0->seq_output;
3282  s->pocTid0 = s0->pocTid0;
3283  s->max_ra = s0->max_ra;
3284  s->eos = s0->eos;
3285 
3286  s->is_nalff = s0->is_nalff;
3287  s->nal_length_size = s0->nal_length_size;
3288 
3289  s->threads_number = s0->threads_number;
3290  s->threads_type = s0->threads_type;
3291 
3292  if (s0->eos) {
3293  s->seq_decode = (s->seq_decode + 1) & 0xff;
3294  s->max_ra = INT_MAX;
3295  }
3296 
3297  return 0;
3298 }
3299 
3300 static int hevc_decode_extradata(HEVCContext *s)
3301 {
3302  AVCodecContext *avctx = s->avctx;
3303  GetByteContext gb;
3304  int ret;
3305 
3306  bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3307 
3308  if (avctx->extradata_size > 3 &&
3309  (avctx->extradata[0] || avctx->extradata[1] ||
3310  avctx->extradata[2] > 1)) {
3311  /* It seems the extradata is encoded as hvcC format.
3312  * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3313  * is finalized. When finalized, configurationVersion will be 1 and we
3314  * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3315  int i, j, num_arrays, nal_len_size;
3316 
3317  s->is_nalff = 1;
3318 
3319  bytestream2_skip(&gb, 21);
3320  nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3321  num_arrays = bytestream2_get_byte(&gb);
3322 
3323  /* nal units in the hvcC always have length coded with 2 bytes,
3324  * so put a fake nal_length_size = 2 while parsing them */
3325  s->nal_length_size = 2;
3326 
3327  /* Decode nal units from hvcC. */
3328  for (i = 0; i < num_arrays; i++) {
3329  int type = bytestream2_get_byte(&gb) & 0x3f;
3330  int cnt = bytestream2_get_be16(&gb);
3331 
3332  for (j = 0; j < cnt; j++) {
3333  // +2 for the nal size field
3334  int nalsize = bytestream2_peek_be16(&gb) + 2;
3335  if (bytestream2_get_bytes_left(&gb) < nalsize) {
3336  av_log(s->avctx, AV_LOG_ERROR,
3337  "Invalid NAL unit size in extradata.\n");
3338  return AVERROR_INVALIDDATA;
3339  }
3340 
3341  ret = decode_nal_units(s, gb.buffer, nalsize);
3342  if (ret < 0) {
3343  av_log(avctx, AV_LOG_ERROR,
3344  "Decoding nal unit %d %d from hvcC failed\n",
3345  type, i);
3346  return ret;
3347  }
3348  bytestream2_skip(&gb, nalsize);
3349  }
3350  }
3351 
3352  /* Now store right nal length size, that will be used to parse
3353  * all other nals */
3354  s->nal_length_size = nal_len_size;
3355  } else {
3356  s->is_nalff = 0;
3357  ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3358  if (ret < 0)
3359  return ret;
3360  }
3361  return 0;
3362 }
3363 
3364 static av_cold int hevc_decode_init(AVCodecContext *avctx)
3365 {
3366  HEVCContext *s = avctx->priv_data;
3367  int ret;
3368 
3369  ff_init_cabac_states();
3370 
3371  avctx->internal->allocate_progress = 1;
3372 
3373  ret = hevc_init_context(avctx);
3374  if (ret < 0)
3375  return ret;
3376 
3377  s->enable_parallel_tiles = 0;
3378  s->picture_struct = 0;
3379 
3380  if(avctx->active_thread_type & FF_THREAD_SLICE)
3381  s->threads_number = avctx->thread_count;
3382  else
3383  s->threads_number = 1;
3384 
3385  if (avctx->extradata_size > 0 && avctx->extradata) {
3386  ret = hevc_decode_extradata(s);
3387  if (ret < 0) {
3388  hevc_decode_free(avctx);
3389  return ret;
3390  }
3391  }
3392 
3393  if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3394  s->threads_type = FF_THREAD_FRAME;
3395  else
3396  s->threads_type = FF_THREAD_SLICE;
3397 
3398  return 0;
3399 }
3400 
3401 static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
3402 {
3403  HEVCContext *s = avctx->priv_data;
3404  int ret;
3405 
3406  memset(s, 0, sizeof(*s));
3407 
3408  ret = hevc_init_context(avctx);
3409  if (ret < 0)
3410  return ret;
3411 
3412  return 0;
3413 }
3414 
3415 static void hevc_decode_flush(AVCodecContext *avctx)
3416 {
3417  HEVCContext *s = avctx->priv_data;
3418  ff_hevc_flush_dpb(s);
3419  s->max_ra = INT_MAX;
3420 }
3421 
3422 #define OFFSET(x) offsetof(HEVCContext, x)
3423 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3424 
3425 static const AVProfile profiles[] = {
3426  { FF_PROFILE_HEVC_MAIN, "Main" },
3427  { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3428  { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3429  { FF_PROFILE_HEVC_REXT, "Rext" },
3430  { FF_PROFILE_UNKNOWN },
3431 };
3432 
3433 static const AVOption options[] = {
3434  { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3435  AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3436  { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3437  AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3438  { NULL },
3439 };
3440 
3441 static const AVClass hevc_decoder_class = {
3442  .class_name = "HEVC decoder",
3443  .item_name = av_default_item_name,
3444  .option = options,
3445  .version = LIBAVUTIL_VERSION_INT,
3446 };
3447 
3448 AVCodec ff_hevc_decoder = {
3449  .name = "hevc",
3450  .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3451  .type = AVMEDIA_TYPE_VIDEO,
3452  .id = AV_CODEC_ID_HEVC,
3453  .priv_data_size = sizeof(HEVCContext),
3454  .priv_class = &hevc_decoder_class,
3455  .init = hevc_decode_init,
3456  .close = hevc_decode_free,
3457  .decode = hevc_decode_frame,
3458  .flush = hevc_decode_flush,
3459  .update_thread_context = hevc_update_thread_context,
3460  .init_thread_copy = hevc_init_thread_copy,
3461  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3462  CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3463  .profiles = NULL_IF_CONFIG_SMALL(profiles),
3464 };
Generated on Sun Sep 14 2014 18:55:56 for FFmpeg by   doxygen 1.8.2