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