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