address string | name string | code string | asm string | file string | bin string |
|---|---|---|---|---|---|
0x229c | init_platform_specific | void init_platform_specific(void)
{
#ifdef ALLEGRO_ANDROID
al_install_touch_input();
al_android_set_apk_file_interface();
#endif
} | retq
| /guzmandrade[P]allegro5/examples/common.c | guzmandrade[P]allegro5[P]build_O1[P]examples[P]ex_blend_bench |
0x229d | abort_example | void abort_example(char const *format, ...)
{
va_list args;
va_start(args, format);
vfprintf(stderr, format, args);
va_end(args);
exit(1);
} | subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x22fb
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %... | /guzmandrade[P]allegro5/examples/common.c | guzmandrade[P]allegro5[P]build_O1[P]examples[P]ex_blend_bench |
0x2337 | open_log | void open_log(void)
{
} | retq
| /guzmandrade[P]allegro5/examples/common.c | guzmandrade[P]allegro5[P]build_O1[P]examples[P]ex_blend_bench |
0x2338 | open_log_monospace | void open_log_monospace(void)
{
} | retq
| /guzmandrade[P]allegro5/examples/common.c | guzmandrade[P]allegro5[P]build_O1[P]examples[P]ex_blend_bench |
0x2339 | close_log | void close_log(bool wait_for_user)
{
(void)wait_for_user;
} | retq
| /guzmandrade[P]allegro5/examples/common.c | guzmandrade[P]allegro5[P]build_O1[P]examples[P]ex_blend_bench |
0x233a | log_printf | void log_printf(char const *format, ...)
{
va_list args;
va_start(args, format);
#ifdef ALLEGRO_ANDROID
char x[1024];
vsnprintf(x, sizeof x, format, args);
ALLEGRO_TRACE_CHANNEL_LEVEL("log", 1)("%s", x);
#else
vprintf(format, args);
#endif
va_end(args);
} | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x2395
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)... | /guzmandrade[P]allegro5/examples/common.c | guzmandrade[P]allegro5[P]build_O1[P]examples[P]ex_blend_bench |
0x23c2 | main | int main(int argc, char **argv)
{
enum Mode mode = ALL;
int i;
if (argc > 1) {
i = strtol(argv[1], NULL, 10);
switch (i) {
case 0:
mode = PLAIN_BLIT;
break;
case 1:
mode = SCALED_BLIT;
break;
case 2:
mode = ROTA... | pushq %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movb $0x1, %bpl
cmpl $0x2, %edi
jl 0x2404
movq 0x8(%rsi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
movl $0xa, %edx
callq 0x2120
cmpl $0x2, %eax
je 0x23fd
cmpl $0x1, %eax
je 0x23f6
testl %eax, %eax
jne 0x2404
movl $0x1, %ebx
jmp 0x2402
movl $0x2, %ebx
jmp 0x2402
movl $0x3, %e... | /guzmandrade[P]allegro5/examples/ex_blend_bench.c | guzmandrade[P]allegro5[P]build_O1[P]examples[P]ex_blend_bench |
0x248b | do_test | static bool do_test(enum Mode mode)
{
ALLEGRO_STATE state;
ALLEGRO_BITMAP *b1;
ALLEGRO_BITMAP *b2;
int REPEAT;
double t0, t1;
int i;
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
b1 = al_load_bitmap("data/mysha.pcx");
if (!b1) {
abort_example("Error loading data/mysha.pcx\n");
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movl %edi, %ebp
movl $0x1, %edi
callq 0x2160
leaq 0xbc5(%rip), %rdi # 0x3074
callq 0x2090
testq %rax, %rax
je 0x2682
movq %rax, %rbx
leaq 0xbda(%rip), %rdi # 0x30a1
callq 0x2090
testq %rax, %rax
je 0... | /guzmandrade[P]allegro5/examples/ex_blend_bench.c | guzmandrade[P]allegro5[P]build_O1[P]examples[P]ex_blend_bench |
0x2690 | step | static void step(enum Mode mode, ALLEGRO_BITMAP *b2)
{
switch (mode) {
case ALL: break;
case PLAIN_BLIT:
al_draw_bitmap(b2, 0, 0, 0);
break;
case SCALED_BLIT:
al_draw_scaled_bitmap(b2, 0, 0, 320, 200, 0, 0, 640, 480, 0);
break;
case ROTATE_BLIT:
al... | cmpl $0x3, %edi
je 0x26e5
cmpl $0x2, %edi
je 0x26af
cmpl $0x1, %edi
jne 0x2713
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %rsi, %rdi
xorl %esi, %esi
jmp 0x2190
movss 0x971(%rip), %xmm2 # 0x3028
movss 0x96d(%rip), %xmm3 # 0x302c
movss 0x969(%rip), %xmm6 # 0x3030
movss 0x965(%rip), %xmm7 # 0x3034
xorp... | /guzmandrade[P]allegro5/examples/ex_blend_bench.c | guzmandrade[P]allegro5[P]build_O1[P]examples[P]ex_blend_bench |
0x3c25 | opus_tags_parse_impl | static int opus_tags_parse_impl(OpusTags *_tags,
const unsigned char *_data,size_t _len){
opus_uint32 count;
size_t len;
int ncomments;
int ci;
len=_len;
if(len<8)return OP_ENOTFORMAT;
if(memcmp(_data,"OpusTags",8)!=0)return OP_ENOTFORMAT;
if(len<16)return OP_EBADHEADER;
_data+=8... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0xffffff7c, %ebx # imm = 0xFFFFFF7C
cmpq $0x8, %rdx
jb 0x3cd0
movq %rsi, %r13
movabsq $0x736761547375704f, %rax # imm = 0x736761547375704F
cmpq %rax, (%rsi)
jne 0x3cd0
movq %rdx, %r14
movl $0xffffff7b, %ebx # imm = 0xFF... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x3e74 | opus_tags_copy | int opus_tags_copy(OpusTags *_dst,const OpusTags *_src){
OpusTags dst;
int ret;
opus_tags_init(&dst);
ret=opus_tags_copy_impl(&dst,_src);
if(OP_UNLIKELY(ret<0))opus_tags_clear(&dst);
else *_dst=*&dst;
return ret;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x18(%rsi), %r12
movq %r12, %rdi
callq 0x3170
cmpq $-0x1, %rax
je 0x4034
movq %rax, %r13
leaq 0x1(%rax), %rdi
callq 0x3460
mov... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x404c | opus_tags_add | int opus_tags_add(OpusTags *_tags,const char *_tag,const char *_value){
char *comment;
size_t tag_len;
size_t value_len;
int ncomments;
int ret;
ncomments=_tags->comments;
ret=op_tags_ensure_capacity(_tags,ncomments+1);
if(OP_UNLIKELY(ret<0))return ret;
tag_len=strlen(_tag);
value_len=st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movslq 0x10(%rdi), %r15
leaq 0x1(%r15), %r12
movq %r12, %rsi
callq 0x4138
testl %eax, %eax
js 0x4133
movq %r12, 0x20(%rsp)
movq %rbp, 0x10(%rsp)
movq %rbp, %rdi
callq 0x3170
movq %rax, %rbp... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x4138 | op_tags_ensure_capacity | static int op_tags_ensure_capacity(OpusTags *_tags,size_t _ncomments){
char **user_comments;
int *comment_lengths;
int cur_ncomments;
size_t size;
if(OP_UNLIKELY(_ncomments>=(size_t)INT_MAX))return OP_EFAULT;
size=sizeof(*_tags->comment_lengths)*(_ncomments+1);
if(size/sizeof(*_tags->comment_... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffff7f, %ebp # imm = 0xFFFFFF7F
cmpq $0x7ffffffe, %rsi # imm = 0x7FFFFFFE
ja 0x41b2
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(,%rsi,4), %rsi
movslq 0x10(%rdi), %r15
movq 0x8(%rdi), %rdi
callq 0x3580
testq %rax, %rax
je 0x41b2
leaq 0x1(%r14), %r... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x41bf | opus_tags_add_comment | int opus_tags_add_comment(OpusTags *_tags,const char *_comment){
char *comment;
int comment_len;
int ncomments;
int ret;
ncomments=_tags->comments;
ret=op_tags_ensure_capacity(_tags,ncomments+1);
if(OP_UNLIKELY(ret<0))return ret;
comment_len=(int)strlen(_comment);
comment=op_strdup_with_len(_com... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movslq 0x10(%rdi), %r14
leaq 0x1(%r14), %rbp
movq %rbp, %rsi
callq 0x4138
testl %eax, %eax
js 0x424b
movq %r12, %rdi
callq 0x3170
movq %rax, %r15
shlq $0x20, %rax
movabsq $-0x100000000, %rcx # imm = 0xFFFFFF... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x4266 | opus_tags_set_binary_suffix | int opus_tags_set_binary_suffix(OpusTags *_tags,
const unsigned char *_data,int _len){
unsigned char *binary_suffix_data;
int ncomments;
int ret;
if(_len<0||_len>0&&(_data==NULL||!(_data[0]&1)))return OP_EINVAL;
ncomments=_tags->comments;
ret=op_tags_ensure_capacity(_tags,ncomments);
... | movl $0xffffff7d, %eax # imm = 0xFFFFFF7D
testl %edx, %edx
js 0x429d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
je 0x429e
testq %r15, %r15
je 0x428f
testb $0x1, (%r15)
jne 0x429e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x42f3 | opus_tagcompare | int opus_tagcompare(const char *_tag_name,const char *_comment){
size_t tag_len;
tag_len=strlen(_tag_name);
if(OP_UNLIKELY(tag_len>(size_t)INT_MAX))return -1;
return opus_tagncompare(_tag_name,(int)tag_len,_comment);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3170
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
ja 0x4330
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0xadac
testl %eax, %eax
jne 0x432a
movsbl (%rbx,%r14), %ecx
pushq $0x3d
popq %rax
subl %ecx, %eax
popq %rbx
popq ... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x4335 | opus_tags_query | const char *opus_tags_query(const OpusTags *_tags,const char *_tag,int _count){
char **user_comments;
size_t tag_len;
int found;
int ncomments;
int ci;
tag_len=strlen(_tag);
if(OP_UNLIKELY(tag_len>(size_t)INT_MAX))return NULL;
ncomments=_tags->comments;
user_comments=_tags->user_com... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
movq %rdi, %r12
movq %rsi, 0x10(%rsp)
movq %rsi, %rdi
callq 0x3170
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
ja 0x43a8
movq %rax, %r15
movslq 0x10(%r12), %r13
xorl %eax, %eax
testq %r13, %r13
jle 0x43aa
movq (%... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x43c5 | opus_tags_query_count | int opus_tags_query_count(const OpusTags *_tags,const char *_tag){
char **user_comments;
size_t tag_len;
int found;
int ncomments;
int ci;
tag_len=strlen(_tag);
if(OP_UNLIKELY(tag_len>(size_t)INT_MAX))return 0;
ncomments=_tags->comments;
user_comments=_tags->user_comments;
found=0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq %rsi, (%rsp)
movq %rsi, %rdi
callq 0x3170
xorl %ebp, %ebp
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
ja 0x442d
movslq 0x10(%r15), %r12
testq %r12, %r12
jle 0x442d
movq %rax, %r14
movq (%r15), %r13
xorl %ebx, %ebx
xorl... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x443e | op_test | int op_test(OpusHead *_head,
const unsigned char *_initial_data,size_t _initial_bytes){
ogg_sync_state oy;
char *data;
int err;
/*The first page of a normal Opus file will be at most 57 bytes (27 Ogg
page header bytes + 1 lacing value + 21 Opus header bytes + 8 channel
mapping ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
cmpq $0x2f, %rdx
jae 0x445d
pushq $-0x1
popq %rbp
jmp 0x4580
movq %rsi, %r14
cmpl $0x5367674f, (%rsi) # imm = 0x5367674F
movl $0xffffff7c, %ebp # imm = 0xFFFFFF7C
jne 0x4580
movq %rdx, %r15
testq %rdx,... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x459b | op_granpos_add | static int op_granpos_add(ogg_int64_t *_dst_gp,ogg_int64_t _src_gp,
opus_int32 _delta){
/*The code below handles this case correctly, but there's no reason we
should ever be called with these values, so make sure we aren't.*/
OP_ASSERT(_src_gp!=-1);
if(_delta>0){
/*Adding this amount to the granule posi... | testl %edx, %edx
jle 0x45bf
testq %rsi, %rsi
js 0x460a
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movl %edx, %ecx
xorq %rax, %rcx
cmpq %rsi, %rcx
jl 0x461b
movq %rsi, %rax
movl %edx, %ecx
jmp 0x45c8
xorl %ecx, %ecx
testl %edx, %edx
js 0x45d4
movq %rsi, %rax
movslq %ecx, %rcx
addq %rax, %rcx
movq %rcx,... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x4624 | op_clear | static void op_clear(OggOpusFile *_of){
OggOpusLink *links;
_ogg_free(_of->od_buffer);
if(_of->od!=NULL)opus_multistream_decoder_destroy(_of->od);
links=_of->links;
if(!_of->seekable){
if(_of->ready_state>OP_OPENED||_of->ready_state==OP_PARTOPEN){
opus_tags_clear(&links[0].tags);
}
}
else if... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3248(%rdi), %rdi
callq 0x33f0
movq 0x3218(%rbx), %rdi
testq %rdi, %rdi
je 0x464c
callq 0x30e0
movq 0x30(%rbx), %r14
cmpl $0x0, 0x28(%rbx)
je 0x4681
testq %r14, %r14
je 0x46a0
movslq 0x2c(%rbx), %r12
testq %r12, %r12
jle 0x46a0
leaq 0x158(%r14... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x46ec | op_open_callbacks | OggOpusFile *op_open_callbacks(void *_stream,const OpusFileCallbacks *_cb,
const unsigned char *_initial_data,size_t _initial_bytes,int *_error){
OggOpusFile *of;
of=op_test_callbacks(_stream,_cb,_initial_data,_initial_bytes,_error);
if(OP_LIKELY(of!=NULL)){
int ret;
ret=op_open2(of);
if(OP_LIKELY(re... | pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r14
callq 0xae24
testq %rax, %rax
je 0x4727
movq %rax, %rbx
movq %rax, %rdi
callq 0xb0ac
testl %eax, %eax
js 0x4717
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testq %r14, %r14
je 0x471f
movl %eax, (%r14)
movq %rbx, %rdi
callq 0x33f0
xorl %ebx, %ebx
jmp 0x470c
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x472b | op_test_open | int op_test_open(OggOpusFile *_of){
int ret;
if(OP_UNLIKELY(_of->ready_state!=OP_PARTOPEN))return OP_EINVAL;
ret=op_open2(_of);
/*op_open2() will clear this structure on failure.
Reset its contents to prevent double-frees in op_free().*/
if(OP_UNLIKELY(ret<0))memset(_of,0,sizeof(*_of));
return ret;
} | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, 0x78(%rdi)
jne 0x474d
movq %rdi, %r14
callq 0xb0ac
movl %eax, %ebx
testl %eax, %eax
js 0x4754
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xffffff7d, %ebx # imm = 0xFFFFFF7D
jmp 0x4743
movl $0x3390, %edx # imm = 0x3390
movq %r14, %rdi
xorl %... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x4765 | op_free | void op_free(OggOpusFile *_of){
if(OP_LIKELY(_of!=NULL)){
op_clear(_of);
_ogg_free(_of);
}
} | testq %rdi, %rdi
je 0x477c
pushq %rbx
movq %rdi, %rbx
callq 0x4624
movq %rbx, %rdi
popq %rbx
jmp 0x33f0
retq
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x477d | op_raw_total | opus_int64 op_raw_total(const OggOpusFile *_of,int _li){
if(OP_UNLIKELY(_of->ready_state<OP_OPENED)
||OP_UNLIKELY(!_of->seekable)
||OP_UNLIKELY(_li>=_of->nlinks)){
return OP_EINVAL;
}
if(_li<0)return _of->end;
return (_li+1>=_of->nlinks?_of->end:_of->links[_li+1].offset)
-(_li>0?_of->links[_li].off... | movq $-0x83, %rax
cmpl $0x2, 0x78(%rdi)
jl 0x47b5
cmpl $0x0, 0x28(%rdi)
je 0x47b5
movl 0x2c(%rdi), %ecx
cmpl %esi, %ecx
jle 0x47b5
testl %esi, %esi
js 0x47b1
leal 0x1(%rsi), %eax
cmpl %ecx, %eax
jge 0x47b6
movl %eax, %eax
imulq $0x178, %rax, %rax # imm = 0x178
addq 0x30(%rdi), %rax
jmp 0x47ba
movq 0x50(%rdi), %rax... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x47da | op_pcm_total | ogg_int64_t op_pcm_total(const OggOpusFile *_of,int _li){
OggOpusLink *links;
ogg_int64_t pcm_total;
ogg_int64_t diff;
int nlinks;
nlinks=_of->nlinks;
if(OP_UNLIKELY(_of->ready_state<OP_OPENED)
||OP_UNLIKELY(!_of->seekable)
||OP_UNLIKELY(_li>=nlinks)){
return OP_EINVAL;
}
links=_of-... | movq $-0x83, %rax
cmpl $0x2, 0x78(%rdi)
jl 0x483f
cmpl $0x0, 0x28(%rdi)
je 0x483f
movslq 0x2c(%rdi), %rcx
cmpl %esi, %ecx
jle 0x483f
movq 0x30(%rdi), %rdi
testl %esi, %esi
js 0x4801
xorl %ecx, %ecx
jmp 0x4813
leal -0x1(%rcx), %esi
imulq $0x178, %rcx, %rax # imm = 0x178
movq -0x160(%rax,%rdi), %rcx
movslq %esi, %ra... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x4860 | op_current_link | int op_current_link(const OggOpusFile *_of){
if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
return _of->cur_link;
} | cmpl $0x2, 0x78(%rdi)
jl 0x486a
movl 0x7c(%rdi), %eax
retq
movl $0xffffff7d, %eax # imm = 0xFFFFFF7D
retq
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x4870 | op_bitrate | opus_int32 op_bitrate(const OggOpusFile *_of,int _li){
if(OP_UNLIKELY(_of->ready_state<OP_OPENED)||OP_UNLIKELY(!_of->seekable)
||OP_UNLIKELY(_li>=_of->nlinks)){
return OP_EINVAL;
}
return op_calc_bitrate(op_raw_total(_of,_li),op_pcm_total(_of,_li));
} | pushq %r15
pushq %r14
pushq %rbx
cmpl $0x2, 0x78(%rdi)
jl 0x48b0
movq %rdi, %r14
cmpl $0x0, 0x28(%rdi)
je 0x48b0
movl %esi, %ebx
cmpl %esi, 0x2c(%r14)
jle 0x48b0
movq %r14, %rdi
movl %ebx, %esi
callq 0x477d
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
callq 0x47da
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x48bb | op_calc_bitrate | static opus_int32 op_calc_bitrate(opus_int64 _bytes,ogg_int64_t _samples){
if(OP_UNLIKELY(_samples<=0))return OP_INT32_MAX;
/*These rates are absurd, but let's handle them anyway.*/
if(OP_UNLIKELY(_bytes>(OP_INT64_MAX-(_samples>>1))/(48000*8))){
ogg_int64_t den;
if(OP_UNLIKELY(_bytes/(OP_INT32_MAX/(48000*... | movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
testq %rsi, %rsi
jle 0x4906
movq %rsi, %r8
shrq %r8
movabsq $0x7ffffffffffffc00, %rax # imm = 0x7FFFFFFFFFFFFC00
xorq %r8, %rax
movl $0x5dc00, %r9d # imm = 0x5DC00
xorl %edx, %edx
divq %r9
cmpq %rdi, %rax
jl 0x4909
imulq $0x5dc00, %rdi, %rax # imm = 0x5DC00
ad... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x493c | op_bitrate_instant | opus_int32 op_bitrate_instant(OggOpusFile *_of){
ogg_int64_t samples_tracked;
opus_int32 ret;
if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
samples_tracked=_of->samples_tracked;
if(OP_UNLIKELY(samples_tracked==0))return OP_FALSE;
ret=op_calc_bitrate(_of->bytes_tracked,samples_tracked);
_of... | pushq %rbx
cmpl $0x2, 0x78(%rdi)
jl 0x496a
movq %rdi, %rbx
movq 0xa0(%rdi), %rsi
testq %rsi, %rsi
je 0x4971
movq 0x98(%rbx), %rdi
callq 0x48bb
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
popq %rbx
retq
movl $0xffffff7d, %eax # imm = 0xFFFFFF7D
jmp 0x4968
pushq $-0x1
popq %rax
jmp 0x4968
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x4976 | op_raw_seek | int op_raw_seek(OggOpusFile *_of,opus_int64 _pos){
int ret;
if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
/*Don't dump the decoder state if we can't seek.*/
if(OP_UNLIKELY(!_of->seekable))return OP_ENOSEEK;
if(OP_UNLIKELY(_pos<0)||OP_UNLIKELY(_pos>_of->end))return OP_EINVAL;
/*Clear out any b... | movl $0xffffff7d, %eax # imm = 0xFFFFFF7D
cmpl $0x2, 0x78(%rdi)
jl 0x4a6d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x28(%rdi)
je 0x4a6e
testq %rsi, %rsi
js 0x4a66
cmpq %rsi, 0x50(%rbx)
jl 0x4a66
andl $0x0, 0x3214(%rbx)
andl $0x0, 0x3254(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x88(%rbx)
movl $... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x4a7a | op_fetch_and_process_page | static int op_fetch_and_process_page(OggOpusFile *_of,
ogg_page *_og,opus_int64 _page_offset,int _spanp,int _ignore_holes){
OggOpusLink *links;
ogg_uint32_t cur_serialno;
int seekable;
int cur_link;
int ret;
/*We shouldn't get here if we have unprocessed packets.*/
OP_ASSE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4d8, %rsp # imm = 0x4D8
movl %r8d, 0x5c(%rsp)
movl %ecx, 0x68(%rsp)
movq %rdx, %rbp
movq %rdi, %r14
movl 0x28(%rdi), %eax
movq 0x30(%rdi), %r12
movl $0x0, %ecx
movl %eax, 0x6c(%rsp)
testl %eax, %eax
je 0x4ab2
movl 0x7c(%r14), %ecx
movq... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x544c | op_raw_tell | opus_int64 op_raw_tell(const OggOpusFile *_of){
if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
return _of->offset;
} | cmpl $0x2, 0x78(%rdi)
jl 0x5457
movq 0x48(%rdi), %rax
retq
movq $-0x83, %rax
retq
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x545f | op_pcm_tell | ogg_int64_t op_pcm_tell(const OggOpusFile *_of){
ogg_int64_t gp;
int nbuffered;
int li;
if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
gp=_of->prev_packet_gp;
if(gp==-1)return 0;
nbuffered=OP_MAX(_of->od_buffer_size-_of->od_buffer_pos,0);
OP_ALWAYS_TRUE(!op_granpos_add(&gp,... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x2, 0x78(%rdi)
jl 0x5562
movq %rdi, %r14
movq 0x88(%rdi), %rsi
movq %rsi, 0x8(%rsp)
xorl %ebx, %ebx
cmpq $-0x1, %rsi
jne 0x5494
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl 0x3254(%r14), %edx
subl 0x3250(%r14), %edx
testl %edx, %edx
cm... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x55e4 | op_filter_read_native | static int op_filter_read_native(OggOpusFile *_of,void *_dst,int _dst_sz,
op_read_filter_func _filter,int *_li){
int ret;
/*Ensure we have some decoded samples in our buffer.*/
ret=op_read_native(_of,NULL,0,_li);
/*Now apply the filter to them.*/
if(OP_LIKELY(ret>=0)&&OP_LIKELY(_of->ready_state>=OP_INITSET))... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
movq %r8, %rcx
callq 0x5674
testl %eax, %eax
js 0x566b
cmpl $0x4, 0x78(%rbx)
jl 0x566b
movl 0x3250(%rbx), %r12d
movl 0x3254(%rbx), %eax
subl %r12d, %eax
jle 0x566b
movq ... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x5674 | op_read_native | static int op_read_native(OggOpusFile *_of,
op_sample *_pcm,int _buf_size,int *_li){
if(OP_UNLIKELY(_of->ready_state<OP_OPENED))return OP_EINVAL;
for(;;){
int ret;
if(OP_LIKELY(_of->ready_state>=OP_INITSET)){
int nchannels;
int od_buffer_pos;
int nsamples;
int op_pos;
nchannel... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0x4(%rsp)
movq %rsi, 0x18(%rsp)
cmpl $0x2, 0x78(%rdi)
jl 0x5a56
movq %rcx, %r14
movq %rdi, %r15
leaq 0x240(%rdi), %rax
movq %rax, 0x30(%rsp)
movq %rcx, 0x8(%rsp)
cmpl $0x4, 0x78(%r15)
jl 0x586d
cmpl $0x0, 0x28(%r15)
je 0x56c4
... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x5a6e | op_read_stereo | int op_read_stereo(OggOpusFile *_of,opus_int16 *_pcm,int _buf_size){
return op_filter_read_native(_of,_pcm,_buf_size,
op_float2short_stereo_filter,NULL);
} | leaq 0x7d8a(%rip), %rcx # 0xd7ff
xorl %r8d, %r8d
jmp 0x55e4
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x5a7d | op_read_float_stereo | int op_read_float_stereo(OggOpusFile *_of,float *_pcm,int _buf_size){
_of->state_channel_count=0;
return op_filter_read_native(_of,_pcm,_buf_size,op_stereo_filter,NULL);
} | andl $0x0, 0x338c(%rdi)
leaq 0x7e15(%rip), %rcx # 0xd8a0
xorl %r8d, %r8d
jmp 0x55e4
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x5a93 | op_fetch_headers | static int op_fetch_headers(OggOpusFile *_of,OpusHead *_head,
OpusTags *_tags,ogg_uint32_t **_serialnos,int *_nserialnos,
int *_cserialnos,ogg_page *_og){
ogg_page og;
int ret;
if(!_og){
/*No need to clamp the boundary offset against _of->end, as all errors
become OP_ENOTFORMAT.*/
if(OP_UNLI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, %rbx
movq 0xc0(%rsp), %r15
movabsq $0x7ffffffffffeffff, %rbp # imm = 0x7FFFFFFFFFFEFFFF
testq %r15, %r15
movq %rcx, (%rsp)
jne 0x5b05
movq 0x... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x5de6 | op_collect_audio_packets | static opus_int32 op_collect_audio_packets(OggOpusFile *_of,
int _durations[255]){
opus_int32 total_duration;
int op_count;
/*Count the durations of all packets in the page.*/
op_count=0;
total_duration=0;
for(;;){
int ret;
/*This takes advantage of undocumented libogg behavior that returned... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
leaq 0xa8(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rdi, (%rsp)
leaq 0x240(%rdi), %rbx
xorl %r13d, %r13d
xorl %ebp, %ebp
movslq %r13d, %r14
imulq $0x30, %r14, %r15
leaq (%rbx,%r15), %r12
movq 0x10(%rsp), %rdi
movq %r12... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x5ea4 | op_get_packet_duration | static int op_get_packet_duration(const unsigned char *_data,int _len){
int nframes;
int frame_size;
int nsamples;
nframes=opus_packet_get_nb_frames(_data,_len);
if(OP_UNLIKELY(nframes<0))return OP_EBADPACKET;
frame_size=opus_packet_get_samples_per_frame(_data,48000);
nsamples=nframes*frame_size;
if(OP_... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x35d0
testl %eax, %eax
js 0x5edc
movl %eax, %ebp
movq %rbx, %rdi
movl $0xbb80, %esi # imm = 0xBB80
callq 0x3250
movl %eax, %ecx
imull %ebp, %ecx
cmpl $0x1681, %ecx # imm = 0x1681
movl $0xffffff78, %eax # imm = 0xFFFFFF78
cmovll %ecx, %eax... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x5ee3 | op_make_decode_ready | static int op_make_decode_ready(OggOpusFile *_of){
const OpusHead *head;
int li;
int stream_count;
int coupled_count;
int channel_count;
if(_of->ready_state>OP_STREAMSET)return 0;
if(OP_UNLIKELY(_of->ready_state<OP_STREAMSET))return OP_EFAULT;
li=_of->seek... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %ebp, %ebp
cmpl $0x3, 0x78(%rdi)
jg 0x6026
movl $0xffffff7f, %ebp # imm = 0xFFFFFF7F
jne 0x6026
movq %rdi, %rbx
cmpl $0x0, 0x28(%rdi)
je 0x5f17
movslq 0x7c(%rbx), %rax
jmp 0x5f19
xorl %eax, %eax
movq 0x30(%rbx), %rcx
imulq $0x... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x6048 | op_find_final_pcm_offset | static int op_find_final_pcm_offset(OggOpusFile *_of,
const ogg_uint32_t *_serialnos,int _nserialnos,OggOpusLink *_link,
opus_int64 _offset,ogg_uint32_t _end_serialno,ogg_int64_t _end_gp,
ogg_int64_t *_total_duration){
ogg_int64_t total_duration;
ogg_int64_t duration;
ogg_uint32_t cur_serialno;
/*For the t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq 0xb0(%rsp), %r10
movl 0x30(%rcx), %eax
movl %eax, 0x34(%rsp)
cmpl %r9d, %eax
sete %al
cmpq $-0x1, %r10
setne %sil
testb %al, %sil
jne 0x6276
movq %rdi, %r12
movq %rcx, 0x40(%rsp)
testl %edx, %edx
setg 0x3(%rsp)
movl ... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x632c | op_decode | static int op_decode(OggOpusFile *_of,op_sample *_pcm,
const ogg_packet *_op,int _nsamples,int _nchannels){
int ret;
/*First we try using the application-provided decode callback.*/
if(_of->decode_cb!=NULL){
#if defined(OP_FIXED_POINT)
ret=(*_of->decode_cb)(_of->decode_cb_ctx,_of->od,_pcm,_op,
_nsamples... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq 0x3220(%rdi), %rax
testq %rax, %rax
je 0x637b
movl %r8d, %r9d
movq 0x3228(%r12), %rdi
movq 0x3218(%r12), %rsi
movl 0x7c(%r12), %r10d
movq %r14, %rdx
movq %r15, %rcx
movl %ebx, %r8d
pushq %r10
push... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x649e | op_url_stream_create_impl | static void *op_url_stream_create_impl(OpusFileCallbacks *_cb,const char *_url,
int _skip_certificate_check,const char *_proxy_host,unsigned _proxy_port,
const char *_proxy_user,const char *_proxy_pass,OpusServerInfo *_info){
const char *path;
/*Check to see if this is a valid file: URL.*/
path=op_parse_file_ur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, 0x58(%rsp)
movl %r8d, %ebp
movq %rcx, 0x38(%rsp)
movl %edx, 0x50(%rsp)
movq %rsi, %r13
movq %rdi, %r12
leaq 0xa403(%rip), %rsi # 0x108d0
movq %r13, %rdi
callq 0x3160
xorl %edi, %edi
cmpq $0x4, %ra... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x75c4 | op_string_dup | static char *op_string_dup(const char *_s){
return op_string_range_dup(_s,_s+strlen(_s));
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x3170
cmpq $0x7ffffffe, %rax # imm = 0x7FFFFFFE
ja 0x7609
movq %rax, %r15
leaq 0x1(%rax), %rdi
callq 0x3460
movq %rax, %rbx
testq %rax, %rax
je 0x7600
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3260
movb $0x0, (%rbx,%r15)
movq %rbx, %rax
popq %r... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x760d | op_validate_url_escapes | static int op_validate_url_escapes(const char *_s){
int i;
for(i=0;_s[i];i++){
if(_s[i]=='%'){
if(OP_UNLIKELY(!isxdigit(_s[i+1]))
||OP_UNLIKELY(!isxdigit(_s[i+2]))
/*RFC 3986 says %00 "should be rejected if the application is not
expecting to receive raw data within a component."*/... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ecx, %ecx
pushq $-0x1
popq %rbp
movslq %ecx, %r14
movzbl (%rbx,%r14), %eax
cmpl $0x25, %eax
je 0x762c
testl %eax, %eax
jne 0x765e
jmp 0x7664
callq 0x3370
movq (%rax), %rdx
movsbq 0x1(%rbx,%r14), %rax
testb $0x10, 0x1(%rdx,%rax,2)
je 0x7662
movsbq 0x2(%rbx,%r14), %r... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x7669 | op_parse_url | static int op_parse_url(OpusParsedURL *_dst,const char *_src){
OpusParsedURL url;
int ret;
op_parsed_url_init(&url);
ret=op_parse_url_impl(&url,_src);
if(OP_UNLIKELY(ret<0))op_parsed_url_clear(&url);
else *_dst=*&url;
return ret;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
leaq 0x923a(%rip), %rsi # 0x108d0
movq %rbx, %rdi
callq 0x3160
cmpb $0x3a, (%rbx,%rax)
movb $0x1, %r15b
jn... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x7b66 | op_sb_append | static int op_sb_append(OpusStringBuf *_sb,const char *_s,int _len){
char *buf;
int nbuf;
int ret;
nbuf=_sb->nbuf;
if(OP_UNLIKELY(nbuf>INT_MAX-_len))return OP_EFAULT;
ret=op_sb_ensure_capacity(_sb,nbuf+_len);
if(OP_UNLIKELY(ret<0))return ret;
buf=_sb->buf;
memcpy(buf+nbuf,_s,sizeof(*buf)*_len);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x8(%rdi), %r12
movl %edx, %eax
xorl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpl %eax, %r12d
jg 0x7bca
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leal (%r12,%r15), %ebp
movl %ebp, %esi
callq 0x85d0
testl %eax, %eax
js 0x7bbb
m... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x7bd1 | op_sb_append_string | static int op_sb_append_string(OpusStringBuf *_sb,const char *_s){
size_t len;
len=strlen(_s);
if(OP_UNLIKELY(len>(size_t)INT_MAX))return OP_EFAULT;
return op_sb_append(_sb,_s,(int)len);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3170
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
ja 0x7bff
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7b66
movl $0xffffff7f, %eax # imm = 0xFFFFFF7F
addq $0x8, %rsp
popq %rbx... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x7c0c | op_sb_append_basic_auth_header | static int op_sb_append_basic_auth_header(OpusStringBuf *_sb,
const char *_header,const char *_user,const char *_pass){
size_t user_len;
size_t pass_len;
int user_pass_len;
int base64_len;
int nbuf_total;
int ret;
ret=op_sb_append_string(_sb,_header);
ret|=op_sb_append(_sb,": Basic ",8);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
callq 0x7bd1
movl %eax, %ebx
leaq 0x8f5e(%rip), %rsi # 0x10b8f
pushq $0x8
popq %rdx
movq %r12, %rdi
callq 0x7b66
movl %eax, %ebp
movq %r15, %rdi
callq 0x3170
movq %rax, %r13
movq %r14,... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x7ea1 | op_http_conn_read_response | static int op_http_conn_read_response(OpusHTTPConn *_conn,
OpusStringBuf *_response){
int ret;
_response->nbuf=0;
ret=op_sb_ensure_capacity(_response,OP_RESPONSE_SIZE_MIN);
if(OP_UNLIKELY(ret<0))return ret;
for(;;){
char *buf;
int size;
int capacity;
int read_limit;
int terminated... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
andl $0x0, 0x8(%rsi)
movq %rsi, %rdi
movl $0x1fe, %esi # imm = 0x1FE
callq 0x85d0
testl %eax, %eax
js 0x8113
movq %r14, (%rsp)
movslq 0x8(%r14), %r15
movl 0xc(%r14), %ebx
decl %ebx
cmpl %e... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x8126 | op_http_parse_status_line | static char *op_http_parse_status_line(int *_v1_1_compat,
char **_status_code,char *_response){
char *next;
char *status_code;
int v1_1_compat;
size_t d;
/*RFC 2616 Section 6.1 does not say if the tokens in the Status-Line can be
separated by optional LWS, but since it specifically calls out wh... | cmpb $0x2f, 0x4(%rdx)
jne 0x8256
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5(%rdx), %r15
leaq 0x89de(%rip), %rsi # 0x10b2d
movq %r15, %rdi
callq 0x3160
movq %rax, %rcx
movb 0x5(%r12), %dl
cmpb $0x30, %dl
jne 0x8170
decq %rcx
... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x8259 | op_http_get_next_header | static int op_http_get_next_header(char **_header,char **_cdr,char **_s){
char *header;
char *header_end;
char *cdr;
char *cdr_end;
char *next;
size_t d;
next=*_s;
/*The second case is for broken servers.*/
if(next[0]=='\r'&&next[1]=='\n'||OP_UNLIKELY(next[0]=='\n')){
/*No more headers.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq (%rdx), %r13
movzbl (%r13), %eax
cmpl $0xd, %eax
jne 0x829b
xorl %r8d, %r8d
cmpb $0xa, %al
je 0x83db
cmpb $0xa, 0x1(%r13)
movl $0x0, %eax
movl $0x0, %ebp
jne 0x82a4
jmp 0x83b9
cmpl $0xa, %eax
je 0x83d... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x83e1 | op_http_parse_content_range | static int op_http_parse_content_range(opus_int64 *_first,opus_int64 *_last,
opus_int64 *_length,const char *_cdr){
opus_int64 first;
opus_int64 last;
opus_int64 length;
size_t d;
if(OP_UNLIKELY(op_strncasecmp(_cdr,"bytes",5)!=0))return OP_FALSE;
_cdr+=5;
d=op_http_lwsspn(_cdr);
if(OP_UNLIKELY(d<=0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, 0x8(%rsp)
leaq 0x8810(%rip), %rsi # 0x10c17
pushq $0x5
popq %rdx
movq %rcx, %rdi
callq 0xadac
pushq $-0x1
popq %rbx
testl %eax, %eax
jne 0x8493
addq $0x5, %r... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x8541 | op_http_parse_connection | static int op_http_parse_connection(char *_cdr){
size_t d;
int ret;
ret=0;
for(;;){
d=strcspn(_cdr,OP_HTTP_CTOKEN);
if(OP_UNLIKELY(d<=0))return OP_FALSE;
if(op_strncasecmp(_cdr,"close",(int)d)==0)ret=1;
/*We're supposed to strip and ignore any headers mentioned in the
Connection header... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x866d(%rip), %rsi # 0x10bc3
callq 0x3080
movq %rax, %r13
pushq $-0x1
popq %rax
testq %r13, %r13
je 0x85c1
xorl %ebp, %ebp
leaq 0x86ae(%rip), %r15 # 0x10c1d
pushq $0x1
popq %rbx
leaq 0x864a(%rip), %r12 # 0x1... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x85d0 | op_sb_ensure_capacity | static int op_sb_ensure_capacity(OpusStringBuf *_sb,int _capacity){
char *buf;
int cbuf;
buf=_sb->buf;
cbuf=_sb->cbuf;
if(_capacity>=cbuf-1){
if(OP_UNLIKELY(cbuf>INT_MAX-1>>1))return OP_EFAULT;
if(OP_UNLIKELY(_capacity>=INT_MAX-1))return OP_EFAULT;
cbuf=OP_MAX(2*cbuf+1,_capacity+1);
buf=_ogg... | pushq %rbp
pushq %r14
pushq %rbx
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
xorl %ebx, %ebx
cmpl %esi, %ecx
jg 0x861f
movl $0xffffff7f, %ebx # imm = 0xFFFFFF7F
cmpl $0x7ffffffd, %esi # imm = 0x7FFFFFFD
jg 0x861f
cmpl $0x3fffffff, %eax # imm = 0x3FFFFFFF
jg 0x861f
movq %rdi, %r14
movq (%rdi), %rdi
leal... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x8626 | op_http_conn_establish_tunnel | static int op_http_conn_establish_tunnel(OpusHTTPStream *_stream,
OpusHTTPConn *_conn,op_sock _fd,SSL *_ssl_conn,BIO *_ssl_bio){
# if (OPENSSL_VERSION_NUMBER>=0x10100000L||LIBRESSL_VERSION_NUMBER>=0x2070000fL)
BIO_METHOD *bio_retry_method;
# endif
BIO *retry_bio;
char *status_code;
char *next;
int ret;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rcx, %r13
movl %edx, %ebp
movq %rsi, %r15
andq $0x0, 0x20(%rsi)
movq %rdi, %r14
movl %edx, 0x50(%rsi)
movq 0x240(%rdi), %rsi
movl 0x248(%rdi), %edx
movq %r15, %rdi
callq 0xf05c
pushq $-0x1
popq %rbx
testl %eax, %eax
... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x87a5 | op_sb_grow | static int op_sb_grow(OpusStringBuf *_sb,int _max_size){
char *buf;
int cbuf;
buf=_sb->buf;
cbuf=_sb->cbuf;
OP_ASSERT(_max_size<=INT_MAX-1);
cbuf=cbuf<=_max_size-1>>1?2*cbuf+1:_max_size+1;
buf=_ogg_realloc(buf,sizeof(*buf)*cbuf);
if(OP_UNLIKELY(buf==NULL))return OP_EFAULT;
_sb->buf=buf;
_sb->cbuf=... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0xc(%rbx), %eax
cmpl $0x3fff, %eax # imm = 0x3FFF
leal 0x1(%rax,%rax), %eax
movl $0x7fff, %ebp # imm = 0x7FFF
cmovll %eax, %ebp
movslq %ebp, %rsi
callq 0x3580
testq %rax, %rax
je 0x87de
movq %rax, (%rbx)
movl %ebp, 0xc(%rbx)
xor... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x87e5 | op_http_parse_nonnegative_int64 | static opus_int64 op_http_parse_nonnegative_int64(const char **_next,
const char *_cdr){
const char *next;
opus_int64 ret;
int i;
next=_cdr+strspn(_cdr,OP_HTTP_DIGIT);
*_next=next;
if(OP_UNLIKELY(next<=_cdr))return OP_FALSE;
while(*_cdr=='0')_cdr++;
if(OP_UNLIKELY(next-_cdr>19))return OP_EIMPL... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8337(%rip), %rsi # 0x10b2d
movq %rbx, %rdi
callq 0x3160
leaq (%rbx,%rax), %rcx
movq %rcx, (%r14)
testq %rax, %rax
jle 0x8877
incq %rax
decq %rax
cmpb $0x30, (%rbx)
leaq 0x1(%rbx), %rbx
je 0x880d
cmpq $0x13, %rax
jg 0x8865
testq %rax, %rax
jle ... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x887c | op_http_stream_close | static int op_http_stream_close(void *_stream){
OpusHTTPStream *stream;
stream=(OpusHTTPStream *)_stream;
if(OP_LIKELY(stream!=NULL)){
op_http_stream_clear(stream);
_ogg_free(stream);
}
return 0;
} | testq %rdi, %rdi
je 0x8893
pushq %rbx
movq %rdi, %rbx
callq 0xe795
movq %rbx, %rdi
callq 0x33f0
popq %rbx
xorl %eax, %eax
retq
| /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x8896 | op_http_conn_open_pos | static int op_http_conn_open_pos(OpusHTTPStream *_stream,
OpusHTTPConn *_conn,opus_int64 _pos,opus_int32 _chunk_size){
op_time start_time;
op_time end_time;
opus_int32 connect_rate;
opus_int32 connect_time;
int ret;
ret=op_http_connect(_stream,_conn,&_stream->addr_info,&start_ti... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1d0(%rdi), %rdx
leaq 0x8(%rsp), %rcx
callq 0xe839
testl %eax, %eax
js 0x8973
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x8991
testl %eax, %eax
js 0x8973
movq %r... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x8991 | op_http_conn_send_request | static int op_http_conn_send_request(OpusHTTPStream *_stream,
OpusHTTPConn *_conn,opus_int64 _pos,opus_int32 _chunk_size,
int _try_not_to_block){
opus_int64 next_end;
int ret;
/*We shouldn't have another request outstanding.*/
OP_ASSERT(_conn->next_pos<0);
/*Build the request to send.*/
OP_ASSERT(_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r15
movl 0x28c(%rdi), %eax
leaq 0x230(%rdi), %r12
movl %eax, 0x238(%rdi)
movq %r12, %rdi
movq %rdx, %rsi
callq 0x8d62
movl %eax, %r14d
leaq 0x7649(%rip), %rsi # 0x1001b
pus... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x8ab7 | op_http_conn_handle_response | static int op_http_conn_handle_response(OpusHTTPStream *_stream,
OpusHTTPConn *_conn){
char *next;
char *status_code;
opus_int64 range_length;
opus_int64 next_pos;
opus_int64 next_end;
int ret;
ret=op_http_conn_read_response(_conn,&_stream->response);
/*If the server just closed ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x250(%rdi), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x7ea1
testl %eax, %eax
js 0x8d55
movq (%r15), %rdx
leaq 0x28(%rsp), %rsi
xorl %edi, %edi
callq 0x8126
movq %rax, 0x30(%rsp)
testq %rax, %rax
je... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x8d62 | op_sb_append_nonnegative_int64 | static int op_sb_append_nonnegative_int64(OpusStringBuf *_sb,opus_int64 _i){
char digit;
int nbuf_start;
int ret;
OP_ASSERT(_i>=0);
nbuf_start=_sb->nbuf;
ret=0;
do{
digit='0'+_i%10;
ret|=op_sb_append(_sb,&digit,1);
_i/=10;
}
while(_i>0);
if(OP_LIKELY(ret>=0)){
char *buf;
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movslq 0x8(%rdi), %r12
xorl %ebx, %ebx
pushq $0x1
popq %rbp
movq %r15, %rax
cqto
pushq $0xa
popq %rcx
idivq %rcx
movq %rax, %r13
addb $0x30, %dl
movb %dl, 0x7(%rsp)
movq %r14, %rdi
leaq 0x7(%rsp), %rsi
movl %ebp... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x8dfd | op_http_conn_read_ahead | static int op_http_conn_read_ahead(OpusHTTPStream *_stream,
OpusHTTPConn *_conn,int _just_read_ahead,opus_int64 _target){
opus_int64 pos;
opus_int64 end_pos;
opus_int64 next_pos;
opus_int64 next_end;
ptrdiff_t nread;
int ret;
pos=_conn->pos;
end_pos=_conn->end_pos;
next_pos=_conn->next_pos;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %r13
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %rbp
movq 0x18(%rsi), %rsi
movl %edx, 0x14(%rsp)
testl %edx, %edx
je 0x8edd
testq %r12, %r12
sets %al
cmpq %rbx, %r12
setg %cl
orb %a... | /xiph[P]opusfile/src/http.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x910c | main | int main(int _argc,const char **_argv){
OggOpusFile *of;
ogg_int64_t duration;
unsigned char wav_header[44];
int ret;
int is_ssl;
int output_seekable;
#if defined(_WIN32)
win32_utf8_setup(&_argc,&_argv);
#endif
if(_argc!=2){
fprintf(stderr,"Usage: %s <file.opus>\n",_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb478, %rsp # imm = 0xB478
movq %rsi, %r15
cmpl $0x2, %edi
jne 0x97b2
movq 0x8(%r15), %rbx
addq $0x8, %r15
leaq 0x6ee3(%rip), %rsi # 0x1001b
movq %rbx, %rdi
callq 0x3470
testl %eax, %eax
je 0x920c
movq %rsp, %rsi
leaq 0x5a70(%rsp), ... | /xiph[P]opusfile/examples/opusfile_example.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x993f | print_duration | static void print_duration(FILE *_fp,ogg_int64_t _nsamples,int _frac){
ogg_int64_t seconds;
ogg_int64_t minutes;
ogg_int64_t hours;
ogg_int64_t days;
ogg_int64_t weeks;
_nsamples+=_frac?24:24000;
seconds=_nsamples/48000;
_nsamples-=seconds*48000;
minutes=seconds/60;
seconds-=minutes*60;
hours=minu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbp
leaq 0x18(%rsi), %rax
addq $0x5dc0, %r14 # imm = 0x5DC0
movl %edx, 0x1c(%rsp)
testl %edx, %edx
cmovneq %rax, %r14
movabsq $-0x513cc1e098ead65b, %rcx # imm = 0xAEC33E1F671529A5
movq %r14, %rax
imu... | /xiph[P]opusfile/examples/opusfile_example.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x9bc7 | print_size | static void print_size(FILE *_fp,opus_int64 _nbytes,int _metric,
const char *_spacer){
static const char SUFFIXES[7]={' ','k','M','G','T','P','E'};
opus_int64 val;
opus_int64 den;
opus_int64 round;
int base;
int shift;
base=_metric?1000:1024;
round=0;
den=1;
for(shift=0;shift<6;shift+... | movq %rcx, %r10
testl %edx, %edx
movl $0x400, %ecx # imm = 0x400
movl $0x3e8, %eax # imm = 0x3E8
cmoveq %rcx, %rax
movl $0x1, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
movl $0x1, %ecx
imulq %rax, %rcx
movq %rcx, %r11
subq %r9, %r11
cmpq %rsi, %r11
jg 0x9c13
movq %rcx, %r9
shrq %r9
incl %r8d
movq %rcx, ... | /xiph[P]opusfile/examples/opusfile_example.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x9d8a | make_wav_header | static void make_wav_header(unsigned char _dst[44],ogg_int64_t _duration){
/*The chunk sizes are set to 0x7FFFFFFF by default.
Many, though not all, programs will interpret this to mean the duration is
"undefined", and continue to read from the file so long as there is actual
data.*/
static const unsi... | movups 0x67eb(%rip), %xmm0 # 0x1057c
movups %xmm0, 0x1c(%rdi)
movaps 0x67d4(%rip), %xmm0 # 0x10570
movups %xmm0, 0x10(%rdi)
movaps 0x67b9(%rip), %xmm0 # 0x10560
movups %xmm0, (%rdi)
testq %rsi, %rsi
jle 0x9df4
cmpq $0x1ffffff7, %rsi # imm = 0x1FFFFFF7
jge 0x9df5
leal (,%rsi,4), %ecx
leal 0x24(,%rsi,4)... | /xiph[P]opusfile/examples/opusfile_example.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x9e00 | opus_head_parse | int opus_head_parse(OpusHead *_head,const unsigned char *_data,size_t _len){
OpusHead head;
if(_len<8)return OP_ENOTFORMAT;
if(memcmp(_data,"OpusHead",8)!=0)return OP_ENOTFORMAT;
if(_len<9)return OP_EBADHEADER;
head.version=_data[8];
if(head.version>15)return OP_EVERSION;
if(_len<19)return OP_EBADHEADER;
... | movl $0xffffff7c, %eax # imm = 0xFFFFFF7C
cmpq $0x8, %rdx
jb 0x9e1a
movabsq $0x646165487375704f, %rcx # imm = 0x646165487375704F
cmpq %rcx, (%rsi)
je 0x9e1b
retq
cmpq $0x8, %rdx
jne 0x9e27
movl $0xffffff7b, %eax # imm = 0xFFFFFF7B
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x9fdb | opus_tags_init | void opus_tags_init(OpusTags *_tags){
memset(_tags,0,sizeof(*_tags));
} | xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
retq
| /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0x9fe6 | opus_tags_clear | void opus_tags_clear(OpusTags *_tags){
int ncomments;
int ci;
ncomments=_tags->comments;
if(_tags->user_comments!=NULL)ncomments++;
else{
OP_ASSERT(ncomments==0);
}
for(ci=ncomments;ci-->0;)_ogg_free(_tags->user_comments[ci]);
_ogg_free(_tags->user_comments);
_ogg_free(_tags->comment_lengths);
_... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x10(%rdi), %r14
movq (%rdi), %rax
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
addl %r14d, %ecx
jle 0xa022
cmpq $0x1, %rax
sbbq $-0x1, %r14
incq %r14
movq (%rbx), %rax
movq -0x10(%rax,%r14,8), %rdi
callq 0x33f0
decq %r14
cmpq $0x1, %r14
jg 0xa00c
movq (%rbx), %rdi
... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xa043 | opus_tags_parse | int opus_tags_parse(OpusTags *_tags,const unsigned char *_data,size_t _len){
if(_tags!=NULL){
OpusTags tags;
int ret;
opus_tags_init(&tags);
ret=opus_tags_parse_impl(&tags,_data,_len);
if(ret<0)opus_tags_clear(&tags);
else *_tags=*&tags;
return ret;
}
else return opus_tags_parse_i... | testq %rdi, %rdi
jne 0xa04f
xorl %edi, %edi
jmp 0x3c25
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x3c25
movl %eax, %ebp
testl %eax, %eax
js 0xa082
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%rbx)
mo... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xa093 | opus_tagncompare | int opus_tagncompare(const char *_tag_name,int _tag_len,const char *_comment){
int ret;
OP_ASSERT(_tag_len>=0);
ret=op_strncasecmp(_tag_name,_comment,_tag_len);
return ret?ret:'='-_comment[_tag_len];
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdx, %rsi
movl %ebp, %edx
callq 0xadac
testl %eax, %eax
jne 0xa0b7
movslq %ebp, %rax
movsbl (%rbx,%rax), %ecx
movl $0x3d, %eax
subl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xa0be | opus_tags_get_binary_suffix | const unsigned char *opus_tags_get_binary_suffix(const OpusTags *_tags,
int *_len){
int ncomments;
int len;
ncomments=_tags->comments;
len=_tags->comment_lengths==NULL?0:_tags->comment_lengths[ncomments];
*_len=len;
OP_ASSERT(len==0||_tags->user_comments!=NULL);
return len>0?(const unsigned char *)_tags-... | movslq 0x10(%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0xa0d0
movl (%rcx,%rax,4), %ecx
jmp 0xa0d2
xorl %ecx, %ecx
movl %ecx, (%rsi)
testl %ecx, %ecx
jle 0xa0e0
movq (%rdi), %rcx
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
| /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xa0e3 | opus_tags_get_album_gain | int opus_tags_get_album_gain(const OpusTags *_tags,int *_gain_q8){
return opus_tags_get_gain(_tags,_gain_q8,"R128_ALBUM_GAIN",15);
} | leaq 0x64f3(%rip), %rdx # 0x105dd
jmp 0xa0ec
| /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xa0ec | opus_tags_get_gain | static int opus_tags_get_gain(const OpusTags *_tags,int *_gain_q8,
const char *_tag_name,size_t _tag_len){
char **comments;
int ncomments;
int ci;
comments=_tags->user_comments;
ncomments=_tags->comments;
/*Look for the first valid tag with the name _tag_name and use that.*/
for(ci=0;ci<ncomments;c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x10(%rdi), %r13
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %r13, %r13
jle 0xa1ab
movq %rdx, %r15
movq %rsi, (%rsp)
movq (%rdi), %rbp
xorl %r14d, %r14d
movq (%rbp,%r14,8), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xf, %edx
... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xa1ca | opus_tags_get_track_gain | int opus_tags_get_track_gain(const OpusTags *_tags,int *_gain_q8){
return opus_tags_get_gain(_tags,_gain_q8,"R128_TRACK_GAIN",15);
} | leaq 0x641c(%rip), %rdx # 0x105ed
jmp 0xa0ec
| /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xa1d6 | opus_picture_tag_parse | int opus_picture_tag_parse(OpusPictureTag *_pic,const char *_tag){
OpusPictureTag pic;
unsigned char *buf;
size_t base64_sz;
size_t buf_sz;
size_t tag_length;
int ret;
if(opus_tagncompare("METADATA_BLOCK_PICTURE",22,_tag)==0)_tag+=23;
/*Figure out how much BASE64... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x60ed(%rip), %rdi # 0x102de
movl $0x16, %edx
callq 0xadac
testl %eax, %eax
je 0xa203
xorl %eax, %eax
jmp 0xa213
xorl %ecx, %ecx
cmpb $0x3d, 0x16(%r15)
movl $0x17, %eax
cmovneq %rcx, %rax
addq %r... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xaa5e | opus_picture_tag_init | void opus_picture_tag_init(OpusPictureTag *_pic){
memset(_pic,0,sizeof(*_pic));
} | xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
retq
| /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xaa71 | opus_picture_tag_clear | void opus_picture_tag_clear(OpusPictureTag *_pic){
_ogg_free(_pic->description);
_ogg_free(_pic->mime_type);
_ogg_free(_pic->data);
} | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x33f0
movq 0x8(%rbx), %rdi
callq 0x33f0
movq 0x30(%rbx), %rdi
popq %rbx
jmp 0x33f0
| /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xaa91 | op_is_gif | static int op_is_gif(const unsigned char *_buf,size_t _buf_sz){
return _buf_sz>=6&&(memcmp(_buf,"GIF87a",6)==0||memcmp(_buf,"GIF89a",6)==0);
} | xorl %eax, %eax
cmpq $0x6, %rsi
jb 0xaac3
movl $0x38464947, %ecx # imm = 0x38464947
movl (%rdi), %eax
xorl %ecx, %eax
movzwl 0x4(%rdi), %edx
xorl $0x6137, %edx # imm = 0x6137
orl %eax, %edx
je 0xaac4
xorl (%rdi), %ecx
movzwl 0x4(%rdi), %edx
xorl $0x6139, %edx # imm = 0x6139
xorl %eax, %eax
orl... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xaaca | op_extract_jpeg_params | static void op_extract_jpeg_params(const unsigned char *_buf,size_t _buf_sz,
opus_uint32 *_width,opus_uint32 *_height,
opus_uint32 *_depth,opus_uint32 *_colors,int *_has_palette){
if(op_is_jpeg(_buf,_buf_sz)){
size_t offs;
offs=2;
for(;;){
size_t segment_len;
int marker;
while(offs<... | cmpq $0x3, %rsi
jb 0xaaea
movzwl (%rdi), %eax
xorl $0xd8ff, %eax # imm = 0xD8FF
movzbl 0x2(%rdi), %r10d
xorl $0xff, %r10d
orw %ax, %r10w
je 0xaaeb
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x30(%rsp), %rax
movl $0x2, %r11d
xorl %r10d, %r10d
cmpq %rsi, %r11
jae 0xab18
cmpb $-0x1, (%rdi,%... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xac09 | op_extract_png_params | static void op_extract_png_params(const unsigned char *_buf,size_t _buf_sz,
opus_uint32 *_width,opus_uint32 *_height,
opus_uint32 *_depth,opus_uint32 *_colors,int *_has_palette){
if(op_is_png(_buf,_buf_sz)){
size_t offs;
offs=8;
while(_buf_sz-offs>=12){
ogg_uint32_t chunk_len;
chunk_len=op_p... | cmpq $0x8, %rsi
jb 0xac1e
movabsq $0xa1a0a0d474e5089, %rax # imm = 0xA1A0A0D474E5089
cmpq %rax, (%rdi)
je 0xac1f
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x38(%rsp), %rax
leaq -0xc(%rsi), %r10
movl $0x8, %r11d
leaq 0x5979(%rip), %rbx # 0x105b8
movl $0xaaaaaaab, %r14d # imm =... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xad37 | op_extract_gif_params | static void op_extract_gif_params(const unsigned char *_buf,size_t _buf_sz,
opus_uint32 *_width,opus_uint32 *_height,
opus_uint32 *_depth,opus_uint32 *_colors,int *_has_palette){
if(op_is_gif(_buf,_buf_sz)&&_buf_sz>=14){
*_width=_buf[6]|_buf[7]<<8;
*_height=_buf[8]|_buf[9]<<8;
/*libFLAC hard-codes the d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
callq 0xaa91
cmpq $0xe, %rbp
jb 0xad9b
testl %eax, %eax
je 0xad9b
movzwl 0x6(%r12), %eax
movl %eax, (%r13)
movzwl 0x8(%r12), %eax
movl %eax, (%r15)
m... | /xiph[P]opusfile/src/info.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xadac | op_strncasecmp | int op_strncasecmp(const char *_a,const char *_b,int _n){
int i;
for(i=0;i<_n;i++){
int a;
int b;
int d;
a=_a[i];
b=_b[i];
if(a>='a'&&a<='z')a-='a'-'A';
if(b>='a'&&b<='z')b-='a'-'A';
d=a-b;
if(d)return d;
}
return 0;
} | testl %edx, %edx
jle 0xadf2
movl %edx, %ecx
xorl %edx, %edx
movl %eax, %r8d
movsbl (%rdi,%rdx), %r9d
movsbl (%rsi,%rdx), %r10d
leal -0x61(%r9), %r11d
leal -0x20(%r9), %eax
cmpb $0x1a, %r11b
cmovael %r9d, %eax
leal -0x61(%r10), %r9d
leal -0x20(%r10), %r11d
cmpb $0x1a, %r9b
cmovael %r10d, %r11d
subl %r11d, %eax
cmovel %r... | /xiph[P]opusfile/src/internal.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xadf8 | opus_granule_sample | ogg_int64_t opus_granule_sample(const OpusHead *_head,ogg_int64_t _gp){
opus_int32 pre_skip;
pre_skip=_head->pre_skip;
if(_gp!=-1&&op_granpos_add(&_gp,_gp,-pre_skip))_gp=-1;
return _gp;
} | pushq %rax
movq %rsi, (%rsp)
cmpq $-0x1, %rsi
jne 0xae09
movq (%rsp), %rax
popq %rcx
retq
xorl %edx, %edx
subl 0x8(%rdi), %edx
movq %rsp, %rdi
callq 0x459b
testl %eax, %eax
je 0xae03
movq $-0x1, (%rsp)
jmp 0xae03
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xae24 | op_test_callbacks | OggOpusFile *op_test_callbacks(void *_stream,const OpusFileCallbacks *_cb,
const unsigned char *_initial_data,size_t _initial_bytes,int *_error){
OggOpusFile *of;
int ret;
of=(OggOpusFile *)_ogg_malloc(sizeof(*of));
ret=OP_EFAULT;
if(OP_LIKELY(of!=NULL)){
ret=op_open1(of,_stream,_cb,_initial_dat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movl $0x3390, %edi # imm = 0x3390
callq 0x3460
testq %rax, %rax
je 0xb07a
movq %r14, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movq %rax, %r14
movl $0x3390, ... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xb0ac | op_open2 | static int op_open2(OggOpusFile *_of){
int ret;
OP_ASSERT(_of->ready_state==OP_PARTOPEN);
if(_of->seekable){
_of->ready_state=OP_OPENED;
ret=op_open_seekable2(_of);
}
else ret=0;
if(OP_LIKELY(ret>=0)){
/*We have buffered packets from op_find_initial_pcm_offset().
Move to OP_INITSET so we c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb38, %rsp # imm = 0xB38
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl $0x0, 0x28(%rdi)
je 0xbed6
movl $0x2, 0x78(%rbx)
movslq 0x3214(%rbx), %rax
movq %rax, 0x130(%rsp)
shlq $0x4, %rax
leaq (%rax,%rax,2), %r15
movq %r15, %rdi
callq 0x3460
movl $... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xbf38 | op_open_file | OggOpusFile *op_open_file(const char *_path,int *_error){
OpusFileCallbacks cb;
return op_open_close_on_failure(op_fopen(&cb,_path,"rb"),&cb,_error);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x40d1(%rip), %rdx # 0x1001d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xdf4c
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xbf6f
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xbf6f | op_open_close_on_failure | static OggOpusFile *op_open_close_on_failure(void *_stream,
const OpusFileCallbacks *_cb,int *_error){
OggOpusFile *of;
if(OP_UNLIKELY(_stream==NULL)){
if(_error!=NULL)*_error=OP_EFAULT;
return NULL;
}
of=op_open_callbacks(_stream,_cb,NULL,0,_error);
if(OP_UNLIKELY(of==NULL))(*_cb->close)(_stream);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r8
testq %rdi, %rdi
je 0xbf9c
movq %rsi, %rbx
movq %rdi, %r15
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x46ec
movq %rax, %r14
testq %rax, %rax
je 0xbfad
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
testq %r8, %r8
je 0xbfa8
movl $0xffffff7f, (%r8) # imm = 0xFFFFFF7F
x... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xbfb5 | op_open_memory | OggOpusFile *op_open_memory(const unsigned char *_data,size_t _size,
int *_error){
OpusFileCallbacks cb;
return op_open_close_on_failure(op_mem_stream_create(&cb,_data,_size),&cb,
_error);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xdfcf
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xbf6f
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xbfe8 | op_test_file | OggOpusFile *op_test_file(const char *_path,int *_error){
OpusFileCallbacks cb;
return op_test_close_on_failure(op_fopen(&cb,_path,"rb"),&cb,_error);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x4021(%rip), %rdx # 0x1001d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xdf4c
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc01f
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xc01f | op_test_close_on_failure | static OggOpusFile *op_test_close_on_failure(void *_stream,
const OpusFileCallbacks *_cb,int *_error){
OggOpusFile *of;
if(OP_UNLIKELY(_stream==NULL)){
if(_error!=NULL)*_error=OP_EFAULT;
return NULL;
}
of=op_test_callbacks(_stream,_cb,NULL,0,_error);
if(OP_UNLIKELY(of==NULL))(*_cb->close)(_stream);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r8
testq %rdi, %rdi
je 0xc04c
movq %rsi, %rbx
movq %rdi, %r15
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xae24
movq %rax, %r14
testq %rax, %rax
je 0xc05d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
testq %r8, %r8
je 0xc058
movl $0xffffff7f, (%r8) # imm = 0xFFFFFF7F
x... | /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xc065 | op_test_memory | OggOpusFile *op_test_memory(const unsigned char *_data,size_t _size,
int *_error){
OpusFileCallbacks cb;
return op_test_close_on_failure(op_mem_stream_create(&cb,_data,_size),&cb,
_error);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xdfcf
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc01f
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xc098 | op_seekable | int op_seekable(const OggOpusFile *_of){
return _of->seekable;
} | movl 0x28(%rdi), %eax
retq
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xc09c | op_link_count | int op_link_count(const OggOpusFile *_of){
return _of->nlinks;
} | movl 0x2c(%rdi), %eax
retq
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xc0a0 | op_serialno | opus_uint32 op_serialno(const OggOpusFile *_of,int _li){
if(OP_UNLIKELY(_li>=_of->nlinks))_li=_of->nlinks-1;
if(!_of->seekable)_li=0;
return _of->links[_li<0?_of->cur_link:_li].serialno;
} | movl 0x2c(%rdi), %eax
cmpl %esi, %eax
jle 0xc0c9
movl 0x28(%rdi), %eax
testl %eax, %eax
cmovel %eax, %esi
movq 0x30(%rdi), %rax
testl %esi, %esi
jns 0xc0ba
movl 0x7c(%rdi), %esi
movslq %esi, %rcx
imulq $0x178, %rcx, %rcx # imm = 0x178
movl 0x30(%rax,%rcx), %eax
retq
decl %eax
movl %eax, %esi
jmp 0xc0a7
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
0xc0cf | op_channel_count | const OpusHead *op_head(const OggOpusFile *_of,int _li){
if(OP_UNLIKELY(_li>=_of->nlinks))_li=_of->nlinks-1;
if(!_of->seekable)_li=0;
return &_of->links[_li<0?_of->cur_link:_li].head;
} | movl 0x2c(%rdi), %eax
cmpl %esi, %eax
jle 0xc0f8
movl 0x28(%rdi), %eax
testl %eax, %eax
cmovel %eax, %esi
movq 0x30(%rdi), %rax
testl %esi, %esi
jns 0xc0e9
movl 0x7c(%rdi), %esi
movslq %esi, %rcx
imulq $0x178, %rcx, %rcx # imm = 0x178
movl 0x38(%rax,%rcx), %eax
retq
decl %eax
movl %eax, %esi
jmp 0xc0d6
| /xiph[P]opusfile/src/opusfile.c | xiph[P]opusfile[P]build_O1[P]opusfile_example |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.