av1/encoder/context_tree.c - aom - Git at Google

 /*
  * 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 "av1/encoder/context_tree.h"
 #include "av1/encoder/encoder.h"

 static const BLOCK_SIZE square[MAX_SB_SIZE_LOG2 - 1] = {
   BLOCK_4X4, BLOCK_8X8, BLOCK_16X16, BLOCK_32X32, BLOCK_64X64, BLOCK_128X128,
 };

 void av1_copy_tree_context(PICK_MODE_CONTEXT *dst_ctx,
                            PICK_MODE_CONTEXT *src_ctx) {
   dst_ctx->mic = src_ctx->mic;
   dst_ctx->mbmi_ext_best = src_ctx->mbmi_ext_best;

   dst_ctx->num_4x4_blk = src_ctx->num_4x4_blk;
   dst_ctx->skippable = src_ctx->skippable;
 #if CONFIG_INTERNAL_STATS
   dst_ctx->best_mode_index = src_ctx->best_mode_index;
 #endif  // CONFIG_INTERNAL_STATS

   memcpy(dst_ctx->blk_skip, src_ctx->blk_skip,
          sizeof(uint8_t) * src_ctx->num_4x4_blk);
   av1_copy_array(dst_ctx->tx_type_map, src_ctx->tx_type_map,
                  src_ctx->num_4x4_blk);

   dst_ctx->hybrid_pred_diff = src_ctx->hybrid_pred_diff;
   dst_ctx->comp_pred_diff = src_ctx->comp_pred_diff;
   dst_ctx->single_pred_diff = src_ctx->single_pred_diff;

   dst_ctx->rd_stats = src_ctx->rd_stats;
   dst_ctx->rd_mode_is_ready = src_ctx->rd_mode_is_ready;
 }

 void av1_setup_shared_coeff_buffer(AV1_COMMON *cm,
                                    PC_TREE_SHARED_BUFFERS *shared_bufs) {
   for (int i = 0; i < 3; i++) {
     const int max_num_pix = MAX_SB_SIZE * MAX_SB_SIZE;
     CHECK_MEM_ERROR(cm, shared_bufs->coeff_buf[i],
                     aom_memalign(32, max_num_pix * sizeof(tran_low_t)));
     CHECK_MEM_ERROR(cm, shared_bufs->qcoeff_buf[i],
                     aom_memalign(32, max_num_pix * sizeof(tran_low_t)));
     CHECK_MEM_ERROR(cm, shared_bufs->dqcoeff_buf[i],
                     aom_memalign(32, max_num_pix * sizeof(tran_low_t)));
   }
 }

 void av1_free_shared_coeff_buffer(PC_TREE_SHARED_BUFFERS *shared_bufs) {
   for (int i = 0; i < 3; i++) {
     aom_free(shared_bufs->coeff_buf[i]);
     aom_free(shared_bufs->qcoeff_buf[i]);
     aom_free(shared_bufs->dqcoeff_buf[i]);
     shared_bufs->coeff_buf[i] = NULL;
     shared_bufs->qcoeff_buf[i] = NULL;
     shared_bufs->dqcoeff_buf[i] = NULL;
   }
 }

 PICK_MODE_CONTEXT *av1_alloc_pmc(const AV1_COMMON *cm, BLOCK_SIZE bsize,
                                  PC_TREE_SHARED_BUFFERS *shared_bufs) {
   PICK_MODE_CONTEXT *ctx = NULL;
   struct aom_internal_error_info error;

   AOM_CHECK_MEM_ERROR(&error, ctx, aom_calloc(1, sizeof(*ctx)));
   ctx->rd_mode_is_ready = 0;

   const int num_planes = av1_num_planes(cm);
   const int num_pix = block_size_wide[bsize] * block_size_high[bsize];
   const int num_blk = num_pix / 16;

   AOM_CHECK_MEM_ERROR(&error, ctx->blk_skip,
                       aom_calloc(num_blk, sizeof(*ctx->blk_skip)));
   AOM_CHECK_MEM_ERROR(&error, ctx->tx_type_map,
                       aom_calloc(num_blk, sizeof(*ctx->tx_type_map)));
   ctx->num_4x4_blk = num_blk;

   for (int i = 0; i < num_planes; ++i) {
     ctx->coeff[i] = shared_bufs->coeff_buf[i];
     ctx->qcoeff[i] = shared_bufs->qcoeff_buf[i];
     ctx->dqcoeff[i] = shared_bufs->dqcoeff_buf[i];
     AOM_CHECK_MEM_ERROR(&error, ctx->eobs[i],
                         aom_memalign(32, num_blk * sizeof(*ctx->eobs[i])));
     AOM_CHECK_MEM_ERROR(
         &error, ctx->txb_entropy_ctx[i],
         aom_memalign(32, num_blk * sizeof(*ctx->txb_entropy_ctx[i])));
   }

   if (num_pix <= MAX_PALETTE_SQUARE) {
     for (int i = 0; i < 2; ++i) {
       AOM_CHECK_MEM_ERROR(
           &error, ctx->color_index_map[i],
           aom_memalign(32, num_pix * sizeof(*ctx->color_index_map[i])));
     }
   }

   return ctx;
 }

 void av1_free_pmc(PICK_MODE_CONTEXT *ctx, int num_planes) {
   if (ctx == NULL) return;

   aom_free(ctx->blk_skip);
   ctx->blk_skip = NULL;
   aom_free(ctx->tx_type_map);
   for (int i = 0; i < num_planes; ++i) {
     ctx->coeff[i] = NULL;
     ctx->qcoeff[i] = NULL;
     ctx->dqcoeff[i] = NULL;
     aom_free(ctx->eobs[i]);
     ctx->eobs[i] = NULL;
     aom_free(ctx->txb_entropy_ctx[i]);
     ctx->txb_entropy_ctx[i] = NULL;
   }

   for (int i = 0; i < 2; ++i) {
     aom_free(ctx->color_index_map[i]);
     ctx->color_index_map[i] = NULL;
   }

   aom_free(ctx);
 }

 PC_TREE *av1_alloc_pc_tree_node(BLOCK_SIZE bsize) {
   PC_TREE *pc_tree = NULL;
   struct aom_internal_error_info error;

   AOM_CHECK_MEM_ERROR(&error, pc_tree, aom_calloc(1, sizeof(*pc_tree)));

   pc_tree->partitioning = PARTITION_NONE;
   pc_tree->block_size = bsize;
   pc_tree->index = 0;

   pc_tree->none = NULL;
   for (int i = 0; i < 2; ++i) {
     pc_tree->horizontal[i] = NULL;
     pc_tree->vertical[i] = NULL;
   }
   for (int i = 0; i < 3; ++i) {
     pc_tree->horizontala[i] = NULL;
     pc_tree->horizontalb[i] = NULL;
     pc_tree->verticala[i] = NULL;
     pc_tree->verticalb[i] = NULL;
   }
   for (int i = 0; i < 4; ++i) {
     pc_tree->horizontal4[i] = NULL;
     pc_tree->vertical4[i] = NULL;
     pc_tree->split[i] = NULL;
   }

   return pc_tree;
 }

 #define FREE_PMC_NODE(CTX)         \
   do {                             \
     av1_free_pmc(CTX, num_planes); \
     CTX = NULL;                    \
   } while (0)

 void av1_free_pc_tree_recursive(PC_TREE *pc_tree, int num_planes, int keep_best,
                                 int keep_none) {
   if (pc_tree == NULL) return;

   const PARTITION_TYPE partition = pc_tree->partitioning;

   if (!keep_none && (!keep_best || (partition != PARTITION_NONE)))
     FREE_PMC_NODE(pc_tree->none);

   for (int i = 0; i < 2; ++i) {
     if (!keep_best || (partition != PARTITION_HORZ))
       FREE_PMC_NODE(pc_tree->horizontal[i]);
     if (!keep_best || (partition != PARTITION_VERT))
       FREE_PMC_NODE(pc_tree->vertical[i]);
   }
   for (int i = 0; i < 3; ++i) {
     if (!keep_best || (partition != PARTITION_HORZ_A))
       FREE_PMC_NODE(pc_tree->horizontala[i]);
     if (!keep_best || (partition != PARTITION_HORZ_B))
       FREE_PMC_NODE(pc_tree->horizontalb[i]);
     if (!keep_best || (partition != PARTITION_VERT_A))
       FREE_PMC_NODE(pc_tree->verticala[i]);
     if (!keep_best || (partition != PARTITION_VERT_B))
       FREE_PMC_NODE(pc_tree->verticalb[i]);
   }
   for (int i = 0; i < 4; ++i) {
     if (!keep_best || (partition != PARTITION_HORZ_4))
       FREE_PMC_NODE(pc_tree->horizontal4[i]);
     if (!keep_best || (partition != PARTITION_VERT_4))
       FREE_PMC_NODE(pc_tree->vertical4[i]);
   }

   if (!keep_best || (partition != PARTITION_SPLIT)) {
     for (int i = 0; i < 4; ++i) {
       if (pc_tree->split[i] != NULL) {
         av1_free_pc_tree_recursive(pc_tree->split[i], num_planes, 0, 0);
         pc_tree->split[i] = NULL;
       }
     }
   }

   if (!keep_best && !keep_none) aom_free(pc_tree);
 }

 static AOM_INLINE int get_pc_tree_nodes(const int is_sb_size_128,
                                         int stat_generation_stage) {
   const int tree_nodes_inc = is_sb_size_128 ? 1024 : 0;
   const int tree_nodes =
       stat_generation_stage ? 1 : (tree_nodes_inc + 256 + 64 + 16 + 4 + 1);
   return tree_nodes;
 }

 void av1_setup_sms_tree(AV1_COMP *const cpi, ThreadData *td) {
   AV1_COMMON *const cm = &cpi->common;
   const int stat_generation_stage = is_stat_generation_stage(cpi);
   const int is_sb_size_128 = cm->seq_params.sb_size == BLOCK_128X128;
   const int tree_nodes =
       get_pc_tree_nodes(is_sb_size_128, stat_generation_stage);
   int sms_tree_index = 0;
   SIMPLE_MOTION_DATA_TREE *this_sms;
   int square_index = 1;
   int nodes;

   aom_free(td->sms_tree);
   CHECK_MEM_ERROR(cm, td->sms_tree,
                   aom_calloc(tree_nodes, sizeof(*td->sms_tree)));
   this_sms = &td->sms_tree[0];

   if (!stat_generation_stage) {
     const int leaf_factor = is_sb_size_128 ? 4 : 1;
     const int leaf_nodes = 256 * leaf_factor;

     // Sets up all the leaf nodes in the tree.
     for (sms_tree_index = 0; sms_tree_index < leaf_nodes; ++sms_tree_index) {
       SIMPLE_MOTION_DATA_TREE *const tree = &td->sms_tree[sms_tree_index];
       tree->block_size = square[0];
     }

     // Each node has 4 leaf nodes, fill each block_size level of the tree
     // from leafs to the root.
     for (nodes = leaf_nodes >> 2; nodes > 0; nodes >>= 2) {
       for (int i = 0; i < nodes; ++i) {
         SIMPLE_MOTION_DATA_TREE *const tree = &td->sms_tree[sms_tree_index];
         tree->block_size = square[square_index];
         for (int j = 0; j < 4; j++) tree->split[j] = this_sms++;
         ++sms_tree_index;
       }
       ++square_index;
     }
   } else {
     // Allocation for firstpass/LAP stage
     // TODO(Mufaddal): refactor square_index to use a common block_size macro
     // from firstpass.c
     SIMPLE_MOTION_DATA_TREE *const tree = &td->sms_tree[sms_tree_index];
     square_index = 2;
     tree->block_size = square[square_index];
   }

   // Set up the root node for the largest superblock size
   td->sms_root = &td->sms_tree[tree_nodes - 1];
 }

 void av1_free_sms_tree(ThreadData *td) {
   if (td->sms_tree != NULL) {
     aom_free(td->sms_tree);
     td->sms_tree = NULL;
   }
 }
	/*
	* 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 "av1/encoder/context_tree.h"
	#include "av1/encoder/encoder.h"

	static const BLOCK_SIZE square[MAX_SB_SIZE_LOG2 - 1] = {
	BLOCK_4X4, BLOCK_8X8, BLOCK_16X16, BLOCK_32X32, BLOCK_64X64, BLOCK_128X128,
	};

	void av1_copy_tree_context(PICK_MODE_CONTEXT *dst_ctx,
	PICK_MODE_CONTEXT *src_ctx) {
	dst_ctx->mic = src_ctx->mic;
	dst_ctx->mbmi_ext_best = src_ctx->mbmi_ext_best;

	dst_ctx->num_4x4_blk = src_ctx->num_4x4_blk;
	dst_ctx->skippable = src_ctx->skippable;
	#if CONFIG_INTERNAL_STATS
	dst_ctx->best_mode_index = src_ctx->best_mode_index;
	#endif // CONFIG_INTERNAL_STATS

	memcpy(dst_ctx->blk_skip, src_ctx->blk_skip,
	sizeof(uint8_t) * src_ctx->num_4x4_blk);
	av1_copy_array(dst_ctx->tx_type_map, src_ctx->tx_type_map,
	src_ctx->num_4x4_blk);

	dst_ctx->hybrid_pred_diff = src_ctx->hybrid_pred_diff;
	dst_ctx->comp_pred_diff = src_ctx->comp_pred_diff;
	dst_ctx->single_pred_diff = src_ctx->single_pred_diff;

	dst_ctx->rd_stats = src_ctx->rd_stats;
	dst_ctx->rd_mode_is_ready = src_ctx->rd_mode_is_ready;
	}

	void av1_setup_shared_coeff_buffer(AV1_COMMON *cm,
	PC_TREE_SHARED_BUFFERS *shared_bufs) {
	for (int i = 0; i < 3; i++) {
	const int max_num_pix = MAX_SB_SIZE * MAX_SB_SIZE;
	CHECK_MEM_ERROR(cm, shared_bufs->coeff_buf[i],
	aom_memalign(32, max_num_pix * sizeof(tran_low_t)));
	CHECK_MEM_ERROR(cm, shared_bufs->qcoeff_buf[i],
	aom_memalign(32, max_num_pix * sizeof(tran_low_t)));
	CHECK_MEM_ERROR(cm, shared_bufs->dqcoeff_buf[i],
	aom_memalign(32, max_num_pix * sizeof(tran_low_t)));
	}
	}

	void av1_free_shared_coeff_buffer(PC_TREE_SHARED_BUFFERS *shared_bufs) {
	for (int i = 0; i < 3; i++) {
	aom_free(shared_bufs->coeff_buf[i]);
	aom_free(shared_bufs->qcoeff_buf[i]);
	aom_free(shared_bufs->dqcoeff_buf[i]);
	shared_bufs->coeff_buf[i] = NULL;
	shared_bufs->qcoeff_buf[i] = NULL;
	shared_bufs->dqcoeff_buf[i] = NULL;
	}
	}

	PICK_MODE_CONTEXT av1_alloc_pmc(const AV1_COMMON cm, BLOCK_SIZE bsize,
	PC_TREE_SHARED_BUFFERS *shared_bufs) {
	PICK_MODE_CONTEXT *ctx = NULL;
	struct aom_internal_error_info error;

	AOM_CHECK_MEM_ERROR(&error, ctx, aom_calloc(1, sizeof(*ctx)));
	ctx->rd_mode_is_ready = 0;

	const int num_planes = av1_num_planes(cm);
	const int num_pix = block_size_wide[bsize] * block_size_high[bsize];
	const int num_blk = num_pix / 16;

	AOM_CHECK_MEM_ERROR(&error, ctx->blk_skip,
	aom_calloc(num_blk, sizeof(*ctx->blk_skip)));
	AOM_CHECK_MEM_ERROR(&error, ctx->tx_type_map,
	aom_calloc(num_blk, sizeof(*ctx->tx_type_map)));
	ctx->num_4x4_blk = num_blk;

	for (int i = 0; i < num_planes; ++i) {
	ctx->coeff[i] = shared_bufs->coeff_buf[i];
	ctx->qcoeff[i] = shared_bufs->qcoeff_buf[i];
	ctx->dqcoeff[i] = shared_bufs->dqcoeff_buf[i];
	AOM_CHECK_MEM_ERROR(&error, ctx->eobs[i],
	aom_memalign(32, num_blk * sizeof(*ctx->eobs[i])));
	AOM_CHECK_MEM_ERROR(
	&error, ctx->txb_entropy_ctx[i],
	aom_memalign(32, num_blk * sizeof(*ctx->txb_entropy_ctx[i])));
	}

	if (num_pix <= MAX_PALETTE_SQUARE) {
	for (int i = 0; i < 2; ++i) {
	AOM_CHECK_MEM_ERROR(
	&error, ctx->color_index_map[i],
	aom_memalign(32, num_pix * sizeof(*ctx->color_index_map[i])));
	}
	}

	return ctx;
	}

	void av1_free_pmc(PICK_MODE_CONTEXT *ctx, int num_planes) {
	if (ctx == NULL) return;

	aom_free(ctx->blk_skip);
	ctx->blk_skip = NULL;
	aom_free(ctx->tx_type_map);
	for (int i = 0; i < num_planes; ++i) {
	ctx->coeff[i] = NULL;
	ctx->qcoeff[i] = NULL;
	ctx->dqcoeff[i] = NULL;
	aom_free(ctx->eobs[i]);
	ctx->eobs[i] = NULL;
	aom_free(ctx->txb_entropy_ctx[i]);
	ctx->txb_entropy_ctx[i] = NULL;
	}

	for (int i = 0; i < 2; ++i) {
	aom_free(ctx->color_index_map[i]);
	ctx->color_index_map[i] = NULL;
	}

	aom_free(ctx);
	}

	PC_TREE *av1_alloc_pc_tree_node(BLOCK_SIZE bsize) {
	PC_TREE *pc_tree = NULL;
	struct aom_internal_error_info error;

	AOM_CHECK_MEM_ERROR(&error, pc_tree, aom_calloc(1, sizeof(*pc_tree)));

	pc_tree->partitioning = PARTITION_NONE;
	pc_tree->block_size = bsize;
	pc_tree->index = 0;

	pc_tree->none = NULL;
	for (int i = 0; i < 2; ++i) {
	pc_tree->horizontal[i] = NULL;
	pc_tree->vertical[i] = NULL;
	}
	for (int i = 0; i < 3; ++i) {
	pc_tree->horizontala[i] = NULL;
	pc_tree->horizontalb[i] = NULL;
	pc_tree->verticala[i] = NULL;
	pc_tree->verticalb[i] = NULL;
	}
	for (int i = 0; i < 4; ++i) {
	pc_tree->horizontal4[i] = NULL;
	pc_tree->vertical4[i] = NULL;
	pc_tree->split[i] = NULL;
	}

	return pc_tree;
	}

	#define FREE_PMC_NODE(CTX) \
	do { \
	av1_free_pmc(CTX, num_planes); \
	CTX = NULL; \
	} while (0)

	void av1_free_pc_tree_recursive(PC_TREE *pc_tree, int num_planes, int keep_best,
	int keep_none) {
	if (pc_tree == NULL) return;

	const PARTITION_TYPE partition = pc_tree->partitioning;

	if (!keep_none && (!keep_best \|\| (partition != PARTITION_NONE)))
	FREE_PMC_NODE(pc_tree->none);

	for (int i = 0; i < 2; ++i) {
	if (!keep_best \|\| (partition != PARTITION_HORZ))
	FREE_PMC_NODE(pc_tree->horizontal[i]);
	if (!keep_best \|\| (partition != PARTITION_VERT))
	FREE_PMC_NODE(pc_tree->vertical[i]);
	}
	for (int i = 0; i < 3; ++i) {
	if (!keep_best \|\| (partition != PARTITION_HORZ_A))
	FREE_PMC_NODE(pc_tree->horizontala[i]);
	if (!keep_best \|\| (partition != PARTITION_HORZ_B))
	FREE_PMC_NODE(pc_tree->horizontalb[i]);
	if (!keep_best \|\| (partition != PARTITION_VERT_A))
	FREE_PMC_NODE(pc_tree->verticala[i]);
	if (!keep_best \|\| (partition != PARTITION_VERT_B))
	FREE_PMC_NODE(pc_tree->verticalb[i]);
	}
	for (int i = 0; i < 4; ++i) {
	if (!keep_best \|\| (partition != PARTITION_HORZ_4))
	FREE_PMC_NODE(pc_tree->horizontal4[i]);
	if (!keep_best \|\| (partition != PARTITION_VERT_4))
	FREE_PMC_NODE(pc_tree->vertical4[i]);
	}

	if (!keep_best \|\| (partition != PARTITION_SPLIT)) {
	for (int i = 0; i < 4; ++i) {
	if (pc_tree->split[i] != NULL) {
	av1_free_pc_tree_recursive(pc_tree->split[i], num_planes, 0, 0);
	pc_tree->split[i] = NULL;
	}
	}
	}

	if (!keep_best && !keep_none) aom_free(pc_tree);
	}

	static AOM_INLINE int get_pc_tree_nodes(const int is_sb_size_128,
	int stat_generation_stage) {
	const int tree_nodes_inc = is_sb_size_128 ? 1024 : 0;
	const int tree_nodes =
	stat_generation_stage ? 1 : (tree_nodes_inc + 256 + 64 + 16 + 4 + 1);
	return tree_nodes;
	}

	void av1_setup_sms_tree(AV1_COMP const cpi, ThreadData td) {
	AV1_COMMON *const cm = &cpi->common;
	const int stat_generation_stage = is_stat_generation_stage(cpi);
	const int is_sb_size_128 = cm->seq_params.sb_size == BLOCK_128X128;
	const int tree_nodes =
	get_pc_tree_nodes(is_sb_size_128, stat_generation_stage);
	int sms_tree_index = 0;
	SIMPLE_MOTION_DATA_TREE *this_sms;
	int square_index = 1;
	int nodes;

	aom_free(td->sms_tree);
	CHECK_MEM_ERROR(cm, td->sms_tree,
	aom_calloc(tree_nodes, sizeof(*td->sms_tree)));
	this_sms = &td->sms_tree[0];

	if (!stat_generation_stage) {
	const int leaf_factor = is_sb_size_128 ? 4 : 1;
	const int leaf_nodes = 256 * leaf_factor;

	// Sets up all the leaf nodes in the tree.
	for (sms_tree_index = 0; sms_tree_index < leaf_nodes; ++sms_tree_index) {
	SIMPLE_MOTION_DATA_TREE *const tree = &td->sms_tree[sms_tree_index];
	tree->block_size = square[0];
	}

	// Each node has 4 leaf nodes, fill each block_size level of the tree
	// from leafs to the root.
	for (nodes = leaf_nodes >> 2; nodes > 0; nodes >>= 2) {
	for (int i = 0; i < nodes; ++i) {
	SIMPLE_MOTION_DATA_TREE *const tree = &td->sms_tree[sms_tree_index];
	tree->block_size = square[square_index];
	for (int j = 0; j < 4; j++) tree->split[j] = this_sms++;
	++sms_tree_index;
	}
	++square_index;
	}
	} else {
	// Allocation for firstpass/LAP stage
	// TODO(Mufaddal): refactor square_index to use a common block_size macro
	// from firstpass.c
	SIMPLE_MOTION_DATA_TREE *const tree = &td->sms_tree[sms_tree_index];
	square_index = 2;
	tree->block_size = square[square_index];
	}

	// Set up the root node for the largest superblock size
	td->sms_root = &td->sms_tree[tree_nodes - 1];
	}

	void av1_free_sms_tree(ThreadData *td) {
	if (td->sms_tree != NULL) {
	aom_free(td->sms_tree);
	td->sms_tree = NULL;
	}
	}