/**
* Main loop of the cache process or thread.
*/
static void cache_mainloop(cache_vars_t *s) {
int sleep_count = 0;
#if FORKED_CACHE
struct sigaction sa = { 0 };
sa.sa_handler = SIG_IGN;
sigaction(SIGUSR1, &sa, NULL);
#endif
do {
if (!cache_fill(s)) {
#if FORKED_CACHE
// Let signal wake us up, we cannot leave this
// enabled since we do not handle EINTR in most places.
// This might need extra code to work on BSD.
sa.sa_handler = dummy_sighandler;
sigaction(SIGUSR1, &sa, NULL);
#endif
if (sleep_count < INITIAL_FILL_USLEEP_COUNT) {
sleep_count++;
usec_sleep(INITIAL_FILL_USLEEP_TIME);
} else
usec_sleep(FILL_USLEEP_TIME); // idle
#if FORKED_CACHE
sa.sa_handler = SIG_IGN;
sigaction(SIGUSR1, &sa, NULL);
#endif
} else
sleep_count = 0;
} while (cache_execute_control(s));
}
static void *cache_thread(void *arg)
{
struct priv *s = arg;
pthread_mutex_lock(&s->mutex);
update_cached_controls(s);
double last = mp_time_sec();
while (s->control != CACHE_CTRL_QUIT) {
if (mp_time_sec() - last > CACHE_UPDATE_CONTROLS_TIME) {
update_cached_controls(s);
last = mp_time_sec();
}
if (s->control > 0) {
cache_execute_control(s);
} else {
cache_fill(s);
}
if (s->control == CACHE_CTRL_PING) {
pthread_cond_signal(&s->wakeup);
s->control = CACHE_CTRL_NONE;
}
if (s->idle && s->control == CACHE_CTRL_NONE)
mpthread_cond_timed_wait(&s->wakeup, &s->mutex, CACHE_IDLE_SLEEP_TIME);
}
pthread_cond_signal(&s->wakeup);
pthread_mutex_unlock(&s->mutex);
mp_msg(MSGT_CACHE, MSGL_V, "Cache exiting...\n");
return NULL;
}
static void *cache_thread(void *arg)
{
struct priv *s = arg;
mpthread_set_name("cache");
pthread_mutex_lock(&s->mutex);
update_cached_controls(s);
double last = mp_time_sec();
while (s->control != CACHE_CTRL_QUIT) {
if (mp_time_sec() - last > CACHE_UPDATE_CONTROLS_TIME) {
update_cached_controls(s);
last = mp_time_sec();
}
if (s->control > 0) {
cache_execute_control(s);
} else {
cache_fill(s);
}
if (s->control == CACHE_CTRL_PING) {
pthread_cond_signal(&s->wakeup);
s->control = CACHE_CTRL_NONE;
}
if (s->idle && s->control == CACHE_CTRL_NONE) {
struct timespec ts = mp_rel_time_to_timespec(CACHE_IDLE_SLEEP_TIME);
pthread_cond_timedwait(&s->wakeup, &s->mutex, &ts);
}
}
pthread_cond_signal(&s->wakeup);
pthread_mutex_unlock(&s->mutex);
MP_VERBOSE(s, "Cache exiting...\n");
return NULL;
}
/**
* \return 1 on success, 0 if the function was interrupted and -1 on error
*/
int stream_enable_cache(stream_t *stream,int size,int min,int seek_limit){
int ss = stream->sector_size ? stream->sector_size : STREAM_BUFFER_SIZE;
int res = -1;
cache_vars_t* s;
if (stream->flags & STREAM_NON_CACHEABLE) {
mp_msg(MSGT_CACHE,MSGL_STATUS,"\rThis stream is non-cacheable\n");
return 1;
}
s=cache_init(size,ss);
if(s == NULL) return -1;
stream->cache_data=s;
s->stream=stream; // callback
s->seek_limit=seek_limit;
//make sure that we won't wait from cache_fill
//more data than it is alowed to fill
if (s->seek_limit > s->buffer_size - s->fill_limit ){
s->seek_limit = s->buffer_size - s->fill_limit;
}
if (min > s->buffer_size - s->fill_limit) {
min = s->buffer_size - s->fill_limit;
}
#if !defined(__MINGW32__) && !defined(PTHREAD_CACHE) && !defined(__OS2__)
if((stream->cache_pid=fork())){
if ((pid_t)stream->cache_pid == -1)
stream->cache_pid = 0;
#else
{
stream_t* stream2=malloc(sizeof(stream_t));
memcpy(stream2,s->stream,sizeof(stream_t));
s->stream=stream2;
#if defined(__MINGW32__)
stream->cache_pid = _beginthread( ThreadProc, 0, s );
#elif defined(__OS2__)
stream->cache_pid = _beginthread( ThreadProc, NULL, 256 * 1024, s );
#else
{
pthread_t tid;
pthread_create(&tid, NULL, ThreadProc, s);
stream->cache_pid = 1;
}
#endif
#endif
if (!stream->cache_pid) {
mp_msg(MSGT_CACHE, MSGL_ERR,
"Starting cache process/thread failed: %s.\n", strerror(errno));
goto err_out;
}
// wait until cache is filled at least prefill_init %
mp_msg(MSGT_CACHE,MSGL_V,"CACHE_PRE_INIT: %"PRId64" [%"PRId64"] %"PRId64" pre:%d eof:%d \n",
(int64_t)s->min_filepos,(int64_t)s->read_filepos,(int64_t)s->max_filepos,min,s->eof);
while(s->read_filepos<s->min_filepos || s->max_filepos-s->read_filepos<min){
mp_msg(MSGT_CACHE,MSGL_STATUS,MSGTR_CacheFill,
100.0*(float)(s->max_filepos-s->read_filepos)/(float)(s->buffer_size),
(int64_t)s->max_filepos-s->read_filepos
);
if(s->eof) break; // file is smaller than prefill size
if(stream_check_interrupt(PREFILL_SLEEP_TIME)) {
res = 0;
goto err_out;
}
}
mp_msg(MSGT_CACHE,MSGL_STATUS,"\n");
return 1; // parent exits
err_out:
cache_uninit(stream);
return res;
}
#if defined(__MINGW32__) || defined(PTHREAD_CACHE) || defined(__OS2__)
}
#ifdef PTHREAD_CACHE
static void *ThreadProc( void *s ){
#else
static void ThreadProc( void *s ){
#endif
#endif
#ifdef CONFIG_GUI
use_gui = 0; // mp_msg may not use gui stuff in forked code
#endif
// cache thread mainloop:
signal(SIGTERM,exit_sighandler); // kill
do {
if(!cache_fill(s)){
usec_sleep(FILL_USLEEP_TIME); // idle
}
// cache_stats(s->cache_data);
} while (cache_execute_control(s));
#if defined(__MINGW32__) || defined(__OS2__)
_endthread();
#elif defined(PTHREAD_CACHE)
return NULL;
#else
// make sure forked code never leaves this function
exit(0);
#endif
}
int cache_stream_fill_buffer(stream_t *s){
int len;
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);
if(s->pos!=((cache_vars_t*)s->cache_data)->read_filepos) mp_msg(MSGT_CACHE,MSGL_ERR,"!!! 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;
s->buf_len=len;
s->pos+=len;
// printf("[%d]",len);fflush(stdout);
return len;
}
int stream_enable_cache(stream_t *stream,int size,int min,int seek_limit){
int ss=(stream->type==STREAMTYPE_VCD)?VCD_SECTOR_DATA:STREAM_BUFFER_SIZE;
cache_vars_t* s;
if (stream->type==STREAMTYPE_STREAM && stream->fd < 0) {
// The stream has no 'fd' behind it, so is non-cacheable
mp_msg(MSGT_CACHE,MSGL_STATUS,"\rThis stream is non-cacheable\n");
return 1;
}
s=cache_init(size,ss);
if(s == NULL) return 0;
stream->cache_data=s;
s->stream=stream; // callback
s->seek_limit=seek_limit;
//make sure that we won't wait from cache_fill
//more data than it is alowed to fill
if (s->seek_limit > s->buffer_size - s->fill_limit ){
s->seek_limit = s->buffer_size - s->fill_limit;
}
if (min > s->buffer_size - s->fill_limit) {
min = s->buffer_size - s->fill_limit;
}
#ifndef WIN32
if((stream->cache_pid=fork())){
#else
{
DWORD threadId;
stream_t* stream2=malloc(sizeof(stream_t));
memcpy(stream2,s->stream,sizeof(stream_t));
s->stream=stream2;
stream->cache_pid = CreateThread(NULL,0,ThreadProc,s,0,&threadId);
#endif
// wait until cache is filled at least prefill_init %
mp_msg(MSGT_CACHE,MSGL_V,"CACHE_PRE_INIT: %"PRId64" [%"PRId64"] %"PRId64" pre:%d eof:%d \n",
(int64_t)s->min_filepos,(int64_t)s->read_filepos,(int64_t)s->max_filepos,min,s->eof);
while(s->read_filepos<s->min_filepos || s->max_filepos-s->read_filepos<min){
mp_msg(MSGT_CACHE,MSGL_STATUS,MSGTR_CacheFill,
100.0*(float)(s->max_filepos-s->read_filepos)/(float)(s->buffer_size),
(int64_t)s->max_filepos-s->read_filepos
);
if(s->eof) break; // file is smaller than prefill size
if(mp_input_check_interrupt(PREFILL_SLEEP_TIME))
return 0;
}
mp_msg(MSGT_CACHE,MSGL_STATUS,"\n");
return 1; // parent exits
}
#ifdef WIN32
}
static DWORD WINAPI ThreadProc(void*s){
#endif
// cache thread mainloop:
signal(SIGTERM,exit_sighandler); // kill
while(1){
if(!cache_fill((cache_vars_t*)s)){
usec_sleep(FILL_USLEEP_TIME); // idle
}
// cache_stats(s->cache_data);
}
}
