name string | code string | asm string | file string |
|---|---|---|---|
stbi__gif_load_next(stbi__context*, stbi__gif*, int*, int, unsigned char*) | static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
{
int dispose;
int first_frame;
int pi;
int pcount;
STBI_NOTUSED(req_comp);
// on first frame, any non-written pixels get the background colour (non-transparent)
first_frame = 0;
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x8(%rsi), %r13
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2
popq %rdi
testq %r13, %r13
je 0x5e5af
movl $0x302, %eax # imm = 0x302
bextrl %eax, 0x30(%r14), %esi
movl 0x4(%r14), %eax
imull (%r14), %eax
cmpl $0x3, %esi
movl %... | /laurinpaech[P]Haswellhof/src/base/stb_image.h |
stbi__readval(stbi__context*, int, unsigned char*) | static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
{
int mask=0x80, i;
for (i=0; i<4; ++i, mask>>=1) {
if (channel & mask) {
if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
dest[i]=stbi__get8(s);
}
}
return dest;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x80, %r15d
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %r12d, %r12d
cmpq $0x4, %r12
je 0x5eeb0
testl %ebp, %r15d
je 0x5ee96
movq %r14, %rdi
callq 0x5b6ff
testl %eax, %eax
jne 0x5ee9e
movq %r14, %rdi
callq 0x5b739
movb %al, (%rbx,%r12)
incq %r12
shrl... | /laurinpaech[P]Haswellhof/src/base/stb_image.h |
stbi__pnm_skip_whitespace(stbi__context*, char*) | static void stbi__pnm_skip_whitespace(stbi__context *s, char *c)
{
for (;;) {
while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
*c = (char) stbi__get8(s);
if (stbi__at_eof(s) || *c != '#')
break;
while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
*c = (char) stbi... | pushq %r15
pushq %r14
pushq %rbx
movabsq $0x100003e00, %r15 # imm = 0x100003E00
movq %rsi, %rbx
movq %rdi, %r14
movq %r14, %rdi
callq 0x5b6ff
testl %eax, %eax
je 0x5f040
movq %r14, %rdi
callq 0x5b6ff
testl %eax, %eax
jne 0x5f05b
cmpb $0x23, (%rbx)
jne 0x5f05b
movq %r14, %rdi
callq 0x5b6ff
testl %eax, %eax
jne 0x5e... | /laurinpaech[P]Haswellhof/src/base/stb_image.h |
stbi__hdr_gettoken(stbi__context*, char*) | static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
{
int len=0;
char c = '\0';
c = (char) stbi__get8(z);
while (!stbi__at_eof(z) && c != '\n') {
buffer[len++] = c;
if (len == STBI__HDR_BUFLEN-1) {
// flush to end of line
while (!stbi__at_eof(z) && stbi__get8(z) !... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x5b739
movq %r14, %rdi
movl %eax, %ebp
callq 0x5b6ff
cmpb $0xa, %bpl
je 0x5f0f8
testl %eax, %eax
jne 0x5f0f8
movb %bpl, (%rbx,%r15)
incq %r15
cmpq $0x3ff, %r15 # imm = 0x3FF
jne 0x5... | /laurinpaech[P]Haswellhof/src/base/stb_image.h |
oonf_viewer_telnet_help | enum oonf_telnet_result
oonf_viewer_telnet_help(
struct autobuf *out, const char *cmd, const char *parameter, struct oonf_viewer_template *template, size_t count)
{
const char *next;
/* skip the layer2info command, NULL output is acceptable */
next = str_hasnextword(parameter, cmd);
/* print out own help te... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
callq 0x10e0
movq %rax, %r13
leaq 0xa1e(%rip), %rsi # 0x2123
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1080
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx,... | /OLSR[P]OONF/src/base/oonf_viewer.c |
curlx_sltoui | unsigned int curlx_sltoui(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < CURL_SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_UINT);
#endif
return... | movq %rdi, %rax
retq
| /pelya[P]curl/lib/warnless.c |
curlx_uitosi | int curlx_uitosi(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_SINT);
return (int) (uinum & (unsigned int) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warni... | movl %edi, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /pelya[P]curl/lib/warnless.c |
nni_reap_sys_init | int
nni_reap_sys_init(void)
{
int rv;
reap_exit = false;
nni_mtx_init(&reap_mtx);
nni_cv_init(&reap_work_cv, &reap_mtx);
nni_cv_init(&reap_empty_cv, &reap_mtx);
// If this fails, we don't fail init, instead we will try to
// start up at reap time.
if ((rv = nni_thr_init(&reap_thr, reap_worker, NULL)) != 0) {
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb $0x0, 0x4723d(%rip) # 0x60f48
leaq 0x4718e(%rip), %rbx # 0x60ea0
movq %rbx, %rdi
callq 0x1d66c
leaq 0x471b7(%rip), %rdi # 0x60ed8
movq %rbx, %rsi
callq 0x1d694
leaq 0x471e0(%rip), %rdi # 0x60f10
movq %rbx, %rsi
callq 0x1d694
leaq 0x47211(%rip), %rdi ... | /nanomsg[P]nng/src/core/reap.c |
reap_worker | static void
reap_worker(void *unused)
{
NNI_ARG_UNUSED(unused);
nni_thr_set_name(NULL, "nng:reap2");
nni_mtx_lock(&reap_mtx);
for (;;) {
nni_reap_list *list;
bool reaped = false;
for (list = reap_list; list != NULL; list = list->rl_next) {
nni_reap_node *node;
size_t offset;
nni_c... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2abac(%rip), %rsi # 0x44927
xorl %edi, %edi
callq 0x1d91e
leaq 0x47117(%rip), %rbx # 0x60ea0
movq %rbx, %rdi
callq 0x1d680
movq 0x47130(%rip), %r15 # 0x60ec8
testq %r15, %r15
je 0x19e04
xorl %eax, %eax
movq 0... | /nanomsg[P]nng/src/core/reap.c |
nng_str_sockaddr | const char *
nng_str_sockaddr(const nng_sockaddr *sa, char *buf, size_t bufsz)
{
switch (sa->s_family) {
case NNG_AF_INPROC:
return (str_sa_inproc(&sa->s_inproc, buf, bufsz));
case NNG_AF_INET:
return (str_sa_inet(&sa->s_in, buf, bufsz));
case NNG_AF_INET6:
return (str_sa_inet6(&sa->s_in6, buf, bufsz));
case... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movzwl (%rdi), %eax
decl %eax
cmpl $0x4, %eax
ja 0x1a012
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x2a9eb(%rip), %rcx # 0x44934
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x2, %r15
leaq 0x2a9ff(%rip)... | /nanomsg[P]nng/src/core/sockaddr.c |
nng_sockaddr_port | uint32_t
nng_sockaddr_port(const nng_sockaddr *sa)
{
uint16_t port16;
switch (sa->s_family) {
case NNG_AF_INET:
NNI_GET16(&sa->s_in.sa_port, port16);
return (port16);
case NNG_AF_INET6:
NNI_GET16(&sa->s_in6.sa_port, port16);
return (port16);
default:
return (0);
}
} | pushq %rbp
movq %rsp, %rbp
movl (%rdi), %ecx
addl $-0x3, %ecx
xorl %eax, %eax
cmpw $0x1, %cx
ja 0x1a06c
movzwl 0x2(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
popq %rbp
retq
| /nanomsg[P]nng/src/core/sockaddr.c |
sock_get_fd | static int
sock_get_fd(nni_sock *s, unsigned flag, int *fdp)
{
int rv;
nni_pollable *p;
if ((flag & nni_sock_flags(s)) == 0) {
return (NNG_ENOTSUP);
}
if (flag == NNI_PROTO_FLAG_SND) {
rv = nni_msgq_get_sendable(s->s_uwq, &p);
} else {
rv = nni_msgq_get_recvable(s->s_urq, &p);
}
if (rv == 0) ... | testl %esi, 0xac(%rdi)
je 0x1a288
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpl $0x2, %esi
jne 0x1a28e
movq 0xc8(%rdi), %rdi
leaq -0x10(%rbp), %rsi
callq 0x27b70
jmp 0x1a29e
movl $0x9, %eax
retq
movq 0xd0(%rdi), %rdi
leaq -0x10(%rbp), %rsi
callq 0x27b3d
testl %eax, %eax
jne 0x1a2ae
movq -0x10(%r... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_open | int
nni_sock_open(nni_sock **sockp, const nni_proto *proto)
{
nni_sock *s = NULL;
int rv;
if (proto->proto_version != NNI_PROTOCOL_VERSION) {
// unsupported protocol version
return (NNG_ENOTSUP);
}
if ((rv = nni_sock_create(&s, proto)) != 0) {
return (rv);
}
nni_mtx_lock(&sock_lk);
if ((rv = nni_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x9, %r15d
cmpl $0x50520003, (%rsi) # imm = 0x50520003
jne 0x1a820
movq %rsi, %r12
movq %rdi, %r13
movq 0x30(%rsi), %rax
movl $0x558, %edi # imm = 0x558
addq (%rax), %rdi
callq 0x1e787
movq %rax, %rbx... | /nanomsg[P]nng/src/core/socket.c |
sock_destroy | static void
sock_destroy(nni_sock *s)
{
#ifdef NNG_ENABLE_STATS
nni_stat_unregister(&s->st_root);
#endif
// The protocol needs to clean up its state.
if (s->s_data != NULL) {
s->s_sock_ops.sock_fini(s->s_data);
}
nni_msgq_fini(s->s_urq);
nni_msgq_fini(s->s_uwq);
nni_cv_fini(&s->s_close_cv);
nni_cv_fini(&s->... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x298, %rdi # imm = 0x298
callq 0x1c4a6
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x1a926
callq *0x138(%rbx)
movq 0xd0(%rbx), %rdi
callq 0x27532
movq 0xc8(%rbx), %rdi
callq 0x27532
leaq 0x70(%rbx), %rdi
callq 0x1d69e
leaq 0x38(%rbx), %rdi... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_remove_listener | void
nni_sock_remove_listener(nni_listener *l)
{
nni_sock *s = l->l_sock;
nni_mtx_lock(&s->s_mx);
NNI_ASSERT(nni_list_node_active(&l->l_node));
nni_list_node_remove(&l->l_node);
nni_mtx_unlock(&s->s_mx);
// also drop the hold from the socket
nni_listener_rele(l);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x90(%rdi), %r14
addq $0x10, %r14
movq %r14, %rdi
callq 0x1d680
leaq 0x80(%rbx), %r15
movq %r15, %rdi
callq 0x17779
testl %eax, %eax
jne 0x1b0dc
leaq 0x28e9e(%rip), %rdi # 0x43f60
leaq 0x29967(%rip), %rsi # 0x44a30
leaq ... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_add_dialer | int
nni_sock_add_dialer(nni_sock *s, nni_dialer *d)
{
int rv;
// grab a hold on the dialer for the socket
if ((rv = nni_dialer_hold(d)) != 0) {
return (rv);
}
// copy initial values for some options from socket
for (int i = 0; ep_options[i].eo_name != NULL; i++) {
uint64_t val; // big enough
co... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, -0x30(%rbp)
movq %rsi, %rdi
callq 0x164b3
testl %eax, %eax
jne 0x1b22d
movq %rbx, -0x48(%rbp)
leaq 0x29091(%rip), %r13 # 0x441c2
movl $0x10, %r12d
movq $0x0, -0x40(%rbp)
leaq 0x425ca(%rip), ... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_remove_dialer | void
nni_sock_remove_dialer(nni_dialer *d)
{
nni_sock *s = d->d_sock;
nni_mtx_lock(&s->s_mx);
NNI_ASSERT(nni_list_node_active(&d->d_node));
nni_list_node_remove(&d->d_node);
nni_mtx_unlock(&s->s_mx);
// also drop the hold from the socket
nni_dialer_rele(d);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x80(%rdi), %r14
addq $0x10, %r14
movq %r14, %rdi
callq 0x1d680
leaq 0x70(%rbx), %r15
movq %r15, %rdi
callq 0x17779
testl %eax, %eax
jne 0x1b28d
leaq 0x28ced(%rip), %rdi # 0x43f60
leaq 0x297b6(%rip), %rsi # 0x44a30
leaq ... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_set_pipe_cb | void
nni_sock_set_pipe_cb(nni_sock *s, int ev, nng_pipe_cb cb, void *arg)
{
if ((ev > NNG_PIPE_EV_NONE) && (ev < NNG_PIPE_EV_NUM)) {
nni_mtx_lock(&s->s_pipe_cbs_mtx);
s->s_pipe_cbs[ev].cb_fn = cb;
s->s_pipe_cbs[ev].cb_arg = arg;
s->s_want_evs = false;
for (ev = NNG_PIPE_EV_NONE; ev < NNG_PIPE_EV_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r13d
leal -0x1(%r13), %eax
cmpl $0x2, %eax
ja 0x1b3d7
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x228(%rdi), %r14
movq %r14, %rdi
callq 0x1d680
leaq 0x250(%rbx), %rax
movl %r13d, %ecx
shlq $0x4, %rcx
movq... | /nanomsg[P]nng/src/core/socket.c |
nni_ctx_find | int
nni_ctx_find(nni_ctx **cp, uint32_t id)
{
int rv = 0;
nni_ctx *ctx;
nni_mtx_lock(&sock_lk);
if ((ctx = nni_id_get(&ctx_ids, id)) != NULL) {
// We refuse a reference if either the socket is
// closed, or the context is closed. (If the socket
// is closed, and we are only getting the reference so
/... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x45bee(%rip), %rdi # 0x60fe8
callq 0x1d680
movl %r14d, %esi
leaq 0x441af(%rip), %rdi # 0x5f5b8
callq 0x16c3d
movl $0x7, %r14d
testq %rax, %rax
je 0x1b435
cmpb $0x0, 0x58(%rax)
jne 0x1b435
movq 0x10(%rax), %rcx
cmpb $0x0, 0x2... | /nanomsg[P]nng/src/core/socket.c |
nni_ctx_rele | void
nni_ctx_rele(nni_ctx *ctx)
{
nni_sock *sock = ctx->c_sock;
nni_mtx_lock(&sock_lk);
ctx->c_ref--;
if ((ctx->c_ref > 0) || (!ctx->c_closed)) {
// Either still have an active reference, or not
// actually closing yet.
nni_mtx_unlock(&sock_lk);
return;
}
// Remove us from the hash, so we can't be found ... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
leaq 0x45b80(%rip), %rdi # 0x60fe8
callq 0x1d680
decl 0x5c(%rbx)
jne 0x1b4ca
cmpb $0x0, 0x58(%rbx)
je 0x1b4ca
movl 0x60(%rbx), %esi
leaq 0x44136(%rip), %rdi # 0x5f5b8
callq 0x16d6c
leaq 0x208(%r14), %rdi
movq %rbx, %rsi
callq... | /nanomsg[P]nng/src/core/socket.c |
nni_pipe_start | void
nni_pipe_start(nni_pipe *p)
{
// exactly one of these must be set.
NNI_ASSERT(p->p_listener == NULL || p->p_dialer == NULL);
NNI_ASSERT(p->p_listener != NULL || p->p_dialer != NULL);
// NB: starting the pipe can actually cause the pipe
// to be deallocated before this returns (if it is rejected)
if (p->p_li... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
cmpq $0x0, 0xc8(%rdi)
je 0x1bbcd
cmpq $0x0, 0xc0(%rbx)
je 0x1bbcd
leaq 0x283ad(%rip), %rdi # 0x43f60
leaq 0x28e76(%rip), %rsi # 0x44a30
leaq 0x28f98(%rip), %rcx # 0x44b59
movl $0x602, %edx # im... | /nanomsg[P]nng/src/core/socket.c |
xreq0_putq_cb | static void
xreq0_putq_cb(void *arg)
{
xreq0_pipe *p = arg;
if (nni_aio_result(&p->aio_putq) != 0) {
nni_msg_free(nni_aio_get_msg(&p->aio_putq));
nni_aio_set_msg(&p->aio_putq, NULL);
nni_pipe_close(p->pipe);
return;
}
nni_aio_set_msg(&p->aio_putq, NULL);
nni_pipe_recv(p->pipe, &p->aio_recv);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x568(%rdi), %r14
movq %r14, %rdi
callq 0x14dab
testl %eax, %eax
je 0x21e09
movq %r14, %rdi
callq 0x14d42
movq %rax, %rdi
callq 0x188d9
movq %r14, %rdi
xorl %esi, %esi
callq 0x14d35
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1950b
movq %r1... | /nanomsg[P]nng/src/sp/protocol/reqrep0/xreq.c |
nuts_clock | uint64_t
nuts_clock(void)
{
#ifdef _WIN32
return (GetTickCount64());
#elif defined(CLOCK_MONTONIC)
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
uint64_t val;
val = ts.tv_sec;
val *= 1000;
val += ts.tv_nsec / 1000000;
return (val);
#else
static time_t epoch;
struct timeval tv;
if (epoch == 0) {... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x3d2e9(%rip) # 0x61210
jne 0x23f37
xorl %edi, %edi
callq 0x9800
movq %rax, 0x3d2d9(%rip) # 0x61210
xorl %ebx, %ebx
leaq -0x20(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x9210
movq (%r14), %rcx
subq 0x3d2bf(%rip), %rcx # 0x... | /nanomsg[P]nng/src/testing/util.c |
nuts_poll_fd | bool
nuts_poll_fd(int fd)
{
#ifdef _WIN32
struct pollfd pfd;
pfd.fd = (SOCKET) fd;
pfd.events = POLLRDNORM;
pfd.revents = 0;
switch (WSAPoll(&pfd, 1, 0)) {
case 0:
return (false);
case 1:
return (true);
}
#else
struct pollfd pfd;
pfd.fd = fd;
pfd.events = POLLRDNORM;
pfd.revents = 0;
swi... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rax
movl %edi, (%rax)
movl $0x40, 0x4(%rax)
movl $0x1, %esi
movq %rax, %rdi
xorl %edx, %edx
callq 0x9440
cmpl $0x1, %eax
sete %al
addq $0x10, %rsp
popq %rbp
retq
| /nanomsg[P]nng/src/testing/util.c |
nuts_sleep | void
nuts_sleep(int msec)
{
#ifdef _WIN32
Sleep(msec);
#elif defined(CLOCK_MONOTONIC)
struct timespec ts;
ts.tv_sec = msec / 1000;
ts.tv_nsec = (msec % 1000) * 1000000;
// Do this in a loop, so that interrupts don't actually wake us.
while (ts.tv_sec || ts.tv_nsec) {
if (nanosleep(&ts, &ts) == 0) {
break;... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movslq %edi, %rax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
movslq %ecx, %rcx
leaq -0x18(%rbp), %rbx
movq %rcx, (%rbx)
imull $0x3e8, %ecx, %ecx # imm = 0x3E8
subl %ecx, %eax
imull $0xf424... | /nanomsg[P]nng/src/testing/util.c |
nuts_has_ipv6 | bool
nuts_has_ipv6(void)
{
nng_sockaddr sa = { 0 };
nng_udp *u;
int rv;
sa.s_in6.sa_family = NNG_AF_INET6;
sa.s_in6.sa_port = 0;
memset(sa.s_in6.sa_addr, 0, 16);
sa.s_in6.sa_addr[15] = 1;
rv = nng_udp_open(&u, &sa);
if (rv == 0) {
nng_udp_close(u);
}
return (rv == 0 ? 1 : 0);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x98, %rsp
leaq -0x98(%rbp), %rbx
movl $0x88, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x90a0
movw $0x4, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x2(%rbx)
movw $0x0, 0x12(%rbx)
movb $0x1, 0x13(%rbx)
leaq -0x10(%rbp), %rdi
movq %rbx, %rsi
callq 0x148e6
movl %eax, %ebx
testl ... | /nanomsg[P]nng/src/testing/util.c |
ipc_ep_init_listener | static int
ipc_ep_init_listener(void *arg, nng_url *url, nni_listener *listener)
{
ipc_ep *ep = arg;
int rv;
nni_sock *sock = nni_listener_sock(listener);
ipc_ep_init(ep, sock, ipc_ep_accept_cb);
ep->nlistener = listener;
if ((rv = nng_stream_listener_alloc_url(&ep->listener, url)) != 0) {
return (rv)... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0x17fd5
leaq 0x1d9(%rip), %rdx # 0x2b306
movq %r14, %rdi
movq %rax, %rsi
callq 0x2ae1e
movq %rbx, 0x48(%r14)
leaq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x36282
testl %eax, ... | /nanomsg[P]nng/src/sp/transport/ipc/ipc.c |
tcptran_dialer_setopt | static int
tcptran_dialer_setopt(
void *arg, const char *name, const void *buf, size_t sz, nni_type t)
{
tcptran_ep *ep = arg;
int rv;
rv = nni_stream_dialer_set(ep->dialer, name, buf, sz, t);
if (rv == NNG_ENOTSUP) {
rv = nni_setopt(tcptran_ep_opts, name, ep, buf, sz, t);
}
return (rv);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq 0x410(%rdi), %rdi
callq 0x361af
cmpl $0x9, %eax
jne 0x2c3ca
leaq 0x31a18(%rip), %rdi # 0x5ddc0
movq %r13, %rsi
movq %r12, %rdx
movq %r15, ... | /nanomsg[P]nng/src/sp/transport/tcp/tcp.c |
tcptran_ep_init | static void
tcptran_ep_init(tcptran_ep *ep, nni_sock *sock, void (*conn_cb)(void *))
{
nni_mtx_init(&ep->mtx);
NNI_LIST_INIT(&ep->waitpipes, tcptran_pipe, node);
NNI_LIST_INIT(&ep->negopipes, tcptran_pipe, node);
ep->proto = nni_sock_proto_id(sock);
nni_aio_init(&ep->connaio, conn_cb, ep);
nni_aio_init(&ep->time... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1d66c
leaq 0x3e0(%rbx), %rdi
movl $0x28, %esi
callq 0x17560
leaq 0x3f8(%rbx), %rdi
movl $0x28, %esi
callq 0x17560
movq %r15, %rdi
callq 0x1ae0e
movw %ax, 0x28(%rbx)
leaq 0x50(%rbx), %rdi
movq %... | /nanomsg[P]nng/src/sp/transport/tcp/tcp.c |
tcptran_dial_cb | static void
tcptran_dial_cb(void *arg)
{
tcptran_ep *ep = arg;
nni_aio *aio = &ep->connaio;
tcptran_pipe *p;
int rv;
nng_stream *conn;
nni_mtx_lock(&ep->mtx);
if ((rv = nni_aio_result(aio)) != 0) {
goto error;
}
conn = nni_aio_get_output(aio, 0);
if (ep->closed) {
nng_stream_free(co... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x50(%rdi), %r15
callq 0x1d680
movq %r15, %rdi
callq 0x14dab
movl %eax, %r14d
testl %eax, %eax
jne 0x2c4c1
movq %r15, %rdi
xorl %esi, %esi
callq 0x14d92
movq %rax, %r15
movl $0x7, %r14d
cmpb $0x0, 0x3a(%rbx)
jne 0x2c4b9
movq 0x4... | /nanomsg[P]nng/src/sp/transport/tcp/tcp.c |
tcptran_pipe_start | static void
tcptran_pipe_start(tcptran_pipe *p, nng_stream *conn, tcptran_ep *ep)
{
nni_iov iov;
p->conn = conn;
p->ep = ep;
p->proto = ep->proto;
p->txlen[0] = 0;
p->txlen[1] = 'S';
p->txlen[2] = 'P';
p->txlen[3] = 0;
NNI_PUT16(&p->txlen[4], p->proto);
NNI_PUT16(&p->txlen[6], 0);
p->gotrxhead = 0;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x38(%rdi)
movzwl 0x28(%rdx), %eax
movw %ax, 0x12(%rdi)
leaq 0x40(%rdi), %rcx
xorl %edx, %edx
movb %dl, 0x40(%rdi)
movb $0x53, 0x41(%rdi)
movb $0x50, 0x42(%rdi)
movb %dl, 0x43(%rdi)
... | /nanomsg[P]nng/src/sp/transport/tcp/tcp.c |
tcptran_ep_cancel | static void
tcptran_ep_cancel(nni_aio *aio, void *arg, int rv)
{
tcptran_ep *ep = arg;
nni_mtx_lock(&ep->mtx);
if (ep->useraio == aio) {
ep->useraio = NULL;
nni_aio_finish_error(aio, rv);
}
nni_mtx_unlock(&ep->mtx);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1d680
cmpq %r15, 0x48(%rbx)
jne 0x2c615
movq $0x0, 0x48(%rbx)
movq %r15, %rdi
movl %r14d, %esi
callq 0x1515e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq ... | /nanomsg[P]nng/src/sp/transport/tcp/tcp.c |
tcptran_ep_get_recvmaxsz | static int
tcptran_ep_get_recvmaxsz(void *arg, void *v, size_t *szp, nni_opt_type t)
{
tcptran_ep *ep = arg;
int rv;
nni_mtx_lock(&ep->mtx);
rv = nni_copyout_size(ep->rcvmax, v, szp, t);
nni_mtx_unlock(&ep->mtx);
return (rv);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1d680
movq 0x30(%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x1915d
movl %eax, %ebx
movq %r12, %rdi
callq 0x1d68a
movl %ebx, %eax
popq %rbx
popq %r12
popq ... | /nanomsg[P]nng/src/sp/transport/tcp/tcp.c |
tcptran_ep_set_recvmaxsz | static int
tcptran_ep_set_recvmaxsz(void *arg, const void *v, size_t sz, nni_opt_type t)
{
tcptran_ep *ep = arg;
size_t val;
int rv;
if ((rv = nni_copyin_size(&val, v, sz, 0, NNI_MAXSZ, t)) == 0) {
nni_mtx_lock(&ep->mtx);
ep->rcvmax = val;
nni_mtx_unlock(&ep->mtx);
#ifdef NNG_ENABLE_STATS
nni_s... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r9d
movq %rdi, %rbx
leaq -0x18(%rbp), %rdi
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x1907a
movl %eax, %r14d
testl %eax, %eax
jne 0x2c6bd
movq %rbx, %rdi
callq 0x1d680
movq -0x18(%rbp), %rax
movq %rax, 0x30(%rbx)
... | /nanomsg[P]nng/src/sp/transport/tcp/tcp.c |
nng_http_handler_alloc_directory | nng_err
nng_http_handler_alloc_directory(
nng_http_handler **hp, const char *uri, const char *path)
{
#ifdef NNG_SUPP_HTTP
return (nni_http_handler_init_directory(hp, uri, path));
#else
NNI_ARG_UNUSED(hp);
NNI_ARG_UNUSED(uri);
NNI_ARG_UNUSED(path);
return (NNG_ENOTSUP);
#endif
} | pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0x3dbeb
| /nanomsg[P]nng/src/supplemental/http/http_public.c |
http_txn_cb | static void
http_txn_cb(void *arg)
{
http_txn *txn = arg;
const char *str;
char *end;
nng_err rv;
uint64_t len;
nni_iov iov;
char *dst;
size_t sz;
nni_http_chunk *chunk = NULL;
nni_mtx_lock(&http_txn_lk);
if ((rv = nni_aio_result(&txn->aio)) != N... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x27a68(%rip), %rdi # 0x61520
callq 0x1d680
movq %rbx, %rdi
callq 0x14dab
testl %eax, %eax
je 0x39afa
movq %rbx, %rdi
movl %eax, %esi
callq 0x39de1
leaq 0x27a46(%rip), %rdi # 0x61520
callq 0x1d68a
leaq 0... | /nanomsg[P]nng/src/supplemental/http/http_client.c |
nni_http_set_header | static nng_err
http_set_header(nng_http *conn, const char *key, const char *val)
{
nni_http_entity *data =
conn->client ? &conn->req.data : &conn->res.data;
http_header *h;
NNI_LIST_FOREACH (&data->hdrs, h) {
if (nni_strcasecmp(key, h->name) == 0) {
char *news;
if ((news = nni_strdup(val)) == NULL) {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
callq 0x3b5eb
xorl %ebx, %ebx
testb %al, %al
jne 0x3b800
leaq 0x530(%r13), %r15
cmpb $0x0, 0x8e1(%r13)
leaq 0x408(%r13), %rax
cmovneq %rax, %r15
addq $0xf8, %r15
movq %r15, %rdi
c... | /nanomsg[P]nng/src/supplemental/http/http_conn.c |
Am_Input_Char::operator==(Am_Input_Char) const | bool operator==(Am_Input_Char i) const
{
//quick exit for mouse_moved == something else, for efficiency.
// Mouse-moved doesn't match ANY-* so is an easy test
if ((i.code == Am_MOUSE_MOVED && code != Am_MOUSE_MOVED) ||
(code == Am_MOUSE_MOVED && i.code != Am_MOUSE_MOVED))
return false;
e... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %esi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movswl -0x8(%rbp), %eax
cmpl $0x103, %eax # imm = 0x103
jne 0x2db0
movq -0x20(%rbp), %rax
movswl (%rax), %eax
cmpl $0x103, %eax # imm = 0x103
jne 0x2dc9
movq -0x20... | /ProgrammerArchaeology[P]openamulet/include/amulet/idefs.h |
WebPAllocateDecBuffer | VP8StatusCode WebPAllocateDecBuffer(int width, int height,
const WebPDecoderOptions* const options,
WebPDecBuffer* const buffer) {
VP8StatusCode status;
if (buffer == NULL || width <= 0 || height <= 0) {
return VP8_STATUS_INVALID_PARAM;
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x2, %ebp
testl %esi, %esi
jle 0xa814
testl %edi, %edi
jle 0xa814
movq %rcx, %rbx
testq %rcx, %rcx
je 0xa814
movq %rdx, %r14
movl %esi, %r15d
testq %rdx, %rdx
je 0xa6ac
cmpl $0x0, 0x8(%r14)
je 0xa676
movl 0x14(%r14), %r12d
movl 0x1... | /PKRoma[P]libwebp/src/dec/buffer_dec.c |
WebPIAppend | VP8StatusCode WebPIAppend(WebPIDecoder* idec,
const uint8_t* data, size_t data_size) {
VP8StatusCode status;
if (idec == NULL || data == NULL) {
return VP8_STATUS_INVALID_PARAM;
}
status = IDecCheckStatus(idec);
if (status != VP8_STATUS_SUSPENDED) {
return status;
}
// Ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0x2, %ebp
jne 0xb13a
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdi), %edx
xorl %eax, %eax
cmpl $0x6, %edx
setne %al
leal (%rax,%rax,4), %eax
cmpl $0x7, %edx
movl $0x3, %... | /PKRoma[P]libwebp/src/dec/idec_dec.c |
FinishDecoding | static VP8StatusCode FinishDecoding(WebPIDecoder* const idec) {
const WebPDecoderOptions* const options = idec->params_.options;
WebPDecBuffer* const output = idec->params_.output;
idec->state_ = STATE_DONE;
if (options != NULL && options->flip) {
const VP8StatusCode status = WebPFlipBuffer(output);
if... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x30(%rdi), %rax
movl $0x6, (%rdi)
testq %rax, %rax
je 0xbd9d
cmpl $0x0, 0x30(%rax)
je 0xbd9d
movq %r14, %rdi
callq 0xa56c
movl %eax, %ebp
testl %eax, %eax
jne 0xbddc
movq 0x1d8(%rbx), %rsi
xorl %ebp, %ebp
testq %rsi, %rsi
je 0xbddc
movq %r14, %... | /PKRoma[P]libwebp/src/dec/idec_dec.c |
CustomSetup | static int CustomSetup(VP8Io* io) {
WebPDecParams* const p = (WebPDecParams*)io->opaque;
const WEBP_CSP_MODE colorspace = p->output->colorspace;
const int is_rgb = WebPIsRGBMode(colorspace);
const int is_alpha = WebPIsAlphaMode(colorspace);
p->memory = NULL;
p->emit = NULL;
p->emit_alpha = NULL;
p->emi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %r13
movq (%r13), %rax
movl (%rax), %r12d
cmpl $0xc, %r12d
ja 0xbf37
movl $0x103a, %eax # imm = 0x103A
btl %r12d, %eax
jae 0xbf37
leaq 0x50(%r13), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r13... | /PKRoma[P]libwebp/src/dec/io_dec.c |
EmitFancyRGB | static int EmitFancyRGB(const VP8Io* const io, WebPDecParams* const p) {
int num_lines_out = io->mb_h; // a priori guess
const WebPRGBABuffer* const buf = &p->output->u.RGBA;
uint8_t* dst = buf->rgba + (size_t)io->mb_y * buf->stride;
WebPUpsampleLinePairFunc upsample = WebPUpsamplers[p->output->colorspace];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl 0x10(%rdi), %r13d
movq (%rsi), %rcx
movslq 0x8(%rdi), %r14
movslq 0x18(%rcx), %rax
movq %rax, %r15
imulq %r14, %r15
addq 0x10(%rcx), %r15
movslq 0xc(%rdi), %r11
movq %rcx, 0x28(%rsp)
movl (%rcx), %ecx
leaq 0x5d3a9(%rip), %rdx # ... | /PKRoma[P]libwebp/src/dec/io_dec.c |
EmitAlphaRGBA4444 | static int EmitAlphaRGBA4444(const VP8Io* const io, WebPDecParams* const p,
int expected_num_lines_out) {
const uint8_t* alpha = io->a;
if (alpha != NULL) {
const int mb_w = io->mb_w;
const WEBP_CSP_MODE colorspace = p->output->colorspace;
const WebPRGBABuffer* const buf = &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x98(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0xc866
movq %rdi, %r14
movl 0xc(%rdi), %ebx
movq (%rsi), %r12
movl (%r12), %ebp
movq %rsp, %rsi
leaq 0xc(%rsp), %r15
movq %r15, %rdx
callq 0xd00a
movl (%r15), %edx
testl %edx, %edx
jle 0xc... | /PKRoma[P]libwebp/src/dec/io_dec.c |
EmitAlphaYUV | static int EmitAlphaYUV(const VP8Io* const io, WebPDecParams* const p,
int expected_num_lines_out) {
const uint8_t* alpha = io->a;
const WebPYUVABuffer* const buf = &p->output->u.YUVA;
const int mb_w = io->mb_w;
const int mb_h = io->mb_h;
uint8_t* dst = buf->a + (size_t)io->mb_y * buf-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x98(%rdi), %r12
movq (%rsi), %r13
movslq 0xc(%rdi), %rbx
movl 0x10(%rdi), %ebp
movq 0x28(%r13), %rax
movslq 0x8(%rdi), %r14
movslq 0x3c(%r13), %rdx
imulq %rdx, %r14
addq %rax, %r14
testq %r12, %r12
je 0xc99a
testl %ebp, %ebp
jle 0xc9c6
m... | /PKRoma[P]libwebp/src/dec/io_dec.c |
EmitRescaledAlphaRGB | static int EmitRescaledAlphaRGB(const VP8Io* const io, WebPDecParams* const p,
int expected_num_out_lines) {
if (io->a != NULL) {
WebPRescaler* const scaler = p->scaler_a;
int lines_left = expected_num_out_lines;
const int y_end = p->last_y + lines_left;
while (lines_le... | cmpq $0x0, 0x98(%rdi)
je 0xcbe6
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
testl %edx, %edx
jle 0xcbde
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rsi), %r12
movl 0x20(%rsi), %ebp
addl %ebx, %ebp
movslq 0x3c(%r12), %rax
movslq 0x8(%r15), %rsi
movq %rax, %rdx
subq %rsi, %rdx
subl %eax, %esi
ad... | /PKRoma[P]libwebp/src/dec/io_dec.c |
EmitRescaledAlphaYUV | static int EmitRescaledAlphaYUV(const VP8Io* const io, WebPDecParams* const p,
int expected_num_lines_out) {
const WebPYUVABuffer* const buf = &p->output->u.YUVA;
uint8_t* const dst_a = buf->a + (size_t)p->last_y * buf->a_stride;
if (io->a != NULL) {
uint8_t* const dst_y = buf-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r12
movq 0x28(%r12), %rcx
movslq 0x20(%rsi), %r13
movslq 0x3c(%r12), %r15
movq %r15, %rbx
imulq %r13, %rbx
addq %rcx, %rbx
movq 0x98(%rdi), %rax
testq %rax, %rax
je 0xcf6a
movq %rsi, %r14
movq 0x10(%r12), %r15
movslq 0x30(%r12), ... | /PKRoma[P]libwebp/src/dec/io_dec.c |
ParsePartitions | static VP8StatusCode ParsePartitions(VP8Decoder* const dec,
const uint8_t* buf, size_t size) {
VP8BitReader* const br = &dec->br_;
const uint8_t* sz = buf;
const uint8_t* buf_end = buf + size;
const uint8_t* part_start;
size_t size_left = size;
size_t last_part;
size_t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
addq $0x10, %rdi
movl $0x2, %esi
callq 0x30593
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edx
notl %edx
movl %edx, 0x1b0(%r14)
leaq (%rdx,%rdx,2), %rsi
movl ... | /PKRoma[P]libwebp/src/dec/vp8_dec.c |
DecodeImageStream | static int DecodeImageStream(int xsize, int ysize,
int is_level0,
VP8LDecoder* const dec,
uint32_t** const decoded_data) {
int ok = 1;
int transform_xsize = xsize;
int transform_ysize = ysize;
VP8LBitReader* const br = &dec->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rsi, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
leaq 0x28(%rcx), %rbx
leaq 0x98(%rcx), %rax
movq %rax, 0x70(%rsp)
movl %edx, 0x1c(%rsp)
testl %edx, %edx
movq %r8, 0x90(%rsp)
je 0xff22
leaq 0xf8(%r14), %r13
movq %rbx, %rdi
mov... | /PKRoma[P]libwebp/src/dec/vp8l_dec.c |
VP8LDecodeAlphaImageStream | int VP8LDecodeAlphaImageStream(ALPHDecoder* const alph_dec, int last_row) {
VP8LDecoder* const dec = alph_dec->vp8l_dec_;
assert(dec != NULL);
assert(last_row <= dec->height_);
if (dec->last_row_ >= last_row) {
return 1; // done
}
if (!alph_dec->use_8b_decode_) WebPInitAlphaProcessing();
// Decode... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x18(%rdi), %rbx
movl $0x1, %eax
cmpl %esi, 0x8c(%rbx)
jge 0x10e00
movl %esi, %r13d
movq %rdi, %r14
cmpl $0x0, 0xc0(%rdi)
jne 0x10797
callq 0x135d3
cmpl $0x0, 0xc0(%r14)
je 0x10d53
movl 0x84(%rbx), %ebp
movl 0x90(%rbx), %ecx
movl %e... | /PKRoma[P]libwebp/src/dec/vp8l_dec.c |
VP8LDecodeHeader | int VP8LDecodeHeader(VP8LDecoder* const dec, VP8Io* const io) {
int width, height, has_alpha;
if (dec == NULL) return 0;
if (io == NULL) {
dec->status_ = VP8_STATUS_INVALID_PARAM;
return 0;
}
dec->io_ = io;
dec->status_ = VP8_STATUS_OK;
VP8LInitBitReader(&dec->br_, io->data, io->data_size);
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x118df
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x118c7
movq %r14, 0x8(%rbx)
movl $0x0, (%rbx)
leaq 0x28(%rbx), %r15
movq 0x60(%r14), %rdx
movq 0x68(%r14), %rsi
movq %r15, %rdi
callq 0x3068d
leaq 0x10(%rsp), %rs... | /PKRoma[P]libwebp/src/dec/vp8l_dec.c |
ExtractPalettedAlphaRows | static void ExtractPalettedAlphaRows(VP8LDecoder* const dec, int last_row) {
// For vertical and gradient filtering, we need to decode the part above the
// crop_top row, in order to have the correct spatial predictors.
ALPHDecoder* const alph_dec = (ALPHDecoder*)dec->io_->opaque;
const int top_row =
(alp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x38(%rax), %r13
leaq 0x80(%rax), %rcx
leaq 0x8c(%rdi), %rdx
cmpl $0x2, 0xc(%r13)
cmovbq %rcx, %rdx
movl %esi, %r12d
movl (%rdx), %esi
movl 0x8c(%rdi), %ecx
cmpl %esi, %ecx
cmovgl %ecx, %esi
movl... | /PKRoma[P]libwebp/src/dec/vp8l_dec.c |
DecodeIntoRGBABuffer | static uint8_t* DecodeIntoRGBABuffer(WEBP_CSP_MODE colorspace,
const uint8_t* const data,
size_t data_size,
uint8_t* const rgba,
int stride, size_t size) {
WebPDecParams ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
testq %rcx, %rcx
je 0x129a1
movl %r8d, %ebp
movq %rcx, %rbx
movq %rsi, %r12
movl %edi, %r14d
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movl $0x209, %esi # imm = 0x209
movq %rdx, 0x8(%rsp)
movq %r9, (%rsp)
callq 0xa832
xorps %xmm0,... | /PKRoma[P]libwebp/src/dec/webp_dec.c |
TransformOne_C | static void TransformOne_C(const int16_t* in, uint8_t* dst) {
int C[4 * 4], *tmp;
int i;
tmp = C;
for (i = 0; i < 4; ++i) { // vertical pass
const int a = in[0] + in[8]; // [-4096, 4094]
const int b = in[0] - in[8]; // [-4095, 4095]
const int c = MUL2(in[4]) - MUL1(in[12]); // [-3783, 378... | pushq %rbx
movq (%rdi), %xmm0
punpcklwd %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3]
psrad $0x10, %xmm0
movq 0x10(%rdi), %xmm1
punpcklwd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3]
psrad $0x10, %xmm2
movdqa %xmm2, %xmm1
paddd %xmm0, %xmm1
psubd %xmm2, %xmm0
movq 0x8(%rdi),... | /PKRoma[P]libwebp/src/dsp/dec.c |
WebPCopyPixels | void WebPCopyPixels(const WebPPicture* const src, WebPPicture* const dst) {
assert(src != NULL && dst != NULL);
assert(src->width == dst->width && src->height == dst->height);
assert(src->use_argb && dst->use_argb);
WebPCopyPlane((uint8_t*)src->argb, 4 * src->argb_stride, (uint8_t*)dst->argb,
4 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0xc(%rdi), %ebp
testl %ebp, %ebp
jle 0x31565
movslq 0x8(%rdi), %rbx
shlq $0x2, %rbx
movslq 0x50(%rsi), %r12
shlq $0x2, %r12
movq 0x48(%rsi), %r14
movslq 0x50(%rdi), %r13
shlq $0x2, %r13
movq 0x48(%rdi), %r15
incl %ebp
movq %r14, %rdi
movq... | /PKRoma[P]libwebp/src/utils/utils.c |
VP8InitDithering | void VP8InitDithering(const WebPDecoderOptions* const options,
VP8Decoder* const dec) {
assert(dec != NULL);
if (options != NULL) {
const int d = options->dithering_strength;
const int max_amp = (1 << VP8_RANDOM_DITHER_FIX) - 1;
const int f = (d < 0) ? 0 : (d > 100) ? max_amp : (d ... | testq %rdi, %rdi
je 0x31bac
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x2c(%rdi), %ecx
testl %ecx, %ecx
js 0x31b85
movl $0xff, %eax
cmpl $0x64, %ecx
ja 0x31b12
testl %ecx, %ecx
je 0x31b85
movl %ecx, %eax
shll $0x8, %eax
subl %ecx, %eax
movzwl %ax, %eax
shrl $0x2, %eax
imull $0x147b, %eax, %e... | /PKRoma[P]libwebp/src/dec/frame_dec.c |
ReconstructRow | static void ReconstructRow(const VP8Decoder* const dec,
const VP8ThreadContext* ctx) {
int j;
int mb_x;
const int mb_y = ctx->mb_y_;
const int cache_id = ctx->id_;
uint8_t* const y_dst = dec->yuv_b_ + Y_OFF;
uint8_t* const u_dst = dec->yuv_b_ + U_OFF;
uint8_t* const v_dst = dec-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r12
movl 0x4(%rsi), %eax
movl %eax, 0xc(%rsp)
movq %rsi, 0x80(%rsp)
movslq (%rsi), %rsi
movq 0xb20(%rdi), %rbp
leaq 0x248(%rbp), %rax
movq %rax, 0x38(%rsp)
xorl %eax, %eax
movb $-0x7f, 0x27(%rbp,%rax)
addq $0x20, %rax
cmpq $0... | /PKRoma[P]libwebp/src/dec/frame_dec.c |
VP8EnterCritical | VP8StatusCode VP8EnterCritical(VP8Decoder* const dec, VP8Io* const io) {
// Call setup() first. This may trigger additional decoding features on 'io'.
// Note: Afterward, we must call teardown() no matter what.
if (io->setup != NULL && !io->setup(io)) {
VP8SetError(dec, VP8_STATUS_USER_ABORT, "Frame setup fai... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rsi), %rax
testq %rax, %rax
je 0x329db
movq %r14, %rdi
callq *%rax
testl %eax, %eax
je 0x32bab
cmpl $0x0, 0x70(%r14)
je 0x329f2
movl $0x0, 0xb68(%rbx)
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x32a22
movsl... | /PKRoma[P]libwebp/src/dec/frame_dec.c |
VP8GetThreadMethod | int VP8GetThreadMethod(const WebPDecoderOptions* const options,
const WebPHeaderStructure* const headers,
int width, int height) {
if (options == NULL || options->use_threads == 0) {
return 0;
}
(void)headers;
(void)width;
(void)height;
assert(headers == NUL... | xorl %eax, %eax
testq %rdi, %rdi
je 0x32c2d
cmpl $0x0, 0x28(%rdi)
je 0x32c2d
xorl %eax, %eax
cmpl $0x200, %edx # imm = 0x200
setge %al
addl %eax, %eax
retq
| /PKRoma[P]libwebp/src/dec/frame_dec.c |
Dither8x8 | static void Dither8x8(VP8Random* const rg, uint8_t* dst, int bps, int amp) {
uint8_t dither[64];
int i;
for (i = 0; i < 8 * 8; ++i) {
dither[i] = VP8RandomBits2(rg, VP8_DITHER_AMP_BITS + 1, amp);
}
VP8DitherCombine8x8(dither, dst, bps);
} | subq $0x48, %rsp
movq (%rdi), %xmm2
xorl %eax, %eax
pcmpeqd %xmm0, %xmm0
movdqa 0x23ef8(%rip), %xmm1 # 0x56f20
movd %xmm2, %r8d
movslq %r8d, %r8
movl 0x8(%rdi,%r8,4), %r9d
pshufd $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
movd %xmm2, %r10d
movslq %r10d, %r10
subl 0x8(%rdi,%r10,4), %r9d
movl %r9d, %r10d
andl $0x7... | /PKRoma[P]libwebp/src/dec/frame_dec.c |
SetResidualCoeffs_C | static void SetResidualCoeffs_C(const int16_t* const coeffs,
VP8Residual* const res) {
int n;
res->last = -1;
assert(res->first == 0 || coeffs[0] == 0);
for (n = 15; n >= 0; --n) {
if (coeffs[n]) {
res->last = n;
break;
}
}
res->coeffs = coeffs;
} | movl $0xffffffff, 0x4(%rsi) # imm = 0xFFFFFFFF
movl $0xf, %eax
movl %eax, %ecx
cmpw $0x0, (%rdi,%rcx,2)
jne 0x334e6
addl $-0x1, %eax
jb 0x334d6
jmp 0x334e9
movl %eax, 0x4(%rsi)
movq %rdi, 0x8(%rsi)
retq
nop
| /PKRoma[P]libwebp/src/dsp/cost.c |
Intra16Preds_C | static WEBP_INLINE void DCMode(uint8_t* dst, const uint8_t* left,
const uint8_t* top,
int size, int round, int shift) {
int DC = 0;
int j;
if (top != NULL) {
for (j = 0; j < size; ++j) DC += top[j];
if (left != NULL) { // top and left present... | testq %rdx, %rdx
je 0x34b90
pxor %xmm0, %xmm0
xorl %eax, %eax
pxor %xmm1, %xmm1
movd (%rdx,%rax), %xmm2
punpcklbw %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3],xmm2[4],xmm0[4],xmm2[5],xmm0[5],xmm2[6],xmm0[6],xmm2[7],xmm0[7]
punpcklwd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xm... | /PKRoma[P]libwebp/src/dsp/enc.c |
ITransformOne | static WEBP_INLINE void ITransformOne(const uint8_t* ref, const int16_t* in,
uint8_t* dst) {
int C[4 * 4], *tmp;
int i;
tmp = C;
for (i = 0; i < 4; ++i) { // vertical pass
const int a = in[0] + in[8];
const int b = in[0] - in[8];
const int c = MUL(in[4], kC2)... | pushq %rbp
pushq %rbx
xorl %eax, %eax
movswl (%rsi,%rax), %ecx
movswl 0x10(%rsi,%rax), %r9d
leal (%r9,%rcx), %r8d
subl %r9d, %ecx
movswl 0x8(%rsi,%rax), %r9d
imull $0x8a8c, %r9d, %r10d # imm = 0x8A8C
sarl $0x10, %r10d
movswl 0x18(%rsi,%rax), %r11d
imull $0x14e7b, %r11d, %ebx # imm = 0x14E7B
sarl $0x10, %ebx
subl %... | /PKRoma[P]libwebp/src/dsp/enc.c |
VP8SSIMFromStats | static WEBP_INLINE double SSIMCalculation(
const VP8DistoStats* const stats, uint32_t N /*num samples*/) {
const uint32_t w2 = N * N;
const uint32_t C1 = 20 * w2;
const uint32_t C2 = 60 * w2;
const uint32_t C3 = 8 * 8 * w2; // 'dark' limit ~= 6
const uint64_t xmxm = (uint64_t)stats->xm * stats->xm;
... | movl 0x4(%rdi), %edx
movl 0x8(%rdi), %ecx
movq %rdx, %rsi
imulq %rdx, %rsi
movq %rcx, %rax
imulq %rcx, %rax
addq %rsi, %rax
cmpq $0x400000, %rax # imm = 0x400000
jae 0x35618
movsd 0x21641(%rip), %xmm0 # 0x56c58
retq
imulq %rdx, %rcx
movl 0xc(%rdi), %esi
movl 0x10(%rdi), %r8d
shlq $0x8, %r8
subq %rcx, %r8
mov... | /PKRoma[P]libwebp/src/dsp/ssim.c |
Quantize2Blocks_SSE2 | static WEBP_INLINE int DoQuantizeBlock_SSE2(int16_t in[16], int16_t out[16],
const uint16_t* const sharpen,
const VP8Matrix* const mtx) {
const __m128i max_coeff_2047 = _mm_set1_epi16(MAX_LEVEL);
const __m128i zero = _mm_setzero... | movdqu (%rdi), %xmm4
movdqu 0x10(%rdi), %xmm5
movdqu (%rdx), %xmm2
movdqu 0x10(%rdx), %xmm3
movdqu 0x20(%rdx), %xmm1
movdqu 0x30(%rdx), %xmm6
pxor %xmm7, %xmm7
psubw %xmm4, %xmm7
pmaxsw %xmm4, %xmm7
psraw $0xf, %xmm4
pxor %xmm8, %xmm8
psubw %xmm5, %xmm8
pmaxsw %xmm5, %xmm8
psraw $0xf, %xmm5
pxor %xmm0, %xmm0
movdqu 0xc... | /PKRoma[P]libwebp/src/dsp/enc_sse2.c |
ITransform_SSE2 | static void ITransform_SSE2(const uint8_t* ref, const int16_t* in, uint8_t* dst,
int do_two) {
// This implementation makes use of 16-bit fixed point versions of two
// multiply constants:
// K1 = sqrt(2) * cos (pi/8) ~= 85627 / 2^16
// K2 = sqrt(2) * sin (pi/8) ~= 35468 / 2^16... | movq (%rsi), %xmm0
movq 0x8(%rsi), %xmm3
movq 0x10(%rsi), %xmm1
movq 0x18(%rsi), %xmm4
testl %ecx, %ecx
je 0x370ac
movq 0x20(%rsi), %xmm2
punpcklqdq %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0]
movq 0x28(%rsi), %xmm2
punpcklqdq %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
movq 0x30(%rsi), %xmm2
punpcklqdq %xmm2, %xmm1 # xmm... | /PKRoma[P]libwebp/src/dsp/enc_sse2.c |
AccumulateSSE_SSE2 | static uint32_t AccumulateSSE_SSE2(const uint8_t* src1,
const uint8_t* src2, int len) {
int i = 0;
uint32_t sse2 = 0;
if (len >= 16) {
const int limit = len - 32;
int32_t tmp[4];
__m128i sum1;
__m128i sum = _mm_setzero_si128();
__m128i a0 = _mm_loadu_si128((c... | xorl %eax, %eax
movl $0x0, %ecx
cmpl $0x10, %edx
jl 0x37e5b
movdqu (%rsi), %xmm1
movdqu (%rdi), %xmm4
movl $0x10, %ecx
pxor %xmm0, %xmm0
cmpl $0x30, %edx
jae 0x37d92
pxor %xmm2, %xmm2
jmp 0x37e19
leal -0x20(%rdx), %eax
pxor %xmm3, %xmm3
movl $0x10, %ecx
pxor %xmm2, %xmm2
movdqa %xmm4, %xmm5
psubusb %xmm1, %xmm5
psubusb... | /PKRoma[P]libwebp/src/dsp/ssim_sse2.c |
VP8EncDspInitSSE41 | WEBP_TSAN_IGNORE_FUNCTION void VP8EncDspInitSSE41(void) {
VP8CollectHistogram = CollectHistogram_SSE41;
VP8EncQuantizeBlock = QuantizeBlock_SSE41;
VP8EncQuantize2Blocks = Quantize2Blocks_SSE41;
VP8EncQuantizeBlockWHT = QuantizeBlockWHT_SSE41;
VP8TDisto4x4 = Disto4x4_SSE41;
VP8TDisto16x16 = Disto16x16_SSE41;... | retq
nopl (%rax)
| /PKRoma[P]libwebp/src/dsp/enc_sse41.c |
CompressAlphaJob | static int CompressAlphaJob(void* arg1, void* unused) {
VP8Encoder* const enc = (VP8Encoder*)arg1;
const WebPConfig* config = enc->config_;
uint8_t* alpha_data = NULL;
size_t alpha_size = 0;
const int effort_level = config->method; // maps to [0..6]
const WEBP_FILTER_TYPE filter =
(config->alpha_filt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movl 0x8(%rcx), %eax
movq %rax, 0x28(%rsp)
movl 0x30(%rcx), %r8d
movl 0x34(%rcx), %eax
movl 0x38(%rcx), %r15d
movslq 0x8(%rdx), %rbx
movq %rdx, 0x20(%rsp)
movl 0xc(%rdx), %... | /PKRoma[P]libwebp/src/enc/alpha_enc.c |
VP8EncDeleteAlpha | int VP8EncDeleteAlpha(VP8Encoder* const enc) {
int ok = 1;
if (enc->thread_level_ > 0) {
WebPWorker* const worker = &enc->alpha_worker_;
// finish anything left in flight
ok = WebPGetWorkerInterface()->Sync(worker);
// still need to end the worker, even if !ok
WebPGetWorkerInterface()->End(worke... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x5c50(%rdi)
jle 0x386f5
leaq 0x230(%rbx), %r14
callq 0x311c6
movq %r14, %rdi
callq *0x10(%rax)
movl %eax, %ebp
callq 0x311c6
movq %r14, %rdi
callq *0x28(%rax)
jmp 0x386fa
movl $0x1, %ebp
movq 0x220(%rbx), %rdi
callq 0x314a8
xorps %xmm0, %xmm0
movups %xmm0, 0x... | /PKRoma[P]libwebp/src/enc/alpha_enc.c |
VP8EncAnalyze | int VP8EncAnalyze(VP8Encoder* const enc) {
int ok = 1;
const int do_segments =
enc->config_->emulate_jpeg_size || // We need the complexity evaluation.
(enc->segment_hdr_.num_segments_ > 1) ||
(enc->method_ <= 1); // for method 0 - 1, we need preds_[] to be filled.
if (do_segments) {
cons... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2718, %rsp # imm = 0x2718
movq %rdi, %r13
movq (%rdi), %rax
cmpl $0x0, 0x50(%rax)
jne 0x389f6
cmpl $0x1, 0x20(%r13)
jg 0x389f6
cmpl $0x1, 0x5c40(%r13)
jg 0x39155
movl 0x34(%r13), %r15d
movl 0x30(%r13), %ebx
imull %r15d, %ebx
movl 0x5c50... | /PKRoma[P]libwebp/src/enc/analysis_enc.c |
DoSegmentsJob | static int DoSegmentsJob(void* arg1, void* arg2) {
SegmentJob* const job = (SegmentJob*)arg1;
VP8EncIterator* const it = (VP8EncIterator*)arg2;
int ok = 1;
if (!VP8IteratorIsDone(it)) {
uint8_t tmp[32 + WEBP_ALIGN_CST];
uint8_t* const scratch = (uint8_t*)WEBP_ALIGN(tmp);
do {
// Let's pretend ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3b533
movl $0x1, %ebp
testl %eax, %eax
jne 0x395b7
leaq 0x8f(%rsp), %rax
andq $-0x20, %rax
movq %rax, 0x10(%rsp)
leaq 0x31ca5(%rip), %r12 # 0x6af48
leaq 0x1f516(%rip), %r13 ... | /PKRoma[P]libwebp/src/enc/analysis_enc.c |
VP8EncLoop | int VP8EncLoop(VP8Encoder* const enc) {
VP8EncIterator it;
int ok = PreLoopInitialize(enc);
if (!ok) return 0;
StatLoop(enc); // stats-collection loop
VP8IteratorInit(enc, &it);
VP8InitFilter(&it);
do {
VP8ModeScore info;
const int dont_use_skip = !enc->proba_.use_skip_proba_;
const VP8RDLe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1398, %rsp # imm = 0x1398
movq %rdi, %r12
callq 0x39ff3
testl %eax, %eax
je 0x39fdf
movl 0x5c40(%r12), %r14d
movl 0x5c54(%r12), %ecx
testl %r14d, %r14d
setne %al
cmpl $0x3, %r14d
setne %r15b
setge %bl
andb %al, %r15b
movl %ecx, 0x3c(%rs... | /PKRoma[P]libwebp/src/enc/frame_enc.c |
PreLoopInitialize | static int PreLoopInitialize(VP8Encoder* const enc) {
int p;
int ok = 1;
const int average_bytes_per_MB = kAverageBytesPerMB[enc->base_quant_ >> 4];
const int bytes_per_parts =
enc->mb_w_ * enc->mb_h_ * average_bytes_per_MB / enc->num_parts_;
// Initialize the bit-writers
for (p = 0; ok && p < enc->nu... | movl 0xe00(%rdi), %eax
sarl $0x4, %eax
cltq
leaq 0x1e6cb(%rip), %rcx # 0x586d0
movzbl (%rax,%rcx), %eax
imull 0x30(%rdi), %eax
imull 0x34(%rdi), %eax
movl 0x3c(%rdi), %ecx
cltd
idivl %ecx
testl %ecx, %ecx
jle 0x3a051
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x70(%rdi), %r14
movslq... | /PKRoma[P]libwebp/src/enc/frame_enc.c |
PostLoopFinalize | static int PostLoopFinalize(VP8EncIterator* const it, int ok) {
VP8Encoder* const enc = it->enc_;
if (ok) { // Finalize the partitions, check for extra errors.
int p;
for (p = 0; p < enc->num_parts_; ++p) {
VP8BitWriterFinish(enc->parts_ + p);
ok &= !enc->parts_[p].error_;
}
}
if (... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x28(%rdi), %r15
testl %esi, %esi
je 0x3a2cd
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x3c(%r15)
jle 0x3a258
leaq 0x70(%r15), %r12
andl $0x1, %ebx
xorl %r13d, %r13d
movl %ebx, %eax
movl %eax, %ebx
movq %r12, %rdi
callq 0x444a5
cmpl $0x0, 0x28(%r12)
movl $0x0... | /PKRoma[P]libwebp/src/enc/frame_enc.c |
VP8EncTokenLoop | int VP8EncTokenLoop(VP8Encoder* const enc) {
// Roughly refresh the proba eight times per pass
int max_count = (enc->mb_w_ * enc->mb_h_) >> 3;
int num_pass_left = enc->config_->pass;
const int do_search = enc->do_search_;
VP8EncIterator it;
VP8EncProba* const proba = &enc->proba_;
const VP8RDLevel rd_opt ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1388, %rsp # imm = 0x1388
movq %rdi, %r14
movslq 0x30(%rdi), %rbx
movslq 0x34(%rdi), %r15
movq (%rdi), %rdi
movl 0x3c(%rdi), %r12d
movl 0x5c54(%r14), %eax
movl %eax, 0x44(%rsp)
movl 0x5c44(%r14), %eax
movl %eax, 0x48(%rsp)
leaq 0xa8(%rs... | /PKRoma[P]libwebp/src/enc/frame_enc.c |
InitPassStats | static int InitPassStats(const VP8Encoder* const enc, PassStats* const s) {
const uint64_t target_size = (uint64_t)enc->config_->target_size;
const int do_size_search = (target_size != 0);
const float target_PSNR = enc->config_->target_PSNR;
s->is_first = 1;
s->dq = 10.f;
s->qmin = 1.f * enc->config_->qmin... | movslq 0x10(%rdi), %rax
movss 0x14(%rdi), %xmm0
movabsq $0x4120000000000001, %rcx # imm = 0x4120000000000001
movq %rcx, (%rsi)
movsd 0x6c(%rdi), %xmm1
cvtdq2ps %xmm1, %xmm1
movlps %xmm1, 0x10(%rsi)
movss 0x4(%rdi), %xmm2
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3 # xmm3 = xmm3[1,1],xmm1[1,1]
minss %xmm2, %xmm3
... | /PKRoma[P]libwebp/src/enc/frame_enc.c |
SetLoopParams | static void SetLoopParams(VP8Encoder* const enc, float q) {
// Make sure the quality parameter is inside valid bounds
q = Clamp(q, 0.f, 100.f);
VP8SetSegmentParams(enc, q); // setup segment quantizations and filters
SetSegmentProbas(enc); // compute segment probabilities
ResetStats(enc);
R... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movss 0x165c9(%rip), %xmm1 # 0x5100c
minss %xmm0, %xmm1
xorps %xmm2, %xmm2
cmpltss %xmm2, %xmm0
andnps %xmm1, %xmm0
callq 0x3c13c
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movl 0x34(%rbx), %ecx
imull 0x30(%rbx), %ecx
testl %ecx, %ecx
jle 0x3aa89
movq 0x... | /PKRoma[P]libwebp/src/enc/frame_enc.c |
ComputeNextQ | static float ComputeNextQ(PassStats* const s) {
float dq;
if (s->is_first) {
dq = (s->value > s->target) ? -s->dq : s->dq;
s->is_first = 0;
} else if (s->value != s->last_value) {
const double slope = (s->target - s->value) / (s->last_value - s->value);
dq = (float)(slope * (s->last_q - s->q));
... | cmpl $0x0, (%rdi)
movsd 0x18(%rdi), %xmm0
je 0x3ae9e
ucomisd 0x28(%rdi), %xmm0
movss 0x4(%rdi), %xmm1
jbe 0x3ae96
xorps 0x1991a(%rip), %xmm1 # 0x547b0
movl $0x0, (%rdi)
jmp 0x3aed8
movsd 0x20(%rdi), %xmm1
ucomisd %xmm1, %xmm0
jne 0x3aeab
jnp 0x3aed4
movsd 0x28(%rdi), %xmm2
subsd %xmm0, %xmm2
subsd %xmm0, %xmm1
divsd... | /PKRoma[P]libwebp/src/enc/frame_enc.c |
PutCoeffs | static int PutCoeffs(VP8BitWriter* const bw, int ctx, const VP8Residual* res) {
int n = res->first;
// should be prob[VP8EncBands[n]], but it's equivalent for n=0 or 1
const uint8_t* p = res->prob[n][ctx];
if (!VP8PutBit(bw, res->last >= 0, p[0])) {
return 0;
}
while (n < 16) {
const int c = res->c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r13
movq %rdi, %r14
movslq (%rdx), %r15
movslq %esi, %rax
leaq (%rax,%rax,4), %rcx
leaq (%rax,%rcx,2), %rbx
movq %r15, %r12
shlq $0x5, %r12
addq %r15, %r12
addq 0x18(%rdx), %r12
movl 0x4(%rdx), %esi
notl %esi
shrl $0x1f, %esi... | /PKRoma[P]libwebp/src/enc/frame_enc.c |
InitLeft | static void InitLeft(VP8EncIterator* const it) {
it->y_left_[-1] = it->u_left_[-1] = it->v_left_[-1] =
(it->y_ > 0) ? 129 : 127;
memset(it->y_left_, 129, 16);
memset(it->u_left_, 129, 8);
memset(it->v_left_, 129, 8);
it->left_nz_[8] = 0;
if (it->top_derr_ != NULL) {
memset(&it->left_derr_, 0, size... | xorl %eax, %eax
cmpl $0x0, 0x4(%rdi)
setg %al
leal 0x7f(,%rax,2), %eax
movq 0x178(%rdi), %rcx
movb %al, -0x1(%rcx)
movq 0x170(%rdi), %rcx
movb %al, -0x1(%rcx)
movq 0x168(%rdi), %rcx
movb %al, -0x1(%rcx)
movq 0x168(%rdi), %rax
movaps 0x1d09e(%rip), %xmm0 # 0x584d0
movups %xmm0, (%rax)
movq 0x170(%rdi), %rax
movabsq $... | /PKRoma[P]libwebp/src/enc/iterator_enc.c |
VP8IteratorInit | void VP8IteratorInit(VP8Encoder* const enc, VP8EncIterator* const it) {
it->enc_ = enc;
it->yuv_in_ = (uint8_t*)WEBP_ALIGN(it->yuv_mem_);
it->yuv_out_ = it->yuv_in_ + YUV_SIZE_ENC;
it->yuv_out2_ = it->yuv_out_ + YUV_SIZE_ENC;
it->yuv_p_ = it->yuv_out2_ + YUV_SIZE_ENC;
it->lf_stats_ = enc->lf_stats_;
... | movq %rdi, 0x28(%rsi)
leaq 0x207(%rsi), %rax
andq $-0x20, %rax
movq %rax, 0x8(%rsi)
leaq 0x200(%rax), %rcx
movq %rcx, 0x10(%rsi)
leaq 0x400(%rax), %rcx
movq %rcx, 0x18(%rsi)
addq $0x600, %rax # imm = 0x600
movq %rax, 0x20(%rsi)
movq 0x5c88(%rdi), %rax
movq %rax, 0x140(%rsi)
movl 0x218(%rdi), %eax
movl %eax, ... | /PKRoma[P]libwebp/src/enc/iterator_enc.c |
VP8IteratorNzToBytes | void VP8IteratorNzToBytes(VP8EncIterator* const it) {
const int tnz = it->nz_[0], lnz = it->nz_[-1];
int* const top_nz = it->top_nz_;
int* const left_nz = it->left_nz_;
// Top-Y
top_nz[0] = BIT(tnz, 12);
top_nz[1] = BIT(tnz, 13);
top_nz[2] = BIT(tnz, 14);
top_nz[3] = BIT(tnz, 15);
// Top-U
top_nz[4... | movq 0x48(%rdi), %rcx
movl -0x4(%rcx), %eax
movl (%rcx), %ecx
movl %ecx, %edx
shrl $0xc, %edx
andl $0x1, %edx
movl %edx, 0x84(%rdi)
movl %ecx, %edx
shrl $0xd, %edx
andl $0x1, %edx
movl %edx, 0x88(%rdi)
movl %ecx, %edx
shrl $0xe, %edx
andl $0x1, %edx
movl %edx, 0x8c(%rdi)
movl %ecx, %edx
shrl $0xf, %edx
andl $0x1, %edx
... | /PKRoma[P]libwebp/src/enc/iterator_enc.c |
VP8IteratorSaveBoundary | void VP8IteratorSaveBoundary(VP8EncIterator* const it) {
VP8Encoder* const enc = it->enc_;
const int x = it->x_, y = it->y_;
const uint8_t* const ysrc = it->yuv_out_ + Y_OFF_ENC;
const uint8_t* const uvsrc = it->yuv_out_ + U_OFF_ENC;
if (x < enc->mb_w_ - 1) { // left
int i;
for (i = 0; i < 16; ++i) ... | movq 0x28(%rdi), %rdx
movl 0x4(%rdi), %ecx
movq 0x10(%rdi), %rax
movl 0x30(%rdx), %esi
decl %esi
cmpl %esi, (%rdi)
jge 0x3bed8
leaq 0xf(%rax), %rsi
xorl %r8d, %r8d
movb (%rsi), %r9b
movq 0x168(%rdi), %r10
movb %r9b, (%r10,%r8)
incq %r8
addq $0x20, %rsi
cmpq $0x10, %r8
jne 0x3be4a
leaq 0x1f(%rax), %rsi
xorl %r8d, %r8d
m... | /PKRoma[P]libwebp/src/enc/iterator_enc.c |
VP8SetIntra16Mode | void VP8SetIntra16Mode(const VP8EncIterator* const it, int mode) {
uint8_t* preds = it->preds_;
int y;
for (y = 0; y < 4; ++y) {
memset(preds, mode, 4);
preds += it->enc_->preds_w_;
}
it->mb_->type_ = 1;
} | movq 0x40(%rdi), %rax
movl $0x4, %ecx
movzbl %sil, %edx
imull $0x1010101, %edx, %edx # imm = 0x1010101
movl %edx, (%rax)
movq 0x28(%rdi), %rsi
movslq 0x38(%rsi), %rsi
addq %rsi, %rax
decl %ecx
jne 0x3bf84
movq 0x30(%rdi), %rax
movb (%rax), %cl
andb $-0x4, %cl
incb %cl
movb %cl, (%rax)
retq
| /PKRoma[P]libwebp/src/enc/iterator_enc.c |
VP8IteratorStartI4 | void VP8IteratorStartI4(VP8EncIterator* const it) {
const VP8Encoder* const enc = it->enc_;
int i;
it->i4_ = 0; // first 4x4 sub-block
it->i4_top_ = it->i4_boundary_ + VP8TopLeftI4[0];
// Import the boundary samples
for (i = 0; i < 17; ++i) { // left
it->i4_boundary_[i] = it->y_left_[15 - i];
... | movq 0x28(%rdi), %rax
movl $0x0, 0x80(%rdi)
leaq 0x50(%rdi), %rcx
leaq 0x61(%rdi), %rdx
movq %rdx, 0x78(%rdi)
movl $0x11, %edx
movq 0x168(%rdi), %rsi
movb -0x2(%rsi,%rdx), %sil
movb %sil, (%rcx)
incq %rcx
decq %rdx
jne 0x3c032
xorl %ecx, %ecx
movq 0x180(%rdi), %rdx
movb (%rdx,%rcx), %dl
movb %dl, 0x61(%rdi,%rcx)
incq %... | /PKRoma[P]libwebp/src/enc/iterator_enc.c |
VP8SetSegmentParams | void VP8SetSegmentParams(VP8Encoder* const enc, float quality) {
int i;
int dq_uv_ac, dq_uv_dc;
const int num_segments = enc->segment_hdr_.num_segments_;
const double amp = SNS_TO_DQ * enc->config_->sns_strength / 100. / 128.;
const double Q = quality / 100.;
const double c_base = enc->config_->emulate_jpeg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x20(%rdi), %r13d
movq (%rdi), %rax
cvtsi2sdl 0x1c(%rax), %xmm1
movsd %xmm1, 0x8(%rsp)
cvtss2sd %xmm0, %xmm0
divsd 0x14ebd(%rip), %xmm0 # 0x51028
cmpl $0x0, 0x50(%rax)
je 0x3c198
xorps %xmm1, %xmm1
cvtsi2sdl 0xe04... | /PKRoma[P]libwebp/src/enc/quant_enc.c |
ReconstructIntra4 | static int ReconstructIntra4(VP8EncIterator* const it,
int16_t levels[16],
const uint8_t* const src,
uint8_t* const yuv_out,
int mode) {
const VP8Encoder* const enc = it->enc_;
const uint8_t* const re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %rax
movq %rsi, %r15
movq %rdi, %rbp
movq 0x28(%rdi), %r12
movq 0x30(%rdi), %rcx
movslq %r8d, %rdx
leaq 0x1a53c(%rip), %rsi # 0x587d0
movzwl (%rsi,%rdx,2), %r14d
addq 0x20(%rdi), %r14
movzbl (%rcx), %ecx
sh... | /PKRoma[P]libwebp/src/enc/quant_enc.c |
VP8TBufferInit | void VP8TBufferInit(VP8TBuffer* const b, int page_size) {
b->tokens_ = NULL;
b->pages_ = NULL;
b->last_page_ = &b->pages_;
b->left_ = 0;
b->page_size_ = (page_size < MIN_PAGE_SIZE) ? MIN_PAGE_SIZE : page_size;
b->error_ = 0;
} | xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rax, (%rdi)
movq %rdi, 0x8(%rdi)
movl %eax, 0x18(%rdi)
cmpl $0x2001, %esi # imm = 0x2001
movl $0x2000, %ecx # imm = 0x2000
cmovgel %esi, %ecx
movl %ecx, 0x1c(%rdi)
movl %eax, 0x20(%rdi)
retq
| /PKRoma[P]libwebp/src/enc/token_enc.c |
VP8RecordCoeffTokens | int VP8RecordCoeffTokens(int ctx, const struct VP8Residual* const res,
VP8TBuffer* const tokens) {
const int16_t* const coeffs = res->coeffs;
const int coeff_type = res->coeff_type;
const int last = res->last;
int n = res->first;
uint32_t base_id = TOKEN_ID(coeff_type, n, ctx);
// s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq 0x8(%rsi), %rax
movq %rax, 0x40(%rsp)
movl 0x10(%rsi), %eax
movl 0x4(%rsi), %r15d
movslq (%rsi), %rbp
movq %rax, 0x28(%rsp)
leal (%rbp,%rax,8), %eax
leal (%rax,%rax,2), %eax
addl %edi, %eax
leal (%rax... | /PKRoma[P]libwebp/src/enc/token_enc.c |
VP8EstimateTokenSize | size_t VP8EstimateTokenSize(VP8TBuffer* const b, const uint8_t* const probas) {
size_t size = 0;
const VP8Tokens* p = b->pages_;
assert(!b->error_);
while (p != NULL) {
const VP8Tokens* const next = p->next_;
const int N = (next == NULL) ? b->left_ : 0;
int n = b->page_size_;
const token_t* cons... | movq (%rdi), %rcx
testq %rcx, %rcx
je 0x3f9d1
pushq %rbp
pushq %rbx
movslq 0x1c(%rdi), %rdx
xorl %eax, %eax
leaq 0x1780e(%rip), %r8 # 0x57180
movq %rcx, %r9
movq (%rcx), %rcx
movl $0x0, %r10d
testq %rcx, %rcx
jne 0x3f987
movl 0x18(%rdi), %r10d
cmpl %r10d, %edx
jle 0x3f9c9
movslq %r10d, %r10
movq %rdx, %r11
movzwl ... | /PKRoma[P]libwebp/src/enc/token_enc.c |
VP8WriteProbas | void VP8WriteProbas(VP8BitWriter* const bw, const VP8EncProba* const probas) {
int t, b, c, p;
for (t = 0; t < NUM_TYPES; ++t) {
for (b = 0; b < NUM_BANDS; ++b) {
for (c = 0; c < NUM_CTX; ++c) {
for (p = 0; p < NUM_PROBAS; ++p) {
const uint8_t p0 = probas->coeffs_[t][b][c][p];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x4(%rsi), %r14
leaq 0x18dc2(%rip), %r12 # 0x58b40
leaq 0x1956b(%rip), %r13 # 0x592f0
xorl %esi, %esi
movq %rsi, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movq %r14, 0x28(%rs... | /PKRoma[P]libwebp/src/enc/tree_enc.c |
VP8LEncoderNew | static VP8LEncoder* VP8LEncoderNew(const WebPConfig* const config,
const WebPPicture* const picture) {
VP8LEncoder* const enc = (VP8LEncoder*)WebPSafeCalloc(1ULL, sizeof(*enc));
if (enc == NULL) {
WebPEncodingSetError(picture, VP8_ENC_ERROR_OUT_OF_MEMORY);
return NULL;
}... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x918, %esi # imm = 0x918
callq 0x31484
movq %rax, %rbx
testq %rax, %rax
je 0x40a7a
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
movl $0x0, 0x18(%rbx)
callq 0x45bcf
jmp 0x40a87
movq %r14, %rdi
movl $0x1, %esi
callq 0x2fb4a
movq ... | /PKRoma[P]libwebp/src/enc/vp8l_enc.c |
VP8LEncodeImage | int VP8LEncodeImage(const WebPConfig* const config,
const WebPPicture* const picture) {
int width, height;
int has_alpha;
size_t coded_size;
int percent = 0;
int initial_size;
WebPEncodingError err = VP8_ENC_OK;
VP8LBitWriter bw;
if (picture == NULL) return 0;
if (config == NULL ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl $0x0, 0x4(%rsp)
xorl %ebp, %ebp
testq %rsi, %rsi
je 0x428de
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x4281b
cmpq $0x0, 0x48(%rbx)
je 0x4281b
movl 0x8(%rbx), %r12d
movl 0xc(%rbx), %r13d
cmpl $0x3, 0xc(%r14)
setne %cl
movl... | /PKRoma[P]libwebp/src/enc/vp8l_enc.c |
VP8LBitWriterResize | static int VP8LBitWriterResize(VP8LBitWriter* const bw, size_t extra_size) {
uint8_t* allocated_buf;
size_t allocated_size;
const size_t max_bytes = bw->end_ - bw->buf_;
const size_t current_size = bw->cur_ - bw->buf_;
const uint64_t size_required_64b = (uint64_t)current_size + extra_size;
const size_t size... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
movq 0x10(%rdi), %r13
movq 0x18(%rdi), %rbp
movq %rbp, %r14
subq %r13, %r14
addq %r14, %rsi
movl $0x1, %eax
subq %r13, %rcx
je 0x44599
cmpq %rcx, %rsi
jbe 0x44609
leaq (%rcx,%rcx,2), %r15
shrq %r15
cmpq %r... | /PKRoma[P]libwebp/src/utils/bit_writer_utils.c |
CompareHuffmanTrees | static int CompareHuffmanTrees(const void* ptr1, const void* ptr2) {
const HuffmanTree* const t1 = (const HuffmanTree*)ptr1;
const HuffmanTree* const t2 = (const HuffmanTree*)ptr2;
if (t1->total_count_ > t2->total_count_) {
return -1;
} else if (t1->total_count_ < t2->total_count_) {
return 1;
} else ... | movl (%rsi), %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl %ecx, (%rdi)
ja 0x44f5e
movl $0x1, %eax
jb 0x44f5e
movl 0x4(%rdi), %eax
xorl %ecx, %ecx
cmpl 0x4(%rsi), %eax
setge %cl
leal -0x1(,%rcx,2), %eax
retq
| /PKRoma[P]libwebp/src/utils/huffman_encode_utils.c |
QuantizeLevels | int QuantizeLevels(uint8_t* const data, int width, int height,
int num_levels, uint64_t* const sse) {
int freq[NUM_SYMBOLS] = { 0 };
int q_level[NUM_SYMBOLS] = { 0 };
double inv_q_level[NUM_SYMBOLS] = { 0 };
int min_s = 255, max_s = 0;
const size_t data_size = height * width;
int i, num_l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2068, %rsp # imm = 0x2068
movq %r8, %rbx
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %r14
leaq 0x460(%rsp), %rdi
xorl %r12d, %r12d
movl $0x400, %edx # imm = 0x400
xorl %esi, %esi
callq 0x40c0
leaq 0x60(%rsp),... | /PKRoma[P]libwebp/src/utils/quant_levels_utils.c |
VP8LBitsEntropyUnrefined | void VP8LBitsEntropyUnrefined(const uint32_t* const array, int n,
VP8LBitEntropy* const entropy) {
int i;
VP8LBitEntropyInit(entropy);
for (i = 0; i < n; ++i) {
if (array[i] != 0) {
entropy->sum += array[i];
entropy->nonzero_code = i;
++entropy->nonzeros;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rax, 0x10(%rdx)
testl %esi, %esi
jle 0x4556a
movq %rdi, %r14
movl %esi, %r12d
xorpd %xmm1, %xmm1
xorl %eax, %eax
movaps 0x... | /PKRoma[P]libwebp/src/dsp/lossless_enc.c |
VP8LSubtractGreenFromBlueAndRed_C | void VP8LSubtractGreenFromBlueAndRed_C(uint32_t* argb_data, int num_pixels) {
int i;
for (i = 0; i < num_pixels; ++i) {
const int argb = argb_data[i];
const int green = (argb >> 8) & 0xff;
const uint32_t new_r = (((argb >> 16) & 0xff) - green) & 0xff;
const uint32_t new_b = (((argb >> 0) & 0xff) - ... | testl %esi, %esi
jle 0x455d9
movl %esi, %eax
xorl %ecx, %ecx
movl (%rdi,%rcx,4), %edx
movl %edx, %esi
shrl $0x8, %esi
movl %edx, %r8d
subl %esi, %r8d
movzbl %r8b, %r8d
movl %edx, %r9d
andl $0xff00ff00, %r9d # imm = 0xFF00FF00
orl %r8d, %r9d
shll $0x10, %esi
subl %esi, %edx
andl $0xff0000, %edx # imm = 0xF... | /PKRoma[P]libwebp/src/dsp/lossless_enc.c |
VP8LCollectColorRedTransforms_C | void VP8LCollectColorRedTransforms_C(const uint32_t* argb, int stride,
int tile_width, int tile_height,
int green_to_red, int histo[]) {
while (tile_height-- > 0) {
int x;
for (x = 0; x < tile_width; ++x) {
++histo[TransformColorR... | testl %ecx, %ecx
jle 0x456ac
pushq %rbx
movsbl %r8b, %eax
movslq %esi, %rsi
movl %edx, %r8d
shlq $0x2, %rsi
testl %edx, %edx
jle 0x4569c
xorl %r10d, %r10d
movl (%rdi,%r10,4), %r11d
movl %r11d, %ebx
shrl $0x10, %ebx
shrl $0x8, %r11d
movsbl %r11b, %r11d
imull %eax, %r11d
shrl $0x5, %r11d
subl %r11d, %ebx
movzbl %bl, %r11... | /PKRoma[P]libwebp/src/dsp/lossless_enc.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.