24 #include "libavutil/attributes.h"
25 #include "libavutil/common.h"
30 #define CABAC_MAX_BIN 100
183 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
186 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
191 111, 111, 125, 110, 110, 94, 124, 108, 124, 107, 125, 141, 179, 153,
192 125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
193 139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
195 140, 92, 137, 138, 140, 152, 138, 139, 153, 74, 149, 92, 139, 107,
196 122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
198 138, 153, 136, 167, 152, 152,
248 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
251 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
256 155, 154, 139, 153, 139, 123, 123, 63, 153, 166, 183, 140, 136, 153,
257 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
258 153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
260 154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
261 136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
263 107, 167, 91, 122, 107, 167,
313 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
316 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
321 170, 154, 139, 153, 139, 123, 123, 63, 124, 166, 183, 140, 136, 153,
322 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
323 153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
325 154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
326 136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
328 107, 167, 91, 107, 107, 167,
359 { 0, 1, 2, 3, 16, 17, 18, 19, },
360 { 4, 5, 6, 7, 20, 21, 22, 23, },
361 { 8, 9, 10, 11, 24, 25, 26, 27, },
362 { 12, 13, 14, 15, 28, 29, 30, 31, },
363 { 32, 33, 34, 35, 48, 49, 50, 51, },
364 { 36, 37, 38, 39, 52, 53, 54, 55, },
365 { 40, 41, 42, 43, 56, 57, 58, 59, },
366 { 44, 45, 46, 47, 60, 61, 62, 63, },
405 { 0, 2, 4, 6, 8, 10, 12, 14, },
406 { 1, 3, 5, 7, 9, 11, 13, 15, },
494 { 0, 2, 5, 9, 14, 20, 27, 35, },
495 { 1, 4, 8, 13, 19, 26, 34, 42, },
496 { 3, 7, 12, 18, 25, 33, 41, 48, },
497 { 6, 11, 17, 24, 32, 40, 47, 53, },
498 { 10, 16, 23, 31, 39, 46, 52, 57, },
499 { 15, 22, 30, 38, 45, 51, 56, 60, },
500 { 21, 29, 37, 44, 50, 55, 59, 62, },
501 { 28, 36, 43, 49, 54, 58, 61, 63, },
544 int m = (init_value >> 4) * 5 - 45;
545 int n = ((init_value & 15) << 3) - 16;
550 pre = 124 + (pre & 1);
598 #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
620 for (i = 0; i < 4; i++)
682 if (prefix_val >= 5) {
685 suffix_val += 1 << k;
694 return prefix_val + suffix_val;
709 int inc = 0, depth_left = 0, depth_top = 0;
720 inc += (depth_left > ct_depth);
721 inc += (depth_top > ct_depth);
734 if (log2_cb_size == 3)
785 for (i = 0; i < 4; i++)
819 if (nPbW + nPbH == 12)
830 int max = num_ref_idx_lx - 1;
831 int max_ctx =
FFMIN(max, 2);
904 #define LAST_SIG_COEFF(elem) \
906 int max = (log2_size << 1) - 1; \
907 int ctx_offset, ctx_shift; \
910 ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2); \
911 ctx_shift = (log2_size + 1) >> 2; \
914 ctx_shift = log2_size - 2; \
917 GET_CABAC(elem_offset[elem] + (i >> ctx_shift) + ctx_offset)) \
934 int last_significant_coeff_prefix)
937 int length = (last_significant_coeff_prefix >> 1) - 1;
940 for (i = 1; i <
length; i++)
949 inc =
FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
955 int log2_trafo_size,
int scan_idx,
int prev_sig)
957 static const uint8_t ctx_idx_map[] = {
958 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8
965 if (x_c + y_c == 0) {
967 }
else if (log2_trafo_size == 2) {
968 sig_ctx = ctx_idx_map[(y_c << 2) + x_c];
974 sig_ctx = ((x_off + y_off) == 0) ? 2 : ((x_off + y_off) <= 2) ? 1 : 0;
978 sig_ctx = 2 -
FFMIN(y_c & 3, 2);
981 sig_ctx = 2 -
FFMIN(x_c & 3, 2);
987 if (c_idx == 0 && (x_cg > 0 || y_cg > 0))
990 if (log2_trafo_size == 3) {
991 sig_ctx += (scan_idx ==
SCAN_DIAG) ? 9 : 15;
993 sig_ctx += c_idx ? 12 : 21;
1027 int last_coeff_abs_level_remaining;
1035 for (i = 0; i < rc_rice_param; i++)
1037 last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
1039 int prefix_minus3 = prefix - 3;
1040 for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
1042 last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
1043 << rc_rice_param) + suffix;
1045 return last_coeff_abs_level_remaining;
1053 for (i = 0; i < nb; i++)
1059 int log2_trafo_size,
enum ScanType scan_idx,
1062 #define GET_COORD(offset, n) \
1064 x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
1065 y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
1068 int transform_skip_flag = 0;
1070 int last_significant_coeff_x, last_significant_coeff_y;
1074 int greater1_ctx = 1;
1076 int num_last_subset;
1077 int x_cg_last_sig, y_cg_last_sig;
1079 const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
1089 int trafo_size = 1 << log2_trafo_size;
1092 const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
1098 static const int qp_c[] = { 29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37 };
1100 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
1101 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
1102 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
1106 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
1107 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
1108 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
1110 int qp_y = lc->
qp_y;
1128 qp = qp_c[qp_i - 30];
1134 add = 1 << (shift-1);
1135 scale = level_scale[rem6[qp]] << (div6[qp]);
1144 if (log2_trafo_size != 5)
1145 matrix_id = 3 * matrix_id + c_idx;
1147 scale_matrix = sl->
sl[log2_trafo_size - 2][matrix_id];
1148 if (log2_trafo_size >= 4)
1149 dc_scale = sl->
sl_dc[log2_trafo_size - 4][matrix_id];
1154 log2_trafo_size == 2) {
1158 last_significant_coeff_x =
1160 last_significant_coeff_y =
1163 if (last_significant_coeff_x > 3) {
1165 last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
1166 (2 + (last_significant_coeff_x & 1)) +
1170 if (last_significant_coeff_y > 3) {
1172 last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1173 (2 + (last_significant_coeff_y & 1)) +
1178 FFSWAP(
int, last_significant_coeff_x, last_significant_coeff_y);
1180 x_cg_last_sig = last_significant_coeff_x >> 2;
1181 y_cg_last_sig = last_significant_coeff_y >> 2;
1185 int last_x_c = last_significant_coeff_x & 3;
1186 int last_y_c = last_significant_coeff_y & 3;
1191 if (trafo_size == 4) {
1194 }
else if (trafo_size == 8) {
1198 }
else if (trafo_size == 16) {
1214 num_coeff =
horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1221 num_coeff =
horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1225 num_last_subset = (num_coeff - 1) >> 4;
1227 for (i = num_last_subset; i >= 0; i--) {
1229 int x_cg, y_cg, x_c, y_c, pos;
1230 int implicit_non_zero_coeff = 0;
1231 int64_t trans_coeff_level;
1235 uint8_t significant_coeff_flag_idx[16];
1236 uint8_t nb_significant_coeff_flag = 0;
1238 x_cg = scan_x_cg[i];
1239 y_cg = scan_y_cg[i];
1241 if ((i < num_last_subset) && (i > 0)) {
1243 if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1244 ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1245 if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1246 ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1248 significant_coeff_group_flag[x_cg][y_cg] =
1250 implicit_non_zero_coeff = 1;
1252 significant_coeff_group_flag[x_cg][y_cg] =
1253 ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1254 (x_cg == 0 && y_cg == 0));
1257 last_scan_pos = num_coeff - offset - 1;
1259 if (i == num_last_subset) {
1260 n_end = last_scan_pos - 1;
1261 significant_coeff_flag_idx[0] = last_scan_pos;
1262 nb_significant_coeff_flag = 1;
1267 if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1268 prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1269 if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1270 prev_sig += (significant_coeff_group_flag[x_cg][y_cg + 1] << 1);
1272 for (n = n_end; n >= 0; n--) {
1275 if (significant_coeff_group_flag[x_cg][y_cg] &&
1276 (n > 0 || implicit_non_zero_coeff == 0)) {
1278 significant_coeff_flag_idx[nb_significant_coeff_flag] =
n;
1279 nb_significant_coeff_flag++;
1280 implicit_non_zero_coeff = 0;
1283 int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1284 if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1285 significant_coeff_flag_idx[nb_significant_coeff_flag] =
n;
1286 nb_significant_coeff_flag++;
1291 n_end = nb_significant_coeff_flag;
1295 int first_nz_pos_in_cg = 16;
1296 int last_nz_pos_in_cg = -1;
1297 int c_rice_param = 0;
1298 int first_greater1_coeff_idx = -1;
1299 uint8_t coeff_abs_level_greater1_flag[16] = {0};
1300 uint16_t coeff_sign_flag;
1302 int sign_hidden = 0;
1305 int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1307 if (!(i == num_last_subset) && greater1_ctx == 0)
1310 last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1312 for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1313 int n_idx = significant_coeff_flag_idx[
m];
1314 int inc = (ctx_set << 2) + greater1_ctx;
1315 coeff_abs_level_greater1_flag[n_idx] =
1317 if (coeff_abs_level_greater1_flag[n_idx]) {
1319 }
else if (greater1_ctx > 0 && greater1_ctx < 3) {
1323 if (coeff_abs_level_greater1_flag[n_idx] &&
1324 first_greater1_coeff_idx == -1)
1325 first_greater1_coeff_idx = n_idx;
1327 first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1328 sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1331 if (first_greater1_coeff_idx != -1) {
1335 coeff_sign_flag =
coeff_sign_flag_decode(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1337 coeff_sign_flag =
coeff_sign_flag_decode(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1340 for (m = 0; m < n_end; m++) {
1341 n = significant_coeff_flag_idx[
m];
1343 trans_coeff_level = 1 + coeff_abs_level_greater1_flag[
n];
1344 if (trans_coeff_level == ((m < 8) ?
1345 ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1348 trans_coeff_level += last_coeff_abs_level_remaining;
1349 if (trans_coeff_level > (3 << c_rice_param))
1350 c_rice_param =
FFMIN(c_rice_param + 1, 4);
1354 sum_abs += trans_coeff_level;
1355 if (n == first_nz_pos_in_cg && (sum_abs&1))
1356 trans_coeff_level = -trans_coeff_level;
1358 if (coeff_sign_flag >> 15)
1359 trans_coeff_level = -trans_coeff_level;
1360 coeff_sign_flag <<= 1;
1363 if(y_c || x_c || log2_trafo_size < 4) {
1364 switch(log2_trafo_size) {
1365 case 3: pos = (y_c << 3) + x_c;
break;
1366 case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1);
break;
1367 case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2);
break;
1368 default: pos = (y_c << 2) + x_c;
1370 scale_m = scale_matrix[pos];
1375 trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1376 if(trans_coeff_level < 0) {
1377 if((~trans_coeff_level) & 0xFffffffffff8000)
1378 trans_coeff_level = -32768;
1380 if(trans_coeff_level & 0xffffffffffff8000)
1381 trans_coeff_level = 32767;
1384 coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1392 if (transform_skip_flag)
1415 case 0: lc->
pu.
mvd.
x = 0;
break;
1421 case 0: lc->
pu.
mvd.
y = 0;
break;
static av_always_inline int significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
static const int8_t num_bins_in_se[]
number of bin by SyntaxElement.
unsigned int log2_min_cb_size
void(* transquant_bypass[4])(uint8_t *_dst, int16_t *coeffs, ptrdiff_t _stride)
static const int16_t coeffs[28]
#define SAMPLE_CTB(tab, x, y)
static int shift(int a, int b)
int ff_hevc_sao_band_position_decode(HEVCContext *s)
int16_t x
horizontal component of motion vector
int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
static const uint8_t diag_scan2x8_y[16]
#define DECLARE_ALIGNED(n, t, v)
Clip a signed integer value into the amin-amax range.
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c, int log2_trafo_size, int scan_idx, int prev_sig)
static const uint8_t rem6[QP_MAX_NUM+1]
#define LAST_SIG_COEFF(elem)
uint8_t entropy_coding_sync_enabled_flag
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
static const uint8_t div6[QP_MAX_NUM+1]
const uint8_t ff_hevc_diag_scan4x4_y[16]
static const uint8_t diag_scan2x8_inv[8][2]
int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
static const uint8_t horiz_scan8x8_inv[8][8]
int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
static const uint8_t offset[511][2]
void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, int log2_trafo_size, enum ScanType scan_idx, int c_idx)
static void cabac_init_state(HEVCContext *s)
int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
int pps_scaling_list_data_present_flag
static const uint8_t horiz_scan4x4_y[16]
int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
static int get_bits_count(const GetBitContext *s)
uint8_t cu_transquant_bypass_flag
#define FFSWAP(type, a, b)
static av_unused const uint8_t * skip_bytes(CABACContext *c, int n)
Skip n bytes and reset the decoder.
const uint8_t ff_hevc_diag_scan8x8_y[64]
static int get_bits_left(GetBitContext *gb)
int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static const uint8_t diag_scan4x4_inv[4][4]
static const uint8_t diag_scan8x2_inv[2][8]
int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
static const int elem_offset[sizeof(num_bins_in_se)]
Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
unsigned int log2_ctb_size
uint8_t tiles_enabled_flag
static const uint8_t diag_scan8x8_inv[8][8]
int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
int ff_hevc_pred_mode_decode(HEVCContext *s)
static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
int ff_hevc_sao_eo_class_decode(HEVCContext *s)
int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
uint8_t cabac_state[HEVC_CONTEXTS]
int ff_hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
int ff_hevc_sao_type_idx_decode(HEVCContext *s)
int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
static const uint8_t scan_1x1[1]
static av_always_inline int last_significant_coeff_x_prefix_decode(HEVCContext *s, int c_idx, int log2_size)
Context Adaptive Binary Arithmetic Coder inline functions.
uint8_t sign_data_hiding_flag
static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
const uint8_t ff_hevc_diag_scan8x8_x[64]
static int av_unused get_cabac_terminate(CABACContext *c)
int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
static av_always_inline int mvd_decode(HEVCContext *s)
static const uint8_t horiz_scan2x2_y[4]
const uint8_t ff_hevc_diag_scan4x4_x[16]
static const uint8_t horiz_scan4x4_x[16]
static av_always_inline int last_significant_coeff_y_prefix_decode(HEVCContext *s, int c_idx, int log2_size)
static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
int ff_hevc_merge_idx_decode(HEVCContext *s)
uint8_t transform_skip_enabled_flag
static const uint8_t diag_scan2x2_x[4]
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
static const uint8_t diag_scan8x2_x[16]
int ff_hevc_merge_flag_decode(HEVCContext *s)
static const uint8_t diag_scan8x2_y[16]
static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext *s, int last_significant_coeff_prefix)
enum PredMode pred_mode
PredMode.
void(* transform_skip)(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
int16_t y
vertical component of motion vector
void(* transform_4x4_luma_add)(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
static const uint8_t horiz_scan2x2_x[4]
int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
static void skip_bits(GetBitContext *s, int n)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s, int base_level, int rc_rice_param)
static const uint8_t diag_scan2x8_x[16]
void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
uint8_t scaling_list_enable_flag
HEVCLocalContext * HEVClc
int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
static const uint8_t diag_scan2x2_inv[2][2]
static const uint16_t scale[4]
static av_always_inline int get_cabac_bypass_sign(CABACContext *c, int val)
static int av_unused get_cabac_bypass(CABACContext *c)
static const uint8_t diag_scan4x1_x[4]
static void load_states(HEVCContext *s)
void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
static const uint8_t diag_scan1x4_y[4]
static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
#define GET_COORD(offset, n)
int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size)
int ff_hevc_mpm_idx_decode(HEVCContext *s)
int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
static const uint8_t * align_get_bits(GetBitContext *s)
static void cabac_init_decoder(HEVCContext *s)
void(* transform_add[4])(uint8_t *dst, int16_t *coeffs, ptrdiff_t _stride)
int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
static const uint8_t init_values[3][HEVC_CONTEXTS]
Indexed by init_type.
static void cabac_reinit(HEVCLocalContext *lc)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
static const uint8_t diag_scan2x2_y[4]
int ff_hevc_pcm_flag_decode(HEVCContext *s)