tokenize.h - mozsearch

Enable keyboard shortcuts

/*

 * 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.

*/

#ifndef AOM_AV1_ENCODER_TOKENIZE_H_

#define AOM_AV1_ENCODER_TOKENIZE_H_

#include "av1/common/entropy.h"

#include "av1/encoder/block.h"

#include "aom_dsp/bitwriter.h"

#ifdef __cplusplus

extern "C" {

#endif

// The token and color_ctx members of the TokenExtra structure are used

// to store the indices of color and color context of each pixel in

// case of palette mode.

// 1) token can take values in the range of [0, 7] as maximum number of possible

// colors is 8 (PALETTE_COLORS). Hence token requires 3 bits (unsigned).

// 2) The reserved field (1-bit) is positioned such that color_ctx occupies the

// most significant bits and token occupies the least significant bits of the

// byte. Thus accesses to token and color_ctx are optimal. If TokenExtra is

// defined as:

//   typedef struct {

//     int8_t color_ctx : 4;

//     uint8_t token : 3;

//   } TokenExtra;

// then read of color_ctx requires an extra left shift to facilitate sign

// extension and write of token requires an extra masking.

// 3) color_ctx can take 5 (PALETTE_COLOR_INDEX_CONTEXTS) valid values, i.e.,

// from 0 to 4. As per the current implementation it can take values in the

// range of [-1, 4]. Here -1 corresponds to invalid color index context and is

// used for default initialization. Hence color_ctx requires 4 bits (signed).

typedef struct {

  uint8_t token : 3;

  uint8_t reserved : 1;

  int8_t color_ctx : 4;

} TokenExtra;

typedef struct {

  TokenExtra *start;

  unsigned int count;

} TokenList;

typedef struct {

  // Number of tile tokens for which memory is allocated.

  unsigned int tokens_allocated;

  // tile_tok[i][j] is a pointer to the buffer storing palette tokens of the ith

  // tile row, jth tile column.

  TokenExtra *tile_tok[MAX_TILE_ROWS][MAX_TILE_COLS];

  // tplist[i][j][k] holds the start pointer of tile_tok[i][j] and the count of

  // palette tokens for the kth superblock row of the ith tile row, jth tile

  // column.

  TokenList *tplist[MAX_TILE_ROWS][MAX_TILE_COLS];

} TokenInfo;

struct AV1_COMP;

struct ThreadData;

struct FRAME_COUNTS;

enum {

  OUTPUT_ENABLED = 0,

  DRY_RUN_NORMAL,

  DRY_RUN_COSTCOEFFS,

} UENUM1BYTE(RUN_TYPE);

struct tokenize_b_args {

  const struct AV1_COMP *cpi;

  struct ThreadData *td;

  int this_rate;

  uint8_t allow_update_cdf;

  RUN_TYPE dry_run;

};

// Note in all the tokenize functions rate if non NULL is incremented

// with the coefficient token cost only if dry_run = DRY_RUN_COSTCOEFS,

// otherwise rate is not incremented.

void av1_tokenize_sb_vartx(const struct AV1_COMP *cpi, struct ThreadData *td,

                           RUN_TYPE dry_run, BLOCK_SIZE bsize, int *rate,

                           uint8_t allow_update_cdf);

int av1_cost_color_map(const MACROBLOCK *const x, int plane, BLOCK_SIZE bsize,

                       TX_SIZE tx_size, COLOR_MAP_TYPE type);

void av1_tokenize_color_map(const MACROBLOCK *const x, int plane,

                            TokenExtra **t, BLOCK_SIZE bsize, TX_SIZE tx_size,

                            COLOR_MAP_TYPE type, int allow_update_cdf,

                            struct FRAME_COUNTS *counts);

static inline int av1_get_tx_eob(const struct segmentation *seg, int segment_id,

                                 TX_SIZE tx_size) {

  const int eob_max = av1_get_max_eob(tx_size);

  return segfeature_active(seg, segment_id, SEG_LVL_SKIP) ? 0 : eob_max;

// Token buffer is only used for palette tokens.

static inline unsigned int get_token_alloc(int mb_rows, int mb_cols,

                                           int sb_size_log2,

                                           const int num_planes) {

  // Calculate the maximum number of max superblocks in the image.

  const int shift = sb_size_log2 - 4;

  const int sb_size = 1 << sb_size_log2;

  const int sb_size_square = sb_size * sb_size;

  const int sb_rows = CEIL_POWER_OF_TWO(mb_rows, shift);

  const int sb_cols = CEIL_POWER_OF_TWO(mb_cols, shift);

  // One palette token for each pixel. There can be palettes on two planes.

  const int sb_palette_toks = AOMMIN(2, num_planes) * sb_size_square;

  return sb_rows * sb_cols * sb_palette_toks;

// Allocate memory for token related info.

static inline void alloc_token_info(AV1_COMMON *cm, TokenInfo *token_info,

                                    unsigned int tokens_required) {

  int sb_rows =

      CEIL_POWER_OF_TWO(cm->mi_params.mi_rows, cm->seq_params->mib_size_log2);

  token_info->tokens_allocated = tokens_required;

  CHECK_MEM_ERROR(cm, token_info->tile_tok[0][0],

                  (TokenExtra *)aom_calloc(

                      tokens_required, sizeof(*token_info->tile_tok[0][0])));

  CHECK_MEM_ERROR(

      cm, token_info->tplist[0][0],

      (TokenList *)aom_calloc(sb_rows * MAX_TILE_ROWS * MAX_TILE_COLS,

                              sizeof(*token_info->tplist[0][0])));

// Check if memory allocation has been done for token related info.

static inline bool is_token_info_allocated(const TokenInfo *token_info) {

  return ((token_info->tile_tok[0][0] != NULL) &&

          (token_info->tplist[0][0] != NULL));

// Free memory from token related variables.

static inline void free_token_info(TokenInfo *token_info) {

  aom_free(token_info->tile_tok[0][0]);

  token_info->tile_tok[0][0] = NULL;

  aom_free(token_info->tplist[0][0]);

  token_info->tplist[0][0] = NULL;

  token_info->tokens_allocated = 0;

#ifdef __cplusplus

}  // extern "C"

#endif

#endif  // AOM_AV1_ENCODER_TOKENIZE_H_