1 |
|
|
/* |
2 |
|
|
* HEVC video decoder |
3 |
|
|
* |
4 |
|
|
* Copyright (C) 2012 - 2013 Guillaume Martres |
5 |
|
|
* |
6 |
|
|
* This file is part of FFmpeg. |
7 |
|
|
* |
8 |
|
|
* FFmpeg is free software; you can redistribute it and/or |
9 |
|
|
* modify it under the terms of the GNU Lesser General Public |
10 |
|
|
* License as published by the Free Software Foundation; either |
11 |
|
|
* version 2.1 of the License, or (at your option) any later version. |
12 |
|
|
* |
13 |
|
|
* FFmpeg is distributed in the hope that it will be useful, |
14 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 |
|
|
* Lesser General Public License for more details. |
17 |
|
|
* |
18 |
|
|
* You should have received a copy of the GNU Lesser General Public |
19 |
|
|
* License along with FFmpeg; if not, write to the Free Software |
20 |
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
21 |
|
|
*/ |
22 |
|
|
|
23 |
|
|
#ifndef AVCODEC_HEVCDEC_H |
24 |
|
|
#define AVCODEC_HEVCDEC_H |
25 |
|
|
|
26 |
|
|
#include <stdatomic.h> |
27 |
|
|
|
28 |
|
|
#include "libavutil/buffer.h" |
29 |
|
|
#include "libavutil/md5.h" |
30 |
|
|
#include "libavutil/mem_internal.h" |
31 |
|
|
|
32 |
|
|
#include "avcodec.h" |
33 |
|
|
#include "bswapdsp.h" |
34 |
|
|
#include "cabac.h" |
35 |
|
|
#include "get_bits.h" |
36 |
|
|
#include "hevcpred.h" |
37 |
|
|
#include "h2645_parse.h" |
38 |
|
|
#include "hevc.h" |
39 |
|
|
#include "hevc_ps.h" |
40 |
|
|
#include "hevc_sei.h" |
41 |
|
|
#include "hevcdsp.h" |
42 |
|
|
#include "internal.h" |
43 |
|
|
#include "thread.h" |
44 |
|
|
#include "videodsp.h" |
45 |
|
|
|
46 |
|
|
#define SHIFT_CTB_WPP 2 |
47 |
|
|
|
48 |
|
|
//TODO: check if this is really the maximum |
49 |
|
|
#define MAX_TRANSFORM_DEPTH 5 |
50 |
|
|
|
51 |
|
|
#define MAX_TB_SIZE 32 |
52 |
|
|
#define MAX_QP 51 |
53 |
|
|
#define DEFAULT_INTRA_TC_OFFSET 2 |
54 |
|
|
|
55 |
|
|
#define HEVC_CONTEXTS 199 |
56 |
|
|
#define HEVC_STAT_COEFFS 4 |
57 |
|
|
|
58 |
|
|
#define MRG_MAX_NUM_CANDS 5 |
59 |
|
|
|
60 |
|
|
#define L0 0 |
61 |
|
|
#define L1 1 |
62 |
|
|
|
63 |
|
|
#define EPEL_EXTRA_BEFORE 1 |
64 |
|
|
#define EPEL_EXTRA_AFTER 2 |
65 |
|
|
#define EPEL_EXTRA 3 |
66 |
|
|
#define QPEL_EXTRA_BEFORE 3 |
67 |
|
|
#define QPEL_EXTRA_AFTER 4 |
68 |
|
|
#define QPEL_EXTRA 7 |
69 |
|
|
|
70 |
|
|
#define EDGE_EMU_BUFFER_STRIDE 80 |
71 |
|
|
|
72 |
|
|
/** |
73 |
|
|
* Value of the luma sample at position (x, y) in the 2D array tab. |
74 |
|
|
*/ |
75 |
|
|
#define SAMPLE(tab, x, y) ((tab)[(y) * s->sps->width + (x)]) |
76 |
|
|
#define SAMPLE_CTB(tab, x, y) ((tab)[(y) * min_cb_width + (x)]) |
77 |
|
|
|
78 |
|
|
#define IS_IDR(s) ((s)->nal_unit_type == HEVC_NAL_IDR_W_RADL || (s)->nal_unit_type == HEVC_NAL_IDR_N_LP) |
79 |
|
|
#define IS_BLA(s) ((s)->nal_unit_type == HEVC_NAL_BLA_W_RADL || (s)->nal_unit_type == HEVC_NAL_BLA_W_LP || \ |
80 |
|
|
(s)->nal_unit_type == HEVC_NAL_BLA_N_LP) |
81 |
|
|
#define IS_IRAP(s) ((s)->nal_unit_type >= 16 && (s)->nal_unit_type <= 23) |
82 |
|
|
|
83 |
|
|
enum RPSType { |
84 |
|
|
ST_CURR_BEF = 0, |
85 |
|
|
ST_CURR_AFT, |
86 |
|
|
ST_FOLL, |
87 |
|
|
LT_CURR, |
88 |
|
|
LT_FOLL, |
89 |
|
|
NB_RPS_TYPE, |
90 |
|
|
}; |
91 |
|
|
|
92 |
|
|
enum SyntaxElement { |
93 |
|
|
SAO_MERGE_FLAG = 0, |
94 |
|
|
SAO_TYPE_IDX, |
95 |
|
|
SAO_EO_CLASS, |
96 |
|
|
SAO_BAND_POSITION, |
97 |
|
|
SAO_OFFSET_ABS, |
98 |
|
|
SAO_OFFSET_SIGN, |
99 |
|
|
END_OF_SLICE_FLAG, |
100 |
|
|
SPLIT_CODING_UNIT_FLAG, |
101 |
|
|
CU_TRANSQUANT_BYPASS_FLAG, |
102 |
|
|
SKIP_FLAG, |
103 |
|
|
CU_QP_DELTA, |
104 |
|
|
PRED_MODE_FLAG, |
105 |
|
|
PART_MODE, |
106 |
|
|
PCM_FLAG, |
107 |
|
|
PREV_INTRA_LUMA_PRED_FLAG, |
108 |
|
|
MPM_IDX, |
109 |
|
|
REM_INTRA_LUMA_PRED_MODE, |
110 |
|
|
INTRA_CHROMA_PRED_MODE, |
111 |
|
|
MERGE_FLAG, |
112 |
|
|
MERGE_IDX, |
113 |
|
|
INTER_PRED_IDC, |
114 |
|
|
REF_IDX_L0, |
115 |
|
|
REF_IDX_L1, |
116 |
|
|
ABS_MVD_GREATER0_FLAG, |
117 |
|
|
ABS_MVD_GREATER1_FLAG, |
118 |
|
|
ABS_MVD_MINUS2, |
119 |
|
|
MVD_SIGN_FLAG, |
120 |
|
|
MVP_LX_FLAG, |
121 |
|
|
NO_RESIDUAL_DATA_FLAG, |
122 |
|
|
SPLIT_TRANSFORM_FLAG, |
123 |
|
|
CBF_LUMA, |
124 |
|
|
CBF_CB_CR, |
125 |
|
|
TRANSFORM_SKIP_FLAG, |
126 |
|
|
EXPLICIT_RDPCM_FLAG, |
127 |
|
|
EXPLICIT_RDPCM_DIR_FLAG, |
128 |
|
|
LAST_SIGNIFICANT_COEFF_X_PREFIX, |
129 |
|
|
LAST_SIGNIFICANT_COEFF_Y_PREFIX, |
130 |
|
|
LAST_SIGNIFICANT_COEFF_X_SUFFIX, |
131 |
|
|
LAST_SIGNIFICANT_COEFF_Y_SUFFIX, |
132 |
|
|
SIGNIFICANT_COEFF_GROUP_FLAG, |
133 |
|
|
SIGNIFICANT_COEFF_FLAG, |
134 |
|
|
COEFF_ABS_LEVEL_GREATER1_FLAG, |
135 |
|
|
COEFF_ABS_LEVEL_GREATER2_FLAG, |
136 |
|
|
COEFF_ABS_LEVEL_REMAINING, |
137 |
|
|
COEFF_SIGN_FLAG, |
138 |
|
|
LOG2_RES_SCALE_ABS, |
139 |
|
|
RES_SCALE_SIGN_FLAG, |
140 |
|
|
CU_CHROMA_QP_OFFSET_FLAG, |
141 |
|
|
CU_CHROMA_QP_OFFSET_IDX, |
142 |
|
|
}; |
143 |
|
|
|
144 |
|
|
enum PartMode { |
145 |
|
|
PART_2Nx2N = 0, |
146 |
|
|
PART_2NxN = 1, |
147 |
|
|
PART_Nx2N = 2, |
148 |
|
|
PART_NxN = 3, |
149 |
|
|
PART_2NxnU = 4, |
150 |
|
|
PART_2NxnD = 5, |
151 |
|
|
PART_nLx2N = 6, |
152 |
|
|
PART_nRx2N = 7, |
153 |
|
|
}; |
154 |
|
|
|
155 |
|
|
enum PredMode { |
156 |
|
|
MODE_INTER = 0, |
157 |
|
|
MODE_INTRA, |
158 |
|
|
MODE_SKIP, |
159 |
|
|
}; |
160 |
|
|
|
161 |
|
|
enum InterPredIdc { |
162 |
|
|
PRED_L0 = 0, |
163 |
|
|
PRED_L1, |
164 |
|
|
PRED_BI, |
165 |
|
|
}; |
166 |
|
|
|
167 |
|
|
enum PredFlag { |
168 |
|
|
PF_INTRA = 0, |
169 |
|
|
PF_L0, |
170 |
|
|
PF_L1, |
171 |
|
|
PF_BI, |
172 |
|
|
}; |
173 |
|
|
|
174 |
|
|
enum IntraPredMode { |
175 |
|
|
INTRA_PLANAR = 0, |
176 |
|
|
INTRA_DC, |
177 |
|
|
INTRA_ANGULAR_2, |
178 |
|
|
INTRA_ANGULAR_3, |
179 |
|
|
INTRA_ANGULAR_4, |
180 |
|
|
INTRA_ANGULAR_5, |
181 |
|
|
INTRA_ANGULAR_6, |
182 |
|
|
INTRA_ANGULAR_7, |
183 |
|
|
INTRA_ANGULAR_8, |
184 |
|
|
INTRA_ANGULAR_9, |
185 |
|
|
INTRA_ANGULAR_10, |
186 |
|
|
INTRA_ANGULAR_11, |
187 |
|
|
INTRA_ANGULAR_12, |
188 |
|
|
INTRA_ANGULAR_13, |
189 |
|
|
INTRA_ANGULAR_14, |
190 |
|
|
INTRA_ANGULAR_15, |
191 |
|
|
INTRA_ANGULAR_16, |
192 |
|
|
INTRA_ANGULAR_17, |
193 |
|
|
INTRA_ANGULAR_18, |
194 |
|
|
INTRA_ANGULAR_19, |
195 |
|
|
INTRA_ANGULAR_20, |
196 |
|
|
INTRA_ANGULAR_21, |
197 |
|
|
INTRA_ANGULAR_22, |
198 |
|
|
INTRA_ANGULAR_23, |
199 |
|
|
INTRA_ANGULAR_24, |
200 |
|
|
INTRA_ANGULAR_25, |
201 |
|
|
INTRA_ANGULAR_26, |
202 |
|
|
INTRA_ANGULAR_27, |
203 |
|
|
INTRA_ANGULAR_28, |
204 |
|
|
INTRA_ANGULAR_29, |
205 |
|
|
INTRA_ANGULAR_30, |
206 |
|
|
INTRA_ANGULAR_31, |
207 |
|
|
INTRA_ANGULAR_32, |
208 |
|
|
INTRA_ANGULAR_33, |
209 |
|
|
INTRA_ANGULAR_34, |
210 |
|
|
}; |
211 |
|
|
|
212 |
|
|
enum SAOType { |
213 |
|
|
SAO_NOT_APPLIED = 0, |
214 |
|
|
SAO_BAND, |
215 |
|
|
SAO_EDGE, |
216 |
|
|
SAO_APPLIED |
217 |
|
|
}; |
218 |
|
|
|
219 |
|
|
enum SAOEOClass { |
220 |
|
|
SAO_EO_HORIZ = 0, |
221 |
|
|
SAO_EO_VERT, |
222 |
|
|
SAO_EO_135D, |
223 |
|
|
SAO_EO_45D, |
224 |
|
|
}; |
225 |
|
|
|
226 |
|
|
enum ScanType { |
227 |
|
|
SCAN_DIAG = 0, |
228 |
|
|
SCAN_HORIZ, |
229 |
|
|
SCAN_VERT, |
230 |
|
|
}; |
231 |
|
|
|
232 |
|
|
typedef struct LongTermRPS { |
233 |
|
|
int poc[32]; |
234 |
|
|
uint8_t poc_msb_present[32]; |
235 |
|
|
uint8_t used[32]; |
236 |
|
|
uint8_t nb_refs; |
237 |
|
|
} LongTermRPS; |
238 |
|
|
|
239 |
|
|
typedef struct RefPicList { |
240 |
|
|
struct HEVCFrame *ref[HEVC_MAX_REFS]; |
241 |
|
|
int list[HEVC_MAX_REFS]; |
242 |
|
|
int isLongTerm[HEVC_MAX_REFS]; |
243 |
|
|
int nb_refs; |
244 |
|
|
} RefPicList; |
245 |
|
|
|
246 |
|
|
typedef struct RefPicListTab { |
247 |
|
|
RefPicList refPicList[2]; |
248 |
|
|
} RefPicListTab; |
249 |
|
|
|
250 |
|
|
typedef struct SliceHeader { |
251 |
|
|
unsigned int pps_id; |
252 |
|
|
|
253 |
|
|
///< address (in raster order) of the first block in the current slice segment |
254 |
|
|
unsigned int slice_segment_addr; |
255 |
|
|
///< address (in raster order) of the first block in the current slice |
256 |
|
|
unsigned int slice_addr; |
257 |
|
|
|
258 |
|
|
enum HEVCSliceType slice_type; |
259 |
|
|
|
260 |
|
|
int pic_order_cnt_lsb; |
261 |
|
|
|
262 |
|
|
uint8_t first_slice_in_pic_flag; |
263 |
|
|
uint8_t dependent_slice_segment_flag; |
264 |
|
|
uint8_t pic_output_flag; |
265 |
|
|
uint8_t colour_plane_id; |
266 |
|
|
|
267 |
|
|
///< RPS coded in the slice header itself is stored here |
268 |
|
|
int short_term_ref_pic_set_sps_flag; |
269 |
|
|
int short_term_ref_pic_set_size; |
270 |
|
|
ShortTermRPS slice_rps; |
271 |
|
|
const ShortTermRPS *short_term_rps; |
272 |
|
|
int long_term_ref_pic_set_size; |
273 |
|
|
LongTermRPS long_term_rps; |
274 |
|
|
unsigned int list_entry_lx[2][32]; |
275 |
|
|
|
276 |
|
|
uint8_t rpl_modification_flag[2]; |
277 |
|
|
uint8_t no_output_of_prior_pics_flag; |
278 |
|
|
uint8_t slice_temporal_mvp_enabled_flag; |
279 |
|
|
|
280 |
|
|
unsigned int nb_refs[2]; |
281 |
|
|
|
282 |
|
|
uint8_t slice_sample_adaptive_offset_flag[3]; |
283 |
|
|
uint8_t mvd_l1_zero_flag; |
284 |
|
|
|
285 |
|
|
uint8_t cabac_init_flag; |
286 |
|
|
uint8_t disable_deblocking_filter_flag; ///< slice_header_disable_deblocking_filter_flag |
287 |
|
|
uint8_t slice_loop_filter_across_slices_enabled_flag; |
288 |
|
|
uint8_t collocated_list; |
289 |
|
|
|
290 |
|
|
unsigned int collocated_ref_idx; |
291 |
|
|
|
292 |
|
|
int slice_qp_delta; |
293 |
|
|
int slice_cb_qp_offset; |
294 |
|
|
int slice_cr_qp_offset; |
295 |
|
|
|
296 |
|
|
uint8_t cu_chroma_qp_offset_enabled_flag; |
297 |
|
|
|
298 |
|
|
int beta_offset; ///< beta_offset_div2 * 2 |
299 |
|
|
int tc_offset; ///< tc_offset_div2 * 2 |
300 |
|
|
|
301 |
|
|
unsigned int max_num_merge_cand; ///< 5 - 5_minus_max_num_merge_cand |
302 |
|
|
|
303 |
|
|
unsigned *entry_point_offset; |
304 |
|
|
int * offset; |
305 |
|
|
int * size; |
306 |
|
|
int num_entry_point_offsets; |
307 |
|
|
|
308 |
|
|
int8_t slice_qp; |
309 |
|
|
|
310 |
|
|
uint8_t luma_log2_weight_denom; |
311 |
|
|
int16_t chroma_log2_weight_denom; |
312 |
|
|
|
313 |
|
|
int16_t luma_weight_l0[16]; |
314 |
|
|
int16_t chroma_weight_l0[16][2]; |
315 |
|
|
int16_t chroma_weight_l1[16][2]; |
316 |
|
|
int16_t luma_weight_l1[16]; |
317 |
|
|
|
318 |
|
|
int16_t luma_offset_l0[16]; |
319 |
|
|
int16_t chroma_offset_l0[16][2]; |
320 |
|
|
|
321 |
|
|
int16_t luma_offset_l1[16]; |
322 |
|
|
int16_t chroma_offset_l1[16][2]; |
323 |
|
|
|
324 |
|
|
int slice_ctb_addr_rs; |
325 |
|
|
} SliceHeader; |
326 |
|
|
|
327 |
|
|
typedef struct CodingUnit { |
328 |
|
|
int x; |
329 |
|
|
int y; |
330 |
|
|
|
331 |
|
|
enum PredMode pred_mode; ///< PredMode |
332 |
|
|
enum PartMode part_mode; ///< PartMode |
333 |
|
|
|
334 |
|
|
// Inferred parameters |
335 |
|
|
uint8_t intra_split_flag; ///< IntraSplitFlag |
336 |
|
|
uint8_t max_trafo_depth; ///< MaxTrafoDepth |
337 |
|
|
uint8_t cu_transquant_bypass_flag; |
338 |
|
|
} CodingUnit; |
339 |
|
|
|
340 |
|
|
typedef struct Mv { |
341 |
|
|
int16_t x; ///< horizontal component of motion vector |
342 |
|
|
int16_t y; ///< vertical component of motion vector |
343 |
|
|
} Mv; |
344 |
|
|
|
345 |
|
|
typedef struct MvField { |
346 |
|
|
DECLARE_ALIGNED(4, Mv, mv)[2]; |
347 |
|
|
int8_t ref_idx[2]; |
348 |
|
|
int8_t pred_flag; |
349 |
|
|
} MvField; |
350 |
|
|
|
351 |
|
|
typedef struct NeighbourAvailable { |
352 |
|
|
int cand_bottom_left; |
353 |
|
|
int cand_left; |
354 |
|
|
int cand_up; |
355 |
|
|
int cand_up_left; |
356 |
|
|
int cand_up_right; |
357 |
|
|
int cand_up_right_sap; |
358 |
|
|
} NeighbourAvailable; |
359 |
|
|
|
360 |
|
|
typedef struct PredictionUnit { |
361 |
|
|
int mpm_idx; |
362 |
|
|
int rem_intra_luma_pred_mode; |
363 |
|
|
uint8_t intra_pred_mode[4]; |
364 |
|
|
Mv mvd; |
365 |
|
|
uint8_t merge_flag; |
366 |
|
|
uint8_t intra_pred_mode_c[4]; |
367 |
|
|
uint8_t chroma_mode_c[4]; |
368 |
|
|
} PredictionUnit; |
369 |
|
|
|
370 |
|
|
typedef struct TransformUnit { |
371 |
|
|
int cu_qp_delta; |
372 |
|
|
|
373 |
|
|
int res_scale_val; |
374 |
|
|
|
375 |
|
|
// Inferred parameters; |
376 |
|
|
int intra_pred_mode; |
377 |
|
|
int intra_pred_mode_c; |
378 |
|
|
int chroma_mode_c; |
379 |
|
|
uint8_t is_cu_qp_delta_coded; |
380 |
|
|
uint8_t is_cu_chroma_qp_offset_coded; |
381 |
|
|
int8_t cu_qp_offset_cb; |
382 |
|
|
int8_t cu_qp_offset_cr; |
383 |
|
|
uint8_t cross_pf; |
384 |
|
|
} TransformUnit; |
385 |
|
|
|
386 |
|
|
typedef struct DBParams { |
387 |
|
|
int beta_offset; |
388 |
|
|
int tc_offset; |
389 |
|
|
} DBParams; |
390 |
|
|
|
391 |
|
|
#define HEVC_FRAME_FLAG_OUTPUT (1 << 0) |
392 |
|
|
#define HEVC_FRAME_FLAG_SHORT_REF (1 << 1) |
393 |
|
|
#define HEVC_FRAME_FLAG_LONG_REF (1 << 2) |
394 |
|
|
#define HEVC_FRAME_FLAG_BUMPING (1 << 3) |
395 |
|
|
|
396 |
|
|
typedef struct HEVCFrame { |
397 |
|
|
AVFrame *frame; |
398 |
|
|
ThreadFrame tf; |
399 |
|
|
MvField *tab_mvf; |
400 |
|
|
RefPicList *refPicList; |
401 |
|
|
RefPicListTab **rpl_tab; |
402 |
|
|
int ctb_count; |
403 |
|
|
int poc; |
404 |
|
|
struct HEVCFrame *collocated_ref; |
405 |
|
|
|
406 |
|
|
AVBufferRef *tab_mvf_buf; |
407 |
|
|
AVBufferRef *rpl_tab_buf; |
408 |
|
|
AVBufferRef *rpl_buf; |
409 |
|
|
|
410 |
|
|
AVBufferRef *hwaccel_priv_buf; |
411 |
|
|
void *hwaccel_picture_private; |
412 |
|
|
|
413 |
|
|
/** |
414 |
|
|
* A sequence counter, so that old frames are output first |
415 |
|
|
* after a POC reset |
416 |
|
|
*/ |
417 |
|
|
uint16_t sequence; |
418 |
|
|
|
419 |
|
|
/** |
420 |
|
|
* A combination of HEVC_FRAME_FLAG_* |
421 |
|
|
*/ |
422 |
|
|
uint8_t flags; |
423 |
|
|
} HEVCFrame; |
424 |
|
|
|
425 |
|
|
typedef struct HEVCLocalContext { |
426 |
|
|
uint8_t cabac_state[HEVC_CONTEXTS]; |
427 |
|
|
|
428 |
|
|
uint8_t stat_coeff[HEVC_STAT_COEFFS]; |
429 |
|
|
|
430 |
|
|
uint8_t first_qp_group; |
431 |
|
|
|
432 |
|
|
GetBitContext gb; |
433 |
|
|
CABACContext cc; |
434 |
|
|
|
435 |
|
|
int8_t qp_y; |
436 |
|
|
int8_t curr_qp_y; |
437 |
|
|
|
438 |
|
|
int qPy_pred; |
439 |
|
|
|
440 |
|
|
TransformUnit tu; |
441 |
|
|
|
442 |
|
|
uint8_t ctb_left_flag; |
443 |
|
|
uint8_t ctb_up_flag; |
444 |
|
|
uint8_t ctb_up_right_flag; |
445 |
|
|
uint8_t ctb_up_left_flag; |
446 |
|
|
int end_of_tiles_x; |
447 |
|
|
int end_of_tiles_y; |
448 |
|
|
/* +7 is for subpixel interpolation, *2 for high bit depths */ |
449 |
|
|
DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer)[(MAX_PB_SIZE + 7) * EDGE_EMU_BUFFER_STRIDE * 2]; |
450 |
|
|
/* The extended size between the new edge emu buffer is abused by SAO */ |
451 |
|
|
DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer2)[(MAX_PB_SIZE + 7) * EDGE_EMU_BUFFER_STRIDE * 2]; |
452 |
|
|
DECLARE_ALIGNED(32, int16_t, tmp)[MAX_PB_SIZE * MAX_PB_SIZE]; |
453 |
|
|
|
454 |
|
|
int ct_depth; |
455 |
|
|
CodingUnit cu; |
456 |
|
|
PredictionUnit pu; |
457 |
|
|
NeighbourAvailable na; |
458 |
|
|
|
459 |
|
|
#define BOUNDARY_LEFT_SLICE (1 << 0) |
460 |
|
|
#define BOUNDARY_LEFT_TILE (1 << 1) |
461 |
|
|
#define BOUNDARY_UPPER_SLICE (1 << 2) |
462 |
|
|
#define BOUNDARY_UPPER_TILE (1 << 3) |
463 |
|
|
/* properties of the boundary of the current CTB for the purposes |
464 |
|
|
* of the deblocking filter */ |
465 |
|
|
int boundary_flags; |
466 |
|
|
} HEVCLocalContext; |
467 |
|
|
|
468 |
|
|
typedef struct HEVCContext { |
469 |
|
|
const AVClass *c; // needed by private avoptions |
470 |
|
|
AVCodecContext *avctx; |
471 |
|
|
|
472 |
|
|
struct HEVCContext **sList; |
473 |
|
|
|
474 |
|
|
HEVCLocalContext **HEVClcList; |
475 |
|
|
HEVCLocalContext *HEVClc; |
476 |
|
|
|
477 |
|
|
uint8_t threads_type; |
478 |
|
|
uint8_t threads_number; |
479 |
|
|
|
480 |
|
|
int width; |
481 |
|
|
int height; |
482 |
|
|
|
483 |
|
|
uint8_t *cabac_state; |
484 |
|
|
uint8_t stat_coeff[HEVC_STAT_COEFFS]; |
485 |
|
|
|
486 |
|
|
/** 1 if the independent slice segment header was successfully parsed */ |
487 |
|
|
uint8_t slice_initialized; |
488 |
|
|
|
489 |
|
|
AVFrame *frame; |
490 |
|
|
AVFrame *output_frame; |
491 |
|
|
uint8_t *sao_pixel_buffer_h[3]; |
492 |
|
|
uint8_t *sao_pixel_buffer_v[3]; |
493 |
|
|
|
494 |
|
|
HEVCParamSets ps; |
495 |
|
|
HEVCSEI sei; |
496 |
|
|
struct AVMD5 *md5_ctx; |
497 |
|
|
|
498 |
|
|
AVBufferPool *tab_mvf_pool; |
499 |
|
|
AVBufferPool *rpl_tab_pool; |
500 |
|
|
|
501 |
|
|
///< candidate references for the current frame |
502 |
|
|
RefPicList rps[5]; |
503 |
|
|
|
504 |
|
|
SliceHeader sh; |
505 |
|
|
SAOParams *sao; |
506 |
|
|
DBParams *deblock; |
507 |
|
|
enum HEVCNALUnitType nal_unit_type; |
508 |
|
|
int temporal_id; ///< temporal_id_plus1 - 1 |
509 |
|
|
HEVCFrame *ref; |
510 |
|
|
HEVCFrame DPB[32]; |
511 |
|
|
int poc; |
512 |
|
|
int pocTid0; |
513 |
|
|
int slice_idx; ///< number of the slice being currently decoded |
514 |
|
|
int eos; ///< current packet contains an EOS/EOB NAL |
515 |
|
|
int last_eos; ///< last packet contains an EOS/EOB NAL |
516 |
|
|
int max_ra; |
517 |
|
|
int bs_width; |
518 |
|
|
int bs_height; |
519 |
|
|
int overlap; |
520 |
|
|
|
521 |
|
|
int is_decoded; |
522 |
|
|
int no_rasl_output_flag; |
523 |
|
|
|
524 |
|
|
HEVCPredContext hpc; |
525 |
|
|
HEVCDSPContext hevcdsp; |
526 |
|
|
VideoDSPContext vdsp; |
527 |
|
|
BswapDSPContext bdsp; |
528 |
|
|
int8_t *qp_y_tab; |
529 |
|
|
uint8_t *horizontal_bs; |
530 |
|
|
uint8_t *vertical_bs; |
531 |
|
|
|
532 |
|
|
int32_t *tab_slice_address; |
533 |
|
|
|
534 |
|
|
// CU |
535 |
|
|
uint8_t *skip_flag; |
536 |
|
|
uint8_t *tab_ct_depth; |
537 |
|
|
// PU |
538 |
|
|
uint8_t *tab_ipm; |
539 |
|
|
|
540 |
|
|
uint8_t *cbf_luma; // cbf_luma of colocated TU |
541 |
|
|
uint8_t *is_pcm; |
542 |
|
|
|
543 |
|
|
// CTB-level flags affecting loop filter operation |
544 |
|
|
uint8_t *filter_slice_edges; |
545 |
|
|
|
546 |
|
|
/** used on BE to byteswap the lines for checksumming */ |
547 |
|
|
uint8_t *checksum_buf; |
548 |
|
|
int checksum_buf_size; |
549 |
|
|
|
550 |
|
|
/** |
551 |
|
|
* Sequence counters for decoded and output frames, so that old |
552 |
|
|
* frames are output first after a POC reset |
553 |
|
|
*/ |
554 |
|
|
uint16_t seq_decode; |
555 |
|
|
uint16_t seq_output; |
556 |
|
|
|
557 |
|
|
int enable_parallel_tiles; |
558 |
|
|
atomic_int wpp_err; |
559 |
|
|
|
560 |
|
|
const uint8_t *data; |
561 |
|
|
|
562 |
|
|
H2645Packet pkt; |
563 |
|
|
// type of the first VCL NAL of the current frame |
564 |
|
|
enum HEVCNALUnitType first_nal_type; |
565 |
|
|
|
566 |
|
|
uint8_t context_initialized; |
567 |
|
|
int is_nalff; ///< this flag is != 0 if bitstream is encapsulated |
568 |
|
|
///< as a format defined in 14496-15 |
569 |
|
|
int apply_defdispwin; |
570 |
|
|
|
571 |
|
|
int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4) |
572 |
|
|
int nuh_layer_id; |
573 |
|
|
} HEVCContext; |
574 |
|
|
|
575 |
|
|
/** |
576 |
|
|
* Mark all frames in DPB as unused for reference. |
577 |
|
|
*/ |
578 |
|
|
void ff_hevc_clear_refs(HEVCContext *s); |
579 |
|
|
|
580 |
|
|
/** |
581 |
|
|
* Drop all frames currently in DPB. |
582 |
|
|
*/ |
583 |
|
|
void ff_hevc_flush_dpb(HEVCContext *s); |
584 |
|
|
|
585 |
|
|
RefPicList *ff_hevc_get_ref_list(HEVCContext *s, HEVCFrame *frame, |
586 |
|
|
int x0, int y0); |
587 |
|
|
|
588 |
|
|
/** |
589 |
|
|
* Construct the reference picture sets for the current frame. |
590 |
|
|
*/ |
591 |
|
|
int ff_hevc_frame_rps(HEVCContext *s); |
592 |
|
|
|
593 |
|
|
/** |
594 |
|
|
* Construct the reference picture list(s) for the current slice. |
595 |
|
|
*/ |
596 |
|
|
int ff_hevc_slice_rpl(HEVCContext *s); |
597 |
|
|
|
598 |
|
|
void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts); |
599 |
|
|
int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts, int thread); |
600 |
|
|
int ff_hevc_sao_merge_flag_decode(HEVCContext *s); |
601 |
|
|
int ff_hevc_sao_type_idx_decode(HEVCContext *s); |
602 |
|
|
int ff_hevc_sao_band_position_decode(HEVCContext *s); |
603 |
|
|
int ff_hevc_sao_offset_abs_decode(HEVCContext *s); |
604 |
|
|
int ff_hevc_sao_offset_sign_decode(HEVCContext *s); |
605 |
|
|
int ff_hevc_sao_eo_class_decode(HEVCContext *s); |
606 |
|
|
int ff_hevc_end_of_slice_flag_decode(HEVCContext *s); |
607 |
|
|
int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s); |
608 |
|
|
int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, |
609 |
|
|
int x_cb, int y_cb); |
610 |
|
|
int ff_hevc_pred_mode_decode(HEVCContext *s); |
611 |
|
|
int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, |
612 |
|
|
int x0, int y0); |
613 |
|
|
int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size); |
614 |
|
|
int ff_hevc_pcm_flag_decode(HEVCContext *s); |
615 |
|
|
int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s); |
616 |
|
|
int ff_hevc_mpm_idx_decode(HEVCContext *s); |
617 |
|
|
int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s); |
618 |
|
|
int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s); |
619 |
|
|
int ff_hevc_merge_idx_decode(HEVCContext *s); |
620 |
|
|
int ff_hevc_merge_flag_decode(HEVCContext *s); |
621 |
|
|
int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH); |
622 |
|
|
int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx); |
623 |
|
|
int ff_hevc_mvp_lx_flag_decode(HEVCContext *s); |
624 |
|
|
int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s); |
625 |
|
|
int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size); |
626 |
|
|
int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth); |
627 |
|
|
int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth); |
628 |
|
|
int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx); |
629 |
|
|
int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx); |
630 |
|
|
|
631 |
|
|
/** |
632 |
|
|
* Get the number of candidate references for the current frame. |
633 |
|
|
*/ |
634 |
|
|
int ff_hevc_frame_nb_refs(const HEVCContext *s); |
635 |
|
|
|
636 |
|
|
int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc); |
637 |
|
|
|
638 |
|
1020 |
static av_always_inline int ff_hevc_nal_is_nonref(enum HEVCNALUnitType type) |
639 |
|
|
{ |
640 |
✗✓ |
1020 |
switch (type) { |
641 |
|
|
case HEVC_NAL_TRAIL_N: |
642 |
|
|
case HEVC_NAL_TSA_N: |
643 |
|
|
case HEVC_NAL_STSA_N: |
644 |
|
|
case HEVC_NAL_RADL_N: |
645 |
|
|
case HEVC_NAL_RASL_N: |
646 |
|
|
case HEVC_NAL_VCL_N10: |
647 |
|
|
case HEVC_NAL_VCL_N12: |
648 |
|
|
case HEVC_NAL_VCL_N14: |
649 |
|
|
return 1; |
650 |
|
1020 |
default: break; |
651 |
|
|
} |
652 |
|
1020 |
return 0; |
653 |
|
|
} |
654 |
|
|
|
655 |
|
|
/** |
656 |
|
|
* Find next frame in output order and put a reference to it in frame. |
657 |
|
|
* @return 1 if a frame was output, 0 otherwise |
658 |
|
|
*/ |
659 |
|
|
int ff_hevc_output_frame(HEVCContext *s, AVFrame *frame, int flush); |
660 |
|
|
|
661 |
|
|
void ff_hevc_bump_frame(HEVCContext *s); |
662 |
|
|
|
663 |
|
|
void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags); |
664 |
|
|
|
665 |
|
|
void ff_hevc_set_neighbour_available(HEVCContext *s, int x0, int y0, |
666 |
|
|
int nPbW, int nPbH); |
667 |
|
|
void ff_hevc_luma_mv_merge_mode(HEVCContext *s, int x0, int y0, |
668 |
|
|
int nPbW, int nPbH, int log2_cb_size, |
669 |
|
|
int part_idx, int merge_idx, MvField *mv); |
670 |
|
|
void ff_hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, |
671 |
|
|
int nPbW, int nPbH, int log2_cb_size, |
672 |
|
|
int part_idx, int merge_idx, |
673 |
|
|
MvField *mv, int mvp_lx_flag, int LX); |
674 |
|
|
void ff_hevc_set_qPy(HEVCContext *s, int xBase, int yBase, |
675 |
|
|
int log2_cb_size); |
676 |
|
|
void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0, |
677 |
|
|
int log2_trafo_size); |
678 |
|
|
int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s); |
679 |
|
|
int ff_hevc_cu_qp_delta_abs(HEVCContext *s); |
680 |
|
|
int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s); |
681 |
|
|
int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s); |
682 |
|
|
void ff_hevc_hls_filter(HEVCContext *s, int x, int y, int ctb_size); |
683 |
|
|
void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size); |
684 |
|
|
void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, |
685 |
|
|
int log2_trafo_size, enum ScanType scan_idx, |
686 |
|
|
int c_idx); |
687 |
|
|
|
688 |
|
|
void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size); |
689 |
|
|
|
690 |
|
|
extern const uint8_t ff_hevc_qpel_extra_before[4]; |
691 |
|
|
extern const uint8_t ff_hevc_qpel_extra_after[4]; |
692 |
|
|
extern const uint8_t ff_hevc_qpel_extra[4]; |
693 |
|
|
|
694 |
|
|
#endif /* AVCODEC_HEVCDEC_H */ |