mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-10-12 02:07:33 +09:00
Update aom to v1.0.0
Update aom to commit id d14c5bb4f336ef1842046089849dee4a301fbbf0.
This commit is contained in:
trav90
Roy Tam
parent
bb61121b44
commit
48f6d2e034
1087 changed files with 154333 additions and 265310 deletions
205
third_party/aom/av1/encoder/hash_motion.c
vendored
205
third_party/aom/av1/encoder/hash_motion.c
vendored
|
|
@ -1,7 +1,9 @@
|
|||
#include <assert.h>
|
||||
|
||||
#include "config/av1_rtcd.h"
|
||||
|
||||
#include "av1/encoder/hash.h"
|
||||
#include "av1/encoder/hash_motion.h"
|
||||
#include "./av1_rtcd.h"
|
||||
|
||||
static const int crc_bits = 16;
|
||||
static const int block_size_bits = 3;
|
||||
|
|
@ -16,7 +18,7 @@ static void hash_table_clear_all(hash_table *p_hash_table) {
|
|||
int max_addr = 1 << (crc_bits + block_size_bits);
|
||||
for (int i = 0; i < max_addr; i++) {
|
||||
if (p_hash_table->p_lookup_table[i] != NULL) {
|
||||
vector_destroy(p_hash_table->p_lookup_table[i]);
|
||||
aom_vector_destroy(p_hash_table->p_lookup_table[i]);
|
||||
aom_free(p_hash_table->p_lookup_table[i]);
|
||||
p_hash_table->p_lookup_table[i] = NULL;
|
||||
}
|
||||
|
|
@ -37,11 +39,30 @@ static void get_pixels_in_1D_char_array_by_block_2x2(uint8_t *y_src, int stride,
|
|||
}
|
||||
}
|
||||
|
||||
static void get_pixels_in_1D_short_array_by_block_2x2(uint16_t *y_src,
|
||||
int stride,
|
||||
uint16_t *p_pixels_in1D) {
|
||||
uint16_t *p_pel = y_src;
|
||||
int index = 0;
|
||||
for (int i = 0; i < 2; i++) {
|
||||
for (int j = 0; j < 2; j++) {
|
||||
p_pixels_in1D[index++] = p_pel[j];
|
||||
}
|
||||
p_pel += stride;
|
||||
}
|
||||
}
|
||||
|
||||
static int is_block_2x2_row_same_value(uint8_t *p) {
|
||||
if (p[0] != p[1] || p[2] != p[3]) {
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int is_block16_2x2_row_same_value(uint16_t *p) {
|
||||
if (p[0] != p[1] || p[2] != p[3]) {
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
@ -49,7 +70,13 @@ static int is_block_2x2_col_same_value(uint8_t *p) {
|
|||
if ((p[0] != p[2]) || (p[1] != p[3])) {
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int is_block16_2x2_col_same_value(uint16_t *p) {
|
||||
if ((p[0] != p[2]) || (p[1] != p[3])) {
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
@ -63,6 +90,7 @@ static int hash_block_size_to_index(int block_size) {
|
|||
case 16: return 2;
|
||||
case 32: return 3;
|
||||
case 64: return 4;
|
||||
case 128: return 5;
|
||||
default: return -1;
|
||||
}
|
||||
}
|
||||
|
|
@ -100,11 +128,13 @@ static void hash_table_add_to_table(hash_table *p_hash_table,
|
|||
if (p_hash_table->p_lookup_table[hash_value] == NULL) {
|
||||
p_hash_table->p_lookup_table[hash_value] =
|
||||
aom_malloc(sizeof(p_hash_table->p_lookup_table[0][0]));
|
||||
vector_setup(p_hash_table->p_lookup_table[hash_value], 10,
|
||||
sizeof(curr_block_hash[0]));
|
||||
vector_push_back(p_hash_table->p_lookup_table[hash_value], curr_block_hash);
|
||||
aom_vector_setup(p_hash_table->p_lookup_table[hash_value], 10,
|
||||
sizeof(curr_block_hash[0]));
|
||||
aom_vector_push_back(p_hash_table->p_lookup_table[hash_value],
|
||||
curr_block_hash);
|
||||
} else {
|
||||
vector_push_back(p_hash_table->p_lookup_table[hash_value], curr_block_hash);
|
||||
aom_vector_push_back(p_hash_table->p_lookup_table[hash_value],
|
||||
curr_block_hash);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -119,7 +149,7 @@ int32_t av1_hash_table_count(hash_table *p_hash_table, uint32_t hash_value) {
|
|||
Iterator av1_hash_get_first_iterator(hash_table *p_hash_table,
|
||||
uint32_t hash_value) {
|
||||
assert(av1_hash_table_count(p_hash_table, hash_value) > 0);
|
||||
return vector_begin(p_hash_table->p_lookup_table[hash_value]);
|
||||
return aom_vector_begin(p_hash_table->p_lookup_table[hash_value]);
|
||||
}
|
||||
|
||||
int32_t av1_has_exact_match(hash_table *p_hash_table, uint32_t hash_value1,
|
||||
|
|
@ -127,8 +157,9 @@ int32_t av1_has_exact_match(hash_table *p_hash_table, uint32_t hash_value1,
|
|||
if (p_hash_table->p_lookup_table[hash_value1] == NULL) {
|
||||
return 0;
|
||||
}
|
||||
Iterator iterator = vector_begin(p_hash_table->p_lookup_table[hash_value1]);
|
||||
Iterator last = vector_end(p_hash_table->p_lookup_table[hash_value1]);
|
||||
Iterator iterator =
|
||||
aom_vector_begin(p_hash_table->p_lookup_table[hash_value1]);
|
||||
Iterator last = aom_vector_end(p_hash_table->p_lookup_table[hash_value1]);
|
||||
for (; !iterator_equals(&iterator, &last); iterator_increment(&iterator)) {
|
||||
if ((*(block_hash *)iterator_get(&iterator)).hash_value2 == hash_value2) {
|
||||
return 1;
|
||||
|
|
@ -146,25 +177,45 @@ void av1_generate_block_2x2_hash_value(const YV12_BUFFER_CONFIG *picture,
|
|||
const int y_end = picture->y_crop_height - height + 1;
|
||||
|
||||
const int length = width * 2;
|
||||
uint8_t p[4];
|
||||
if (picture->flags & YV12_FLAG_HIGHBITDEPTH) {
|
||||
uint16_t p[4];
|
||||
int pos = 0;
|
||||
for (int y_pos = 0; y_pos < y_end; y_pos++) {
|
||||
for (int x_pos = 0; x_pos < x_end; x_pos++) {
|
||||
get_pixels_in_1D_short_array_by_block_2x2(
|
||||
CONVERT_TO_SHORTPTR(picture->y_buffer) + y_pos * picture->y_stride +
|
||||
x_pos,
|
||||
picture->y_stride, p);
|
||||
pic_block_same_info[0][pos] = is_block16_2x2_row_same_value(p);
|
||||
pic_block_same_info[1][pos] = is_block16_2x2_col_same_value(p);
|
||||
|
||||
int pos = 0;
|
||||
for (int y_pos = 0; y_pos < y_end; y_pos++) {
|
||||
for (int x_pos = 0; x_pos < x_end; x_pos++) {
|
||||
get_pixels_in_1D_char_array_by_block_2x2(
|
||||
picture->y_buffer + y_pos * picture->y_stride + x_pos,
|
||||
picture->y_stride, p);
|
||||
pic_block_same_info[0][pos] = is_block_2x2_row_same_value(p);
|
||||
pic_block_same_info[1][pos] = is_block_2x2_col_same_value(p);
|
||||
|
||||
pic_block_hash[0][pos] =
|
||||
av1_get_crc_value(&crc_calculator1, p, length * sizeof(p[0]));
|
||||
pic_block_hash[1][pos] =
|
||||
av1_get_crc_value(&crc_calculator2, p, length * sizeof(p[0]));
|
||||
|
||||
pos++;
|
||||
pic_block_hash[0][pos] = av1_get_crc_value(
|
||||
&crc_calculator1, (uint8_t *)p, length * sizeof(p[0]));
|
||||
pic_block_hash[1][pos] = av1_get_crc_value(
|
||||
&crc_calculator2, (uint8_t *)p, length * sizeof(p[0]));
|
||||
pos++;
|
||||
}
|
||||
pos += width - 1;
|
||||
}
|
||||
} else {
|
||||
uint8_t p[4];
|
||||
int pos = 0;
|
||||
for (int y_pos = 0; y_pos < y_end; y_pos++) {
|
||||
for (int x_pos = 0; x_pos < x_end; x_pos++) {
|
||||
get_pixels_in_1D_char_array_by_block_2x2(
|
||||
picture->y_buffer + y_pos * picture->y_stride + x_pos,
|
||||
picture->y_stride, p);
|
||||
pic_block_same_info[0][pos] = is_block_2x2_row_same_value(p);
|
||||
pic_block_same_info[1][pos] = is_block_2x2_col_same_value(p);
|
||||
|
||||
pic_block_hash[0][pos] =
|
||||
av1_get_crc_value(&crc_calculator1, p, length * sizeof(p[0]));
|
||||
pic_block_hash[1][pos] =
|
||||
av1_get_crc_value(&crc_calculator2, p, length * sizeof(p[0]));
|
||||
pos++;
|
||||
}
|
||||
pos += width - 1;
|
||||
}
|
||||
pos += width - 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -222,14 +273,14 @@ void av1_generate_block_hash_value(const YV12_BUFFER_CONFIG *picture,
|
|||
}
|
||||
|
||||
if (block_size >= 4) {
|
||||
const int size_minus1 = block_size - 1;
|
||||
const int size_minus_1 = block_size - 1;
|
||||
pos = 0;
|
||||
for (int y_pos = 0; y_pos < y_end; y_pos++) {
|
||||
for (int x_pos = 0; x_pos < x_end; x_pos++) {
|
||||
dst_pic_block_same_info[2][pos] =
|
||||
(!dst_pic_block_same_info[0][pos] &&
|
||||
!dst_pic_block_same_info[1][pos]) ||
|
||||
(((x_pos & size_minus1) == 0) && ((y_pos & size_minus1) == 0));
|
||||
(((x_pos & size_minus_1) == 0) && ((y_pos & size_minus_1) == 0));
|
||||
pos++;
|
||||
}
|
||||
pos += block_size - 1;
|
||||
|
|
@ -276,13 +327,25 @@ int av1_hash_is_horizontal_perfect(const YV12_BUFFER_CONFIG *picture,
|
|||
const int stride = picture->y_stride;
|
||||
const uint8_t *p = picture->y_buffer + y_start * stride + x_start;
|
||||
|
||||
for (int i = 0; i < block_size; i++) {
|
||||
for (int j = 1; j < block_size; j++) {
|
||||
if (p[j] != p[0]) {
|
||||
return 0;
|
||||
if (picture->flags & YV12_FLAG_HIGHBITDEPTH) {
|
||||
const uint16_t *p16 = CONVERT_TO_SHORTPTR(p);
|
||||
for (int i = 0; i < block_size; i++) {
|
||||
for (int j = 1; j < block_size; j++) {
|
||||
if (p16[j] != p16[0]) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
p16 += stride;
|
||||
}
|
||||
} else {
|
||||
for (int i = 0; i < block_size; i++) {
|
||||
for (int j = 1; j < block_size; j++) {
|
||||
if (p[j] != p[0]) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
p += stride;
|
||||
}
|
||||
p += stride;
|
||||
}
|
||||
|
||||
return 1;
|
||||
|
|
@ -293,26 +356,38 @@ int av1_hash_is_vertical_perfect(const YV12_BUFFER_CONFIG *picture,
|
|||
const int stride = picture->y_stride;
|
||||
const uint8_t *p = picture->y_buffer + y_start * stride + x_start;
|
||||
|
||||
for (int i = 0; i < block_size; i++) {
|
||||
for (int j = 1; j < block_size; j++) {
|
||||
if (p[j * stride + i] != p[i]) {
|
||||
return 0;
|
||||
if (picture->flags & YV12_FLAG_HIGHBITDEPTH) {
|
||||
const uint16_t *p16 = CONVERT_TO_SHORTPTR(p);
|
||||
for (int i = 0; i < block_size; i++) {
|
||||
for (int j = 1; j < block_size; j++) {
|
||||
if (p16[j * stride + i] != p16[i]) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (int i = 0; i < block_size; i++) {
|
||||
for (int j = 1; j < block_size; j++) {
|
||||
if (p[j * stride + i] != p[i]) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// global buffer for hash value calculation of a block
|
||||
// used only in av1_get_block_hash_value()
|
||||
static uint32_t hash_value_buffer[2][2][1024]; // [first hash/second hash]
|
||||
// [two buffers used ping-pong]
|
||||
// [num of 2x2 blocks in 64x64]
|
||||
#define AOM_BUFFER_SIZE_FOR_BLOCK_HASH (4096)
|
||||
// [first hash/second hash]
|
||||
// [two buffers used ping-pong]
|
||||
// [num of 2x2 blocks in 128x128]
|
||||
static uint32_t hash_value_buffer[2][2][AOM_BUFFER_SIZE_FOR_BLOCK_HASH];
|
||||
|
||||
void av1_get_block_hash_value(uint8_t *y_src, int stride, int block_size,
|
||||
uint32_t *hash_value1, uint32_t *hash_value2) {
|
||||
uint8_t pixel_to_hash[4];
|
||||
uint32_t *hash_value1, uint32_t *hash_value2,
|
||||
int use_highbitdepth) {
|
||||
uint32_t to_hash[4];
|
||||
const int add_value = hash_block_size_to_index(block_size) << crc_bits;
|
||||
assert(add_value >= 0);
|
||||
|
|
@ -320,16 +395,34 @@ void av1_get_block_hash_value(uint8_t *y_src, int stride, int block_size,
|
|||
|
||||
// 2x2 subblock hash values in current CU
|
||||
int sub_block_in_width = (block_size >> 1);
|
||||
for (int y_pos = 0; y_pos < block_size; y_pos += 2) {
|
||||
for (int x_pos = 0; x_pos < block_size; x_pos += 2) {
|
||||
int pos = (y_pos >> 1) * sub_block_in_width + (x_pos >> 1);
|
||||
get_pixels_in_1D_char_array_by_block_2x2(y_src + y_pos * stride + x_pos,
|
||||
stride, pixel_to_hash);
|
||||
|
||||
hash_value_buffer[0][0][pos] = av1_get_crc_value(
|
||||
&crc_calculator1, pixel_to_hash, sizeof(pixel_to_hash));
|
||||
hash_value_buffer[1][0][pos] = av1_get_crc_value(
|
||||
&crc_calculator2, pixel_to_hash, sizeof(pixel_to_hash));
|
||||
if (use_highbitdepth) {
|
||||
uint16_t pixel_to_hash[4];
|
||||
uint16_t *y16_src = CONVERT_TO_SHORTPTR(y_src);
|
||||
for (int y_pos = 0; y_pos < block_size; y_pos += 2) {
|
||||
for (int x_pos = 0; x_pos < block_size; x_pos += 2) {
|
||||
int pos = (y_pos >> 1) * sub_block_in_width + (x_pos >> 1);
|
||||
get_pixels_in_1D_short_array_by_block_2x2(
|
||||
y16_src + y_pos * stride + x_pos, stride, pixel_to_hash);
|
||||
assert(pos < AOM_BUFFER_SIZE_FOR_BLOCK_HASH);
|
||||
hash_value_buffer[0][0][pos] = av1_get_crc_value(
|
||||
&crc_calculator1, (uint8_t *)pixel_to_hash, sizeof(pixel_to_hash));
|
||||
hash_value_buffer[1][0][pos] = av1_get_crc_value(
|
||||
&crc_calculator2, (uint8_t *)pixel_to_hash, sizeof(pixel_to_hash));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
uint8_t pixel_to_hash[4];
|
||||
for (int y_pos = 0; y_pos < block_size; y_pos += 2) {
|
||||
for (int x_pos = 0; x_pos < block_size; x_pos += 2) {
|
||||
int pos = (y_pos >> 1) * sub_block_in_width + (x_pos >> 1);
|
||||
get_pixels_in_1D_char_array_by_block_2x2(y_src + y_pos * stride + x_pos,
|
||||
stride, pixel_to_hash);
|
||||
assert(pos < AOM_BUFFER_SIZE_FOR_BLOCK_HASH);
|
||||
hash_value_buffer[0][0][pos] = av1_get_crc_value(
|
||||
&crc_calculator1, pixel_to_hash, sizeof(pixel_to_hash));
|
||||
hash_value_buffer[1][0][pos] = av1_get_crc_value(
|
||||
&crc_calculator2, pixel_to_hash, sizeof(pixel_to_hash));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -349,6 +442,10 @@ void av1_get_block_hash_value(uint8_t *y_src, int stride, int block_size,
|
|||
for (int x_pos = 0; x_pos < sub_block_in_width; x_pos++) {
|
||||
int srcPos = (y_pos << 1) * src_sub_block_in_width + (x_pos << 1);
|
||||
|
||||
assert(srcPos + 1 < AOM_BUFFER_SIZE_FOR_BLOCK_HASH);
|
||||
assert(srcPos + src_sub_block_in_width + 1 <
|
||||
AOM_BUFFER_SIZE_FOR_BLOCK_HASH);
|
||||
assert(dst_pos < AOM_BUFFER_SIZE_FOR_BLOCK_HASH);
|
||||
to_hash[0] = hash_value_buffer[0][src_idx][srcPos];
|
||||
to_hash[1] = hash_value_buffer[0][src_idx][srcPos + 1];
|
||||
to_hash[2] =
|
||||
|
|
@ -378,3 +475,5 @@ void av1_get_block_hash_value(uint8_t *y_src, int stride, int block_size,
|
|||
*hash_value1 = (hash_value_buffer[0][dst_idx][0] & crc_mask) + add_value;
|
||||
*hash_value2 = hash_value_buffer[1][dst_idx][0];
|
||||
}
|
||||
|
||||
#undef AOM_BUFFER_SIZE_FOR_BLOCK_HASH
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue