3 // Initial draft of my new cache system...
4 // Note it runs in 2 processes (using fork()), but doesn't requires locking!!
5 // TODO: seeking, data consistency checking
7 #define READ_USLEEP_TIME 10000
8 #define FILL_USLEEP_TIME 50000
9 #define PREFILL_SLEEP_TIME 200
15 #include <sys/types.h>
18 #include "osdep/timer.h"
21 #include "osdep/shmem.h"
24 static DWORD WINAPI
ThreadProc(void* s
);
31 #include "input/input.h"
33 int stream_fill_buffer(stream_t
*s
);
34 int stream_seek_long(stream_t
*s
,off_t pos
);
38 unsigned char *buffer
; // base pointer of the alllocated buffer memory
39 int buffer_size
; // size of the alllocated buffer memory
40 int sector_size
; // size of a single sector (2048/2324)
41 int back_size
; // we should keep back_size amount of old bytes for backward seek
42 int fill_limit
; // we should fill buffer only if space>=fill_limit
43 int seek_limit
; // keep filling cache if distanse is less that seek limit
46 off_t min_filepos
; // buffer contain only a part of the file, from min-max pos
48 off_t offset
; // filepos <-> bufferpos offset value (filepos of the buffer's first byte)
52 // int seek_lock; // 1 if we will seek/reset buffer, 2 if we are ready for cmd
53 // int fifo_flag; // 1 if we should use FIFO to notice cache about buffer reads.
58 static int min_fill
=0;
60 int cache_fill_status
=0;
62 void cache_stats(cache_vars_t
* s
){
63 int newb
=s
->max_filepos
-s
->read_filepos
; // new bytes in the buffer
64 mp_msg(MSGT_CACHE
,MSGL_INFO
,"0x%06X [0x%06X] 0x%06X ",(int)s
->min_filepos
,(int)s
->read_filepos
,(int)s
->max_filepos
);
65 mp_msg(MSGT_CACHE
,MSGL_INFO
,"%3d %% (%3d%%)\n",100*newb
/s
->buffer_size
,100*min_fill
/s
->buffer_size
);
68 int cache_read(cache_vars_t
* s
,unsigned char* buf
,int size
){
73 //printf("CACHE2_READ: 0x%X <= 0x%X <= 0x%X \n",s->min_filepos,s->read_filepos,s->max_filepos);
75 if(s
->read_filepos
>=s
->max_filepos
|| s
->read_filepos
<s
->min_filepos
){
78 // waiting for buffer fill...
79 usec_sleep(READ_USLEEP_TIME
); // 10ms
80 continue; // try again...
83 newb
=s
->max_filepos
-s
->read_filepos
; // new bytes in the buffer
84 if(newb
<min_fill
) min_fill
=newb
; // statistics...
86 // printf("*** newb: %d bytes ***\n",newb);
88 pos
=s
->read_filepos
- s
->offset
;
89 if(pos
<0) pos
+=s
->buffer_size
; else
90 if(pos
>=s
->buffer_size
) pos
-=s
->buffer_size
;
92 if(newb
>s
->buffer_size
-pos
) newb
=s
->buffer_size
-pos
; // handle wrap...
93 if(newb
>size
) newb
=size
;
96 if(s
->read_filepos
<s
->min_filepos
) mp_msg(MSGT_CACHE
,MSGL_ERR
,"Ehh. s->read_filepos<s->min_filepos !!! Report bug...\n");
98 // len=write(mem,newb)
99 //printf("Buffer read: %d bytes\n",newb);
100 memcpy(buf
,&s
->buffer
[pos
],newb
);
105 s
->read_filepos
+=len
;
110 cache_fill_status
=(s
->max_filepos
-s
->read_filepos
)/(s
->buffer_size
/ 100);
114 int cache_fill(cache_vars_t
* s
){
115 int back
,back2
,newb
,space
,len
,pos
;
116 off_t read
=s
->read_filepos
;
118 if(read
<s
->min_filepos
|| read
>s
->max_filepos
){
120 mp_msg(MSGT_CACHE
,MSGL_DBG2
,"Out of boundaries... seeking to 0x%"PRIX64
" \n",(int64_t)read
);
121 // streaming: drop cache contents only if seeking backward or too much fwd:
122 if(s
->stream
->type
!=STREAMTYPE_STREAM
||
123 read
<s
->min_filepos
|| read
>=s
->max_filepos
+s
->seek_limit
)
125 s
->offset
= // FIXME!?
126 s
->min_filepos
=s
->max_filepos
=read
; // drop cache content :(
127 if(s
->stream
->eof
) stream_reset(s
->stream
);
128 stream_seek(s
->stream
,read
);
129 mp_msg(MSGT_CACHE
,MSGL_DBG2
,"Seek done. new pos: 0x%"PRIX64
" \n",(int64_t)stream_tell(s
->stream
));
133 // calc number of back-bytes:
134 back
=read
- s
->min_filepos
;
135 if(back
<0) back
=0; // strange...
136 if(back
>s
->back_size
) back
=s
->back_size
;
138 // calc number of new bytes:
139 newb
=s
->max_filepos
- read
;
140 if(newb
<0) newb
=0; // strange...
142 // calc free buffer space:
143 space
=s
->buffer_size
- (newb
+back
);
146 pos
=s
->max_filepos
- s
->offset
;
147 if(pos
>=s
->buffer_size
) pos
-=s
->buffer_size
; // wrap-around
149 if(space
<s
->fill_limit
){
150 // printf("Buffer is full (%d bytes free, limit: %d)\n",space,s->fill_limit);
151 return 0; // no fill...
154 // printf("### read=0x%X back=%d newb=%d space=%d pos=%d\n",read,back,newb,space,pos);
156 // reduce space if needed:
157 if(space
>s
->buffer_size
-pos
) space
=s
->buffer_size
-pos
;
159 // if(space>32768) space=32768; // limit one-time block size
160 if(space
>4*s
->sector_size
) space
=4*s
->sector_size
;
162 // if(s->seek_lock) return 0; // FIXME
165 // back+newb+space <= buffer_size
166 back2
=s
->buffer_size
-(space
+newb
); // max back size
167 if(s
->min_filepos
<(read
-back2
)) s
->min_filepos
=read
-back2
;
169 s
->min_filepos
=read
-back
; // avoid seeking-back to temp area...
173 //printf("Buffer fill: %d bytes of %d\n",space,s->buffer_size);
174 //len=stream_fill_buffer(s->stream);
175 //memcpy(&s->buffer[pos],s->stream->buffer,len); // avoid this extra copy!
177 len
=stream_read(s
->stream
,&s
->buffer
[pos
],space
);
181 if(pos
+len
>=s
->buffer_size
){
183 s
->offset
+=s
->buffer_size
;
190 cache_vars_t
* cache_init(int size
,int sector
){
193 cache_vars_t
* s
=shmem_alloc(sizeof(cache_vars_t
));
195 cache_vars_t
* s
=malloc(sizeof(cache_vars_t
));
197 if(s
==NULL
) return NULL
;
199 memset(s
,0,sizeof(cache_vars_t
));
204 s
->buffer_size
=num
*sector
;
205 s
->sector_size
=sector
;
207 s
->buffer
=shmem_alloc(s
->buffer_size
);
209 s
->buffer
=malloc(s
->buffer_size
);
212 if(s
->buffer
== NULL
){
214 shmem_free(s
,sizeof(cache_vars_t
));
221 s
->fill_limit
=8*sector
;
222 s
->back_size
=s
->buffer_size
/2;
226 void cache_uninit(stream_t
*s
) {
227 cache_vars_t
* c
= s
->cache_data
;
228 if(!s
->cache_pid
) return;
230 kill(s
->cache_pid
,SIGKILL
);
231 waitpid(s
->cache_pid
,NULL
,0);
233 TerminateThread((HANDLE
)s
->cache_pid
,0);
238 shmem_free(c
->buffer
,c
->buffer_size
);
239 shmem_free(s
->cache_data
,sizeof(cache_vars_t
));
246 static void exit_sighandler(int x
){
251 int stream_enable_cache(stream_t
*stream
,int size
,int min
,int seek_limit
){
252 int ss
=(stream
->type
==STREAMTYPE_VCD
)?VCD_SECTOR_DATA
:STREAM_BUFFER_SIZE
;
255 if (stream
->type
==STREAMTYPE_STREAM
&& stream
->fd
< 0) {
256 // The stream has no 'fd' behind it, so is non-cacheable
257 mp_msg(MSGT_CACHE
,MSGL_STATUS
,"\rThis stream is non-cacheable\n");
261 s
=cache_init(size
,ss
);
262 if(s
== NULL
) return 0;
263 stream
->cache_data
=s
;
264 s
->stream
=stream
; // callback
265 s
->seek_limit
=seek_limit
;
268 //make sure that we won't wait from cache_fill
269 //more data than it is alowed to fill
270 if (s
->seek_limit
> s
->buffer_size
- s
->fill_limit
){
271 s
->seek_limit
= s
->buffer_size
- s
->fill_limit
;
273 if (min
> s
->buffer_size
- s
->fill_limit
) {
274 min
= s
->buffer_size
- s
->fill_limit
;
278 if((stream
->cache_pid
=fork())){
282 stream_t
* stream2
=malloc(sizeof(stream_t
));
283 memcpy(stream2
,s
->stream
,sizeof(stream_t
));
285 stream
->cache_pid
= CreateThread(NULL
,0,ThreadProc
,s
,0,&threadId
);
287 // wait until cache is filled at least prefill_init %
288 mp_msg(MSGT_CACHE
,MSGL_V
,"CACHE_PRE_INIT: %"PRId64
" [%"PRId64
"] %"PRId64
" pre:%d eof:%d \n",
289 (int64_t)s
->min_filepos
,(int64_t)s
->read_filepos
,(int64_t)s
->max_filepos
,min
,s
->eof
);
290 while(s
->read_filepos
<s
->min_filepos
|| s
->max_filepos
-s
->read_filepos
<min
){
291 mp_msg(MSGT_CACHE
,MSGL_STATUS
,MSGTR_CacheFill
,
292 100.0*(float)(s
->max_filepos
-s
->read_filepos
)/(float)(s
->buffer_size
),
293 (int64_t)s
->max_filepos
-s
->read_filepos
295 if(s
->eof
) break; // file is smaller than prefill size
296 if(mp_input_check_interrupt(PREFILL_SLEEP_TIME
))
299 mp_msg(MSGT_CACHE
,MSGL_STATUS
,"\n");
300 return 1; // parent exits
305 static DWORD WINAPI
ThreadProc(void*s
){
308 // cache thread mainloop:
309 signal(SIGTERM
,exit_sighandler
); // kill
311 if(!cache_fill((cache_vars_t
*)s
)){
312 usec_sleep(FILL_USLEEP_TIME
); // idle
314 // cache_stats(s->cache_data);
318 int cache_stream_fill_buffer(stream_t
*s
){
320 if(s
->eof
){ s
->buf_pos
=s
->buf_len
=0; return 0; }
321 if(!s
->cache_pid
) return stream_fill_buffer(s
);
323 // cache_stats(s->cache_data);
325 if(s
->pos
!=((cache_vars_t
*)s
->cache_data
)->read_filepos
) mp_msg(MSGT_CACHE
,MSGL_ERR
,"!!! read_filepos differs!!! report this bug...\n");
327 len
=cache_read(s
->cache_data
,s
->buffer
, ((cache_vars_t
*)s
->cache_data
)->sector_size
);
328 //printf("cache_stream_fill_buffer->read -> %d\n",len);
330 if(len
<=0){ s
->eof
=1; s
->buf_pos
=s
->buf_len
=0; return 0; }
334 // printf("[%d]",len);fflush(stdout);
339 int cache_stream_seek_long(stream_t
*stream
,off_t pos
){
342 if(!stream
->cache_pid
) return stream_seek_long(stream
,pos
);
344 s
=stream
->cache_data
;
347 mp_msg(MSGT_CACHE
,MSGL_DBG2
,"CACHE2_SEEK: 0x%"PRIX64
" <= 0x%"PRIX64
" (0x%"PRIX64
") <= 0x%"PRIX64
" \n",s
->min_filepos
,pos
,s
->read_filepos
,s
->max_filepos
);
349 newpos
=pos
/s
->sector_size
; newpos
*=s
->sector_size
; // align
350 stream
->pos
=s
->read_filepos
=newpos
;
353 cache_stream_fill_buffer(stream
);
356 if(pos
>=0 && pos
<=stream
->buf_len
){
357 stream
->buf_pos
=pos
; // byte position in sector
361 // stream->buf_pos=stream->buf_len=0;
364 mp_msg(MSGT_CACHE
,MSGL_V
,"cache_stream_seek: WARNING! Can't seek to 0x%"PRIX64
" !\n",(int64_t)(pos
+newpos
));