2 * This file is part of MPlayer.
4 * MPlayer is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * MPlayer is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 // Initial draft of my new cache system...
22 // Note it runs in 2 processes (using fork()), but doesn't requires locking!!
23 // TODO: seeking, data consistency checking
25 #define READ_USLEEP_TIME 10000
26 #define FILL_USLEEP_TIME 50000
27 #define PREFILL_SLEEP_TIME 200
28 #define CONTROL_SLEEP_TIME 0
34 #include <sys/types.h>
38 #include "osdep/shmem.h"
39 #include "osdep/timer.h"
40 #if defined(__MINGW32__)
42 static void ThreadProc( void *s
);
43 #elif defined(__OS2__)
46 static void ThreadProc( void *s
);
47 #elif defined(PTHREAD_CACHE)
49 static void *ThreadProc(void *s
);
63 unsigned char *buffer
; // base pointer of the alllocated buffer memory
64 int buffer_size
; // size of the alllocated buffer memory
65 int sector_size
; // size of a single sector (2048/2324)
66 int back_size
; // we should keep back_size amount of old bytes for backward seek
67 int fill_limit
; // we should fill buffer only if space>=fill_limit
68 int seek_limit
; // keep filling cache if distanse is less that seek limit
71 off_t min_filepos
; // buffer contain only a part of the file, from min-max pos
73 off_t offset
; // filepos <-> bufferpos offset value (filepos of the buffer's first byte)
77 // int seek_lock; // 1 if we will seek/reset buffer, 2 if we are ready for cmd
78 // int fifo_flag; // 1 if we should use FIFO to notice cache about buffer reads.
82 volatile unsigned control_uint_arg
;
83 volatile double control_double_arg
;
84 volatile int control_res
;
85 volatile off_t control_new_pos
;
86 volatile double stream_time_length
;
89 static int min_fill
=0;
91 int cache_fill_status
=0;
93 static void cache_stats(cache_vars_t
*s
)
95 int newb
=s
->max_filepos
-s
->read_filepos
; // new bytes in the buffer
96 mp_msg(MSGT_CACHE
,MSGL_INFO
,"0x%06X [0x%06X] 0x%06X ",(int)s
->min_filepos
,(int)s
->read_filepos
,(int)s
->max_filepos
);
97 mp_msg(MSGT_CACHE
,MSGL_INFO
,"%3d %% (%3d%%)\n",100*newb
/s
->buffer_size
,100*min_fill
/s
->buffer_size
);
100 static int cache_read(cache_vars_t
*s
, unsigned char *buf
, int size
)
106 //printf("CACHE2_READ: 0x%X <= 0x%X <= 0x%X \n",s->min_filepos,s->read_filepos,s->max_filepos);
108 if(s
->read_filepos
>=s
->max_filepos
|| s
->read_filepos
<s
->min_filepos
){
111 // waiting for buffer fill...
112 usec_sleep(READ_USLEEP_TIME
); // 10ms
113 continue; // try again...
116 newb
=s
->max_filepos
-s
->read_filepos
; // new bytes in the buffer
117 if(newb
<min_fill
) min_fill
=newb
; // statistics...
119 // printf("*** newb: %d bytes ***\n",newb);
121 pos
=s
->read_filepos
- s
->offset
;
122 if(pos
<0) pos
+=s
->buffer_size
; else
123 if(pos
>=s
->buffer_size
) pos
-=s
->buffer_size
;
125 if(newb
>s
->buffer_size
-pos
) newb
=s
->buffer_size
-pos
; // handle wrap...
126 if(newb
>size
) newb
=size
;
129 if(s
->read_filepos
<s
->min_filepos
) mp_msg(MSGT_CACHE
,MSGL_ERR
,"Ehh. s->read_filepos<s->min_filepos !!! Report bug...\n");
131 // len=write(mem,newb)
132 //printf("Buffer read: %d bytes\n",newb);
133 memcpy(buf
,&s
->buffer
[pos
],newb
);
138 s
->read_filepos
+=len
;
143 cache_fill_status
=(s
->max_filepos
-s
->read_filepos
)/(s
->buffer_size
/ 100);
147 static int cache_fill(cache_vars_t
*s
)
149 int back
,back2
,newb
,space
,len
,pos
;
150 off_t read
=s
->read_filepos
;
152 if(read
<s
->min_filepos
|| read
>s
->max_filepos
){
154 mp_msg(MSGT_CACHE
,MSGL_DBG2
,"Out of boundaries... seeking to 0x%"PRIX64
" \n",(int64_t)read
);
155 // streaming: drop cache contents only if seeking backward or too much fwd:
156 if(s
->stream
->type
!=STREAMTYPE_STREAM
||
157 read
<s
->min_filepos
|| read
>=s
->max_filepos
+s
->seek_limit
)
159 s
->offset
= // FIXME!?
160 s
->min_filepos
=s
->max_filepos
=read
; // drop cache content :(
161 if(s
->stream
->eof
) stream_reset(s
->stream
);
162 stream_seek(s
->stream
,read
);
163 mp_msg(MSGT_CACHE
,MSGL_DBG2
,"Seek done. new pos: 0x%"PRIX64
" \n",(int64_t)stream_tell(s
->stream
));
167 // calc number of back-bytes:
168 back
=read
- s
->min_filepos
;
169 if(back
<0) back
=0; // strange...
170 if(back
>s
->back_size
) back
=s
->back_size
;
172 // calc number of new bytes:
173 newb
=s
->max_filepos
- read
;
174 if(newb
<0) newb
=0; // strange...
176 // calc free buffer space:
177 space
=s
->buffer_size
- (newb
+back
);
180 pos
=s
->max_filepos
- s
->offset
;
181 if(pos
>=s
->buffer_size
) pos
-=s
->buffer_size
; // wrap-around
183 if(space
<s
->fill_limit
){
184 // printf("Buffer is full (%d bytes free, limit: %d)\n",space,s->fill_limit);
185 return 0; // no fill...
188 // printf("### read=0x%X back=%d newb=%d space=%d pos=%d\n",read,back,newb,space,pos);
190 // reduce space if needed:
191 if(space
>s
->buffer_size
-pos
) space
=s
->buffer_size
-pos
;
193 // if(space>32768) space=32768; // limit one-time block size
194 if(space
>4*s
->sector_size
) space
=4*s
->sector_size
;
196 // if(s->seek_lock) return 0; // FIXME
199 // back+newb+space <= buffer_size
200 back2
=s
->buffer_size
-(space
+newb
); // max back size
201 if(s
->min_filepos
<(read
-back2
)) s
->min_filepos
=read
-back2
;
203 s
->min_filepos
=read
-back
; // avoid seeking-back to temp area...
207 //printf("Buffer fill: %d bytes of %d\n",space,s->buffer_size);
208 //len=stream_fill_buffer(s->stream);
209 //memcpy(&s->buffer[pos],s->stream->buffer,len); // avoid this extra copy!
211 len
=stream_read(s
->stream
,&s
->buffer
[pos
],space
);
215 if(pos
+len
>=s
->buffer_size
){
217 s
->offset
+=s
->buffer_size
;
224 static int cache_execute_control(cache_vars_t
*s
) {
225 static unsigned last
;
226 int quit
= s
->control
== -2;
227 if (quit
|| !s
->stream
->control
) {
228 s
->stream_time_length
= 0;
229 s
->control_new_pos
= 0;
230 s
->control_res
= STREAM_UNSUPPORTED
;
234 if (GetTimerMS() - last
> 99) {
236 if (s
->stream
->control(s
->stream
, STREAM_CTRL_GET_TIME_LENGTH
, &len
) == STREAM_OK
)
237 s
->stream_time_length
= len
;
239 s
->stream_time_length
= 0;
242 if (s
->control
== -1) return 1;
243 switch (s
->control
) {
244 case STREAM_CTRL_GET_CURRENT_TIME
:
245 case STREAM_CTRL_SEEK_TO_TIME
:
246 case STREAM_CTRL_GET_ASPECT_RATIO
:
247 s
->control_res
= s
->stream
->control(s
->stream
, s
->control
, &s
->control_double_arg
);
249 case STREAM_CTRL_SEEK_TO_CHAPTER
:
250 case STREAM_CTRL_GET_NUM_CHAPTERS
:
251 case STREAM_CTRL_GET_CURRENT_CHAPTER
:
252 case STREAM_CTRL_GET_NUM_ANGLES
:
253 case STREAM_CTRL_GET_ANGLE
:
254 case STREAM_CTRL_SET_ANGLE
:
255 s
->control_res
= s
->stream
->control(s
->stream
, s
->control
, &s
->control_uint_arg
);
258 s
->control_res
= STREAM_UNSUPPORTED
;
261 s
->control_new_pos
= s
->stream
->pos
;
266 static cache_vars_t
* cache_init(int size
,int sector
){
268 #if !defined(__MINGW32__) && !defined(PTHREAD_CACHE) && !defined(__OS2__)
269 cache_vars_t
* s
=shmem_alloc(sizeof(cache_vars_t
));
271 cache_vars_t
* s
=malloc(sizeof(cache_vars_t
));
273 if(s
==NULL
) return NULL
;
275 memset(s
,0,sizeof(cache_vars_t
));
280 s
->buffer_size
=num
*sector
;
281 s
->sector_size
=sector
;
282 #if !defined(__MINGW32__) && !defined(PTHREAD_CACHE) && !defined(__OS2__)
283 s
->buffer
=shmem_alloc(s
->buffer_size
);
285 s
->buffer
=malloc(s
->buffer_size
);
288 if(s
->buffer
== NULL
){
289 #if !defined(__MINGW32__) && !defined(PTHREAD_CACHE) && !defined(__OS2__)
290 shmem_free(s
,sizeof(cache_vars_t
));
297 s
->fill_limit
=8*sector
;
298 s
->back_size
=s
->buffer_size
/2;
302 void cache_uninit(stream_t
*s
) {
303 cache_vars_t
* c
= s
->cache_data
;
305 #if defined(__MINGW32__) || defined(PTHREAD_CACHE) || defined(__OS2__)
306 cache_do_control(s
, -2, NULL
);
308 kill(s
->cache_pid
,SIGKILL
);
309 waitpid(s
->cache_pid
,NULL
,0);
314 #if defined(__MINGW32__) || defined(PTHREAD_CACHE) || defined(__OS2__)
320 shmem_free(c
->buffer
,c
->buffer_size
);
322 shmem_free(s
->cache_data
,sizeof(cache_vars_t
));
324 s
->cache_data
= NULL
;
327 static void exit_sighandler(int x
){
333 * \return 1 on success, 0 if the function was interrupted and -1 on error
335 int stream_enable_cache(stream_t
*stream
,int size
,int min
,int seek_limit
){
336 int ss
= stream
->sector_size
? stream
->sector_size
: STREAM_BUFFER_SIZE
;
340 if (stream
->flags
& STREAM_NON_CACHEABLE
) {
341 mp_msg(MSGT_CACHE
,MSGL_STATUS
,"\rThis stream is non-cacheable\n");
345 s
=cache_init(size
,ss
);
346 if(s
== NULL
) return -1;
347 stream
->cache_data
=s
;
348 s
->stream
=stream
; // callback
349 s
->seek_limit
=seek_limit
;
352 //make sure that we won't wait from cache_fill
353 //more data than it is alowed to fill
354 if (s
->seek_limit
> s
->buffer_size
- s
->fill_limit
){
355 s
->seek_limit
= s
->buffer_size
- s
->fill_limit
;
357 if (min
> s
->buffer_size
- s
->fill_limit
) {
358 min
= s
->buffer_size
- s
->fill_limit
;
361 #if !defined(__MINGW32__) && !defined(PTHREAD_CACHE) && !defined(__OS2__)
362 if((stream
->cache_pid
=fork())){
363 if ((pid_t
)stream
->cache_pid
== -1)
364 stream
->cache_pid
= 0;
367 stream_t
* stream2
=malloc(sizeof(stream_t
));
368 memcpy(stream2
,s
->stream
,sizeof(stream_t
));
370 #if defined(__MINGW32__)
371 stream
->cache_pid
= _beginthread( ThreadProc
, 0, s
);
372 #elif defined(__OS2__)
373 stream
->cache_pid
= _beginthread( ThreadProc
, NULL
, 256 * 1024, s
);
377 pthread_create(&tid
, NULL
, ThreadProc
, s
);
378 stream
->cache_pid
= 1;
382 if (!stream
->cache_pid
) {
383 mp_msg(MSGT_CACHE
, MSGL_ERR
,
384 "Starting cache process/thread failed: %s.\n", strerror(errno
));
387 // wait until cache is filled at least prefill_init %
388 mp_msg(MSGT_CACHE
,MSGL_V
,"CACHE_PRE_INIT: %"PRId64
" [%"PRId64
"] %"PRId64
" pre:%d eof:%d \n",
389 (int64_t)s
->min_filepos
,(int64_t)s
->read_filepos
,(int64_t)s
->max_filepos
,min
,s
->eof
);
390 while(s
->read_filepos
<s
->min_filepos
|| s
->max_filepos
-s
->read_filepos
<min
){
391 mp_msg(MSGT_CACHE
,MSGL_STATUS
,MSGTR_CacheFill
,
392 100.0*(float)(s
->max_filepos
-s
->read_filepos
)/(float)(s
->buffer_size
),
393 (int64_t)s
->max_filepos
-s
->read_filepos
395 if(s
->eof
) break; // file is smaller than prefill size
396 if(stream_check_interrupt(PREFILL_SLEEP_TIME
)) {
401 mp_msg(MSGT_CACHE
,MSGL_STATUS
,"\n");
402 return 1; // parent exits
405 cache_uninit(stream
);
409 #if defined(__MINGW32__) || defined(PTHREAD_CACHE) || defined(__OS2__)
412 static void *ThreadProc( void *s
){
414 static void ThreadProc( void *s
){
419 use_gui
= 0; // mp_msg may not use gui stuff in forked code
421 // cache thread mainloop:
422 signal(SIGTERM
,exit_sighandler
); // kill
425 usec_sleep(FILL_USLEEP_TIME
); // idle
427 // cache_stats(s->cache_data);
428 } while (cache_execute_control(s
));
429 #if defined(__MINGW32__) || defined(__OS2__)
431 #elif defined(PTHREAD_CACHE)
434 // make sure forked code never leaves this function
439 int cache_stream_fill_buffer(stream_t
*s
){
441 if(s
->eof
){ s
->buf_pos
=s
->buf_len
=0; return 0; }
442 if(!s
->cache_pid
) return stream_fill_buffer(s
);
444 // cache_stats(s->cache_data);
446 if(s
->pos
!=((cache_vars_t
*)s
->cache_data
)->read_filepos
) mp_msg(MSGT_CACHE
,MSGL_ERR
,"!!! read_filepos differs!!! report this bug...\n");
448 len
=cache_read(s
->cache_data
,s
->buffer
, ((cache_vars_t
*)s
->cache_data
)->sector_size
);
449 //printf("cache_stream_fill_buffer->read -> %d\n",len);
451 if(len
<=0){ s
->eof
=1; s
->buf_pos
=s
->buf_len
=0; return 0; }
455 // printf("[%d]",len);fflush(stdout);
460 int cache_stream_seek_long(stream_t
*stream
,off_t pos
){
463 if(!stream
->cache_pid
) return stream_seek_long(stream
,pos
);
465 s
=stream
->cache_data
;
468 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
);
470 newpos
=pos
/s
->sector_size
; newpos
*=s
->sector_size
; // align
471 stream
->pos
=s
->read_filepos
=newpos
;
474 cache_stream_fill_buffer(stream
);
477 if(pos
>=0 && pos
<=stream
->buf_len
){
478 stream
->buf_pos
=pos
; // byte position in sector
482 // stream->buf_pos=stream->buf_len=0;
485 mp_msg(MSGT_CACHE
,MSGL_V
,"cache_stream_seek: WARNING! Can't seek to 0x%"PRIX64
" !\n",(int64_t)(pos
+newpos
));
489 int cache_do_control(stream_t
*stream
, int cmd
, void *arg
) {
490 cache_vars_t
* s
= stream
->cache_data
;
492 case STREAM_CTRL_SEEK_TO_TIME
:
493 s
->control_double_arg
= *(double *)arg
;
496 case STREAM_CTRL_SEEK_TO_CHAPTER
:
497 case STREAM_CTRL_SET_ANGLE
:
498 s
->control_uint_arg
= *(unsigned *)arg
;
501 // the core might call these every frame, they are too slow for this...
502 case STREAM_CTRL_GET_TIME_LENGTH
:
503 // case STREAM_CTRL_GET_CURRENT_TIME:
504 *(double *)arg
= s
->stream_time_length
;
505 return s
->stream_time_length
? STREAM_OK
: STREAM_UNSUPPORTED
;
506 case STREAM_CTRL_GET_NUM_CHAPTERS
:
507 case STREAM_CTRL_GET_CURRENT_CHAPTER
:
508 case STREAM_CTRL_GET_ASPECT_RATIO
:
509 case STREAM_CTRL_GET_NUM_ANGLES
:
510 case STREAM_CTRL_GET_ANGLE
:
515 return STREAM_UNSUPPORTED
;
517 while (s
->control
!= -1)
518 usec_sleep(CONTROL_SLEEP_TIME
);
520 case STREAM_CTRL_GET_TIME_LENGTH
:
521 case STREAM_CTRL_GET_CURRENT_TIME
:
522 case STREAM_CTRL_GET_ASPECT_RATIO
:
523 *(double *)arg
= s
->control_double_arg
;
525 case STREAM_CTRL_GET_NUM_CHAPTERS
:
526 case STREAM_CTRL_GET_CURRENT_CHAPTER
:
527 case STREAM_CTRL_GET_NUM_ANGLES
:
528 case STREAM_CTRL_GET_ANGLE
:
529 *(unsigned *)arg
= s
->control_uint_arg
;
531 case STREAM_CTRL_SEEK_TO_CHAPTER
:
532 case STREAM_CTRL_SEEK_TO_TIME
:
533 case STREAM_CTRL_SET_ANGLE
:
534 stream
->pos
= s
->read_filepos
= s
->control_new_pos
;
537 return s
->control_res
;