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 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 4