/* * Copyright (c) 2016, Alliance for Open Media. All rights reserved. * * This source code is subject to the terms of the BSD 2 Clause License and * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License * was not distributed with this source code in the LICENSE file, you can * obtain it at www.aomedia.org/license/software. If the Alliance for Open * Media Patent License 1.0 was not distributed with this source code in the * PATENTS file, you can obtain it at www.aomedia.org/license/patent. */ #include <assert.h> #include <limits.h> #include <stdbool.h> #include <stdint.h> #include <stdio.h> #include <string.h> #include "aom/aom_encoder.h" #include "aom_dsp/aom_dsp_common.h" #include "aom_dsp/binary_codes_writer.h" #include "aom_dsp/bitwriter_buffer.h" #include "aom_mem/aom_mem.h" #include "aom_ports/bitops.h" #include "aom_ports/mem_ops.h" #if CONFIG_BITSTREAM_DEBUG #include "aom_util/debug_util.h" #endif // CONFIG_BITSTREAM_DEBUG #include "av1/common/cdef.h" #include "av1/common/cfl.h" #include "av1/common/debugmodes.h" #include "av1/common/entropy.h" #include "av1/common/entropymode.h" #include "av1/common/entropymv.h" #include "av1/common/mvref_common.h" #include "av1/common/pred_common.h" #include "av1/common/reconinter.h" #include "av1/common/reconintra.h" #include "av1/common/seg_common.h" #include "av1/common/tile_common.h" #include "av1/encoder/bitstream.h" #include "av1/encoder/cost.h" #include "av1/encoder/encodemv.h" #include "av1/encoder/encodetxb.h" #include "av1/encoder/ethread.h" #include "av1/encoder/mcomp.h" #include "av1/encoder/palette.h" #include "av1/encoder/pickrst.h" #include "av1/encoder/segmentation.h" #include "av1/encoder/tokenize.h" #define ENC_MISMATCH_DEBUG … #define SETUP_TIME_OH_CONST … #define JOB_DISP_TIME_OH_CONST … static inline void write_uniform(aom_writer *w, int n, int v) { … } #if !CONFIG_REALTIME_ONLY static inline void loop_restoration_write_sb_coeffs( const AV1_COMMON *const cm, MACROBLOCKD *xd, int runit_idx, aom_writer *const w, int plane, FRAME_COUNTS *counts); #endif static inline void write_intra_y_mode_kf(FRAME_CONTEXT *frame_ctx, const MB_MODE_INFO *mi, const MB_MODE_INFO *above_mi, const MB_MODE_INFO *left_mi, PREDICTION_MODE mode, aom_writer *w) { … } static inline void write_inter_mode(aom_writer *w, PREDICTION_MODE mode, FRAME_CONTEXT *ec_ctx, const int16_t mode_ctx) { … } static inline void write_drl_idx(FRAME_CONTEXT *ec_ctx, const MB_MODE_INFO *mbmi, const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame, aom_writer *w) { … } static inline void write_inter_compound_mode(MACROBLOCKD *xd, aom_writer *w, PREDICTION_MODE mode, const int16_t mode_ctx) { … } static inline void write_tx_size_vartx(MACROBLOCKD *xd, const MB_MODE_INFO *mbmi, TX_SIZE tx_size, int depth, int blk_row, int blk_col, aom_writer *w) { … } static inline void write_selected_tx_size(const MACROBLOCKD *xd, aom_writer *w) { … } static int write_skip(const AV1_COMMON *cm, const MACROBLOCKD *xd, uint8_t segment_id, const MB_MODE_INFO *mi, aom_writer *w) { … } static int write_skip_mode(const AV1_COMMON *cm, const MACROBLOCKD *xd, uint8_t segment_id, const MB_MODE_INFO *mi, aom_writer *w) { … } static inline void write_is_inter(const AV1_COMMON *cm, const MACROBLOCKD *xd, uint8_t segment_id, aom_writer *w, const int is_inter) { … } static inline void write_motion_mode(const AV1_COMMON *cm, MACROBLOCKD *xd, const MB_MODE_INFO *mbmi, aom_writer *w) { … } static inline void write_delta_qindex(const MACROBLOCKD *xd, int delta_qindex, aom_writer *w) { … } static inline void write_delta_lflevel(const AV1_COMMON *cm, const MACROBLOCKD *xd, int lf_id, int delta_lflevel, int delta_lf_multi, aom_writer *w) { … } static inline void pack_map_tokens(aom_writer *w, const TokenExtra **tp, int n, int num, MapCdf map_pb_cdf) { … } static inline void pack_txb_tokens( aom_writer *w, AV1_COMMON *cm, MACROBLOCK *const x, const TokenExtra **tp, const TokenExtra *const tok_end, MACROBLOCKD *xd, MB_MODE_INFO *mbmi, int plane, BLOCK_SIZE plane_bsize, aom_bit_depth_t bit_depth, int block, int blk_row, int blk_col, TX_SIZE tx_size, TOKEN_STATS *token_stats) { … } static inline void set_spatial_segment_id( const CommonModeInfoParams *const mi_params, uint8_t *segment_ids, BLOCK_SIZE bsize, int mi_row, int mi_col, uint8_t segment_id) { … } int av1_neg_interleave(int x, int ref, int max) { … } static inline void write_segment_id(AV1_COMP *cpi, MACROBLOCKD *const xd, const MB_MODE_INFO *const mbmi, aom_writer *w, const struct segmentation *seg, struct segmentation_probs *segp, int skip_txfm) { … } #define WRITE_REF_BIT(bname, pname) … // This function encodes the reference frame static inline void write_ref_frames(const AV1_COMMON *cm, const MACROBLOCKD *xd, aom_writer *w) { … } static inline void write_filter_intra_mode_info(const AV1_COMMON *cm, const MACROBLOCKD *xd, const MB_MODE_INFO *const mbmi, aom_writer *w) { … } static inline void write_angle_delta(aom_writer *w, int angle_delta, aom_cdf_prob *cdf) { … } static inline void write_mb_interp_filter(AV1_COMMON *const cm, ThreadData *td, aom_writer *w) { … } // Transmit color values with delta encoding. Write the first value as // literal, and the deltas between each value and the previous one. "min_val" is // the smallest possible value of the deltas. static inline void delta_encode_palette_colors(const int *colors, int num, int bit_depth, int min_val, aom_writer *w) { … } // Transmit luma palette color values. First signal if each color in the color // cache is used. Those colors that are not in the cache are transmitted with // delta encoding. static inline void write_palette_colors_y(const MACROBLOCKD *const xd, const PALETTE_MODE_INFO *const pmi, int bit_depth, aom_writer *w) { … } // Write chroma palette color values. U channel is handled similarly to the luma // channel. For v channel, either use delta encoding or transmit raw values // directly, whichever costs less. static inline void write_palette_colors_uv(const MACROBLOCKD *const xd, const PALETTE_MODE_INFO *const pmi, int bit_depth, aom_writer *w) { … } static inline void write_palette_mode_info(const AV1_COMMON *cm, const MACROBLOCKD *xd, const MB_MODE_INFO *const mbmi, aom_writer *w) { … } void av1_write_tx_type(const AV1_COMMON *const cm, const MACROBLOCKD *xd, TX_TYPE tx_type, TX_SIZE tx_size, aom_writer *w) { … } static inline void write_intra_y_mode_nonkf(FRAME_CONTEXT *frame_ctx, BLOCK_SIZE bsize, PREDICTION_MODE mode, aom_writer *w) { … } static inline void write_intra_uv_mode(FRAME_CONTEXT *frame_ctx, UV_PREDICTION_MODE uv_mode, PREDICTION_MODE y_mode, CFL_ALLOWED_TYPE cfl_allowed, aom_writer *w) { … } static inline void write_cfl_alphas(FRAME_CONTEXT *const ec_ctx, uint8_t idx, int8_t joint_sign, aom_writer *w) { … } static inline void write_cdef(AV1_COMMON *cm, MACROBLOCKD *const xd, aom_writer *w, int skip) { … } static inline void write_inter_segment_id(AV1_COMP *cpi, MACROBLOCKD *const xd, aom_writer *w, const struct segmentation *const seg, struct segmentation_probs *const segp, int skip, int preskip) { … } // If delta q is present, writes delta_q index. // Also writes delta_q loop filter levels, if present. static inline void write_delta_q_params(AV1_COMMON *const cm, MACROBLOCKD *const xd, int skip, aom_writer *w) { … } static inline void write_intra_prediction_modes(const AV1_COMMON *cm, MACROBLOCKD *const xd, int is_keyframe, aom_writer *w) { … } static inline int16_t mode_context_analyzer( const int16_t mode_context, const MV_REFERENCE_FRAME *const rf) { … } static inline int_mv get_ref_mv_from_stack( int ref_idx, const MV_REFERENCE_FRAME *ref_frame, int ref_mv_idx, const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame) { … } static inline int_mv get_ref_mv(const MACROBLOCK *x, int ref_idx) { … } static inline void pack_inter_mode_mvs(AV1_COMP *cpi, ThreadData *const td, aom_writer *w) { … } static inline void write_intrabc_info( MACROBLOCKD *xd, const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame, aom_writer *w) { … } static inline void write_mb_modes_kf( AV1_COMP *cpi, MACROBLOCKD *xd, const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame, aom_writer *w) { … } #if CONFIG_RD_DEBUG static inline void dump_mode_info(MB_MODE_INFO *mi) { printf("\nmi->mi_row == %d\n", mi->mi_row); printf("&& mi->mi_col == %d\n", mi->mi_col); printf("&& mi->bsize == %d\n", mi->bsize); printf("&& mi->tx_size == %d\n", mi->tx_size); printf("&& mi->mode == %d\n", mi->mode); } static int rd_token_stats_mismatch(RD_STATS *rd_stats, TOKEN_STATS *token_stats, int plane) { if (rd_stats->txb_coeff_cost[plane] != token_stats->cost) { printf("\nplane %d rd_stats->txb_coeff_cost %d token_stats->cost %d\n", plane, rd_stats->txb_coeff_cost[plane], token_stats->cost); return 1; } return 0; } #endif #if ENC_MISMATCH_DEBUG static inline void enc_dump_logs( const AV1_COMMON *const cm, const MBMIExtFrameBufferInfo *const mbmi_ext_info, int mi_row, int mi_col) { const MB_MODE_INFO *const mbmi = *( cm->mi_params.mi_grid_base + (mi_row * cm->mi_params.mi_stride + mi_col)); const MB_MODE_INFO_EXT_FRAME *const mbmi_ext_frame = mbmi_ext_info->frame_base + get_mi_ext_idx(mi_row, mi_col, cm->mi_params.mi_alloc_bsize, mbmi_ext_info->stride); if (is_inter_block(mbmi)) { #define FRAME_TO_CHECK … if (cm->current_frame.frame_number == FRAME_TO_CHECK && cm->show_frame == 1) { const BLOCK_SIZE bsize = mbmi->bsize; int_mv mv[2] = { 0 }; const int is_comp_ref = has_second_ref(mbmi); for (int ref = 0; ref < 1 + is_comp_ref; ++ref) mv[ref].as_mv = mbmi->mv[ref].as_mv; if (!is_comp_ref) { mv[1].as_int = 0; } const int16_t mode_ctx = is_comp_ref ? 0 : mode_context_analyzer(mbmi_ext_frame->mode_context, mbmi->ref_frame); const int16_t newmv_ctx = mode_ctx & NEWMV_CTX_MASK; int16_t zeromv_ctx = -1; int16_t refmv_ctx = -1; if (mbmi->mode != NEWMV) { zeromv_ctx = (mode_ctx >> GLOBALMV_OFFSET) & GLOBALMV_CTX_MASK; if (mbmi->mode != GLOBALMV) refmv_ctx = (mode_ctx >> REFMV_OFFSET) & REFMV_CTX_MASK; } printf( "=== ENCODER ===: " "Frame=%d, (mi_row,mi_col)=(%d,%d), skip_mode=%d, mode=%d, bsize=%d, " "show_frame=%d, mv[0]=(%d,%d), mv[1]=(%d,%d), ref[0]=%d, " "ref[1]=%d, motion_mode=%d, mode_ctx=%d, " "newmv_ctx=%d, zeromv_ctx=%d, refmv_ctx=%d, tx_size=%d\n", cm->current_frame.frame_number, mi_row, mi_col, mbmi->skip_mode, mbmi->mode, bsize, cm->show_frame, mv[0].as_mv.row, mv[0].as_mv.col, mv[1].as_mv.row, mv[1].as_mv.col, mbmi->ref_frame[0], mbmi->ref_frame[1], mbmi->motion_mode, mode_ctx, newmv_ctx, zeromv_ctx, refmv_ctx, mbmi->tx_size); } } } #endif // ENC_MISMATCH_DEBUG static inline void write_mbmi_b(AV1_COMP *cpi, ThreadData *const td, aom_writer *w) { … } static inline void write_inter_txb_coeff( AV1_COMMON *const cm, MACROBLOCK *const x, MB_MODE_INFO *const mbmi, aom_writer *w, const TokenExtra **tok, const TokenExtra *const tok_end, TOKEN_STATS *token_stats, const int row, const int col, int *block, const int plane) { … } static inline void write_tokens_b(AV1_COMP *cpi, MACROBLOCK *const x, aom_writer *w, const TokenExtra **tok, const TokenExtra *const tok_end) { … } static inline void write_modes_b(AV1_COMP *cpi, ThreadData *const td, const TileInfo *const tile, aom_writer *w, const TokenExtra **tok, const TokenExtra *const tok_end, int mi_row, int mi_col) { … } static inline void write_partition(const AV1_COMMON *const cm, const MACROBLOCKD *const xd, int hbs, int mi_row, int mi_col, PARTITION_TYPE p, BLOCK_SIZE bsize, aom_writer *w) { … } static inline void write_modes_sb(AV1_COMP *const cpi, ThreadData *const td, const TileInfo *const tile, aom_writer *const w, const TokenExtra **tok, const TokenExtra *const tok_end, int mi_row, int mi_col, BLOCK_SIZE bsize) { … } // Populate token pointers appropriately based on token_info. static inline void get_token_pointers(const TokenInfo *token_info, const int tile_row, int tile_col, const int sb_row_in_tile, const TokenExtra **tok, const TokenExtra **tok_end) { … } static inline void write_modes(AV1_COMP *const cpi, ThreadData *const td, const TileInfo *const tile, aom_writer *const w, int tile_row, int tile_col) { … } static inline void encode_restoration_mode(AV1_COMMON *cm, struct aom_write_bit_buffer *wb) { … } #if !CONFIG_REALTIME_ONLY static inline void write_wiener_filter(int wiener_win, const WienerInfo *wiener_info, WienerInfo *ref_wiener_info, aom_writer *wb) { if (wiener_win == WIENER_WIN) aom_write_primitive_refsubexpfin( wb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1, WIENER_FILT_TAP0_SUBEXP_K, ref_wiener_info->vfilter[0] - WIENER_FILT_TAP0_MINV, wiener_info->vfilter[0] - WIENER_FILT_TAP0_MINV); else assert(wiener_info->vfilter[0] == 0 && wiener_info->vfilter[WIENER_WIN - 1] == 0); aom_write_primitive_refsubexpfin( wb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1, WIENER_FILT_TAP1_SUBEXP_K, ref_wiener_info->vfilter[1] - WIENER_FILT_TAP1_MINV, wiener_info->vfilter[1] - WIENER_FILT_TAP1_MINV); aom_write_primitive_refsubexpfin( wb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1, WIENER_FILT_TAP2_SUBEXP_K, ref_wiener_info->vfilter[2] - WIENER_FILT_TAP2_MINV, wiener_info->vfilter[2] - WIENER_FILT_TAP2_MINV); if (wiener_win == WIENER_WIN) aom_write_primitive_refsubexpfin( wb, WIENER_FILT_TAP0_MAXV - WIENER_FILT_TAP0_MINV + 1, WIENER_FILT_TAP0_SUBEXP_K, ref_wiener_info->hfilter[0] - WIENER_FILT_TAP0_MINV, wiener_info->hfilter[0] - WIENER_FILT_TAP0_MINV); else assert(wiener_info->hfilter[0] == 0 && wiener_info->hfilter[WIENER_WIN - 1] == 0); aom_write_primitive_refsubexpfin( wb, WIENER_FILT_TAP1_MAXV - WIENER_FILT_TAP1_MINV + 1, WIENER_FILT_TAP1_SUBEXP_K, ref_wiener_info->hfilter[1] - WIENER_FILT_TAP1_MINV, wiener_info->hfilter[1] - WIENER_FILT_TAP1_MINV); aom_write_primitive_refsubexpfin( wb, WIENER_FILT_TAP2_MAXV - WIENER_FILT_TAP2_MINV + 1, WIENER_FILT_TAP2_SUBEXP_K, ref_wiener_info->hfilter[2] - WIENER_FILT_TAP2_MINV, wiener_info->hfilter[2] - WIENER_FILT_TAP2_MINV); memcpy(ref_wiener_info, wiener_info, sizeof(*wiener_info)); } static inline void write_sgrproj_filter(const SgrprojInfo *sgrproj_info, SgrprojInfo *ref_sgrproj_info, aom_writer *wb) { aom_write_literal(wb, sgrproj_info->ep, SGRPROJ_PARAMS_BITS); const sgr_params_type *params = &av1_sgr_params[sgrproj_info->ep]; if (params->r[0] == 0) { assert(sgrproj_info->xqd[0] == 0); aom_write_primitive_refsubexpfin( wb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K, ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1); } else if (params->r[1] == 0) { aom_write_primitive_refsubexpfin( wb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K, ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0); } else { aom_write_primitive_refsubexpfin( wb, SGRPROJ_PRJ_MAX0 - SGRPROJ_PRJ_MIN0 + 1, SGRPROJ_PRJ_SUBEXP_K, ref_sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0, sgrproj_info->xqd[0] - SGRPROJ_PRJ_MIN0); aom_write_primitive_refsubexpfin( wb, SGRPROJ_PRJ_MAX1 - SGRPROJ_PRJ_MIN1 + 1, SGRPROJ_PRJ_SUBEXP_K, ref_sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1, sgrproj_info->xqd[1] - SGRPROJ_PRJ_MIN1); } memcpy(ref_sgrproj_info, sgrproj_info, sizeof(*sgrproj_info)); } static inline void loop_restoration_write_sb_coeffs( const AV1_COMMON *const cm, MACROBLOCKD *xd, int runit_idx, aom_writer *const w, int plane, FRAME_COUNTS *counts) { const RestorationUnitInfo *rui = &cm->rst_info[plane].unit_info[runit_idx]; const RestorationInfo *rsi = cm->rst_info + plane; RestorationType frame_rtype = rsi->frame_restoration_type; assert(frame_rtype != RESTORE_NONE); (void)counts; assert(!cm->features.all_lossless); const int wiener_win = (plane > 0) ? WIENER_WIN_CHROMA : WIENER_WIN; WienerInfo *ref_wiener_info = &xd->wiener_info[plane]; SgrprojInfo *ref_sgrproj_info = &xd->sgrproj_info[plane]; RestorationType unit_rtype = rui->restoration_type; if (frame_rtype == RESTORE_SWITCHABLE) { aom_write_symbol(w, unit_rtype, xd->tile_ctx->switchable_restore_cdf, RESTORE_SWITCHABLE_TYPES); #if CONFIG_ENTROPY_STATS ++counts->switchable_restore[unit_rtype]; #endif switch (unit_rtype) { case RESTORE_WIENER: #if DEBUG_LR_COSTING assert(!memcmp( ref_wiener_info, &lr_ref_params[RESTORE_SWITCHABLE][plane][runit_idx].wiener_info, sizeof(*ref_wiener_info))); #endif write_wiener_filter(wiener_win, &rui->wiener_info, ref_wiener_info, w); break; case RESTORE_SGRPROJ: #if DEBUG_LR_COSTING assert(!memcmp(&ref_sgrproj_info->xqd, &lr_ref_params[RESTORE_SWITCHABLE][plane][runit_idx] .sgrproj_info.xqd, sizeof(ref_sgrproj_info->xqd))); #endif write_sgrproj_filter(&rui->sgrproj_info, ref_sgrproj_info, w); break; default: assert(unit_rtype == RESTORE_NONE); break; } } else if (frame_rtype == RESTORE_WIENER) { aom_write_symbol(w, unit_rtype != RESTORE_NONE, xd->tile_ctx->wiener_restore_cdf, 2); #if CONFIG_ENTROPY_STATS ++counts->wiener_restore[unit_rtype != RESTORE_NONE]; #endif if (unit_rtype != RESTORE_NONE) { #if DEBUG_LR_COSTING assert( !memcmp(ref_wiener_info, &lr_ref_params[RESTORE_WIENER][plane][runit_idx].wiener_info, sizeof(*ref_wiener_info))); #endif write_wiener_filter(wiener_win, &rui->wiener_info, ref_wiener_info, w); } } else if (frame_rtype == RESTORE_SGRPROJ) { aom_write_symbol(w, unit_rtype != RESTORE_NONE, xd->tile_ctx->sgrproj_restore_cdf, 2); #if CONFIG_ENTROPY_STATS ++counts->sgrproj_restore[unit_rtype != RESTORE_NONE]; #endif if (unit_rtype != RESTORE_NONE) { #if DEBUG_LR_COSTING assert(!memcmp( &ref_sgrproj_info->xqd, &lr_ref_params[RESTORE_SGRPROJ][plane][runit_idx].sgrproj_info.xqd, sizeof(ref_sgrproj_info->xqd))); #endif write_sgrproj_filter(&rui->sgrproj_info, ref_sgrproj_info, w); } } } #endif // !CONFIG_REALTIME_ONLY // Only write out the ref delta section if any of the elements // will signal a delta. static bool is_mode_ref_delta_meaningful(AV1_COMMON *cm) { … } static inline void encode_loopfilter(AV1_COMMON *cm, struct aom_write_bit_buffer *wb) { … } static inline void encode_cdef(const AV1_COMMON *cm, struct aom_write_bit_buffer *wb) { … } static inline void write_delta_q(struct aom_write_bit_buffer *wb, int delta_q) { … } static inline void encode_quantization( const CommonQuantParams *const quant_params, int num_planes, bool separate_uv_delta_q, struct aom_write_bit_buffer *wb) { … } static inline void encode_segmentation(AV1_COMMON *cm, struct aom_write_bit_buffer *wb) { … } static inline void write_frame_interp_filter(InterpFilter filter, struct aom_write_bit_buffer *wb) { … } // Same function as write_uniform but writing to uncompresses header wb static inline void wb_write_uniform(struct aom_write_bit_buffer *wb, int n, int v) { … } static inline void write_tile_info_max_tile(const AV1_COMMON *const cm, struct aom_write_bit_buffer *wb) { … } static inline void write_tile_info(const AV1_COMMON *const cm, struct aom_write_bit_buffer *saved_wb, struct aom_write_bit_buffer *wb) { … } static inline void write_ext_tile_info(const AV1_COMMON *const cm, struct aom_write_bit_buffer *saved_wb, struct aom_write_bit_buffer *wb) { … } static inline int find_identical_tile( const int tile_row, const int tile_col, TileBufferEnc (*const tile_buffers)[MAX_TILE_COLS]) { … } static inline void write_render_size(const AV1_COMMON *cm, struct aom_write_bit_buffer *wb) { … } static inline void write_superres_scale(const AV1_COMMON *const cm, struct aom_write_bit_buffer *wb) { … } static inline void write_frame_size(const AV1_COMMON *cm, int frame_size_override, struct aom_write_bit_buffer *wb) { … } static inline void write_frame_size_with_refs(const AV1_COMMON *const cm, struct aom_write_bit_buffer *wb) { … } static inline void write_profile(BITSTREAM_PROFILE profile, struct aom_write_bit_buffer *wb) { … } static inline void write_bitdepth(const SequenceHeader *const seq_params, struct aom_write_bit_buffer *wb) { … } static inline void write_color_config(const SequenceHeader *const seq_params, struct aom_write_bit_buffer *wb) { … } static inline void write_timing_info_header( const aom_timing_info_t *const timing_info, struct aom_write_bit_buffer *wb) { … } static inline void write_decoder_model_info( const aom_dec_model_info_t *const decoder_model_info, struct aom_write_bit_buffer *wb) { … } static inline void write_dec_model_op_parameters( const aom_dec_model_op_parameters_t *op_params, int buffer_delay_length, struct aom_write_bit_buffer *wb) { … } static inline void write_tu_pts_info(AV1_COMMON *const cm, struct aom_write_bit_buffer *wb) { … } static inline void write_film_grain_params(const AV1_COMP *const cpi, struct aom_write_bit_buffer *wb) { … } static inline void write_sb_size(const SequenceHeader *const seq_params, struct aom_write_bit_buffer *wb) { … } static inline void write_sequence_header(const SequenceHeader *const seq_params, struct aom_write_bit_buffer *wb) { … } static inline void write_global_motion_params( const WarpedMotionParams *params, const WarpedMotionParams *ref_params, struct aom_write_bit_buffer *wb, int allow_hp) { … } static inline void write_global_motion(AV1_COMP *cpi, struct aom_write_bit_buffer *wb) { … } static int check_frame_refs_short_signaling(AV1_COMMON *const cm, bool enable_ref_short_signaling) { … } // New function based on HLS R18 static inline void write_uncompressed_header_obu( AV1_COMP *cpi, MACROBLOCKD *const xd, struct aom_write_bit_buffer *saved_wb, struct aom_write_bit_buffer *wb) { … } static int choose_size_bytes(uint32_t size, int spare_msbs) { … } static inline void mem_put_varsize(uint8_t *const dst, const int sz, const int val) { … } static int remux_tiles(const CommonTileParams *const tiles, uint8_t *dst, const uint32_t data_size, const uint32_t max_tile_size, const uint32_t max_tile_col_size, int *const tile_size_bytes, int *const tile_col_size_bytes) { … } uint32_t av1_write_obu_header(AV1LevelParams *const level_params, int *frame_header_count, OBU_TYPE obu_type, bool has_nonzero_operating_point_idc, int obu_extension, uint8_t *const dst) { … } int av1_write_uleb_obu_size(size_t obu_header_size, size_t obu_payload_size, uint8_t *dest, size_t dest_size) { … } int av1_write_uleb_obu_size_unsafe(size_t obu_header_size, size_t obu_payload_size, uint8_t *dest) { … } // Returns 0 on failure. static size_t obu_memmove(size_t obu_header_size, size_t obu_payload_size, uint8_t *data, size_t data_size) { … } // Deprecated. Use obu_memmove() instead. static size_t obu_memmove_unsafe(size_t obu_header_size, size_t obu_payload_size, uint8_t *data) { … } static inline void add_trailing_bits(struct aom_write_bit_buffer *wb) { … } static inline void write_bitstream_level(AV1_LEVEL seq_level_idx, struct aom_write_bit_buffer *wb) { … } uint32_t av1_write_sequence_header_obu(const SequenceHeader *seq_params, uint8_t *const dst, size_t dst_size) { … } static uint32_t write_frame_header_obu(AV1_COMP *cpi, MACROBLOCKD *const xd, struct aom_write_bit_buffer *saved_wb, uint8_t *const dst, int append_trailing_bits) { … } static uint32_t write_tile_group_header(uint8_t *const dst, int start_tile, int end_tile, int tiles_log2, int tile_start_and_end_present_flag) { … } LargeTileFrameOBU; // Initialize OBU header for large scale tile case. static uint32_t init_large_scale_tile_obu_header( AV1_COMP *const cpi, uint8_t **data, struct aom_write_bit_buffer *saved_wb, uint8_t obu_extension_header, LargeTileFrameOBU *lst_obu) { … } // Write total buffer size and related information into the OBU header for large // scale tile case. static void write_large_scale_tile_obu_size( const CommonTileParams *const tiles, uint8_t *const dst, uint8_t *data, struct aom_write_bit_buffer *saved_wb, LargeTileFrameOBU *const lst_obu, int have_tiles, uint32_t *total_size, int max_tile_size, int max_tile_col_size) { … } // Store information on each large scale tile in the OBU header. static void write_large_scale_tile_obu( AV1_COMP *const cpi, uint8_t *const dst, LargeTileFrameOBU *const lst_obu, int *const largest_tile_id, uint32_t *total_size, const int have_tiles, unsigned int *const max_tile_size, unsigned int *const max_tile_col_size) { … } // Packs information in the obu header for large scale tiles. static inline uint32_t pack_large_scale_tiles_in_tg_obus( AV1_COMP *const cpi, uint8_t *const dst, struct aom_write_bit_buffer *saved_wb, uint8_t obu_extension_header, int *const largest_tile_id) { … } // Writes obu, tile group and uncompressed headers to bitstream. void av1_write_obu_tg_tile_headers(AV1_COMP *const cpi, MACROBLOCKD *const xd, PackBSParams *const pack_bs_params, const int tile_idx) { … } // Pack tile data in the bitstream with tile_group, frame // and OBU header. void av1_pack_tile_info(AV1_COMP *const cpi, ThreadData *const td, PackBSParams *const pack_bs_params) { … } void av1_write_last_tile_info( AV1_COMP *const cpi, const FrameHeaderInfo *fh_info, struct aom_write_bit_buffer *saved_wb, size_t *curr_tg_data_size, uint8_t *curr_tg_start, uint32_t *const total_size, uint8_t **tile_data_start, int *const largest_tile_id, int *const is_first_tg, uint32_t obu_header_size, uint8_t obu_extn_header) { … } void av1_reset_pack_bs_thread_data(ThreadData *const td) { … } void av1_accumulate_pack_bs_thread_data(AV1_COMP *const cpi, ThreadData const *td) { … } // Store information related to each default tile in the OBU header. static void write_tile_obu( AV1_COMP *const cpi, uint8_t *const dst, uint32_t *total_size, struct aom_write_bit_buffer *saved_wb, uint8_t obu_extn_header, const FrameHeaderInfo *fh_info, int *const largest_tile_id, unsigned int *max_tile_size, uint32_t *const obu_header_size, uint8_t **tile_data_start) { … } // Write total buffer size and related information into the OBU header for // default tile case. static void write_tile_obu_size(AV1_COMP *const cpi, uint8_t *const dst, struct aom_write_bit_buffer *saved_wb, int largest_tile_id, uint32_t *const total_size, unsigned int max_tile_size, uint32_t obu_header_size, uint8_t *tile_data_start) { … } // As per the experiments, single-thread bitstream packing is better for // frames with a smaller bitstream size. This behavior is due to setup time // overhead of multithread function would be more than that of time required // to pack the smaller bitstream of such frames. This function computes the // number of required number of workers based on setup time overhead and job // dispatch time overhead for given tiles and available workers. static int calc_pack_bs_mt_workers(const TileDataEnc *tile_data, int num_tiles, int avail_workers, bool pack_bs_mt_enabled) { … } static inline uint32_t pack_tiles_in_tg_obus( AV1_COMP *const cpi, uint8_t *const dst, struct aom_write_bit_buffer *saved_wb, uint8_t obu_extension_header, const FrameHeaderInfo *fh_info, int *const largest_tile_id) { … } static uint32_t write_tiles_in_tg_obus(AV1_COMP *const cpi, uint8_t *const dst, size_t dst_size, struct aom_write_bit_buffer *saved_wb, uint8_t obu_extension_header, const FrameHeaderInfo *fh_info, int *const largest_tile_id) { … } // Returns the number of bytes written on success. Returns 0 on failure. static size_t av1_write_metadata_obu(const aom_metadata_t *metadata, uint8_t *const dst, size_t dst_size) { … } static size_t av1_write_metadata_array(AV1_COMP *const cpi, uint8_t *dst, size_t dst_size) { … } int av1_pack_bitstream(AV1_COMP *const cpi, uint8_t *dst, size_t dst_size, size_t *size, int *const largest_tile_id) { … }
Codebase Browser
chromium