name string | code string | asm string | file string |
|---|---|---|---|
aom_memalign | void *aom_memalign(size_t align, size_t size) {
void *x = NULL;
if (!check_size_argument_overflow(1, size, align)) return NULL;
const size_t aligned_size = size + GetAllocationPaddingSize(align);
void *const addr = malloc(aligned_size);
if (addr) {
x = aom_align_addr((unsigned char *)addr + ADDRESS_STORAG... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl $0x1, %edi
callq 0xa0c90
cmpl $0x0, %eax
jne 0xa0bfb
movq $0x0, 0x30(%rsp)
jmp 0xa0c77
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0xa0d10
movq %rax, %rcx
movq (%rs... | /m-ab-s[P]aom/aom_mem/aom_mem.c |
aom_read_obu_header | aom_codec_err_t aom_read_obu_header(uint8_t *buffer, size_t buffer_length,
size_t *consumed, ObuHeader *header,
int is_annexb) {
if (buffer_length < 1 || !consumed || !header) return AOM_CODEC_INVALID_PARAM;
// TODO(tomfinegan): Set the error ... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
cmpq $0x1, 0x50(%rsp)
jb 0xa0ea5
cmpq $0x0, 0x48(%rsp)
je 0xa0ea5
cmpq $0x0, 0x40(%rsp)
jne 0xa0eaf
movl $0x8, 0x64(%rsp)
jmp 0xa0f18
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp)... | /m-ab-s[P]aom/av1/common/obu_util.c |
aom_read_obu_header_and_size | aom_codec_err_t aom_read_obu_header_and_size(const uint8_t *data,
size_t bytes_available,
int is_annexb,
ObuHeader *obu_header,
size_t *cons... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movl %edx, 0x6c(%rsp)
movq %rcx, 0x60(%rsp)
movq %r8, 0x58(%rsp)
movq %r9, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
cmpl $0x0, 0x6c(%rsp)
je 0xa113c
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x4... | /m-ab-s[P]aom/av1/common/obu_util.c |
decoder_init | static aom_codec_err_t decoder_init(aom_codec_ctx_t *ctx) {
// This function only allocates space for the aom_codec_alg_priv_t
// structure. More memory may be required at the time the stream
// information becomes known.
if (!ctx->priv) {
aom_codec_alg_priv_t *const priv =
(aom_codec_alg_priv_t *)a... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0xa13f8
movl $0x1, %edi
movl $0x6b30, %esi # imm = 0x6B30
callq 0xa0d80
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xa1330
movl $0x2, 0x14(%rsp)
jmp 0xa1400
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
decoder_decode | static aom_codec_err_t decoder_decode(aom_codec_alg_priv_t *ctx,
const uint8_t *data, size_t data_sz,
void *user_priv) {
aom_codec_err_t res = AOM_CODEC_OK;
#if CONFIG_INSPECTION
if (user_priv != 0) {
return decoder_inspect(ctx, data, ... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x58(%rsp), %rdi
callq 0xa5aa0
cmpq $0x0, 0x50(%rsp)
jne 0xa16c6
cmpq $0x0, 0x48(%rsp)
jne 0xa16c6
movq 0x58(%rsp), %rax
movl $0x1, 0x1a4(%rax)
movl $0x0, 0x64(%rsp)
jmp 0xa18c0
cmpq $0x0,... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
decoder_set_fb_fn | static aom_codec_err_t decoder_set_fb_fn(
aom_codec_alg_priv_t *ctx, aom_get_frame_buffer_cb_fn_t cb_get,
aom_release_frame_buffer_cb_fn_t cb_release, void *cb_priv) {
if (cb_get == NULL || cb_release == NULL) {
return AOM_CODEC_INVALID_PARAM;
}
if (ctx->frame_worker != NULL) {
// If the decoder h... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xa20e4
cmpq $0x0, -0x20(%rsp)
jne 0xa20ee
movl $0x8, -0x4(%rsp)
jmp 0xa2142
movq -0x10(%rsp), %rax
cmpq $0x0, 0x69f0(%rax)
je 0xa2107
movl $0x1, -0x4(%rsp)
jmp 0xa2142
movq -0x18(%rsp), %rcx
movq -0x10... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_copy_reference | static aom_codec_err_t ctrl_copy_reference(aom_codec_alg_priv_t *ctx,
va_list args) {
const av1_ref_frame_t *const frame = va_arg(args, av1_ref_frame_t *);
if (frame) {
YV12_BUFFER_CONFIG sd;
AVxWorker *const worker = ctx->frame_worker;
FrameWorkerData *const f... | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %eax
movl %eax, 0x14(%rsp)
cmpl $0x28, %eax
ja 0xa250a
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
mo... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_set_byte_alignment | static aom_codec_err_t ctrl_set_byte_alignment(aom_codec_alg_priv_t *ctx,
va_list args) {
const int legacy_byte_alignment = 0;
const int min_byte_alignment = 32;
const int max_byte_alignment = 1024;
const int byte_alignment = va_arg(args, int);
if (byte_alignmen... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x20, -0x20(%rsp)
movl $0x400, -0x24(%rsp) # imm = 0x400
movq -0x18(%rsp), %rax
movq %rax, -0x48(%rsp)
movl (%rax), %eax
movl %eax, -0x3c(%rsp)
cmpl $0x28, %eax
ja 0xa27a3
movq -0x48(%rsp), %rcx
movl -0x3c(%rsp), %edx
movslq %edx, %rax
addq ... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_set_skip_film_grain | static aom_codec_err_t ctrl_set_skip_film_grain(aom_codec_alg_priv_t *ctx,
va_list args) {
ctx->skip_film_grain = va_arg(args, int);
if (ctx->frame_worker) {
AVxWorker *const worker = ctx->frame_worker;
FrameWorkerData *const frame_worker_data = (FrameWorkerD... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movl (%rax), %eax
movl %eax, -0x24(%rsp)
cmpl $0x28, %eax
ja 0xa2deb
movq -0x30(%rsp), %rcx
movl -0x24(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x38(%rsp)
jmp 0xa2e04
movq ... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_last_quantizer | static aom_codec_err_t ctrl_get_last_quantizer(aom_codec_alg_priv_t *ctx,
va_list args) {
int *const arg = va_arg(args, int *);
if (arg == NULL) return AOM_CODEC_INVALID_PARAM;
if (ctx->frame_worker == NULL) return AOM_CODEC_ERROR;
*arg = ((FrameWorkerData *)ctx->f... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movl (%rax), %eax
movl %eax, -0x24(%rsp)
cmpl $0x28, %eax
ja 0xa2fbb
movq -0x30(%rsp), %rcx
movl -0x24(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x38(%rsp)
jmp 0xa2fd4
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_bit_depth | static aom_codec_err_t ctrl_get_bit_depth(aom_codec_alg_priv_t *ctx,
va_list args) {
unsigned int *const bit_depth = va_arg(args, unsigned int *);
AVxWorker *const worker = ctx->frame_worker;
if (bit_depth) {
if (worker) {
FrameWorkerData *const frame_worker_da... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x48(%rsp)
movl (%rax), %eax
movl %eax, -0x3c(%rsp)
cmpl $0x28, %eax
ja 0xa314b
movq -0x48(%rsp), %rcx
movl -0x3c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rsp)
jmp 0xa3164
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_tile_size | static aom_codec_err_t ctrl_get_tile_size(aom_codec_alg_priv_t *ctx,
va_list args) {
unsigned int *const tile_size = va_arg(args, unsigned int *);
AVxWorker *const worker = ctx->frame_worker;
if (tile_size) {
if (worker) {
FrameWorkerData *const frame_worker_da... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %eax
movl %eax, 0x14(%rsp)
cmpl $0x28, %eax
ja 0xa333e
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, (%rsp)
jmp 0xa3356
m... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_render_size | static aom_codec_err_t ctrl_get_render_size(aom_codec_alg_priv_t *ctx,
va_list args) {
int *const render_size = va_arg(args, int *);
if (render_size) {
if (ctx->frame_worker) {
AVxWorker *const worker = ctx->frame_worker;
FrameWorkerData *const frame_work... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x48(%rsp)
movl (%rax), %eax
movl %eax, -0x3c(%rsp)
cmpl $0x28, %eax
ja 0xa351b
movq -0x48(%rsp), %rcx
movl -0x3c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rsp)
jmp 0xa3534
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_accounting | static aom_codec_err_t ctrl_get_accounting(aom_codec_alg_priv_t *ctx,
va_list args) {
#if !CONFIG_ACCOUNTING
(void)ctx;
(void)args;
return AOM_CODEC_INCAPABLE;
#else
Accounting **acct = va_arg(args, Accounting **);
if (acct) {
if (ctx->frame_worker) {
AVxW... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x4, %eax
retq
| /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_reference | static aom_codec_err_t ctrl_get_reference(aom_codec_alg_priv_t *ctx,
va_list args) {
av1_ref_frame_t *data = va_arg(args, av1_ref_frame_t *);
if (data) {
YV12_BUFFER_CONFIG *fb;
AVxWorker *const worker = ctx->frame_worker;
FrameWorkerData *const frame_worker_dat... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x28, %eax
ja 0xa393f
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, 0x8(%rsp)
jmp 0xa3... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_frame_header_info | static aom_codec_err_t ctrl_get_frame_header_info(aom_codec_alg_priv_t *ctx,
va_list args) {
aom_tile_data *const frame_header_info = va_arg(args, aom_tile_data *);
if (frame_header_info) {
if (ctx->frame_worker) {
AVxWorker *const worker = ctx->frame_wor... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x48(%rsp)
movl (%rax), %eax
movl %eax, -0x3c(%rsp)
cmpl $0x28, %eax
ja 0xa3a2b
movq -0x48(%rsp), %rcx
movl -0x3c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rsp)
jmp 0xa3a44
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_tile_data | static aom_codec_err_t ctrl_get_tile_data(aom_codec_alg_priv_t *ctx,
va_list args) {
aom_tile_data *const tile_data = va_arg(args, aom_tile_data *);
if (tile_data) {
if (ctx->frame_worker) {
AVxWorker *const worker = ctx->frame_worker;
FrameWorkerData *cons... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x48(%rsp)
movl (%rax), %eax
movl %eax, -0x3c(%rsp)
cmpl $0x28, %eax
ja 0xa3b3b
movq -0x48(%rsp), %rcx
movl -0x3c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rsp)
jmp 0xa3b54
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_fwd_kf_value | static aom_codec_err_t ctrl_get_fwd_kf_value(aom_codec_alg_priv_t *ctx,
va_list args) {
int *const arg = va_arg(args, int *);
if (arg == NULL) return AOM_CODEC_INVALID_PARAM;
if (ctx->frame_worker == NULL) return AOM_CODEC_ERROR;
*arg = ((FrameWorkerData *)ctx->frame... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movl (%rax), %eax
movl %eax, -0x24(%rsp)
cmpl $0x28, %eax
ja 0xa3c8b
movq -0x30(%rsp), %rcx
movl -0x24(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x38(%rsp)
jmp 0xa3ca4
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_altref_present | static aom_codec_err_t ctrl_get_altref_present(aom_codec_alg_priv_t *ctx,
va_list args) {
int *const arg = va_arg(args, int *);
if (arg == NULL) return AOM_CODEC_INVALID_PARAM;
if (ctx->frame_worker == NULL) return AOM_CODEC_ERROR;
*arg =
((FrameWorkerData *)... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movl (%rax), %eax
movl %eax, -0x24(%rsp)
cmpl $0x28, %eax
ja 0xa3d4b
movq -0x30(%rsp), %rcx
movl -0x24(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x38(%rsp)
jmp 0xa3d64
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_frame_flags | static aom_codec_err_t ctrl_get_frame_flags(aom_codec_alg_priv_t *ctx,
va_list args) {
int *const arg = va_arg(args, int *);
if (arg == NULL) return AOM_CODEC_INVALID_PARAM;
if (ctx->frame_worker == NULL) return AOM_CODEC_ERROR;
AV1Decoder *pbi = ((FrameWorkerData *)c... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x38(%rsp)
movl (%rax), %eax
movl %eax, -0x2c(%rsp)
cmpl $0x28, %eax
ja 0xa3e0b
movq -0x38(%rsp), %rcx
movl -0x2c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x40(%rsp)
jmp 0xa3e24
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_tile_info | static aom_codec_err_t ctrl_get_tile_info(aom_codec_alg_priv_t *ctx,
va_list args) {
aom_tile_info *const tile_info = va_arg(args, aom_tile_info *);
if (tile_info) {
if (ctx->frame_worker) {
AVxWorker *const worker = ctx->frame_worker;
FrameWorkerData *cons... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x60(%rsp)
movl (%rax), %eax
movl %eax, -0x54(%rsp)
cmpl $0x28, %eax
ja 0xa3f6b
movq -0x60(%rsp), %rcx
movl -0x54(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x68(%rsp)
jmp 0xa3f84
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_screen_content_tools_info | static aom_codec_err_t ctrl_get_screen_content_tools_info(
aom_codec_alg_priv_t *ctx, va_list args) {
aom_screen_content_tools_info *const sc_info =
va_arg(args, aom_screen_content_tools_info *);
if (sc_info) {
if (ctx->frame_worker) {
AVxWorker *const worker = ctx->frame_worker;
FrameWork... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x48(%rsp)
movl (%rax), %eax
movl %eax, -0x3c(%rsp)
cmpl $0x28, %eax
ja 0xa418b
movq -0x48(%rsp), %rcx
movl -0x3c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rsp)
jmp 0xa41a4
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_still_picture | static aom_codec_err_t ctrl_get_still_picture(aom_codec_alg_priv_t *ctx,
va_list args) {
aom_still_picture_info *const still_picture_info =
va_arg(args, aom_still_picture_info *);
if (still_picture_info) {
if (ctx->frame_worker) {
AVxWorker *const worker... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x48(%rsp)
movl (%rax), %eax
movl %eax, -0x3c(%rsp)
cmpl $0x28, %eax
ja 0xa429b
movq -0x48(%rsp), %rcx
movl -0x3c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rsp)
jmp 0xa42b4
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_sb_size | static aom_codec_err_t ctrl_get_sb_size(aom_codec_alg_priv_t *ctx,
va_list args) {
aom_superblock_size_t *const sb_size = va_arg(args, aom_superblock_size_t *);
if (sb_size) {
if (ctx->frame_worker) {
AVxWorker *const worker = ctx->frame_worker;
FrameWorkerDat... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x48(%rsp)
movl (%rax), %eax
movl %eax, -0x3c(%rsp)
cmpl $0x28, %eax
ja 0xa438b
movq -0x48(%rsp), %rcx
movl -0x3c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rsp)
jmp 0xa43a4
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_show_existing_frame_flag | static aom_codec_err_t ctrl_get_show_existing_frame_flag(
aom_codec_alg_priv_t *ctx, va_list args) {
int *const arg = va_arg(args, int *);
if (arg == NULL) return AOM_CODEC_INVALID_PARAM;
if (ctx->frame_worker == NULL) return AOM_CODEC_ERROR;
*arg = ((FrameWorkerData *)ctx->frame_worker->data1)
... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movl (%rax), %eax
movl %eax, -0x24(%rsp)
cmpl $0x28, %eax
ja 0xa447b
movq -0x30(%rsp), %rcx
movl -0x24(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x38(%rsp)
jmp 0xa4494
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_s_frame_info | static aom_codec_err_t ctrl_get_s_frame_info(aom_codec_alg_priv_t *ctx,
va_list args) {
aom_s_frame_info *const s_frame_info = va_arg(args, aom_s_frame_info *);
if (s_frame_info) {
if (ctx->frame_worker) {
AVxWorker *const worker = ctx->frame_worker;
Fram... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x48(%rsp)
movl (%rax), %eax
movl %eax, -0x3c(%rsp)
cmpl $0x28, %eax
ja 0xa453b
movq -0x48(%rsp), %rcx
movl -0x3c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rsp)
jmp 0xa4554
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_show_frame_flag | static aom_codec_err_t ctrl_get_show_frame_flag(aom_codec_alg_priv_t *ctx,
va_list args) {
int *const arg = va_arg(args, int *);
if (arg == NULL) return AOM_CODEC_INVALID_PARAM;
if (ctx->frame_worker == NULL) return AOM_CODEC_ERROR;
FrameWorkerData *const frame_wo... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x38(%rsp)
movl (%rax), %eax
movl %eax, -0x2c(%rsp)
cmpl $0x28, %eax
ja 0xa462b
movq -0x38(%rsp), %rcx
movl -0x2c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x40(%rsp)
jmp 0xa4644
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_base_q_idx | static aom_codec_err_t ctrl_get_base_q_idx(aom_codec_alg_priv_t *ctx,
va_list args) {
int *const arg = va_arg(args, int *);
if (arg == NULL) return AOM_CODEC_INVALID_PARAM;
if (ctx->frame_worker == NULL) return AOM_CODEC_ERROR;
FrameWorkerData *const frame_worker_data ... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x38(%rsp)
movl (%rax), %eax
movl %eax, -0x2c(%rsp)
cmpl $0x28, %eax
ja 0xa46fb
movq -0x38(%rsp), %rcx
movl -0x2c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x40(%rsp)
jmp 0xa4714
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_order_hint | static aom_codec_err_t ctrl_get_order_hint(aom_codec_alg_priv_t *ctx,
va_list args) {
unsigned int *const arg = va_arg(args, unsigned int *);
if (arg == NULL) return AOM_CODEC_INVALID_PARAM;
if (ctx->frame_worker == NULL) return AOM_CODEC_ERROR;
FrameWorkerData *const ... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x38(%rsp)
movl (%rax), %eax
movl %eax, -0x2c(%rsp)
cmpl $0x28, %eax
ja 0xa47cb
movq -0x38(%rsp), %rcx
movl -0x2c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x40(%rsp)
jmp 0xa47e4
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_mi_info | static aom_codec_err_t ctrl_get_mi_info(aom_codec_alg_priv_t *ctx,
va_list args) {
int mi_row = va_arg(args, int);
int mi_col = va_arg(args, int);
MB_MODE_INFO *mi = va_arg(args, MB_MODE_INFO *);
if (mi == NULL) return AOM_CODEC_INVALID_PARAM;
if (ctx->frame_worker == N... | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x40(%rsp)
movl (%rax), %eax
movl %eax, 0x4c(%rsp)
cmpl $0x28, %eax
ja 0xa48ab
movq 0x40(%rsp), %rcx
movl 0x4c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, 0x38(%rsp)
jmp 0xa... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
set_mi_row_col | static inline void set_mi_row_col(MACROBLOCKD *xd, const TileInfo *const tile,
int mi_row, int bh, int mi_col, int bw,
int mi_rows, int mi_cols) {
xd->mb_to_top_edge = -GET_MV_SUBPEL(mi_row * MI_SIZE);
xd->mb_to_bottom_edge = GET_MV_SUBPEL((mi_rows... | movl 0x10(%rsp), %eax
movl 0x8(%rsp), %eax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movl %r8d, -0x1c(%rsp)
movl %r9d, -0x20(%rsp)
movl -0x14(%rsp), %eax
shll $0x2, %eax
shll $0x3, %eax
xorl %ecx, %ecx
subl %eax, %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x1efc(%rax)
movl 0x... | /m-ab-s[P]aom/av1/common/av1_common_int.h |
av1_find_ref_dv | static inline void av1_find_ref_dv(int_mv *ref_dv, const TileInfo *const tile,
int mib_size, int mi_row) {
if (mi_row - mib_size < tile->mi_row_start) {
ref_dv->as_fullmv.row = 0;
ref_dv->as_fullmv.col = -MI_SIZE * mib_size - INTRABC_DELAY_PIXELS;
} else {
ref_dv->as_f... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl %ecx, (%rsp)
movl (%rsp), %eax
subl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xc0c9a
movq 0x10(%rsp), %rax
movw $0x0, (%rax)
imull $0xfffffffc, 0x4(%rsp), %eax # imm = 0xFFFFFFFC
subl $0x100, %eax # imm = ... | /m-ab-s[P]aom/av1/common/mvref_common.h |
av1_zero_above_context | static inline void av1_zero_above_context(AV1_COMMON *const cm,
const MACROBLOCKD *xd,
int mi_col_start, int mi_col_end,
const int tile_row) {
const SequenceHeader *const seq_params = cm->seq_... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
movq 0x50(%rsp), %rax
movq 0x6088(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rdi
callq 0x107890
movl %eax, 0x2c(%rsp)
movl 0x40(%rsp), %eax
subl 0x44(%rsp), %eax
movl %eax, 0x28(%rsp)
... | /m-ab-s[P]aom/av1/common/av1_common_int.h |
max_block_high | static inline int max_block_high(const MACROBLOCKD *xd, BLOCK_SIZE bsize,
int plane) {
int max_blocks_high = block_size_high[bsize];
if (xd->mb_to_bottom_edge < 0) {
const struct macroblockd_plane *const pd = &xd->plane[plane];
max_blocks_high += xd->mb_to_bottom_edge >> (3... | movb %sil, %al
movq %rdi, -0x8(%rsp)
movb %al, -0x9(%rsp)
movl %edx, -0x10(%rsp)
movzbl -0x9(%rsp), %eax
movl %eax, %ecx
leaq 0x8ffe32(%rip), %rax # 0xa952d0
movzbl (%rax,%rcx), %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
cmpl $0x0, 0x1f00(%rax)
jge 0x1954f1
movq -0x8(%rsp), %rax
addq $0x10, %rax
movslq -0x10(... | /m-ab-s[P]aom/av1/common/av1_common_int.h |
txfm_partition_update | static inline void txfm_partition_update(TXFM_CONTEXT *above_ctx,
TXFM_CONTEXT *left_ctx,
TX_SIZE tx_size, TX_SIZE txb_size) {
BLOCK_SIZE bsize = txsize_to_bsize[txb_size];
int bh = mi_size_high[bsize];
int bw = mi_size_wide[bsize];... | movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb %cl, -0x11(%rsp)
movb %al, -0x12(%rsp)
movzbl -0x12(%rsp), %eax
movl %eax, %ecx
leaq 0x8ffd5c(%rip), %rax # 0xa954d0
movb (%rax,%rcx), %al
movb %al, -0x13(%rsp)
movzbl -0x13(%rsp), %eax
movl %eax, %ecx
leaq 0x8ffa87(%rip), %rax # 0xa952... | /m-ab-s[P]aom/av1/common/av1_common_int.h |
is_nontrans_global_motion | static inline int is_nontrans_global_motion(const MACROBLOCKD *xd,
const MB_MODE_INFO *mbmi) {
int ref;
// First check if all modes are GLOBALMV
if (mbmi->mode != GLOBALMV && mbmi->mode != GLOBAL_GLOBALMV) return 0;
if (AOMMIN(mi_size_wide[mbmi->bsize], mi_size_high... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
cmpl $0xf, %eax
je 0x198db7
movq 0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x17, %eax
je 0x198db7
movl $0x0, 0x24(%rsp)
jmp 0x198ea0
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x8fc428(%rip)... | /m-ab-s[P]aom/av1/common/blockd.h |
get_uni_comp_ref_idx | static inline int8_t get_uni_comp_ref_idx(const MV_REFERENCE_FRAME *const rf) {
// Single ref pred
if (rf[1] <= INTRA_FRAME) return -1;
// Bi-directional comp ref pred
if ((rf[0] < BWDREF_FRAME) && (rf[1] >= BWDREF_FRAME)) return -1;
for (int8_t ref_idx = 0; ref_idx < TOTAL_UNIDIR_COMP_REFS; ++ref_idx) {
... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jg 0x199111
movb $-0x1, 0x27(%rsp)
jmp 0x1991a6
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5, %eax
jge 0x199133
movq 0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x5, %eax
jl 0x199133
movb $-0x1, 0x27(%rsp)
jmp 0... | /m-ab-s[P]aom/av1/common/mvref_common.h |
update_partition_context | static inline void update_partition_context(MACROBLOCKD *xd, int mi_row,
int mi_col, BLOCK_SIZE subsize,
BLOCK_SIZE bsize) {
PARTITION_CONTEXT *const above_ctx = xd->above_partition_context + mi_col;
PARTITION_CONTEXT *const lef... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movb %cl, 0x27(%rsp)
movb %al, 0x26(%rsp)
movq 0x30(%rsp), %rax
movq 0x1f98(%rax), %rax
movslq 0x28(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
addq $0x1fa0, %rax # imm = 0x1FA0
movl 0... | /m-ab-s[P]aom/av1/common/av1_common_int.h |
is_nontrans_global_motion | static inline int is_nontrans_global_motion(const MACROBLOCKD *xd,
const MB_MODE_INFO *mbmi) {
int ref;
// First check if all modes are GLOBALMV
if (mbmi->mode != GLOBALMV && mbmi->mode != GLOBAL_GLOBALMV) return 0;
if (AOMMIN(mi_size_wide[mbmi->bsize], mi_size_high... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
cmpl $0xf, %eax
je 0x1e28a7
movq 0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x17, %eax
je 0x1e28a7
movl $0x0, 0x24(%rsp)
jmp 0x1e2990
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x8d6648(%rip)... | /m-ab-s[P]aom/av1/common/blockd.h |
cost_mv_ref | static int cost_mv_ref(const ModeCosts *const mode_costs, PREDICTION_MODE mode,
int16_t mode_context) {
if (is_inter_compound_mode(mode)) {
return mode_costs
->inter_compound_mode_cost[mode_context][INTER_COMPOUND_OFFSET(mode)];
}
int mode_cost = 0;
int16_t mode_ctx = mode_co... | subq $0x28, %rsp
movw %dx, %ax
movb %sil, %cl
movq %rdi, 0x18(%rsp)
movb %cl, 0x17(%rsp)
movw %ax, 0x14(%rsp)
movzbl 0x17(%rsp), %edi
callq 0x1e9ab0
cmpl $0x0, %eax
je 0x1e99a6
movq 0x18(%rsp), %rax
addq $0x3f38, %rax # imm = 0x3F38
movswq 0x14(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movzbl 0x17(%rsp), %e... | /m-ab-s[P]aom/av1/encoder/rdopt.c |
compound_skip_get_candidates | static int compound_skip_get_candidates(
const AV1_COMP *cpi, const InterModeSearchState *search_state,
const int dir, const PREDICTION_MODE mode) {
const int mode_offset = INTER_OFFSET(mode);
const SingleInterModeState *state =
search_state->single_state[dir][mode_offset];
const SingleInterModeStat... | movb %cl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movb %al, -0x15(%rsp)
movzbl -0x15(%rsp), %eax
subl $0xd, %eax
movl %eax, -0x1c(%rsp)
movq -0x10(%rsp), %rax
addq $0x2d98, %rax # imm = 0x2D98
movslq -0x14(%rsp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x1c(%rsp), %rcx
shl... | /m-ab-s[P]aom/av1/encoder/rdopt.c |
is_filter_search_enabled_blk | static inline int is_filter_search_enabled_blk(AV1_COMP *cpi, MACROBLOCK *x,
int mi_row, int mi_col,
BLOCK_SIZE bsize, int segment_id,
int cb_pred_filter_search,
... | subq $0x48, %rsp
movb %r8b, %al
movq 0x58(%rsp), %r8
movl 0x50(%rsp), %r8d
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl %ecx, 0x28(%rsp)
movb %al, 0x27(%rsp)
movl %r9d, 0x20(%rsp)
movq 0x38(%rsp), %rax
addq $0x3bf80, %rax # imm = 0x3BF80
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
cmp... | /m-ab-s[P]aom/av1/encoder/nonrd_pickmode.c |
init_inter_block_params | static inline void init_inter_block_params(InterPredParams *inter_pred_params,
int block_width, int block_height,
int pix_row, int pix_col,
int subsampling_x, int subsampling_y,
... | movl 0x20(%rsp), %eax
movl 0x18(%rsp), %eax
movl 0x10(%rsp), %eax
movl 0x8(%rsp), %eax
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movl %r9d, -0x1c(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x70(%rax)
movl -0x10(%rsp), %ecx
movq -0x... | /m-ab-s[P]aom/av1/common/reconinter.h |
get_uni_comp_ref_idx | static inline int8_t get_uni_comp_ref_idx(const MV_REFERENCE_FRAME *const rf) {
// Single ref pred
if (rf[1] <= INTRA_FRAME) return -1;
// Bi-directional comp ref pred
if ((rf[0] < BWDREF_FRAME) && (rf[1] >= BWDREF_FRAME)) return -1;
for (int8_t ref_idx = 0; ref_idx < TOTAL_UNIDIR_COMP_REFS; ++ref_idx) {
... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jg 0x1f9821
movb $-0x1, 0x27(%rsp)
jmp 0x1f98b6
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5, %eax
jge 0x1f9843
movq 0x18(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x5, %eax
jl 0x1f9843
movb $-0x1, 0x27(%rsp)
jmp 0... | /m-ab-s[P]aom/av1/common/mvref_common.h |
get_ref_frame_use_mask | static inline void get_ref_frame_use_mask(AV1_COMP *cpi, MACROBLOCK *x,
MB_MODE_INFO *mi, int mi_row,
int mi_col, BLOCK_SIZE bsize,
int gf_temporal_ref,
... | subq $0x68, %rsp
movb %r9b, %al
movq 0x80(%rsp), %r9
movq 0x78(%rsp), %r9
movl 0x70(%rsp), %r9d
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl %r8d, 0x48(%rsp)
movb %al, 0x47(%rsp)
movq 0x60(%rsp), %rax
addq $0x3bf80, %rax # imm = 0x3BF80
movq %rax, 0x38(%rsp)
movq... | /m-ab-s[P]aom/av1/encoder/nonrd_pickmode.c |
av1_mode_context_analyzer | static inline int16_t av1_mode_context_analyzer(
const int16_t *const mode_context, const MV_REFERENCE_FRAME *const rf) {
const int8_t ref_frame = av1_ref_frame_type(rf);
if (rf[1] <= INTRA_FRAME) return mode_context[ref_frame];
const int16_t newmv_ctx = mode_context[ref_frame] & NEWMV_CTX_MASK;
const int... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1f9780
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jg 0x1fa7b3
movq 0x28(%rsp), %rax
movsbq 0x1f(%rsp), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, 0x36(%rsp)
jmp 0x1fa840
movq 0x28(%rsp), %rax
mo... | /m-ab-s[P]aom/av1/common/mvref_common.h |
setup_pred_plane | static inline void setup_pred_plane(struct buf_2d *dst, BLOCK_SIZE bsize,
uint8_t *src, int width, int height,
int stride, int mi_row, int mi_col,
const struct scale_factors *scale,
... | subq $0x38, %rsp
movb %sil, %al
movl 0x60(%rsp), %esi
movl 0x58(%rsp), %esi
movq 0x50(%rsp), %rsi
movl 0x48(%rsp), %esi
movl 0x40(%rsp), %esi
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movl %r9d, 0x14(%rsp)
cmpl $0x0, 0x60(%rsp)
je 0x20994d
movl 0x40(%rs... | /m-ab-s[P]aom/av1/common/reconinter.h |
tf_alloc_and_reset_data | static inline bool tf_alloc_and_reset_data(TemporalFilterData *tf_data,
int num_pels, int is_high_bitdepth) {
tf_data->tmp_mbmi = (MB_MODE_INFO *)aom_calloc(1, sizeof(*tf_data->tmp_mbmi));
tf_data->accum =
(uint32_t *)aom_memalign(16, num_pels * sizeof(*tf_data->accu... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
movl $0x1, %edi
movl $0xb0, %esi
callq 0xa0d80
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movslq 0x4(%rsp), %rsi
shlq $0x2, %rsi
movl $0x10, %edi
callq 0xa0bc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movslq 0... | /m-ab-s[P]aom/av1/encoder/temporal_filter.h |
tf_dealloc_data | static inline void tf_dealloc_data(TemporalFilterData *tf_data,
int is_high_bitdepth) {
if (is_high_bitdepth)
tf_data->pred = (uint8_t *)CONVERT_TO_SHORTPTR(tf_data->pred);
aom_free(tf_data->tmp_mbmi);
tf_data->tmp_mbmi = NULL;
aom_free(tf_data->accum);
tf_data->accum = ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x219a99
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rcx
shlq %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xa0e00
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq ... | /m-ab-s[P]aom/av1/encoder/temporal_filter.h |
av1_tf_info_alloc | bool av1_tf_info_alloc(TEMPORAL_FILTER_INFO *tf_info, const AV1_COMP *cpi) {
const AV1EncoderConfig *oxcf = &cpi->oxcf;
tf_info->is_temporal_filter_on = av1_is_temporal_filter_on(oxcf);
if (tf_info->is_temporal_filter_on == 0) return true;
const AV1_COMMON *cm = &cpi->common;
const SequenceHeader *const seq_... | pushq %rbx
subq $0x70, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
addq $0x42320, %rax # imm = 0x42320
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x219b10
movl %eax, %ecx
movq 0x60(%rsp), %rax
movl %ecx, (%rax)
movq 0x60(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x219b96
movb $0x1, 0x... | /m-ab-s[P]aom/av1/encoder/temporal_filter.c |
av1_tf_info_filtering | void av1_tf_info_filtering(TEMPORAL_FILTER_INFO *tf_info, AV1_COMP *cpi,
const GF_GROUP *gf_group) {
if (tf_info->is_temporal_filter_on == 0) return;
const AV1_COMMON *const cm = &cpi->common;
for (int gf_index = 0; gf_index < gf_group->size; ++gf_index) {
int update_type = gf_group... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x219d82
jmp 0x219f0c
movq 0x38(%rsp), %rax
addq $0x3bf80, %rax # imm = 0x3BF80
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x1878(%rcx... | /m-ab-s[P]aom/av1/encoder/temporal_filter.c |
av1_tf_info_get_filtered_buf | YV12_BUFFER_CONFIG *av1_tf_info_get_filtered_buf(TEMPORAL_FILTER_INFO *tf_info,
int gf_index,
FRAME_DIFF *frame_diff) {
if (tf_info->is_temporal_filter_on == 0) return NULL;
YV12_BUFFER_CONFIG *out_buf = NULL;
for (i... | movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x219f46
movq $0x0, -0x8(%rsp)
jmp 0x219ff1
movq $0x0, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
cmpl $0x2, -0x2c(%rsp)
jge 0x219fe7
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
cmpl $0x0, 0x2a8(%rax,%rcx,4)
je... | /m-ab-s[P]aom/av1/encoder/temporal_filter.c |
av1_get_search_site_config | static inline const search_site_config *av1_get_search_site_config(
const AV1_COMP *cpi, MACROBLOCK *x, SEARCH_METHODS search_method) {
const int ref_stride = x->e_mbd.plane[0].pre[0].stride;
// AV1_COMP::mv_search_params.search_site_config is a compressor level cache
// that's shared by multiple threads. In... | subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movl 0x1f8(%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
addq $0x60df8, %rax # imm = 0x60DF8
movq %rax, (%rsp)
movl 0x8(%rsp), %eax
movq (%rsp), %rcx
cmpl 0xc74(%rcx), %eax
jne 0x21a0b4... | /m-ab-s[P]aom/av1/encoder/motion_search_facade.h |
get_noise_var | static inline double get_noise_var(const uint8_t *data, const uint8_t *denoised,
int w, int h, int stride, int x_o, int y_o,
int block_size_x, int block_size_y,
int use_highbd) {
if (use_highbd)
return get_noi... | subq $0x48, %rsp
movl 0x68(%rsp), %eax
movl 0x60(%rsp), %eax
movl 0x58(%rsp), %eax
movl 0x50(%rsp), %eax
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl %ecx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movl %r9d, 0x20(%rsp)
cmpl $0x0, 0x68(%rsp)
je 0x2bd47b
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl ... | /m-ab-s[P]aom/aom_dsp/noise_model.c |
get_noise_var_highbd | static inline double get_noise_var(const uint8_t *data, const uint8_t *denoised,
int w, int h, int stride, int x_o, int y_o,
int block_size_x, int block_size_y,
int use_highbd) {
if (use_highbd)
return get_noi... | movl 0x18(%rsp), %eax
movl 0x10(%rsp), %eax
movl 0x8(%rsp), %eax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movl %r8d, -0x1c(%rsp)
movl %r9d, -0x20(%rsp)
movl -0x1c(%rsp), %eax
subl 0x8(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x2bd804
movl -0x1c(%rsp), %eax
subl 0x8(%rsp), ... | /m-ab-s[P]aom/aom_dsp/noise_model.c |
ransac | bool ransac(const Correspondence *matched_points, int npoints,
TransformationType type, MotionModel *motion_models,
int num_desired_motions, bool *mem_alloc_failed) {
#if ALLOW_TRANSLATION_MODELS
assert(type > IDENTITY && type < TRANS_TYPES);
#else
assert(type > TRANSLATION && type < TRANS_T... | subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movb %al, 0x1b(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movq %r9, (%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
movzbl 0x1b(%rsp), %eax
leaq 0x8db911(%rip), %r8 # 0xb9a360
imulq $0x18, ... | /m-ab-s[P]aom/aom_dsp/flow_estimation/ransac.c |
aom_highbd_lpf_horizontal_8_dual_sse2 | void aom_highbd_lpf_horizontal_8_dual_sse2(
uint16_t *s, int p, const uint8_t *_blimit0, const uint8_t *_limit0,
const uint8_t *_thresh0, const uint8_t *_blimit1, const uint8_t *_limit1,
const uint8_t *_thresh1, int bd) {
__m128i p2, p1, p0, q0, q1, q2, p3, q3;
p3 = _mm_loadu_si128((__m128i *)(s - 4 * ... | subq $0x1508, %rsp # imm = 0x1508
movl 0x1520(%rsp), %eax
movq 0x1518(%rsp), %rax
movq 0x1510(%rsp), %rax
movq %rdi, 0xe8(%rsp)
movl %esi, 0xe4(%rsp)
movq %rdx, 0xd8(%rsp)
movq %rcx, 0xd0(%rsp)
movq %r8, 0xc8(%rsp)
movq %r9, 0xc0(%rsp)
movq 0xe8(%rsp), %rax
movl 0xe4(%rsp), %ecx
shll $0x2, %ecx
movslq %ecx, %... | /m-ab-s[P]aom/aom_dsp/x86/highbd_loopfilter_sse2.c |
aom_highbd_lpf_horizontal_4_sse2 | void aom_highbd_lpf_horizontal_4_sse2(uint16_t *s, int p,
const uint8_t *_blimit,
const uint8_t *_limit,
const uint8_t *_thresh, int bd) {
__m128i p1p0, q1q0;
__m128i p1 = _mm_loadl_epi64((__m128i *)(s ... | subq $0x998, %rsp # imm = 0x998
movq %rdi, 0xe8(%rsp)
movl %esi, 0xe4(%rsp)
movq %rdx, 0xd8(%rsp)
movq %rcx, 0xd0(%rsp)
movq %r8, 0xc8(%rsp)
movl %r9d, 0xc4(%rsp)
movq 0xe8(%rsp), %rax
movl 0xe4(%rsp), %ecx
addl %ecx, %ecx
movslq %ecx, %rcx
addq %rcx, %rcx
subq %rcx, %rax
movq %rax, 0x168(%rsp)
movq 0x168(%r... | /m-ab-s[P]aom/aom_dsp/x86/highbd_loopfilter_sse2.c |
aom_masked_sub_pixel_variance16x64_ssse3 | static inline __m128i filter_block(const __m128i a, const __m128i b,
const __m128i filter) {
__m128i v0 = _mm_unpacklo_epi8(a, b);
v0 = _mm_maddubs_epi16(v0, filter);
v0 = xx_roundn_epu16(v0, FILTER_BITS);
__m128i v1 = _mm_unpackhi_epi8(a, b);
v1 = _mm_maddubs_epi16(v1, fil... | pushq %rbx
subq $0x480, %rsp # imm = 0x480
movq 0x4b0(%rsp), %rax
movl 0x4a8(%rsp), %eax
movl 0x4a0(%rsp), %eax
movq 0x498(%rsp), %rax
movq 0x490(%rsp), %rax
movq %rdi, 0x478(%rsp)
movl %esi, 0x474(%rsp)
movl %edx, 0x470(%rsp)
movl %ecx, 0x46c(%rsp)
movq %r8, 0x460(%rsp)
movl %r9d, 0x45c(%rsp)
movq 0x478(%rs... | /m-ab-s[P]aom/aom_dsp/x86/masked_variance_intrin_ssse3.c |
blend_a64_mask_sx_sy_w8_sse4_1 | static void blend_a64_mask_sx_sy_w8_sse4_1(
uint8_t *dst, uint32_t dst_stride, const uint8_t *src0,
uint32_t src0_stride, const uint8_t *src1, uint32_t src1_stride,
const uint8_t *mask, uint32_t mask_stride, int w, int h) {
const __m128i v_shuffle_b = xx_loadu_128(g_blend_a64_mask_shuffle);
const __m128... | subq $0x238, %rsp # imm = 0x238
movl 0x258(%rsp), %eax
movl 0x250(%rsp), %eax
movl 0x248(%rsp), %eax
movq 0x240(%rsp), %rax
movq %rdi, 0x120(%rsp)
movl %esi, 0x11c(%rsp)
movq %rdx, 0x110(%rsp)
movl %ecx, 0x10c(%rsp)
movq %r8, 0x100(%rsp)
movl %r9d, 0xfc(%rsp)
leaq 0x69f287(%rip), %rdi # 0xac73e0
callq 0x4... | /m-ab-s[P]aom/aom_dsp/x86/blend_a64_mask_sse4.c |
aom_highbd_blend_a64_mask_sse4_1 | void aom_highbd_blend_a64_mask_sse4_1(uint8_t *dst_8, uint32_t dst_stride,
const uint8_t *src0_8,
uint32_t src0_stride,
const uint8_t *src1_8,
uint32_t src1_stride, con... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl 0xe0(%rsp), %eax
movl 0xd8(%rsp), %eax
movl 0xd0(%rsp), %eax
movl 0xc8(%rsp), %eax
movl 0xc0(%rsp), %eax
movl 0xb8(%rsp), %eax
movq 0xb0(%rsp), %rax
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq %r8, 0x60(%r... | /m-ab-s[P]aom/aom_dsp/x86/blend_a64_mask_sse4.c |
aom_lowbd_blend_a64_d16_mask_sse4_1 | void aom_lowbd_blend_a64_d16_mask_sse4_1(
uint8_t *dst, uint32_t dst_stride, const CONV_BUF_TYPE *src0,
uint32_t src0_stride, const CONV_BUF_TYPE *src1, uint32_t src1_stride,
const uint8_t *mask, uint32_t mask_stride, int w, int h, int subw, int subh,
ConvolveParams *conv_params) {
const int bd = 8;
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq 0x120(%rsp), %rax
movl 0x118(%rsp), %eax
movl 0x110(%rsp), %eax
movl 0x108(%rsp), %eax
movl 0x100(%rsp), %eax
movl 0xf8(%rsp), %eax
movq 0xf0(%rsp), %rax
movq %rdi, 0xa0(%rsp)
movl %esi, 0x9c(%rsp)
movq %rdx, 0x90(%rsp)
movl %ecx, 0x8c(%rsp)
movq %r8, 0x80(%rsp)
mo... | /m-ab-s[P]aom/aom_dsp/x86/blend_a64_mask_sse4.c |
aom_lowbd_blend_a64_d16_mask_subw0_subh0_w4_sse4_1 | static inline void aom_lowbd_blend_a64_d16_mask_subw0_subh0_w4_sse4_1(
uint8_t *dst, uint32_t dst_stride, const CONV_BUF_TYPE *src0,
uint32_t src0_stride, const CONV_BUF_TYPE *src1, uint32_t src1_stride,
const uint8_t *mask, uint32_t mask_stride, int h,
const __m128i *round_offset, int shift) {
const ... | subq $0xc8, %rsp
movl 0xf0(%rsp), %eax
movq 0xe8(%rsp), %rax
movl 0xe0(%rsp), %eax
movl 0xd8(%rsp), %eax
movq 0xd0(%rsp), %rax
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq %r8, 0x60(%rsp)
movl %r9d, 0x5c(%rsp)
movw $0x40, 0x8e(%rsp)
movw 0x8e(%rsp), %ax
movw %ax, 0xe(%rsp... | /m-ab-s[P]aom/aom_dsp/x86/blend_mask_sse4.h |
aom_lowbd_blend_a64_d16_mask_subw1_subh1_w8_sse4_1 | static inline void aom_lowbd_blend_a64_d16_mask_subw1_subh1_w8_sse4_1(
uint8_t *dst, uint32_t dst_stride, const CONV_BUF_TYPE *src0,
uint32_t src0_stride, const CONV_BUF_TYPE *src1, uint32_t src1_stride,
const uint8_t *mask, uint32_t mask_stride, int h,
const __m128i *round_offset, int shift) {
const ... | subq $0x1d8, %rsp # imm = 0x1D8
movl 0x200(%rsp), %eax
movq 0x1f8(%rsp), %rax
movl 0x1f0(%rsp), %eax
movl 0x1e8(%rsp), %eax
movq 0x1e0(%rsp), %rax
movq %rdi, 0xe0(%rsp)
movl %esi, 0xdc(%rsp)
movq %rdx, 0xd0(%rsp)
movl %ecx, 0xcc(%rsp)
movq %r8, 0xc0(%rsp)
movl %r9d, 0xbc(%rsp)
movw $0x40, 0xec(%rsp)
movw 0xe... | /m-ab-s[P]aom/aom_dsp/x86/blend_mask_sse4.h |
lowbd_blend_a64_d16_mask_subw1_subh1_w16_sse4_1 | static inline void lowbd_blend_a64_d16_mask_subw1_subh1_w16_sse4_1(
uint8_t *dst, uint32_t dst_stride, const CONV_BUF_TYPE *src0,
uint32_t src0_stride, const CONV_BUF_TYPE *src1, uint32_t src1_stride,
const uint8_t *mask, uint32_t mask_stride, int h, int w,
const __m128i *round_offset, int shift) {
co... | subq $0x2a8, %rsp # imm = 0x2A8
movl 0x2d8(%rsp), %eax
movq 0x2d0(%rsp), %rax
movl 0x2c8(%rsp), %eax
movl 0x2c0(%rsp), %eax
movl 0x2b8(%rsp), %eax
movq 0x2b0(%rsp), %rax
movq %rdi, 0x130(%rsp)
movl %esi, 0x12c(%rsp)
movq %rdx, 0x120(%rsp)
movl %ecx, 0x11c(%rsp)
movq %r8, 0x110(%rsp)
movl %r9d, 0x10c(%rsp)
mo... | /m-ab-s[P]aom/aom_dsp/x86/blend_a64_mask_sse4.c |
aom_lowbd_blend_a64_d16_mask_subw1_subh0_w4_sse4_1 | static inline void aom_lowbd_blend_a64_d16_mask_subw1_subh0_w4_sse4_1(
uint8_t *dst, uint32_t dst_stride, const CONV_BUF_TYPE *src0,
uint32_t src0_stride, const CONV_BUF_TYPE *src1, uint32_t src1_stride,
const uint8_t *mask, uint32_t mask_stride, int h,
const __m128i *round_offset, int shift) {
const ... | subq $0x158, %rsp # imm = 0x158
movl 0x180(%rsp), %eax
movq 0x178(%rsp), %rax
movl 0x170(%rsp), %eax
movl 0x168(%rsp), %eax
movq 0x160(%rsp), %rax
movq %rdi, 0xa8(%rsp)
movl %esi, 0xa4(%rsp)
movq %rdx, 0x98(%rsp)
movl %ecx, 0x94(%rsp)
movq %r8, 0x88(%rsp)
movl %r9d, 0x84(%rsp)
movw $0x40, 0xcc(%rsp)
movw 0xc... | /m-ab-s[P]aom/aom_dsp/x86/blend_mask_sse4.h |
aom_lowbd_blend_a64_d16_mask_subw1_subh0_w8_sse4_1 | static inline void aom_lowbd_blend_a64_d16_mask_subw1_subh0_w8_sse4_1(
uint8_t *dst, uint32_t dst_stride, const CONV_BUF_TYPE *src0,
uint32_t src0_stride, const CONV_BUF_TYPE *src1, uint32_t src1_stride,
const uint8_t *mask, uint32_t mask_stride, int h,
const __m128i *round_offset, int shift) {
const ... | subq $0x158, %rsp # imm = 0x158
movl 0x180(%rsp), %eax
movq 0x178(%rsp), %rax
movl 0x170(%rsp), %eax
movl 0x168(%rsp), %eax
movq 0x160(%rsp), %rax
movq %rdi, 0xa8(%rsp)
movl %esi, 0xa4(%rsp)
movq %rdx, 0x98(%rsp)
movl %ecx, 0x94(%rsp)
movq %r8, 0x88(%rsp)
movl %r9d, 0x84(%rsp)
movw $0x40, 0xcc(%rsp)
movw 0xc... | /m-ab-s[P]aom/aom_dsp/x86/blend_mask_sse4.h |
lowbd_blend_a64_d16_mask_subw1_subh0_w16_sse4_1 | static inline void lowbd_blend_a64_d16_mask_subw1_subh0_w16_sse4_1(
uint8_t *dst, uint32_t dst_stride, const CONV_BUF_TYPE *src0,
uint32_t src0_stride, const CONV_BUF_TYPE *src1, uint32_t src1_stride,
const uint8_t *mask, uint32_t mask_stride, int h, int w,
const __m128i *round_offset, int shift) {
co... | subq $0x1d8, %rsp # imm = 0x1D8
movl 0x208(%rsp), %eax
movq 0x200(%rsp), %rax
movl 0x1f8(%rsp), %eax
movl 0x1f0(%rsp), %eax
movl 0x1e8(%rsp), %eax
movq 0x1e0(%rsp), %rax
movq %rdi, 0xe8(%rsp)
movl %esi, 0xe4(%rsp)
movq %rdx, 0xd8(%rsp)
movl %ecx, 0xd4(%rsp)
movq %r8, 0xc8(%rsp)
movl %r9d, 0xc4(%rsp)
movw $0x... | /m-ab-s[P]aom/aom_dsp/x86/blend_a64_mask_sse4.c |
aom_lowbd_blend_a64_d16_mask_subw0_subh1_w8_sse4_1 | static inline void aom_lowbd_blend_a64_d16_mask_subw0_subh1_w8_sse4_1(
uint8_t *dst, uint32_t dst_stride, const CONV_BUF_TYPE *src0,
uint32_t src0_stride, const CONV_BUF_TYPE *src1, uint32_t src1_stride,
const uint8_t *mask, uint32_t mask_stride, int h,
const __m128i *round_offset, int shift) {
const ... | subq $0x148, %rsp # imm = 0x148
movl 0x170(%rsp), %eax
movq 0x168(%rsp), %rax
movl 0x160(%rsp), %eax
movl 0x158(%rsp), %eax
movq 0x150(%rsp), %rax
movq %rdi, 0xa8(%rsp)
movl %esi, 0xa4(%rsp)
movq %rdx, 0x98(%rsp)
movl %ecx, 0x94(%rsp)
movq %r8, 0x88(%rsp)
movl %r9d, 0x84(%rsp)
movw $0x40, 0xce(%rsp)
movw 0xc... | /m-ab-s[P]aom/aom_dsp/x86/blend_mask_sse4.h |
get_var_sse_sum_16x16_dual_avx2 | static inline void get_var_sse_sum_16x16_dual_avx2(
const uint8_t *src, int src_stride, const uint8_t *ref,
const int ref_stride, const int h, uint32_t *sse16x16,
unsigned int *tot_sse, int *tot_sum, uint32_t *var16x16) {
assert(h <= 128); // May overflow for larger height.
__m256i sse_16x16[2], sum_16... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x360, %rsp # imm = 0x360
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, 0x178(%rsp)
movl %esi, 0x174(%rsp)
movq %rdx, 0x168(%rsp)
movl %ecx, 0x164(%rsp)
movl %r8d, 0x160(%rsp)
movq %r9, 0x158(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vm... | /m-ab-s[P]aom/aom_dsp/x86/variance_avx2.c |
variance16_kernel_avx2 | static inline void variance16_kernel_avx2(
const uint8_t *const src, const int src_stride, const uint8_t *const ref,
const int ref_stride, __m256i *const sse, __m256i *const sum) {
const __m128i s0 = _mm_loadu_si128((__m128i const *)(src + 0 * src_stride));
const __m128i s1 = _mm_loadu_si128((__m128i const ... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x100, %rsp # imm = 0x100
movq %rdi, 0xa8(%rsp)
movl %esi, 0xa4(%rsp)
movq %rdx, 0x98(%rsp)
movl %ecx, 0x94(%rsp)
movq %r8, 0x88(%rsp)
movq %r9, 0x80(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0,... | /m-ab-s[P]aom/aom_dsp/x86/variance_avx2.c |
variance_kernel_avx2 | static inline void variance_kernel_avx2(const __m256i src, const __m256i ref,
__m256i *const sse,
__m256i *const sum) {
const __m256i adj_sub = _mm256_set1_epi16((short)0xff01); // (1,-1)
// unpack into pairs of source and reference v... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x440, %rsp # imm = 0x440
vmovaps %ymm0, 0x120(%rsp)
vmovaps %ymm1, 0x100(%rsp)
movq %rdi, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movw $0xff01, 0x21e(%rsp) # imm = 0xFF01
movw 0x21e(%rsp), %ax
movw %ax, 0x42e(%rsp)
movw %ax, 0x42c(%rsp)
movw %ax, 0x42a(%rsp)
mo... | /m-ab-s[P]aom/aom_dsp/x86/variance_avx2.c |
constrain | static inline int constrain(int diff, int threshold, int damping) {
if (!threshold) return 0;
const int shift = AOMMAX(0, damping - get_msb(threshold));
return sign(diff) *
AOMMIN(abs(diff), AOMMAX(0, threshold - (abs(diff) >> shift)));
} | subq $0x48, %rsp
movl %edi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0x5c2c84
movl $0x0, 0x44(%rsp)
jmp 0x5c2db2
movl 0x38(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x3c(%rsp), %edi
callq 0x5c2e10
movl 0x30(%rsp), %ecx
subl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x5c2ca9
xor... | /m-ab-s[P]aom/av1/common/cdef.h |
loop_filter_rows | static void loop_filter_rows(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
MACROBLOCKD *xd, int start, int stop,
const int planes_to_lf[MAX_MB_PLANE],
int lpf_opt_level) {
// Filter top rows of all planes first, in case the output can... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x2b0, %rsp # imm = 0x2B0
movl 0x2d0(%rsp), %eax
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq %rdx, 0x280(%rsp)
movl %ecx, 0x27c(%rsp)
movl %r8d, 0x278(%rsp)
movq %r9, 0x270(%rsp)
movl 0x27c(%rsp), %eax
movl %eax, 0x26c(%rsp)
movl 0x26c(%rsp), %eax
cmpl 0x278(%rsp... | /m-ab-s[P]aom/av1/common/thread_common.c |
av1_loop_restoration_alloc | void av1_loop_restoration_alloc(AV1LrSync *lr_sync, AV1_COMMON *cm,
int num_workers, int num_rows_lr,
int num_planes, int width) {
lr_sync->rows = num_rows_lr;
lr_sync->num_planes = num_planes;
#if CONFIG_MULTITHREAD
{
int i, j;
for (j = 0; ... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movl %r9d, 0x18(%rsp)
movl 0x20(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x4c(%rax)
movl 0x1c(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x50(%rax)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), ... | /m-ab-s[P]aom/av1/common/thread_common.c |
av1_cdef_init_fb_row_mt | void av1_cdef_init_fb_row_mt(const AV1_COMMON *const cm,
const MACROBLOCKD *const xd,
CdefBlockInfo *const fb_info,
uint16_t **const linebuf, uint16_t *const src,
struct AV1CdefSyncData *const cdef_sync, ... | subq $0x88, %rsp
movl 0x90(%rsp), %eax
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movq 0x80(%rsp), %rdi
callq 0x5f24f0
movl %eax, 0x54(%rsp)
movq 0x80(%rsp), %rax
movl 0x214(%rax), %eax
addl $0x10, %eax
subl $0x1, %eax
movl $0x10, %e... | /m-ab-s[P]aom/av1/common/thread_common.c |
set_segment_id | static inline void set_segment_id(uint8_t *segment_ids, int mi_offset,
int x_mis, int y_mis, int mi_stride,
uint8_t segment_id) {
segment_ids += mi_offset;
for (int y = 0; y < y_mis; ++y) {
memset(&segment_ids[y * mi_stride], segment_id,
... | subq $0x28, %rsp
movb %r9b, %al
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movb %al, 0xf(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x14(%rsp),... | /m-ab-s[P]aom/av1/common/seg_common.h |
av1_vaq_frame_setup | void av1_vaq_frame_setup(AV1_COMP *cpi) {
AV1_COMMON *cm = &cpi->common;
const RefreshFrameInfo *const refresh_frame = &cpi->refresh_frame;
const int base_qindex = cm->quant_params.base_qindex;
struct segmentation *seg = &cm->seg;
int i;
int resolution_change =
cm->prev_frame && (cm->width != cm->pre... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x3bf80, %rax # imm = 0x3BF80
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
addq $0x42d78, %rax # imm = 0x42D78
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movl 0x268(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rax
addq $0x4a38, ... | /m-ab-s[P]aom/av1/encoder/aq_variance.c |
av1_log_block_avg | int av1_log_block_avg(const AV1_COMP *cpi, const MACROBLOCK *x, BLOCK_SIZE bs,
int mi_row, int mi_col) {
// This functions returns the block average of luma block
unsigned int sum, avg, num_pix;
int r, c;
const int pic_w = cpi->common.width;
const int pic_h = cpi->common.height;
const ... | movb %dl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movl %ecx, -0x18(%rsp)
movl %r8d, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movl 0x3bfb8(%rax), %eax
movl %eax, -0x34(%rsp)
movq -0x8(%rsp), %rax
movl 0x3bfbc(%rax), %eax
movl %eax, -0x38(%rsp)
movzbl -0x11(%rsp), %eax
movl %eax, %ecx
leaq 0x51b5c... | /m-ab-s[P]aom/av1/encoder/aq_variance.c |
save_comp_rd_search_stat | static inline void save_comp_rd_search_stat(
MACROBLOCK *x, const MB_MODE_INFO *const mbmi, const int32_t *comp_rate,
const int64_t *comp_dist, const int32_t *comp_model_rate,
const int64_t *comp_model_dist, const int_mv *cur_mv, const int *comp_rs2) {
const int offset = x->comp_rd_stats_idx;
if (offset... | subq $0x58, %rsp
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x50(%rsp), %rax
movl 0x1ee50(%rax), %eax
movl %eax, 0x24(%rsp)
cmpl $0x40, 0x24(%rsp)
jge 0x607d62
movq 0x50(%rsp), %rax
ad... | /m-ab-s[P]aom/av1/encoder/compound_type.c |
compute_best_interintra_mode | static inline void compute_best_interintra_mode(
const AV1_COMP *const cpi, MB_MODE_INFO *mbmi, MACROBLOCKD *xd,
MACROBLOCK *const x, const int *const interintra_mode_cost,
const BUFFER_SET *orig_dst, uint8_t *intrapred, const uint8_t *tmp_buf,
INTERINTRA_MODE *best_interintra_mode, int64_t *best_interi... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movb 0xd8(%rsp), %al
movb 0xd0(%rsp), %al
movq 0xc8(%rsp), %rax
movq 0xc0(%rsp), %rax
movq 0xb8(%rsp), %rax
movq 0xb0(%rsp), %rax
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x70(%rsp)
movq %r9, 0x68(%rsp)
movq 0x90(%rsp), %rax... | /m-ab-s[P]aom/av1/encoder/compound_type.c |
get_rd_thresh_from_best_rd | static inline int64_t get_rd_thresh_from_best_rd(int64_t ref_best_rd,
int mul_factor,
int div_factor) {
int64_t rd_thresh = ref_best_rd;
if (div_factor != 0) {
rd_thresh = ref_best_rd < (div_factor * (INT64_MAX / m... | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpl $0x0, -0x10(%rsp)
je 0x60808c
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movslq -0x10(%rsp), %rcx
movslq -0xc(%rsp), %rsi
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cqto
idivq %rsi
mo... | /m-ab-s[P]aom/av1/encoder/rdopt_utils.h |
pick_interintra_wedge | static int64_t pick_interintra_wedge(const AV1_COMP *const cpi,
const MACROBLOCK *const x,
const BLOCK_SIZE bsize,
const uint8_t *const p0,
const uint8_t *const p1) {
con... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x100a0, %rsp # imm = 0x100A0
movb %dl, %al
movq %rdi, 0x10088(%rsp)
movq %rsi, 0x10080(%rsp)
movb %al, 0x1007f(%rsp)
movq %rcx, 0x10070(%rsp)
movq %r8, 0x10068(%rsp)
movq 0x10080(%rsp), %rax
addq $0x1a0, %rax # imm = 0x1A0
movq %rax, 0x10060(%rsp)
... | /m-ab-s[P]aom/av1/encoder/compound_type.c |
get_txfm_rd_gate_level | static inline int get_txfm_rd_gate_level(
const int is_masked_compound_enabled,
const int txfm_rd_gate_level[TX_SEARCH_CASES], BLOCK_SIZE bsize,
TX_SEARCH_CASE tx_search_case, int eval_motion_mode) {
assert(tx_search_case < TX_SEARCH_CASES);
if (tx_search_case == TX_SEARCH_MOTION_MODE && !eval_motion_mo... | movb %cl, %al
movb %dl, %cl
movl %edi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb %cl, -0x11(%rsp)
movb %al, -0x12(%rsp)
movl %r8d, -0x18(%rsp)
movzbl -0x12(%rsp), %eax
cmpl $0x1, %eax
jne 0x6094d0
cmpl $0x0, -0x18(%rsp)
jne 0x6094d0
movzbl -0x11(%rsp), %eax
movl %eax, %ecx
leaq 0x50ddb7(%rip), %rax # 0xb17270
movzbl (%... | /m-ab-s[P]aom/av1/encoder/rdopt_utils.h |
check_txfm_eval | static inline int check_txfm_eval(MACROBLOCK *const x, BLOCK_SIZE bsize,
int64_t best_skip_rd, int64_t skip_rd,
int level, int is_luma_only) {
int eval_txfm = 1;
// Derive aggressiveness factor for gating the transform search
// Lower value indic... | subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movl %r9d, (%rsp)
movl $0x1, -0x4(%rsp)
movq 0x50dc6e(%rip), %rax # 0xb172a0
movq %rax, -0x20(%rsp)
movq 0x50dc6a(%rip), %rax # 0xb172a8
movq %rax, -0x18(%rsp)
movq 0x50dc66(%... | /m-ab-s[P]aom/av1/encoder/rdopt_utils.h |
model_rd_for_sb | static inline void model_rd_for_sb(const AV1_COMP *const cpi, BLOCK_SIZE bsize,
MACROBLOCK *x, MACROBLOCKD *xd,
int plane_from, int plane_to,
int *out_rate_sum, int64_t *out_dist_sum,
... | subq $0xa8, %rsp
movb %sil, %al
movq 0xe0(%rsp), %rsi
movq 0xd8(%rsp), %rsi
movq 0xd0(%rsp), %rsi
movq 0xc8(%rsp), %rsi
movq 0xc0(%rsp), %rsi
movq 0xb8(%rsp), %rsi
movq 0xb0(%rsp), %rsi
movq %rdi, 0xa0(%rsp)
movb %al, 0x9f(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movl %r8d, 0x84(%rsp)
movl %r9d, 0x80(%rsp)
mov... | /m-ab-s[P]aom/av1/encoder/model_rd.h |
get_inter_predictors_masked_compound | static inline void get_inter_predictors_masked_compound(
MACROBLOCK *x, const BLOCK_SIZE bsize, uint8_t **preds0, uint8_t **preds1,
int16_t *residual1, int16_t *diff10, int *strides) {
MACROBLOCKD *xd = &x->e_mbd;
const int bw = block_size_wide[bsize];
const int bh = block_size_high[bsize];
// get inter... | subq $0x58, %rsp
movb %sil, %al
movq 0x60(%rsp), %rsi
movq %rdi, 0x50(%rsp)
movb %al, 0x4f(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x50(%rsp), %rax
addq $0x1a0, %rax # imm = 0x1A0
movq %rax, 0x20(%rsp)
movzbl 0x4f(%rsp), %eax
movl %eax, %ecx
leaq 0x50c... | /m-ab-s[P]aom/av1/encoder/compound_type.c |
prepare_coeffs_12tap | static inline void prepare_coeffs_12tap(const InterpFilterParams *filter_params,
int subpel_q4,
__m128i *coeffs /* [6] */) {
const int16_t *const y_filter = av1_get_interp_filter_subpel_kernel(
filter_params, subpel_q4 & SUBPEL_MASK... | subq $0x58, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
andl $0xf, %esi
callq 0x637370
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, (%rsp)
movaps (%rsp), %xmm0
pshufd $0x0... | /m-ab-s[P]aom/aom_dsp/x86/convolve_common_intrin.h |
highbd_apply_temporal_filter | static void highbd_apply_temporal_filter(
const uint16_t *frame1, const unsigned int stride, const uint16_t *frame2,
const unsigned int stride2, const int block_width, const int block_height,
const int *subblock_mses, unsigned int *accumulator, uint16_t *count,
uint32_t *frame_sse, uint32_t *luma_sse_su... | subq $0x1528, %rsp # imm = 0x1528
movl 0x1568(%rsp), %eax
movq 0x1560(%rsp), %rax
movl 0x1558(%rsp), %eax
movq 0x1550(%rsp), %rax
movq 0x1548(%rsp), %rax
movq 0x1540(%rsp), %rax
movq 0x1538(%rsp), %rax
movq 0x1530(%rsp), %rax
movq %rdi, 0x1318(%rsp)
movl %esi, 0x1314(%rsp)
movq %rdx, 0x1308(%rsp)
movl %ecx, 0... | /m-ab-s[P]aom/av1/encoder/x86/highbd_temporal_filter_sse2.c |
nn_propagate_8to1 | static void nn_propagate_8to1(const float *const inputs,
const float *const weights,
__m128 *const output) {
const __m128 inputs_h = _mm_loadu_ps(&inputs[4]);
const __m128 inputs_l = _mm_loadu_ps(inputs);
const __m128 weights_h = _mm_loadu_ps(&weights[4... | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movups (%rax), %xmm0... | /m-ab-s[P]aom/av1/encoder/x86/ml_sse3.c |
reduce_max | static inline __m128 reduce_max(__m128 reg) {
__m128 tmp_reg;
tmp_reg = _mm_shuffle_ps(reg, reg, 0x4e); // 01 00 11 10
reg = _mm_max_ps(reg, tmp_reg);
tmp_reg = _mm_shuffle_ps(reg, reg, 0xb1); // 10 11 00 01
reg = _mm_max_ps(reg, tmp_reg);
return reg;
} | movaps %xmm0, -0x58(%rsp)
movapd -0x58(%rsp), %xmm0
shufpd $0x1, %xmm0, %xmm0 # xmm0 = xmm0[1,0]
movapd %xmm0, -0x68(%rsp)
movaps -0x58(%rsp), %xmm1
movaps -0x68(%rsp), %xmm0
movaps %xmm1, -0x18(%rsp)
movaps %xmm0, -0x28(%rsp)
movaps -0x18(%rsp), %xmm0
movaps -0x28(%rsp), %xmm1
maxps %xmm1, %xmm0
movaps %xmm0, -0x... | /m-ab-s[P]aom/av1/encoder/x86/ml_sse3.c |
av1_idct8_sse2 | void av1_idct8_sse2(const __m128i *input, __m128i *output) {
const int8_t cos_bit = INV_COS_BIT;
const int32_t *cospi = cospi_arr(INV_COS_BIT);
const __m128i __rounding = _mm_set1_epi32(1 << (INV_COS_BIT - 1));
const __m128i cospi_p56_m08 = pair_set_epi16(cospi[56], -cospi[8]);
const __m128i cospi_p08_p56 = ... | subq $0x1418, %rsp # imm = 0x1418
movq %rdi, 0x6a0(%rsp)
movq %rsi, 0x698(%rsp)
movb $0xc, 0x697(%rsp)
movl $0xc, %edi
callq 0x649d00
movq %rax, 0x688(%rsp)
movl $0x800, 0x6cc(%rsp) # imm = 0x800
movl 0x6cc(%rsp), %eax
movl %eax, 0x12ec(%rsp)
movl %eax, 0x12e8(%rsp)
movl %eax, 0x12e4(%rsp)
movl %eax, 0x12e0(%... | /m-ab-s[P]aom/av1/common/x86/av1_inv_txfm_ssse3.c |
get_rect_tx_log_ratio | static inline int get_rect_tx_log_ratio(int col, int row) {
if (col == row) return 0;
if (col > row) {
if (col == row * 2) return 1;
if (col == row * 4) return 2;
assert(0 && "Unsupported transform size");
} else {
if (row == col * 2) return -1;
if (row == col * 4) return -2;
assert(0 && "... | movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0x8(%rsp), %eax
cmpl -0xc(%rsp), %eax
jne 0x6502dc
movl $0x0, -0x4(%rsp)
jmp 0x650354
movl -0x8(%rsp), %eax
cmpl -0xc(%rsp), %eax
jle 0x650319
movl -0x8(%rsp), %eax
movl -0xc(%rsp), %ecx
shll %ecx
cmpl %ecx, %eax
jne 0x6502fe
movl $0x1, -0x4(%rsp)
jmp 0x650354
movl -0x8... | /m-ab-s[P]aom/av1/common/av1_txfm.h |
transpose_16bit_8x8 | static inline void transpose_16bit_8x8(const __m128i *const in,
__m128i *const out) {
// Unpack 16 bit elements. Goes from:
// in[0]: 00 01 02 03 04 05 06 07
// in[1]: 10 11 12 13 14 15 16 17
// in[2]: 20 21 22 23 24 25 26 27
// in[3]: 30 31 32 33 34 35 36 37
// in... | subq $0x398, %rsp # imm = 0x398
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rax
movaps (%rax), %xmm1
movaps 0x10(%rax), %xmm0
movaps %xmm1, 0x100(%rsp)
movaps %xmm0, 0xf0(%rsp)
movaps 0x100(%rsp), %xmm0
movaps 0xf0(%rsp), %xmm1
punpcklwd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1... | /m-ab-s[P]aom/aom_dsp/x86/transpose_sse2.h |
av1_highbd_inv_txfm_add_16x4_sse4_1 | static void av1_highbd_inv_txfm_add_16x4_sse4_1(const tran_low_t *input,
uint8_t *dest, int stride,
const TxfmParam *txfm_param) {
int bd = txfm_param->bd;
const TX_TYPE tx_type = txfm_param->tx_type;
const TX_SIZE tx_... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movb (%rax), %al
movb %al, 0x13(%rsp)
movq 0x18(%rsp), %rax
movb 0x1(%rax), %al
movb %al, 0x12(%rsp)
movq 0x18(%rsp), %rax
movl ... | /m-ab-s[P]aom/av1/common/x86/highbd_inv_txfm_sse4.c |
av1_round_shift_array_32_sse4_1 | static inline void av1_round_shift_array_32_sse4_1(const __m128i *input,
__m128i *output,
const int size,
const int bit) {
if (bit > 0) {
int i;
for (i = 0; ... | subq $0x48, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jle 0x7a2f81
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x7a2f7f
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movdqa (%rax), %xmm0
movl ... | /m-ab-s[P]aom/av1/common/x86/av1_txfm_sse4.h |
iidentity8_sse4_1 | static void iidentity8_sse4_1(__m128i *in, __m128i *out, int bit, int do_cols,
int bd, int out_shift) {
(void)bit;
out[0] = _mm_add_epi32(in[0], in[0]);
out[1] = _mm_add_epi32(in[1], in[1]);
out[2] = _mm_add_epi32(in[2], in[2]);
out[3] = _mm_add_epi32(in[3], in[3]);
out[4] = _m... | subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movl %ecx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movl %r9d, 0x40(%rsp)
movq 0x58(%rsp), %rax
movdqa (%rax), %xmm1
movq 0x58(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm1, 0x150(%rsp)
movdqa %xmm0, 0x140(%rsp)
movdqa ... | /m-ab-s[P]aom/av1/common/x86/highbd_inv_txfm_sse4.c |
idct32x32_low8_sse4_1 | static void idct32x32_low8_sse4_1(__m128i *in, __m128i *out, int bit,
int do_cols, int bd, int out_shift) {
const int32_t *cospi = cospi_arr(bit);
const __m128i cospi62 = _mm_set1_epi32(cospi[62]);
const __m128i cospi14 = _mm_set1_epi32(cospi[14]);
const __m128i cospi54 = _mm_s... | pushq %r14
pushq %rbx
subq $0x858, %rsp # imm = 0x858
movq %rdi, 0x430(%rsp)
movq %rsi, 0x428(%rsp)
movl %edx, 0x424(%rsp)
movl %ecx, 0x420(%rsp)
movl %r8d, 0x41c(%rsp)
movl %r9d, 0x418(%rsp)
movl 0x424(%rsp), %edi
callq 0x7a1bb0
movq %rax, 0x410(%rsp)
movq 0x410(%rsp), %rax
movl 0xf8(%rax), %eax
movl %eax, ... | /m-ab-s[P]aom/av1/common/x86/highbd_inv_txfm_sse4.c |
av1_build_compound_diffwtd_mask_d16_sse4_1 | void av1_build_compound_diffwtd_mask_d16_sse4_1(
uint8_t *mask, DIFFWTD_MASK_TYPE mask_type, const CONV_BUF_TYPE *src0,
int src0_stride, const CONV_BUF_TYPE *src1, int src1_stride, int h, int w,
ConvolveParams *conv_params, int bd) {
const int which_inverse = (mask_type == DIFFWTD_38) ? 0 : 1;
const int... | subq $0x368, %rsp # imm = 0x368
movb %sil, %al
movl 0x388(%rsp), %esi
movq 0x380(%rsp), %rsi
movl 0x378(%rsp), %esi
movl 0x370(%rsp), %esi
movq %rdi, 0xf8(%rsp)
movb %al, 0xf7(%rsp)
movq %rdx, 0xe8(%rsp)
movl %ecx, 0xe4(%rsp)
movq %r8, 0xd8(%rsp)
movl %r9d, 0xd4(%rsp)
movb 0xf7(%rsp), %al
testb %al, %al
setn... | /m-ab-s[P]aom/av1/common/x86/reconinter_sse4.c |
av1_selfguided_restoration_sse4_1 | int av1_selfguided_restoration_sse4_1(const uint8_t *dgd8, int width,
int height, int dgd_stride, int32_t *flt0,
int32_t *flt1, int flt_stride,
int sgr_params_idx, int bit_depth,
... | pushq %rbx
subq $0xf0, %rsp
movl 0x118(%rsp), %eax
movl 0x110(%rsp), %eax
movl 0x108(%rsp), %eax
movl 0x100(%rsp), %eax
movq %rdi, 0xe0(%rsp)
movl %esi, 0xdc(%rsp)
movl %edx, 0xd8(%rsp)
movl %ecx, 0xd4(%rsp)
movq %r8, 0xc8(%rsp)
movq %r9, 0xc0(%rsp)
movl $0x10, %edi
movl $0x1fa40, %esi # imm = 0x1FA40
callq 0x... | /m-ab-s[P]aom/av1/common/x86/selfguided_sse4.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.