av1/encoder/encoder_alloc.h - avm - Git at Google


            
            /*

            
             * Copyright (c) 2021, Alliance for Open Media. All rights reserved

            
             *

            
             * This source code is subject to the terms of the BSD 3-Clause Clear License

            
             * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear

            
             * License was not distributed with this source code in the LICENSE file, you

            
             * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/.  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

            
             * aomedia.org/license/patent-license/.

            
             */


            #ifndef AOM_AV1_ENCODER_ENCODER_ALLOC_H_

            
            #define AOM_AV1_ENCODER_ENCODER_ALLOC_H_


            #include "av1/encoder/encoder.h"

            
            #include "av1/encoder/encodetxb.h"


            #if CONFIG_ML_PART_SPLIT

            
            #include "av1/encoder/part_split_prune_tflite.h"

            
            #endif  // CONFIG_ML_PART_SPLIT


            #if CONFIG_DIP_EXT_PRUNING

            
            #include "av1/encoder/intra_dip_mode_prune_tflite.h"

            
            #endif  // CONFIG_DIP_EXT_PRUNING


            #ifdef __cplusplus

            
            extern "C" {

            
            #endif


            static AOM_INLINE void dealloc_context_buffers_ext(

            
                MBMIExtFrameBufferInfo *mbmi_ext_info) {

            
              if (mbmi_ext_info->frame_base) {

            
                aom_free(mbmi_ext_info->frame_base);

            
                mbmi_ext_info->frame_base = NULL;

            
                mbmi_ext_info->alloc_size = 0;

            
              }

            
            }


            static AOM_INLINE void alloc_context_buffers_ext(

            
                AV1_COMMON *cm, MBMIExtFrameBufferInfo *mbmi_ext_info) {

            
              const CommonModeInfoParams *const mi_params = &cm->mi_params;


              const int mi_alloc_size_1d = mi_size_wide[mi_params->mi_alloc_bsize];

            
              const int mi_alloc_rows =

            
                  (mi_params->mi_rows + mi_alloc_size_1d - 1) / mi_alloc_size_1d;

            
              const int mi_alloc_cols =

            
                  (mi_params->mi_cols + mi_alloc_size_1d - 1) / mi_alloc_size_1d;

            
              const int new_ext_mi_size = mi_alloc_rows * mi_alloc_cols;


              if (new_ext_mi_size > mbmi_ext_info->alloc_size) {

            
                dealloc_context_buffers_ext(mbmi_ext_info);

            
                CHECK_MEM_ERROR(

            
                    cm, mbmi_ext_info->frame_base,

            
                    aom_calloc(new_ext_mi_size, sizeof(*mbmi_ext_info->frame_base)));

            
                mbmi_ext_info->alloc_size = new_ext_mi_size;

            
              }

            
              // The stride needs to be updated regardless of whether new allocation

            
              // happened or not.

            
              mbmi_ext_info->stride = mi_alloc_cols;

            
            }


            static AOM_INLINE void alloc_compressor_data(AV1_COMP *cpi) {

            
              AV1_COMMON *cm = &cpi->common;

            
              TokenInfo *token_info = &cpi->token_info;

            
              cpi->alloc_width = cm->width;

            
              cpi->alloc_height = cm->height;

            
              cpi->alloc_sb_size = cm->sb_size;

            
              if (av1_alloc_context_buffers(cm, cm->width, cm->height)) {

            
                aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,

            
                                   "Failed to allocate context buffers");

            
              }


              if (!is_stat_generation_stage(cpi)) {

            
                av1_alloc_txb_buf(cpi);


                alloc_context_buffers_ext(cm, &cpi->mbmi_ext_info);

            
              }


              free_token_info(token_info);


              if (!is_stat_generation_stage(cpi)) {

            
                alloc_token_info(cm, token_info);

            
              }


              av1_setup_shared_coeff_buffer(&cpi->common, &cpi->td.shared_coeff_buf);

            
              av1_setup_sms_tree(cpi, &cpi->td);

            
              av1_setup_sms_bufs(&cpi->common, &cpi->td);


              cpi->td.firstpass_ctx =

            
                  av1_alloc_pmc(cm, SHARED_PART, 0, 0, BLOCK_16X16, NULL, PARTITION_NONE, 0,

            
                                cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,

            
                                &cpi->td.shared_coeff_buf);

            
            }


            static AOM_INLINE void realloc_segmentation_maps(AV1_COMP *cpi) {

            
              AV1_COMMON *const cm = &cpi->common;

            
              CommonModeInfoParams *const mi_params = &cm->mi_params;


              // Create the encoder segmentation map and set all entries to 0

            
              aom_free(cpi->enc_seg.map);

            
              CHECK_MEM_ERROR(cm, cpi->enc_seg.map,

            
                              aom_calloc(mi_params->mi_rows * mi_params->mi_cols, 1));


              // Create a map used for cyclic background refresh.

            
              if (cpi->cyclic_refresh) av1_cyclic_refresh_free(cpi->cyclic_refresh);

            
              CHECK_MEM_ERROR(

            
                  cm, cpi->cyclic_refresh,

            
                  av1_cyclic_refresh_alloc(mi_params->mi_rows, mi_params->mi_cols,

            
                                           cm->seq_params.bit_depth));


              // Create a map used to mark inactive areas.

            
              aom_free(cpi->active_map.map);

            
              CHECK_MEM_ERROR(cm, cpi->active_map.map,

            
                              aom_calloc(mi_params->mi_rows * mi_params->mi_cols, 1));

            
            }


            #if CONFIG_BRU

            
            static AOM_INLINE void realloc_ARD_queue(AV1_COMP *cpi) {

            
              AV1_COMMON *const cm = &cpi->common;

            
              CommonModeInfoParams *const mi_params = &cm->mi_params;

            
              // have to make sure empty queue

            
              for (uint32_t r = 0; r < cpi->enc_act_queue_size; r++) {

            
                ARD_Queue *q = cpi->enc_act_sb_queue[r];

            
                if (q != NULL) {

            
                  while (!ard_is_queue_empty(q)) {

            
                    ard_dequeue(q);

            
                  }

            
                  cpi->enc_act_sb_queue[r] = NULL;

            
                }

            
              }

            
              aom_free(cpi->enc_act_sb_queue);

            
              CHECK_MEM_ERROR(

            
                  cm, cpi->enc_act_sb_queue,

            
                  aom_calloc((mi_params->mb_cols / 3 + 1) * (mi_params->mb_rows / 3 + 1),

            
                             sizeof(ARD_Queue *)));

            
              cpi->enc_act_queue_size =

            
                  (mi_params->mb_cols / 3 + 1) * (mi_params->mb_rows / 3 + 1);

            
            }

            
            #endif  // CONFIG_BRU

            
            static AOM_INLINE void alloc_compound_type_rd_buffers(

            
                AV1_COMMON *const cm, CompoundTypeRdBuffers *const bufs) {

            
              CHECK_MEM_ERROR(

            
                  cm, bufs->pred0,

            
                  (uint16_t *)aom_memalign(16, MAX_SB_SQUARE * sizeof(*bufs->pred0)));

            
              CHECK_MEM_ERROR(

            
                  cm, bufs->pred1,

            
                  (uint16_t *)aom_memalign(16, MAX_SB_SQUARE * sizeof(*bufs->pred1)));

            
              CHECK_MEM_ERROR(

            
                  cm, bufs->residual1,

            
                  (int16_t *)aom_memalign(32, MAX_SB_SQUARE * sizeof(*bufs->residual1)));

            
              CHECK_MEM_ERROR(

            
                  cm, bufs->diff10,

            
                  (int16_t *)aom_memalign(32, MAX_SB_SQUARE * sizeof(*bufs->diff10)));

            
              CHECK_MEM_ERROR(cm, bufs->tmp_best_mask_buf,

            
                              (uint8_t *)aom_malloc(2 * MAX_SB_SQUARE *

            
                                                    sizeof(*bufs->tmp_best_mask_buf)));

            
            }


            static AOM_INLINE void release_compound_type_rd_buffers(

            
                CompoundTypeRdBuffers *const bufs) {

            
              aom_free(bufs->pred0);

            
              aom_free(bufs->pred1);

            
              aom_free(bufs->residual1);

            
              aom_free(bufs->diff10);

            
              aom_free(bufs->tmp_best_mask_buf);

            
              av1_zero(*bufs);  // Set all pointers to NULL for safety.

            
            }


            static AOM_INLINE void dealloc_compressor_data(AV1_COMP *cpi) {

            
              AV1_COMMON *const cm = &cpi->common;

            
              TokenInfo *token_info = &cpi->token_info;


              dealloc_context_buffers_ext(&cpi->mbmi_ext_info);


              aom_free(cpi->tile_data);

            
              cpi->tile_data = NULL;


              // Delete sementation map

            
              aom_free(cpi->enc_seg.map);

            
              cpi->enc_seg.map = NULL;

            
            #if CONFIG_BRU

            
              // have to make sure empty queue

            
              for (uint32_t r = 0; r < cpi->enc_act_queue_size; r++) {

            
                ARD_Queue *q = cpi->enc_act_sb_queue[r];

            
                if (q != NULL) {

            
                  while (!ard_is_queue_empty(q)) {

            
                    ard_dequeue(q);

            
                  }

            
                  cpi->enc_act_sb_queue[r] = NULL;

            
                }

            
              }

            
              aom_free(cpi->enc_act_sb_queue);

            
              cpi->enc_act_sb_queue = NULL;

            
            #endif  // CONFIG_BRU


              av1_cyclic_refresh_free(cpi->cyclic_refresh);

            
              cpi->cyclic_refresh = NULL;


              aom_free(cpi->active_map.map);

            
              cpi->active_map.map = NULL;


              aom_free(cpi->ssim_rdmult_scaling_factors);

            
              cpi->ssim_rdmult_scaling_factors = NULL;


              aom_free(cpi->tpl_rdmult_scaling_factors);

            
              cpi->tpl_rdmult_scaling_factors = NULL;


              aom_free(cpi->tpl_sb_rdmult_scaling_factors);

            
              cpi->tpl_sb_rdmult_scaling_factors = NULL;


            #if CONFIG_TUNE_VMAF

            
              aom_free(cpi->vmaf_info.rdmult_scaling_factors);

            
              cpi->vmaf_info.rdmult_scaling_factors = NULL;


            #if CONFIG_USE_VMAF_RC

            
              aom_close_vmaf_model_rc(cpi->vmaf_info.vmaf_model);

            
            #endif

            
            #endif

            
            #if CONFIG_BRU

            
              BruInfo *bru_info = &cpi->common.bru;

            
              aom_free(bru_info->active_mode_map);

            
              bru_info->active_mode_map = NULL;

            
              aom_free(bru_info->active_region);

            
              bru_info->active_region = NULL;

            
            #endif  // CONFIG_BRU


              aom_free(cpi->td.mb.inter_modes_info);

            
              cpi->td.mb.inter_modes_info = NULL;


              for (int i = 0; i < 2; i++)

            
                for (int j = 0; j < 2; j++) {

            
                  aom_free(cpi->td.mb.intrabc_hash_info.hash_value_buffer[i][j]);

            
                  cpi->td.mb.intrabc_hash_info.hash_value_buffer[i][j] = NULL;

            
                }


              aom_free(cm->tpl_mvs);

            
              cm->tpl_mvs = NULL;

            
            #if CONFIG_MV_TRAJECTORY

            
              for (int rf = 0; rf < INTER_REFS_PER_FRAME; rf++) {

            
                aom_free(cm->id_offset_map[rf]);

            
                cm->id_offset_map[rf] = NULL;

            
            #if CONFIG_TMVP_SIMPLIFICATIONS_F085

            
                for (int k = 0; k < 3; k++) {

            
                  aom_free(cm->blk_id_map[k][rf]);

            
                  cm->blk_id_map[k][rf] = NULL;

            
                }

            
            #else

            
                aom_free(cm->blk_id_map[rf]);

            
                cm->blk_id_map[rf] = NULL;

            
            #endif  // CONFIG_TMVP_SIMPLIFICATIONS_F085

            
              }

            
            #endif  // CONFIG_MV_TRAJECTORY


              aom_free(cm->tip_ref.mf_need_clamp);

            
              cm->tip_ref.mf_need_clamp = NULL;


              aom_free(cpi->td.mb.mbmi_ext);

            
              cpi->td.mb.mbmi_ext = NULL;


              av1_free_pmc(cpi->td.firstpass_ctx, av1_num_planes(cm));

            
              cpi->td.firstpass_ctx = NULL;


              av1_free_ref_frame_buffers(cm->buffer_pool);

            
              av1_free_txb_buf(cpi);

            
              av1_free_context_buffers(cm);


              aom_free_frame_buffer(&cpi->last_frame_uf);

            
              av1_free_restoration_buffers(cm);

            
            #if CONFIG_GDF

            
              free_gdf_buffers(&cm->gdf_info);

            
            #endif  // CONFIG_GDF

            
              aom_free_frame_buffer(&cpi->trial_frame_rst);

            
              aom_free_frame_buffer(&cpi->scaled_source);

            
              aom_free_frame_buffer(&cpi->scaled_last_source);

            
              aom_free_frame_buffer(&cpi->alt_ref_buffer);

            
              av1_lookahead_destroy(cpi->lookahead);


              free_token_info(token_info);


              av1_free_shared_coeff_buffer(&cpi->td.shared_coeff_buf);

            
              av1_free_sms_tree(&cpi->td);

            
              av1_free_sms_bufs(&cpi->td);

            
            #if CONFIG_ML_PART_SPLIT

            
              av2_part_split_prune_tflite_close(&(cpi->td.partition_model));

            
            #endif  // CONFIG_ML_PART_SPLIT

            
            #if CONFIG_DIP_EXT_PRUNING

            
              intra_dip_mode_prune_close(&(cpi->td.dip_pruning_model));

            
            #endif  // CONFIG_DIP_EXT_PRUNING

            
              aom_free(cpi->td.mb.palette_buffer);

            
              release_compound_type_rd_buffers(&cpi->td.mb.comp_rd_buffer);

            
              aom_free(cpi->td.mb.tmp_conv_dst);

            
              aom_free(cpi->td.mb.upsample_pred);

            
              aom_free(cpi->td.mb.coef_info);


              // Temporary buffers used during the DMVR and OPFL processing.

            
              aom_free(cpi->td.mb.opfl_vxy_bufs);

            
              aom_free(cpi->td.mb.opfl_gxy_bufs);

            
              aom_free(cpi->td.mb.opfl_dst_bufs);

            
              for (int j = 0; j < 2; ++j) {

            
                aom_free(cpi->td.mb.tmp_pred_bufs[j]);

            
              }


            #if CONFIG_DENOISE

            
              if (cpi->denoise_and_model) {

            
                aom_denoise_and_model_free(cpi->denoise_and_model);

            
                cpi->denoise_and_model = NULL;

            
              }

            
            #endif

            
              if (cpi->film_grain_table) {

            
                aom_film_grain_table_free(cpi->film_grain_table);

            
                cpi->film_grain_table = NULL;

            
              }


              for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) {

            
                aom_free(cpi->level_params.level_info[i]);

            
              }


              if (cpi->consec_zero_mv) {

            
                aom_free(cpi->consec_zero_mv);

            
                cpi->consec_zero_mv = NULL;

            
              }

            
              cpi->alloc_width = 0;

            
              cpi->alloc_height = 0;

            
              cpi->alloc_sb_size = 0;


              av1_free_qm(cm->seq_params.quantizer_matrix_8x8);

            
              av1_free_qm(cm->seq_params.quantizer_matrix_8x4);

            
              av1_free_qm(cm->seq_params.quantizer_matrix_4x8);

            
            }


            static AOM_INLINE void alloc_altref_frame_buffer(AV1_COMP *cpi) {

            
              AV1_COMMON *cm = &cpi->common;

            
              const SequenceHeader *const seq_params = &cm->seq_params;

            
              const AV1EncoderConfig *oxcf = &cpi->oxcf;


              // TODO(agrange) Check if ARF is enabled and skip allocation if not.

            
              if (aom_realloc_frame_buffer(

            
                      &cpi->alt_ref_buffer, oxcf->frm_dim_cfg.width,

            
                      oxcf->frm_dim_cfg.height, seq_params->subsampling_x,

            
                      seq_params->subsampling_y, cpi->oxcf.border_in_pixels,

            
                      cm->features.byte_alignment, NULL, NULL, NULL, cpi->alloc_pyramid))

            
                aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,

            
                                   "Failed to allocate altref buffer");

            
            }


            static AOM_INLINE void alloc_util_frame_buffers(AV1_COMP *cpi) {

            
              AV1_COMMON *const cm = &cpi->common;

            
              const SequenceHeader *const seq_params = &cm->seq_params;

            
              const int byte_alignment = cm->features.byte_alignment;

            
              if (aom_realloc_frame_buffer(

            
                      &cpi->last_frame_uf, cm->width, cm->height, seq_params->subsampling_x,

            
                      seq_params->subsampling_y, cpi->oxcf.border_in_pixels, byte_alignment,

            
                      NULL, NULL, NULL, false))

            
                aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,

            
                                   "Failed to allocate last frame buffer");


              if (aom_realloc_frame_buffer(

            
                      &cpi->trial_frame_rst,

            
            #if CONFIG_ENABLE_SR

            
                      cm->superres_upscaled_width, cm->superres_upscaled_height,

            
            #else

            
                      cm->width, cm->height,

            
            #endif  // CONFIG_ENABLE_SR

            
                      seq_params->subsampling_x, seq_params->subsampling_y,

            
                      AOM_RESTORATION_FRAME_BORDER, byte_alignment, NULL, NULL, NULL,

            
                      false))

            
                aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,

            
                                   "Failed to allocate trial restored frame buffer");


              if (aom_realloc_frame_buffer(

            
                      &cpi->scaled_source, cm->width, cm->height, seq_params->subsampling_x,

            
                      seq_params->subsampling_y, cpi->oxcf.border_in_pixels, byte_alignment,

            
                      NULL, NULL, NULL, cpi->alloc_pyramid))

            
                aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,

            
                                   "Failed to allocate scaled source buffer");


              if (aom_realloc_frame_buffer(&cpi->scaled_last_source, cm->width, cm->height,

            
                                           seq_params->subsampling_x,

            
                                           seq_params->subsampling_y,

            
                                           cpi->oxcf.border_in_pixels, byte_alignment, NULL,

            
                                           NULL, NULL, cpi->alloc_pyramid))

            
                aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,

            
                                   "Failed to allocate scaled last source buffer");

            
            }


            static AOM_INLINE YV12_BUFFER_CONFIG *realloc_and_scale_source(

            
                AV1_COMP *cpi, int scaled_width, int scaled_height) {

            
              AV1_COMMON *cm = &cpi->common;

            
              const int num_planes = av1_num_planes(cm);


              if (scaled_width == cpi->unscaled_source->y_crop_width &&

            
                  scaled_height == cpi->unscaled_source->y_crop_height) {

            
                return cpi->unscaled_source;

            
              }


              if (aom_realloc_frame_buffer(

            
                      &cpi->scaled_source, scaled_width, scaled_height,

            
                      cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,

            
                      AOM_BORDER_IN_PIXELS, cm->features.byte_alignment, NULL, NULL, NULL,

            
                      cpi->alloc_pyramid))

            
                aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,

            
                                   "Failed to reallocate scaled source buffer");

            
              assert(cpi->scaled_source.y_crop_width == scaled_width);

            
              assert(cpi->scaled_source.y_crop_height == scaled_height);

            
              av1_resize_and_extend_frame_nonnormative(

            
                  cpi->unscaled_source, &cpi->scaled_source, (int)cm->seq_params.bit_depth,

            
                  num_planes);

            
              return &cpi->scaled_source;

            
            }


            #ifdef __cplusplus

            
            }  // extern "C"

            
            #endif


            #endif  // AOM_AV1_ENCODER_ENCODER_ALLOC_H_
	/*
	* Copyright (c) 2021, Alliance for Open Media. All rights reserved
	*
	* This source code is subject to the terms of the BSD 3-Clause Clear License
	* and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
	* License was not distributed with this source code in the LICENSE file, you
	* can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. 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
	* aomedia.org/license/patent-license/.
	*/

	#ifndef AOM_AV1_ENCODER_ENCODER_ALLOC_H_
	#define AOM_AV1_ENCODER_ENCODER_ALLOC_H_

	#include "av1/encoder/encoder.h"
	#include "av1/encoder/encodetxb.h"

	#if CONFIG_ML_PART_SPLIT
	#include "av1/encoder/part_split_prune_tflite.h"
	#endif // CONFIG_ML_PART_SPLIT

	#if CONFIG_DIP_EXT_PRUNING
	#include "av1/encoder/intra_dip_mode_prune_tflite.h"
	#endif // CONFIG_DIP_EXT_PRUNING

	#ifdef __cplusplus
	extern "C" {
	#endif

	static AOM_INLINE void dealloc_context_buffers_ext(
	MBMIExtFrameBufferInfo *mbmi_ext_info) {
	if (mbmi_ext_info->frame_base) {
	aom_free(mbmi_ext_info->frame_base);
	mbmi_ext_info->frame_base = NULL;
	mbmi_ext_info->alloc_size = 0;
	}
	}

	static AOM_INLINE void alloc_context_buffers_ext(
	AV1_COMMON cm, MBMIExtFrameBufferInfo mbmi_ext_info) {
	const CommonModeInfoParams *const mi_params = &cm->mi_params;

	const int mi_alloc_size_1d = mi_size_wide[mi_params->mi_alloc_bsize];
	const int mi_alloc_rows =
	(mi_params->mi_rows + mi_alloc_size_1d - 1) / mi_alloc_size_1d;
	const int mi_alloc_cols =
	(mi_params->mi_cols + mi_alloc_size_1d - 1) / mi_alloc_size_1d;
	const int new_ext_mi_size = mi_alloc_rows * mi_alloc_cols;

	if (new_ext_mi_size > mbmi_ext_info->alloc_size) {
	dealloc_context_buffers_ext(mbmi_ext_info);
	CHECK_MEM_ERROR(
	cm, mbmi_ext_info->frame_base,
	aom_calloc(new_ext_mi_size, sizeof(*mbmi_ext_info->frame_base)));
	mbmi_ext_info->alloc_size = new_ext_mi_size;
	}
	// The stride needs to be updated regardless of whether new allocation
	// happened or not.
	mbmi_ext_info->stride = mi_alloc_cols;
	}

	static AOM_INLINE void alloc_compressor_data(AV1_COMP *cpi) {
	AV1_COMMON *cm = &cpi->common;
	TokenInfo *token_info = &cpi->token_info;
	cpi->alloc_width = cm->width;
	cpi->alloc_height = cm->height;
	cpi->alloc_sb_size = cm->sb_size;
	if (av1_alloc_context_buffers(cm, cm->width, cm->height)) {
	aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
	"Failed to allocate context buffers");
	}

	if (!is_stat_generation_stage(cpi)) {
	av1_alloc_txb_buf(cpi);

	alloc_context_buffers_ext(cm, &cpi->mbmi_ext_info);
	}

	free_token_info(token_info);

	if (!is_stat_generation_stage(cpi)) {
	alloc_token_info(cm, token_info);
	}

	av1_setup_shared_coeff_buffer(&cpi->common, &cpi->td.shared_coeff_buf);
	av1_setup_sms_tree(cpi, &cpi->td);
	av1_setup_sms_bufs(&cpi->common, &cpi->td);

	cpi->td.firstpass_ctx =
	av1_alloc_pmc(cm, SHARED_PART, 0, 0, BLOCK_16X16, NULL, PARTITION_NONE, 0,
	cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
	&cpi->td.shared_coeff_buf);
	}

	static AOM_INLINE void realloc_segmentation_maps(AV1_COMP *cpi) {
	AV1_COMMON *const cm = &cpi->common;
	CommonModeInfoParams *const mi_params = &cm->mi_params;

	// Create the encoder segmentation map and set all entries to 0
	aom_free(cpi->enc_seg.map);
	CHECK_MEM_ERROR(cm, cpi->enc_seg.map,
	aom_calloc(mi_params->mi_rows * mi_params->mi_cols, 1));

	// Create a map used for cyclic background refresh.
	if (cpi->cyclic_refresh) av1_cyclic_refresh_free(cpi->cyclic_refresh);
	CHECK_MEM_ERROR(
	cm, cpi->cyclic_refresh,
	av1_cyclic_refresh_alloc(mi_params->mi_rows, mi_params->mi_cols,
	cm->seq_params.bit_depth));

	// Create a map used to mark inactive areas.
	aom_free(cpi->active_map.map);
	CHECK_MEM_ERROR(cm, cpi->active_map.map,
	aom_calloc(mi_params->mi_rows * mi_params->mi_cols, 1));
	}

	#if CONFIG_BRU
	static AOM_INLINE void realloc_ARD_queue(AV1_COMP *cpi) {
	AV1_COMMON *const cm = &cpi->common;
	CommonModeInfoParams *const mi_params = &cm->mi_params;
	// have to make sure empty queue
	for (uint32_t r = 0; r < cpi->enc_act_queue_size; r++) {
	ARD_Queue *q = cpi->enc_act_sb_queue[r];
	if (q != NULL) {
	while (!ard_is_queue_empty(q)) {
	ard_dequeue(q);
	}
	cpi->enc_act_sb_queue[r] = NULL;
	}
	}
	aom_free(cpi->enc_act_sb_queue);
	CHECK_MEM_ERROR(
	cm, cpi->enc_act_sb_queue,
	aom_calloc((mi_params->mb_cols / 3 + 1) * (mi_params->mb_rows / 3 + 1),
	sizeof(ARD_Queue *)));
	cpi->enc_act_queue_size =
	(mi_params->mb_cols / 3 + 1) * (mi_params->mb_rows / 3 + 1);
	}
	#endif // CONFIG_BRU
	static AOM_INLINE void alloc_compound_type_rd_buffers(
	AV1_COMMON const cm, CompoundTypeRdBuffers const bufs) {
	CHECK_MEM_ERROR(
	cm, bufs->pred0,
	(uint16_t )aom_memalign(16, MAX_SB_SQUARE sizeof(*bufs->pred0)));
	CHECK_MEM_ERROR(
	cm, bufs->pred1,
	(uint16_t )aom_memalign(16, MAX_SB_SQUARE sizeof(*bufs->pred1)));
	CHECK_MEM_ERROR(
	cm, bufs->residual1,
	(int16_t )aom_memalign(32, MAX_SB_SQUARE sizeof(*bufs->residual1)));
	CHECK_MEM_ERROR(
	cm, bufs->diff10,
	(int16_t )aom_memalign(32, MAX_SB_SQUARE sizeof(*bufs->diff10)));
	CHECK_MEM_ERROR(cm, bufs->tmp_best_mask_buf,
	(uint8_t )aom_malloc(2 MAX_SB_SQUARE *
	sizeof(*bufs->tmp_best_mask_buf)));
	}

	static AOM_INLINE void release_compound_type_rd_buffers(
	CompoundTypeRdBuffers *const bufs) {
	aom_free(bufs->pred0);
	aom_free(bufs->pred1);
	aom_free(bufs->residual1);
	aom_free(bufs->diff10);
	aom_free(bufs->tmp_best_mask_buf);
	av1_zero(*bufs); // Set all pointers to NULL for safety.
	}

	static AOM_INLINE void dealloc_compressor_data(AV1_COMP *cpi) {
	AV1_COMMON *const cm = &cpi->common;
	TokenInfo *token_info = &cpi->token_info;

	dealloc_context_buffers_ext(&cpi->mbmi_ext_info);

	aom_free(cpi->tile_data);
	cpi->tile_data = NULL;

	// Delete sementation map
	aom_free(cpi->enc_seg.map);
	cpi->enc_seg.map = NULL;
	#if CONFIG_BRU
	// have to make sure empty queue
	for (uint32_t r = 0; r < cpi->enc_act_queue_size; r++) {
	ARD_Queue *q = cpi->enc_act_sb_queue[r];
	if (q != NULL) {
	while (!ard_is_queue_empty(q)) {
	ard_dequeue(q);
	}
	cpi->enc_act_sb_queue[r] = NULL;
	}
	}
	aom_free(cpi->enc_act_sb_queue);
	cpi->enc_act_sb_queue = NULL;
	#endif // CONFIG_BRU

	av1_cyclic_refresh_free(cpi->cyclic_refresh);
	cpi->cyclic_refresh = NULL;

	aom_free(cpi->active_map.map);
	cpi->active_map.map = NULL;

	aom_free(cpi->ssim_rdmult_scaling_factors);
	cpi->ssim_rdmult_scaling_factors = NULL;

	aom_free(cpi->tpl_rdmult_scaling_factors);
	cpi->tpl_rdmult_scaling_factors = NULL;

	aom_free(cpi->tpl_sb_rdmult_scaling_factors);
	cpi->tpl_sb_rdmult_scaling_factors = NULL;

	#if CONFIG_TUNE_VMAF
	aom_free(cpi->vmaf_info.rdmult_scaling_factors);
	cpi->vmaf_info.rdmult_scaling_factors = NULL;

	#if CONFIG_USE_VMAF_RC
	aom_close_vmaf_model_rc(cpi->vmaf_info.vmaf_model);
	#endif
	#endif
	#if CONFIG_BRU
	BruInfo *bru_info = &cpi->common.bru;
	aom_free(bru_info->active_mode_map);
	bru_info->active_mode_map = NULL;
	aom_free(bru_info->active_region);
	bru_info->active_region = NULL;
	#endif // CONFIG_BRU

	aom_free(cpi->td.mb.inter_modes_info);
	cpi->td.mb.inter_modes_info = NULL;

	for (int i = 0; i < 2; i++)
	for (int j = 0; j < 2; j++) {
	aom_free(cpi->td.mb.intrabc_hash_info.hash_value_buffer[i][j]);
	cpi->td.mb.intrabc_hash_info.hash_value_buffer[i][j] = NULL;
	}

	aom_free(cm->tpl_mvs);
	cm->tpl_mvs = NULL;
	#if CONFIG_MV_TRAJECTORY
	for (int rf = 0; rf < INTER_REFS_PER_FRAME; rf++) {
	aom_free(cm->id_offset_map[rf]);
	cm->id_offset_map[rf] = NULL;
	#if CONFIG_TMVP_SIMPLIFICATIONS_F085
	for (int k = 0; k < 3; k++) {
	aom_free(cm->blk_id_map[k][rf]);
	cm->blk_id_map[k][rf] = NULL;
	}
	#else
	aom_free(cm->blk_id_map[rf]);
	cm->blk_id_map[rf] = NULL;
	#endif // CONFIG_TMVP_SIMPLIFICATIONS_F085
	}
	#endif // CONFIG_MV_TRAJECTORY

	aom_free(cm->tip_ref.mf_need_clamp);
	cm->tip_ref.mf_need_clamp = NULL;

	aom_free(cpi->td.mb.mbmi_ext);
	cpi->td.mb.mbmi_ext = NULL;

	av1_free_pmc(cpi->td.firstpass_ctx, av1_num_planes(cm));
	cpi->td.firstpass_ctx = NULL;

	av1_free_ref_frame_buffers(cm->buffer_pool);
	av1_free_txb_buf(cpi);
	av1_free_context_buffers(cm);

	aom_free_frame_buffer(&cpi->last_frame_uf);
	av1_free_restoration_buffers(cm);
	#if CONFIG_GDF
	free_gdf_buffers(&cm->gdf_info);
	#endif // CONFIG_GDF
	aom_free_frame_buffer(&cpi->trial_frame_rst);
	aom_free_frame_buffer(&cpi->scaled_source);
	aom_free_frame_buffer(&cpi->scaled_last_source);
	aom_free_frame_buffer(&cpi->alt_ref_buffer);
	av1_lookahead_destroy(cpi->lookahead);

	free_token_info(token_info);

	av1_free_shared_coeff_buffer(&cpi->td.shared_coeff_buf);
	av1_free_sms_tree(&cpi->td);
	av1_free_sms_bufs(&cpi->td);
	#if CONFIG_ML_PART_SPLIT
	av2_part_split_prune_tflite_close(&(cpi->td.partition_model));
	#endif // CONFIG_ML_PART_SPLIT
	#if CONFIG_DIP_EXT_PRUNING
	intra_dip_mode_prune_close(&(cpi->td.dip_pruning_model));
	#endif // CONFIG_DIP_EXT_PRUNING
	aom_free(cpi->td.mb.palette_buffer);
	release_compound_type_rd_buffers(&cpi->td.mb.comp_rd_buffer);
	aom_free(cpi->td.mb.tmp_conv_dst);
	aom_free(cpi->td.mb.upsample_pred);
	aom_free(cpi->td.mb.coef_info);

	// Temporary buffers used during the DMVR and OPFL processing.
	aom_free(cpi->td.mb.opfl_vxy_bufs);
	aom_free(cpi->td.mb.opfl_gxy_bufs);
	aom_free(cpi->td.mb.opfl_dst_bufs);
	for (int j = 0; j < 2; ++j) {
	aom_free(cpi->td.mb.tmp_pred_bufs[j]);
	}

	#if CONFIG_DENOISE
	if (cpi->denoise_and_model) {
	aom_denoise_and_model_free(cpi->denoise_and_model);
	cpi->denoise_and_model = NULL;
	}
	#endif
	if (cpi->film_grain_table) {
	aom_film_grain_table_free(cpi->film_grain_table);
	cpi->film_grain_table = NULL;
	}

	for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) {
	aom_free(cpi->level_params.level_info[i]);
	}

	if (cpi->consec_zero_mv) {
	aom_free(cpi->consec_zero_mv);
	cpi->consec_zero_mv = NULL;
	}
	cpi->alloc_width = 0;
	cpi->alloc_height = 0;
	cpi->alloc_sb_size = 0;

	av1_free_qm(cm->seq_params.quantizer_matrix_8x8);
	av1_free_qm(cm->seq_params.quantizer_matrix_8x4);
	av1_free_qm(cm->seq_params.quantizer_matrix_4x8);
	}

	static AOM_INLINE void alloc_altref_frame_buffer(AV1_COMP *cpi) {
	AV1_COMMON *cm = &cpi->common;
	const SequenceHeader *const seq_params = &cm->seq_params;
	const AV1EncoderConfig *oxcf = &cpi->oxcf;

	// TODO(agrange) Check if ARF is enabled and skip allocation if not.
	if (aom_realloc_frame_buffer(
	&cpi->alt_ref_buffer, oxcf->frm_dim_cfg.width,
	oxcf->frm_dim_cfg.height, seq_params->subsampling_x,
	seq_params->subsampling_y, cpi->oxcf.border_in_pixels,
	cm->features.byte_alignment, NULL, NULL, NULL, cpi->alloc_pyramid))
	aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
	"Failed to allocate altref buffer");
	}

	static AOM_INLINE void alloc_util_frame_buffers(AV1_COMP *cpi) {
	AV1_COMMON *const cm = &cpi->common;
	const SequenceHeader *const seq_params = &cm->seq_params;
	const int byte_alignment = cm->features.byte_alignment;
	if (aom_realloc_frame_buffer(
	&cpi->last_frame_uf, cm->width, cm->height, seq_params->subsampling_x,
	seq_params->subsampling_y, cpi->oxcf.border_in_pixels, byte_alignment,
	NULL, NULL, NULL, false))
	aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
	"Failed to allocate last frame buffer");

	if (aom_realloc_frame_buffer(
	&cpi->trial_frame_rst,
	#if CONFIG_ENABLE_SR
	cm->superres_upscaled_width, cm->superres_upscaled_height,
	#else
	cm->width, cm->height,
	#endif // CONFIG_ENABLE_SR
	seq_params->subsampling_x, seq_params->subsampling_y,
	AOM_RESTORATION_FRAME_BORDER, byte_alignment, NULL, NULL, NULL,
	false))
	aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
	"Failed to allocate trial restored frame buffer");

	if (aom_realloc_frame_buffer(
	&cpi->scaled_source, cm->width, cm->height, seq_params->subsampling_x,
	seq_params->subsampling_y, cpi->oxcf.border_in_pixels, byte_alignment,
	NULL, NULL, NULL, cpi->alloc_pyramid))
	aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
	"Failed to allocate scaled source buffer");

	if (aom_realloc_frame_buffer(&cpi->scaled_last_source, cm->width, cm->height,
	seq_params->subsampling_x,
	seq_params->subsampling_y,
	cpi->oxcf.border_in_pixels, byte_alignment, NULL,
	NULL, NULL, cpi->alloc_pyramid))
	aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
	"Failed to allocate scaled last source buffer");
	}

	static AOM_INLINE YV12_BUFFER_CONFIG *realloc_and_scale_source(
	AV1_COMP *cpi, int scaled_width, int scaled_height) {
	AV1_COMMON *cm = &cpi->common;
	const int num_planes = av1_num_planes(cm);

	if (scaled_width == cpi->unscaled_source->y_crop_width &&
	scaled_height == cpi->unscaled_source->y_crop_height) {
	return cpi->unscaled_source;
	}

	if (aom_realloc_frame_buffer(
	&cpi->scaled_source, scaled_width, scaled_height,
	cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
	AOM_BORDER_IN_PIXELS, cm->features.byte_alignment, NULL, NULL, NULL,
	cpi->alloc_pyramid))
	aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
	"Failed to reallocate scaled source buffer");
	assert(cpi->scaled_source.y_crop_width == scaled_width);
	assert(cpi->scaled_source.y_crop_height == scaled_height);
	av1_resize_and_extend_frame_nonnormative(
	cpi->unscaled_source, &cpi->scaled_source, (int)cm->seq_params.bit_depth,
	num_planes);
	return &cpi->scaled_source;
	}

	#ifdef __cplusplus
	} // extern "C"
	#endif

	#endif // AOM_AV1_ENCODER_ENCODER_ALLOC_H_