summaryrefslogtreecommitdiff
path: root/src/input/libdvdnav/read_cache.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/input/libdvdnav/read_cache.c')
-rw-r--r--src/input/libdvdnav/read_cache.c261
1 files changed, 156 insertions, 105 deletions
diff --git a/src/input/libdvdnav/read_cache.c b/src/input/libdvdnav/read_cache.c
index 5a0177128..2029881c7 100644
--- a/src/input/libdvdnav/read_cache.c
+++ b/src/input/libdvdnav/read_cache.c
@@ -1,23 +1,23 @@
-/*
+/*
* Copyright (C) 2000 Rich Wareham <richwareham@users.sourceforge.net>
- *
+ *
* This file is part of libdvdnav, a DVD navigation library.
- *
+ *
* libdvdnav is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
- *
+ *
* libdvdnav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
- * $Id: read_cache.c,v 1.4 2002/10/24 15:04:41 jkeil Exp $
+ * $Id: read_cache.c,v 1.5 2002/11/18 12:41:16 mroi Exp $
*
*/
@@ -31,9 +31,9 @@
#include <sys/time.h>
#include <time.h>
-/*
+
#define DVDNAV_PROFILE
-*/
+
/* Read-ahead cache structure. */
#if _MULTITHREAD_
@@ -48,10 +48,10 @@
struct read_cache_s {
pthread_mutex_t cache_lock;
pthread_t read_thread;
-
+
/* Buffer */
uint8_t *buffer;
-
+
/* Size of buffer */
int32_t size;
/* block offset from sector start of buffer 'head' */
@@ -60,7 +60,7 @@ struct read_cache_s {
uint32_t read_point;
/* block offset from buffer start to ring-boundary */
uint32_t start;
-
+
/* Bit of strange cross-linking going on here :) -- Gotta love C :) */
dvdnav_t *dvd_self;
};
@@ -72,11 +72,15 @@ struct read_cache_s {
/* all cache chunks must be memory aligned to allow use of raw devices */
#define ALIGNMENT 2048
+#define READ_AHEAD_SIZE_MIN 4
+#define READ_AHEAD_SIZE_MAX 512
+
typedef struct read_cache_chunk_s {
uint8_t *cache_buffer;
uint8_t *cache_buffer_base; /* used in malloc and free for alignment */
int32_t cache_start_sector; /* -1 means cache invalid */
- size_t cache_block_count;
+ int32_t cache_read_count; /* this many sectors are already read */
+ size_t cache_block_count; /* this many sectors will go in this chunk */
size_t cache_malloc_size;
int cache_valid;
int usage_count; /* counts how many buffers where issued from this chunk */
@@ -86,6 +90,9 @@ struct read_cache_s {
read_cache_chunk_t chunk[READ_CACHE_CHUNKS];
int current;
int freeing; /* is set to one when we are about to dispose the cache */
+ int read_ahead_size;
+ int read_ahead_incr;
+ int last_sector;
pthread_mutex_t lock;
/* Bit of strange cross-linking going on here :) -- Gotta love C :) */
@@ -93,17 +100,19 @@ struct read_cache_s {
};
#endif
+/*
#define READ_CACHE_TRACE 0
+*/
#ifdef __GNUC__
# if READ_CACHE_TRACE
-# define dprintf(fmt, args...) fprintf(MSG_OUT, "libdvdnav: %s: "fmt, __func__ , ## args);
+# define dprintf(fmt, args...) fprintf(MSG_OUT, "libdvdnav: %s: "fmt, __func__ , ## arg
# else
# define dprintf(fmt, args...) /* Nowt */
# endif
#else
# if READ_CACHE_TRACE
-# define dprintf(fmt, ...) fprintf(MSG_OUT, "libdvdnav: %s: "fmt, __func__ , __VA_ARGS__);
+# define dprintf(fmt, ...) fprintf(MSG_OUT, "libdvdnav: %s: "fmt, __func__ , __VA_ARGS_
# else
# define dprintf(fmt, ...) /* Nowt */
# endif
@@ -120,9 +129,9 @@ void * read_cache_read_thread (void * this_gen) {
read_cache_t *self = (read_cache_t*)this_gen;
while(cont) {
-
+
pthread_mutex_lock(&self->cache_lock);
-
+
if(self->size >= 0) {
diff = self->read_point - self->pos;
if(diff >= self->size/2) {
@@ -131,11 +140,11 @@ void * read_cache_read_thread (void * this_gen) {
startp = (self->start) % CACHE_BUFFER_SIZE;
endp = abs((self->start + diff - 1) % CACHE_BUFFER_SIZE);
dprintf("startp = %i, endp = %i -- ",startp, endp);
-
+
pos = self->pos + diff;
size = self->size - diff;
start = (self->start + diff) % CACHE_BUFFER_SIZE;
-
+
/* Fill remainder of buffer */
if(startp > endp) {
@@ -147,7 +156,7 @@ void * read_cache_read_thread (void * this_gen) {
DVDReadBlocks(self->dvd_self->file, s,c, at);
pthread_mutex_lock(&self->cache_lock);
}
-
+
s = pos + size + c; c = CACHE_BUFFER_SIZE - size - c;
at = self->buffer;
if(c > 0) {
@@ -168,12 +177,12 @@ void * read_cache_read_thread (void * this_gen) {
}
dprintf("\n");
-
+
self->pos = pos;
self->start = start; self->size = CACHE_BUFFER_SIZE;
}
}
-
+
pthread_mutex_unlock(&self->cache_lock);
cont = (self->buffer != NULL);
usleep(100);
@@ -181,7 +190,7 @@ void * read_cache_read_thread (void * this_gen) {
return NULL;
}
-
+
read_cache_t *dvdnav_read_cache_new(dvdnav_t* dvd_self) {
read_cache_t *me;
@@ -189,7 +198,7 @@ read_cache_t *dvdnav_read_cache_new(dvdnav_t* dvd_self) {
if(me) {
int err;
-
+
me->dvd_self = dvd_self;
me->buffer = (uint8_t*)malloc(CACHE_BUFFER_SIZE * DVD_VIDEO_LB_LEN);
me->start = 0;
@@ -205,15 +214,15 @@ read_cache_t *dvdnav_read_cache_new(dvdnav_t* dvd_self) {
dprintf("read_cache: can't create new thread (%s)\n",strerror(err));
}
}
-
+
return me;
}
void dvdnav_read_cache_free(read_cache_t* self) {
dvdnav_t *tmp;
-
+
pthread_mutex_lock(&self->cache_lock);
-
+
if(self->buffer) {
free(self->buffer);
self->buffer = NULL;
@@ -223,12 +232,12 @@ void dvdnav_read_cache_free(read_cache_t* self) {
pthread_mutex_unlock(&self->cache_lock);
pthread_join(self->read_thread, NULL);
-
+
pthread_mutex_destroy(&self->cache_lock);
-
+
tmp = self->dvd_self;
free(self);
-
+
/* We free the main structure, too, because we have no buffers out there. */
free(tmp);
}
@@ -237,7 +246,7 @@ void dvdnav_read_cache_free(read_cache_t* self) {
void dvdnav_read_cache_clear(read_cache_t *self) {
if(!self)
return;
-
+
pthread_mutex_lock(&self->cache_lock);
self->size = -1;
self->start = 0;
@@ -250,15 +259,15 @@ void dvdnav_read_cache_clear(read_cache_t *self) {
void dvdnav_pre_cache_blocks(read_cache_t *self, int sector, size_t block_count) {
if(!self)
return;
-
+
if(!self->dvd_self->use_read_ahead) {
return;
}
-
+
pthread_mutex_lock(&self->cache_lock);
- dprintf("Requested pre-cache (%i -> +%i) : current state pos=%i, size=%i.\n",
+ dprintf("Requested pre-cache (%i -> +%i) : current state pos=%i, size=%i.\n",
sector, block_count, self->pos, self->size);
-
+
/* Are the contents of the buffer in any way relevant? */
if((self->size > 0) && (sector >= self->pos) && (sector <= self->pos+self->size)) {
dprintf("Contents relevant ... adjusting\n");
@@ -271,24 +280,24 @@ void dvdnav_pre_cache_blocks(read_cache_t *self, int sector, size_t block_count)
self->pos = sector;
self->read_point = sector;
}
-
+
pthread_mutex_unlock(&self->cache_lock);
}
/* This function will do the cache read once implemented */
int dvdnav_read_cache_block( read_cache_t *self, int sector, size_t block_count, uint8_t **buf) {
int result, diff;
-
+
if(!self)
return 0;
pthread_mutex_lock(&self->cache_lock);
dprintf("Read from %i -> +%i (buffer pos=%i, read_point=%i, size=%i)... ", sector, block_count,
self->pos, self->read_point, self->size);
- if((self->size > 0) && (sector >= self->read_point) &&
+ if((self->size > 0) && (sector >= self->read_point) &&
(sector + block_count <= self->pos + self->size)) {
/* Hit */
-
+
/* Drop any skipped blocks */
diff = sector - self->read_point;
if(diff > 0)
@@ -298,7 +307,7 @@ int dvdnav_read_cache_block( read_cache_t *self, int sector, size_t block_count,
if(((self->start + diff) % CACHE_BUFFER_SIZE) + block_count <= CACHE_BUFFER_SIZE) {
dprintf("************** Single read\n");
- memcpy(*buf, self->buffer + (((self->start + diff) % CACHE_BUFFER_SIZE) * DVD_VIDEO_LB_LEN),
+ memcpy(*buf, self->buffer + (((self->start + diff) % CACHE_BUFFER_SIZE) * DVD_VIDEO_LB_LEN),
block_count * DVD_VIDEO_LB_LEN);
self->read_point += block_count;
pthread_mutex_unlock(&self->cache_lock);
@@ -308,19 +317,19 @@ int dvdnav_read_cache_block( read_cache_t *self, int sector, size_t block_count,
int32_t boundary = CACHE_BUFFER_SIZE - self->start;
dprintf("************** Multiple read\n");
- memcpy(*buf, self->buffer + (((self->start + diff) % CACHE_BUFFER_SIZE) * DVD_VIDEO_LB_LEN),
+ memcpy(*buf, self->buffer + (((self->start + diff) % CACHE_BUFFER_SIZE) * DVD_VIDEO_LB_LEN),
boundary * DVD_VIDEO_LB_LEN);
- memcpy(*buf + (boundary * DVD_VIDEO_LB_LEN), self->buffer,
+ memcpy(*buf + (boundary * DVD_VIDEO_LB_LEN), self->buffer,
(block_count-boundary) * DVD_VIDEO_LB_LEN);
self->read_point += block_count;
pthread_mutex_unlock(&self->cache_lock);
- return (int)block_count;
+ return (int)block_count;
}
} else {
/* Miss */
- fprintf(MSG_OUT, "libdvdnav: DVD read cache miss! (not bad but a performance hit) sector=%d\n", sector);
+ fprintf(MSG_OUT, "libdvdnav: DVD read cache miss! (not bad but a performance hit) sector=%d\n", sector);
result = DVDReadBlocks( self->dvd_self->file, sector, block_count, *buf);
self->read_point = sector+block_count;
if(self->read_point > self->pos + self->size) {
@@ -334,7 +343,7 @@ int dvdnav_read_cache_block( read_cache_t *self, int sector, size_t block_count,
usleep(300);
return result;
}
-
+
/* Should never get here */
return 0;
}
@@ -355,6 +364,9 @@ read_cache_t *dvdnav_read_cache_new(dvdnav_t* dvd_self) {
self->current = 0;
self->freeing = 0;
self->dvd_self = dvd_self;
+ self->last_sector = 0;
+ self->read_ahead_size = READ_AHEAD_SIZE_MIN;
+ self->read_ahead_incr = 0;
pthread_mutex_init(&self->lock, NULL);
dvdnav_read_cache_clear(self);
for (i = 0; i < READ_CACHE_CHUNKS; i++) {
@@ -362,14 +374,14 @@ read_cache_t *dvdnav_read_cache_new(dvdnav_t* dvd_self) {
self->chunk[i].usage_count = 0;
}
}
-
+
return self;
}
void dvdnav_read_cache_free(read_cache_t* self) {
dvdnav_t *tmp;
int i;
-
+
pthread_mutex_lock(&self->lock);
self->freeing = 1;
for (i = 0; i < READ_CACHE_CHUNKS; i++)
@@ -378,7 +390,7 @@ void dvdnav_read_cache_free(read_cache_t* self) {
self->chunk[i].cache_buffer = NULL;
}
pthread_mutex_unlock(&self->lock);
-
+
for (i = 0; i < READ_CACHE_CHUNKS; i++)
if (self->chunk[i].cache_buffer) return;
@@ -395,35 +407,20 @@ void dvdnav_read_cache_clear(read_cache_t *self) {
if(!self)
return;
-
+
pthread_mutex_lock(&self->lock);
for (i = 0; i < READ_CACHE_CHUNKS; i++)
self->chunk[i].cache_valid = 0;
pthread_mutex_unlock(&self->lock);
}
-#ifdef DVDNAV_PROFILE
-//#ifdef ARCH_X86
-__inline__ unsigned long long int dvdnav_rdtsc()
-{
- unsigned long long int x;
- __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
- return x;
-}
-//#endif
-#endif
-
/* This function is called just after reading the NAV packet. */
void dvdnav_pre_cache_blocks(read_cache_t *self, int sector, size_t block_count) {
- int i, use, result;
-#ifdef DVDNAV_PROFILE
- struct timeval tv1, tv2, tv3;
- unsigned long long p1, p2, p3;
-#endif
-
+ int i, use;
+
if(!self)
return;
-
+
if(!self->dvd_self->use_read_ahead)
return;
@@ -436,7 +433,7 @@ void dvdnav_pre_cache_blocks(read_cache_t *self, int sector, size_t block_count)
self->chunk[i].cache_malloc_size >= block_count &&
(use == -1 || self->chunk[use].cache_malloc_size > self->chunk[i].cache_malloc_size))
use = i;
-
+
if (use == -1) {
/* we haven't found a cache chunk, so we try to reallocate an existing one */
for (i = 0; i < READ_CACHE_CHUNKS; i++)
@@ -461,99 +458,153 @@ void dvdnav_pre_cache_blocks(read_cache_t *self, int sector, size_t block_count)
/* We start with a sensible figure for the first malloc of 500 blocks.
* Some DVDs I have seen venture to 450 blocks.
* This is so that fewer realloc's happen if at all.
- */
+ */
self->chunk[i].cache_buffer_base =
malloc((block_count > 500 ? block_count : 500) * DVD_VIDEO_LB_LEN + ALIGNMENT);
self->chunk[i].cache_buffer =
(uint8_t *)(((int)self->chunk[i].cache_buffer_base & ~(ALIGNMENT - 1)) + ALIGNMENT);
self->chunk[i].cache_malloc_size = block_count > 500 ? block_count : 500;
dprintf("pre_cache DVD read malloc %d blocks\n",
- (block_count > 500 ? block_count : 500 ));
+ (block_count > 500 ? block_count : 500 ));
}
}
}
-
+
if (use >= 0) {
self->chunk[use].cache_start_sector = sector;
self->chunk[use].cache_block_count = block_count;
- self->current = use;
-#ifdef DVDNAV_PROFILE
- gettimeofday(&tv1, NULL);
- p1 = dvdnav_rdtsc();
-#endif
- result = DVDReadBlocks (self->dvd_self->file, sector, block_count, self->chunk[use].cache_buffer);
-#ifdef DVDNAV_PROFILE
- p2 = dvdnav_rdtsc();
- gettimeofday(&tv2, NULL);
- timersub(&tv2, &tv1, &tv3);
- dprintf("pre_cache DVD read %ld us, profile = %lld, block_count = %d\n",
- tv3.tv_usec, p2-p1, block_count);
-#endif
+ self->chunk[use].cache_read_count = 0;
self->chunk[use].cache_valid = 1;
- } else
+ self->current = use;
+ } else {
dprintf("pre_caching was impossible, no cache chunk available\n");
-
+ }
pthread_mutex_unlock(&self->lock);
}
int dvdnav_read_cache_block(read_cache_t *self, int sector, size_t block_count, uint8_t **buf) {
int i, use;
-
+ int start;
+ int size;
+ int incr;
+ uint8_t *read_ahead_buf;
+ int32_t res;
+
if(!self)
return 0;
-
- pthread_mutex_lock(&self->lock);
-
+
use = -1;
+
if(self->dvd_self->use_read_ahead) {
/* first check, if sector is in current chunk */
read_cache_chunk_t cur = self->chunk[self->current];
if (cur.cache_valid && sector >= cur.cache_start_sector &&
+ sector <= (cur.cache_start_sector + cur.cache_read_count) &&
sector + block_count <= cur.cache_start_sector + cur.cache_block_count)
use = self->current;
else
for (i = 0; i < READ_CACHE_CHUNKS; i++)
- if (self->chunk[i].cache_valid && sector >= self->chunk[i].cache_start_sector &&
- sector + block_count <= self->chunk[i].cache_start_sector + self->chunk[i].cache_block_count)
- use = i;
+ if (self->chunk[i].cache_valid &&
+ sector >= self->chunk[i].cache_start_sector &&
+ sector <= (self->chunk[i].cache_start_sector + self->chunk[i].cache_read_count) &&
+ sector + block_count <= self->chunk[i].cache_start_sector + self->chunk[i].cache_block_count)
+ use = i;
}
-
+
if (use >= 0) {
- self->chunk[use].usage_count++;
- *buf = &self->chunk[use].cache_buffer[(sector - self->chunk[use].cache_start_sector) *
- DVD_VIDEO_LB_LEN * block_count];
+ read_cache_chunk_t *chunk;
+
+ /* Increment read-ahead size if sector follows the last sector */
+ if (sector == (self->last_sector + 1)) {
+ self->read_ahead_incr++;
+ } else {
+ self->read_ahead_size = READ_AHEAD_SIZE_MIN;
+ self->read_ahead_incr = 0;
+ }
+ self->last_sector = sector;
+
+ /* The following resources need to be protected by a mutex :
+ * self->chunk[*].cache_buffer
+ * self->chunk[*].cache_malloc_size
+ * self->chunk[*].usage_count
+ */
+ pthread_mutex_lock(&self->lock);
+ chunk = &self->chunk[use];
+ read_ahead_buf = chunk->cache_buffer + chunk->cache_read_count * DVD_VIDEO_LB_LEN;
+ *buf = chunk->cache_buffer + (sector - chunk->cache_start_sector) * DVD_VIDEO_LB_LEN;
+ chunk->usage_count++;
pthread_mutex_unlock(&self->lock);
- return DVD_VIDEO_LB_LEN * block_count;
+
+ /* Read blocks if needed */
+ if (sector >= (chunk->cache_start_sector + chunk->cache_read_count)) {
+
+ dprintf("libdvdnav: sector=%d, start_sector=%d, last_sector=%d\n", sector, chunk->cache_start_sector, chunk->cache_start_sector + chunk->cache_block_count);
+
+ /* read_ahead_size */
+ incr = self->read_ahead_incr >> 1;
+ if ((self->read_ahead_size + incr) > READ_AHEAD_SIZE_MAX) {
+ self->read_ahead_size = READ_AHEAD_SIZE_MAX;
+ } else {
+ self->read_ahead_size = self->read_ahead_size + incr;
+ }
+ self->read_ahead_incr = 0;
+
+ /* real read size */
+ start = chunk->cache_start_sector + chunk->cache_read_count;
+ if (chunk->cache_read_count + self->read_ahead_size > chunk->cache_block_count) {
+ size = chunk->cache_block_count - chunk->cache_read_count;
+ } else {
+ size = self->read_ahead_size;
+ }
+ dprintf("libdvdnav: read_ahead_size=%d, size=%d\n", self->read_ahead_size, size);
+
+ chunk->cache_read_count += DVDReadBlocks(self->dvd_self->file,
+ start,
+ size,
+ read_ahead_buf);
+ }
+
+ res = DVD_VIDEO_LB_LEN * block_count;
+
} else {
+
if (self->dvd_self->use_read_ahead)
dprintf("cache miss on sector %d\n", sector);
- pthread_mutex_unlock(&self->lock);
- return DVDReadBlocks(self->dvd_self->file, sector, block_count, *buf);
+
+ res = DVDReadBlocks(self->dvd_self->file,
+ sector,
+ block_count,
+ *buf) * DVD_VIDEO_LB_LEN;
}
+
+ return res;
+
}
dvdnav_status_t dvdnav_free_cache_block(dvdnav_t *self, unsigned char *buf) {
read_cache_t *cache;
int i;
-
+
if (!self)
return DVDNAV_STATUS_ERR;
-
+
cache = self->cache;
if (!cache)
return DVDNAV_STATUS_ERR;
-
+
pthread_mutex_lock(&cache->lock);
- for (i = 0; i < READ_CACHE_CHUNKS; i++)
+ for (i = 0; i < READ_CACHE_CHUNKS; i++) {
if (cache->chunk[i].cache_buffer && buf >= cache->chunk[i].cache_buffer &&
- buf < cache->chunk[i].cache_buffer + cache->chunk[i].cache_malloc_size * DVD_VIDEO_LB_LEN)
+ buf < cache->chunk[i].cache_buffer + cache->chunk[i].cache_malloc_size * DVD_VIDEO_LB_LEN) {
cache->chunk[i].usage_count--;
+ }
+ }
pthread_mutex_unlock(&cache->lock);
if (cache->freeing)
/* when we want to dispose the cache, try freeing it now */
dvdnav_read_cache_free(cache);
-
+
return DVDNAV_STATUS_OK;
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-16 22:52:31 +0000