From d44dc01224b68c49fedf6eb1b615e9cae0c3169c Mon Sep 17 00:00:00 2001 From: arpi Date: Sun, 21 Oct 2001 22:13:12 +0000 Subject: cache seeking fixed(?) git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@2353 b3059339-0415-0410-9bf9-f77b7e298cf2 --- libmpdemux/cache2.c | 111 +++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 79 insertions(+), 32 deletions(-) (limited to 'libmpdemux/cache2.c') diff --git a/libmpdemux/cache2.c b/libmpdemux/cache2.c index 16f813ef9e..aa2e868443 100644 --- a/libmpdemux/cache2.c +++ b/libmpdemux/cache2.c @@ -1,14 +1,13 @@ #include "config.h" #ifdef USE_STREAM_CACHE -// gcc cache2.c ../linux/shmem.o -o cache2 // Initial draft of my new cache system... -// includes some simulation code, using usleep() to emulate limited bandwith +// Note it runs in 2 processes (using fork()), but doesn't requires locking!! // TODO: seeking, data consistency checking -#define READ_SPEED 20 -#define FILL_SPEED 10 +#define READ_USLEEP_TIME 10000 +#define FILL_USLEEP_TIME 50000 #include #include @@ -26,11 +25,10 @@ int stream_seek_long(stream_t *s,off_t pos); typedef struct { // constats: unsigned char *buffer; // base pointer of the alllocated buffer memory - int buffer_size; // size of the alllocated buffer memory - int sector_size; // size of a single sector (2048/2324) - // Note: buffer_size should be N*sector_size, where N is integer... - int back_size; // we should keep back_size amount of old bytes for backward seek - int fill_limit; // we should fill buffer if space>fill_limit + int buffer_size; // size of the alllocated buffer memory + int sector_size; // size of a single sector (2048/2324) + int back_size; // we should keep back_size amount of old bytes for backward seek + int fill_limit; // we should fill buffer only if space>=fill_limit // reader's pointers: int read_filepos; // filler's pointers: @@ -39,14 +37,16 @@ typedef struct { int offset; // filepos <-> bufferpos offset value (filepos of the buffer's first byte) int eof; // commands/locking: - int cmd_lock; // 1 if we will seek/reset buffer, 2 if we are ready for cmd - int fifo_flag; // 1 if we should use FIFO to notice cache about buffer reads. +// int seek_lock; // 1 if we will seek/reset buffer, 2 if we are ready for cmd +// int fifo_flag; // 1 if we should use FIFO to notice cache about buffer reads. // callback stream_t* stream; } cache_vars_t; -int min_fill=0; -int sleep_flag=0; +static int min_fill=0; +static int sleep_flag=0; + +int cache_fill_status=0; void cache_stats(cache_vars_t* s){ int newb=s->max_filepos-s->read_filepos; // new bytes in the buffer @@ -58,33 +58,38 @@ int cache_read(cache_vars_t* s,unsigned char* buf,int size){ int total=0; while(size>0){ int pos,newb,len; - - pos=s->read_filepos - s->offset; - if(pos<0) pos+=s->buffer_size; else - if(pos>=s->buffer_size) pos-=s->buffer_size; + + //printf("CACHE2_READ: 0x%X <= 0x%X <= 0x%X \n",s->min_filepos,s->read_filepos,s->max_filepos); newb=s->max_filepos-s->read_filepos; // new bytes in the buffer - if(newbread_fileposmin_filepos){ // eof? if(s->eof) break; // waiting for buffer fill... - usleep(10000); // 10ms - continue; + usleep(READ_USLEEP_TIME); // 10ms + continue; // try again... } - + + if(newbread_filepos - s->offset; + if(pos<0) pos+=s->buffer_size; else + if(pos>=s->buffer_size) pos-=s->buffer_size; + if(newb>s->buffer_size-pos) newb=s->buffer_size-pos; // handle wrap... if(newb>size) newb=size; + // check: + if(s->read_fileposmin_filepos) printf("Ehh. s->read_fileposmin_filepos !!! Report bug...\n"); + // len=write(mem,newb) //printf("Buffer read: %d bytes\n",newb); memcpy(buf,&s->buffer[pos],newb); buf+=newb; - len=newb; //usleep(len*READ_SPEED*sleep_flag); + len=newb; // ... s->read_filepos+=len; @@ -92,14 +97,25 @@ int cache_read(cache_vars_t* s,unsigned char* buf,int size){ total+=len; } + cache_fill_status=100*(s->max_filepos-s->read_filepos)/s->buffer_size; return total; } int cache_fill(cache_vars_t* s){ - int read,back,newb,space,len,pos,endpos; + int read,back,back2,newb,space,len,pos,endpos; read=s->read_filepos; + if(readmin_filepos || read>s->max_filepos){ + // seek... + printf("Out of boundaries... seeking to 0x%X \n",read); + s->offset= // FIXME!? + s->min_filepos=s->max_filepos=read; // drop cache content :( + if(s->stream->eof) stream_reset(s->stream); + stream_seek(s->stream,read); + printf("Seek done. new pos: 0x%X \n",(int)stream_tell(s->stream)); + } + // calc number of back-bytes: back=read - s->min_filepos; if(back<0) back=0; // strange... @@ -129,11 +145,18 @@ int cache_fill(cache_vars_t* s){ // if(space>32768) space=32768; // limit one-time block size if(space>4*s->sector_size) space=4*s->sector_size; +// if(s->seek_lock) return 0; // FIXME + +#if 1 + // back+newb+space <= buffer_size + back2=s->buffer_size-(space+newb); // max back size + if(s->min_filepos<(read-back2)) s->min_filepos=read-back2; +#else s->min_filepos=read-back; // avoid seeking-back to temp area... +#endif // .... //printf("Buffer fill: %d bytes of %d\n",space,s->buffer_size); - //len=space; usleep(len*FILL_SPEED*sleep_flag); //len=stream_fill_buffer(s->stream); //memcpy(&s->buffer[pos],s->stream->buffer,len); // avoid this extra copy! // .... @@ -177,7 +200,7 @@ void stream_enable_cache(stream_t *s,int size){ signal(SIGTERM,exit_sighandler); // kill while(1){ if(!cache_fill(s->cache_data)){ - usleep(50000); // idle + usleep(FILL_USLEEP_TIME); // idle } // cache_stats(s->cache_data); } @@ -188,9 +211,12 @@ int cache_stream_fill_buffer(stream_t *s){ if(s->eof){ s->buf_pos=s->buf_len=0; return 0; } if(!s->cache_pid) return stream_fill_buffer(s); - cache_stats(s->cache_data); +// cache_stats(s->cache_data); + + if(s->pos!=((cache_vars_t*)s->cache_data)->read_filepos) printf("!!! read_filepos differs!!! report this bug...\n"); len=cache_read(s->cache_data,s->buffer, ((cache_vars_t*)s->cache_data)->sector_size); + //printf("cache_stream_fill_buffer->read -> %d\n",len); if(len<=0){ s->eof=1; s->buf_pos=s->buf_len=0; return 0; } s->buf_pos=0; @@ -201,11 +227,32 @@ int cache_stream_fill_buffer(stream_t *s){ } -int cache_stream_seek_long(stream_t *s,off_t pos){ +int cache_stream_seek_long(stream_t *stream,off_t pos){ + cache_vars_t* s; + off_t newpos; + if(!stream->cache_pid) return stream_seek_long(stream,pos); + + s=stream->cache_data; +// s->seek_lock=1; + + printf("CACHE2_SEEK: 0x%X <= 0x%X (0x%X) <= 0x%X \n",s->min_filepos,(int)pos,s->read_filepos,s->max_filepos); + + newpos=pos/s->sector_size; newpos*=s->sector_size; // align + stream->pos=s->read_filepos=newpos; + s->eof=0; // !!!!!!! + + cache_stream_fill_buffer(stream); + + pos-=newpos; + if(pos>=0 && pos<=stream->buf_len){ + stream->buf_pos=pos; // byte position in sector + return 1; + } - if(!s->cache_pid) return stream_seek_long(s,pos); +// stream->buf_pos=stream->buf_len=0; +// return 1; - printf("cache2 seek not implemented!!!!!!!!\n"); + printf("cache_stream_seek: WARNING! Can't seek to 0x%X !\n",(int)(pos+newpos)); return 0; } -- cgit v1.2.3