/*

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

#define AOM_AV1_ENCODER_HASH_MOTION_H_

#include <stdbool.h>

#include "aom/aom_integer.h"

#include "aom_scale/yv12config.h"

#include "av1/encoder/hash.h"

#ifdef __cplusplus

extern "C" {

#endif

// Block size used for force_integer_mv decisions

#define FORCE_INT_MV_DECISION_BLOCK_SIZE 8

// store a block's hash info.

// x and y are the position from the top left of the picture

// hash_value2 is used to store the second hash value

typedef struct _block_hash {

  int16_t x;

  int16_t y;

  uint32_t hash_value2;

} block_hash;

// The rectangle of the frame, in luma pixels, that a hash table takes its

// blocks from. The end values are exclusive.

typedef struct {

  int x_start;

  int y_start;

  int x_end;

  int y_end;

} IntraBCHashRegion;

// The most tables built for a frame, to keep the memory down. Frames with more

// tiles than this let neighboring tiles share a table.

#define MAX_INTRABC_HASH_TABLES 16

// A table keeps its buffers from frame to frame. cpi->td.mb owns it and frees

// it with the encoder. The encoder threads build the tables before the tiles

// are encoded, one table at a time per thread. After that they only read them

// through the tile_tables pointer in their own MACROBLOCK, so a table must not

// change while the tiles are encoded.

typedef struct _hash_table {

  // For each block size from 4x4 to 128x128, the number of entries in each

  // bucket and the index of the first one. Each array has 1 << 16 elements,

  // one for each bucket. NULL for the sizes not built.

  uint16_t *bucket_count[6];

  uint32_t *bucket_start[6];

  // The entries of each block size, stored bucket after bucket, and how many

  // entries each array has room for.

  block_hash *block_hashes[6];

  uint32_t block_hashes_size[6];

} hash_table;

struct intrabc_hash_info;

typedef struct intrabc_hash_info {

  // buffer for hash value calculation of a block

  // used only in av1_get_block_hash_value()

  // [two buffers used ping-pong]

  // buffers are AOM_BUFFER_SIZE_FOR_BLOCK_HASH elements long

  uint32_t *hash_value_buffer[2];

  // The tables in raster order, table_cols x table_rows of them. Each one

  // covers a rectangle of tile_cols_per_table x tile_rows_per_table tiles.

  // Every tile has its own table unless the frame has more than

  // MAX_INTRABC_HASH_TABLES tiles.

  hash_table *tile_tables;

  int num_tile_tables;

  int table_cols;

  int table_rows;

  int tile_cols_per_table;

  int tile_rows_per_table;

  // Hash values of every position of the frame, only needed while the tables

  // are built. The first buffer holds the 8x8 hashes. The second one holds the

  // 4x4 hashes when the 4x4 table is built, and the two are used alternately

  // for the sizes above 8x8. It is NULL when neither is needed. Both cover

  // the luma size of the source frame they were allocated for,

  // frame_hash_width x frame_hash_height. Both sizes are 0 when the buffers

  // are freed.

  uint32_t *frame_hash_buffer[2];

  int frame_hash_width;

  int frame_hash_height;

  CRC32C crc_calculator;

  int crc_initialized;

} IntraBCHashInfo;

// Returns the index of the table that covers the given tile.

static inline int av1_intrabc_hash_table_idx(

    const IntraBCHashInfo *intra_bc_hash_info, int tile_row, int tile_col) {

  return tile_row / intra_bc_hash_info->tile_rows_per_table *

             intra_bc_hash_info->table_cols +

         tile_col / intra_bc_hash_info->tile_cols_per_table;

}

Unexecuted instantiation: av1_quantize.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: encodetxb.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: pickrst.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: rd.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: rdopt.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: temporal_filter.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: tokenize.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: tpl_model.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: tx_search.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: txb_rdopt.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: intra_mode_search.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: var_based_part.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: av1_noise_estimate.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: intra_mode_search_sse2.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: temporal_filter_sse2.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: highbd_temporal_filter_sse2.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: rdopt_sse4.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: pickrst_sse4.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: rdopt_avx2.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: temporal_filter_avx2.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: pickrst_avx2.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: highbd_temporal_filter_avx2.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: bitstream.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: compound_type.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: encodeframe.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: encodeframe_utils.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: encodemb.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: encodemv.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: encode_strategy.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: encoder.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: encoder_utils.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: ethread.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: firstpass.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: global_motion_facade.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: gop_structure.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: hash_motion.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: interp_search.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: level.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: lookahead.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: mcomp.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: motion_search_facade.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: mv_prec.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: palette.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: partition_search.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: partition_strategy.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: pass2_strategy.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: pickcdef.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: picklpf.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: ratectrl.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: nonrd_pickmode.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: nonrd_opt.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: segmentation.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: speed_features.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: superres_scale.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: svc_layercontext.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: aq_complexity.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: aq_cyclicrefresh.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: aq_variance.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: allintra_vis.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: context_tree.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: global_motion.c:av1_intrabc_hash_table_idx

Unexecuted instantiation: av1_cx_iface.c:av1_intrabc_hash_table_idx

void av1_hash_table_init(IntraBCHashInfo *intra_bc_hash_info);

// Makes num_tables empty tables. Their buffers are kept for the next frame

// while the number of tables stays the same.

bool av1_hash_tables_create(IntraBCHashInfo *intra_bc_hash_info,

                            int num_tables);

// Frees the tables and the frame hash buffers.

void av1_hash_tables_destroy(IntraBCHashInfo *intra_bc_hash_info);

int32_t av1_hash_table_count(const hash_table *p_hash_table,

                             uint32_t hash_value);

// Returns the first of the av1_hash_table_count() entries for hash_value.

const block_hash *av1_hash_get_first_block_hash(const hash_table *p_hash_table,

                                                uint32_t hash_value);

// These fill the hash values of the blocks that lie inside region. The stride

// parameters give the distance in values between rows of the hash buffers.

// av1_generate_block_8x8_hash_value() hashes the picture into hash_8x8, and

// into hash_4x4 too unless it is NULL. It returns false if it runs out of

// memory.

bool av1_generate_block_8x8_hash_value(IntraBCHashInfo *intrabc_hash_info,

                                       const YV12_BUFFER_CONFIG *picture,

                                       const IntraBCHashRegion *region,

                                       uint32_t *hash_4x4, uint32_t *hash_8x8,

                                       int pic_block_hash_stride);

// Hashes block_size blocks from the block_size / 2 hashes in src.

void av1_generate_block_hash_value(IntraBCHashInfo *intra_bc_hash_info,

                                   const IntraBCHashRegion *region,

                                   int block_size,

                                   const uint32_t *src_pic_block_hash,

                                   uint32_t *dst_pic_block_hash,

                                   int pic_block_hash_stride);

bool av1_add_to_hash_map_by_row_with_precal_data(

    hash_table *p_hash_table, const uint32_t *pic_hash, int pic_hash_stride,

    const IntraBCHashRegion *region, int block_size);

// check whether the block starts from (x_start, y_start) with the size of

// block_size x block_size has the same color in all rows

int av1_hash_is_horizontal_perfect(const YV12_BUFFER_CONFIG *picture,

                                   int block_size, int x_start, int y_start);

// check whether the block starts from (x_start, y_start) with the size of

// block_size x block_size has the same color in all columns

int av1_hash_is_vertical_perfect(const YV12_BUFFER_CONFIG *picture,

                                 int block_size, int x_start, int y_start);

void av1_get_block_hash_value(IntraBCHashInfo *intra_bc_hash_info,

                              const uint8_t *y_src, int stride, int block_size,

                              uint32_t *hash_value1, uint32_t *hash_value2,

                              int use_highbitdepth);

#ifdef __cplusplus

}  // extern "C"

#endif

#endif  // AOM_AV1_ENCODER_HASH_MOTION_H_