Prepare for cch_handle_write(), cue testing

Signed-off-by: Andrew Opalach <andrew@akon.city>

13 files changed, 54 insertions, 47 deletions

diff --git a/src/cache/entry.c b/src/cache/entry.c
index 0bace31..183278a 100644
--- a/src/cache/entry.c
+++ b/src/cache/entry.c
@@ -9,8 +9,6 @@ bool cch_entry_get_handle(struct cch_entry *entry, struct cch_handle *handle)
     handle->wait.disabled = false;
     nn_cond_init(&handle->wait.cond);
     nn_mutex_init(&handle->wait.lock);
-    nn_mutex_lock(&entry->mutex);
-    nn_mutex_unlock(&entry->mutex);
     return true;
 }
 
@@ -31,7 +29,6 @@ void cch_entry_free(struct cch_entry **entry)
 {
     (*entry)->handler->free(&(*entry)->handler);
     (*entry)->backing->free(&(*entry)->backing);
-    nn_mutex_destroy(&(*entry)->mutex);
     al_free(*entry);
     *entry = NULL;
 }
diff --git a/src/cache/entry.h b/src/cache/entry.h
index eb98c2f..c74870d 100644
--- a/src/cache/entry.h
+++ b/src/cache/entry.h
@@ -32,6 +32,11 @@
     [x] get/set_size() no longer make sense.
     [x] // @TODO: Unknown size is unhandled in backings.
      - Handle keeps reading but will eventually have a wait cut short after a backing finalize.
+    [ ] Separate cch_handler from cch_entry.
+     - Move waits to entry?
+     - Create cache entry with argument like file, cue, http, hls, etc.
+     - Handlers created internally, and run on different step.
+    [ ] Maybe rename cch_handler.
     [ ] Rethink liana field on handler.
      - Data format hint on backing (codec or raw+description).
      - Codec hints (priority)?
@@ -54,7 +59,6 @@ struct cch_entry {
     struct cch_chapter *chapter;
     struct cch_backing *backing;
     struct cch_handler *handler;
-    struct nn_mutex mutex;
 };
 
 bool cch_entry_get_handle(struct cch_entry *entry, struct cch_handle *handle);
diff --git a/src/cache/handle.c b/src/cache/handle.c
index 1ec0f47..74db306 100644
--- a/src/cache/handle.c
+++ b/src/cache/handle.c
@@ -19,7 +19,7 @@ static off_t wait_for_size(struct cch_handle *handle, struct cch_handler *handle
     return backing->get_size_if_known(backing);
 }
 
-s32 cch_handle_read(struct cch_handle *handle, u8 *buf, s32 size)
+s32 cch_handle_read(struct cch_handle *handle, u8 *buf, s32 count)
 {
     struct cch_handler *handler = handle->entry->handler;
     struct cch_backing *backing = handle->entry->backing;
@@ -30,18 +30,18 @@ s32 cch_handle_read(struct cch_handle *handle, u8 *buf, s32 size)
     if (filesize > 0) {
         if (handle->pointer >= filesize) {
             return CAMU_ERR_EOF;
-        } else if (handle->pointer + size >= filesize) {
-            size = filesize - handle->pointer;
+        } else if (handle->pointer + count >= filesize) {
+            count = filesize - handle->pointer;
         }
     }
-    al_assert(size >= 0);
+    al_assert(count >= 0);
     handle->wait.start = handle->pointer;
-    handle->wait.end = handle->pointer + size;
+    handle->wait.end = handle->pointer + count;
     if (!handler->wait_for_range(handler, &handle->wait)) {
         log_trace("Wait for range (%zd-%zd) failed.", handle->wait.start, handle->wait.end);
         return CAMU_ERR_EOF;
     }
-    size_t available = (size_t)size;
+    size_t available = (size_t)count;
     if (backing->mode == CACHE_BACKING_MAPPED) {
         u8 *ptr = backing->get_ptr(backing, handle->pointer, &available);
         if (ptr && available > 0) {
@@ -52,10 +52,18 @@ s32 cch_handle_read(struct cch_handle *handle, u8 *buf, s32 size)
         backing->read(backing, buf, handle->pointer, &available);
     }
     handle->pointer += available;
-    log_trace("read(%u), pointer: %zd.", size, handle->pointer);
+    log_trace("read(%u), pointer: %zd.", count, handle->pointer);
     return (available > 0) ? (s32)available : CAMU_ERR_EOF;
 }
 
+s32 cch_handle_write(struct cch_handle *handle, const u8 *buf, s32 count)
+{
+    (void)handle;
+    (void)buf;
+    (void)count;
+    return -1;
+}
+
 off_t cch_handle_seek(struct cch_handle *handle, off_t offset, s32 whence)
 {
     struct cch_handler *handler = handle->entry->handler;
diff --git a/src/cache/handle.h b/src/cache/handle.h
index 0052c02..d42cd5a 100644
--- a/src/cache/handle.h
+++ b/src/cache/handle.h
@@ -9,10 +9,11 @@ struct cch_entry;
 struct cch_handle {
     struct cch_entry *entry;
     off_t pointer;
-    struct cch_handler_wait wait;
+    struct cch_wait wait;
 };
 
-s32 cch_handle_read(struct cch_handle *handle, u8 *buf, s32 size);
+s32 cch_handle_read(struct cch_handle *handle, u8 *buf, s32 count);
+s32 cch_handle_write(struct cch_handle *handle, const u8 *buf, s32 count);
 off_t cch_handle_seek(struct cch_handle *handle, off_t offset, s32 whence);
 bool cch_handle_can_seek(struct cch_handle *handle);
 void cch_handle_disable(struct cch_handle *handle);
diff --git a/src/cache/handler.h b/src/cache/handler.h
index 0a64573..4051449 100644
--- a/src/cache/handler.h
+++ b/src/cache/handler.h
@@ -8,7 +8,7 @@
 struct cch_handler {
     bool (*can_seek)(struct cch_handler *);
     void (*maybe_spawn_worker)(struct cch_handler *, size_t);
-    bool (*wait_for_range)(struct cch_handler *, struct cch_handler_wait *);
+    bool (*wait_for_range)(struct cch_handler *, struct cch_wait *);
     void (*free)(struct cch_handler **);
     struct cch_entry *entry;
     str liana;
diff --git a/src/cache/handlers/cdio.c b/src/cache/handlers/cdio.c
index 9a5e698..ba7898f 100644
--- a/src/cache/handlers/cdio.c
+++ b/src/cache/handlers/cdio.c
@@ -99,7 +99,7 @@ static void handler_cdio_maybe_spawn_worker(struct cch_handler *handler, size_t
     nn_thread_create(&cdio->thread, cd_read_thread, cdio);
 }
 
-static bool handler_cdio_wait_for_range(struct cch_handler *handler, struct cch_handler_wait *wait)
+static bool handler_cdio_wait_for_range(struct cch_handler *handler, struct cch_wait *wait)
 {
     struct cch_handler_cdio *cdio = (struct cch_handler_cdio *)handler;
     return cch_threaded_wait_for_range(&cdio->waits, cdio->backing, wait);
@@ -192,7 +192,6 @@ struct cch_entry *cch_handler_cdio_create(void)
     struct cch_entry *entry = al_alloc_object(struct cch_entry);
     entry->backing = backing;
     entry->handler = (struct cch_handler *)cdio;
-    nn_mutex_init(&entry->mutex);
     entry->handler->can_seek = handler_cdio_can_seek;
     entry->handler->maybe_spawn_worker = handler_cdio_maybe_spawn_worker;
     entry->handler->wait_for_range = handler_cdio_wait_for_range;
diff --git a/src/cache/handlers/cdio.h b/src/cache/handlers/cdio.h
index 650d2e5..a2734ca 100644
--- a/src/cache/handlers/cdio.h
+++ b/src/cache/handlers/cdio.h
@@ -17,7 +17,7 @@ struct cch_handler_cdio {
     struct nn_buffer buffer;
     atomic(s32) running;
     struct nn_thread thread;
-    struct cch_handler_waits waits;
+    struct cch_threaded_waits waits;
 };
 
 struct cch_entry *cch_handler_cdio_create(void);
diff --git a/src/cache/handlers/file.c b/src/cache/handlers/file.c
index cd78a2c..345cdca 100644
--- a/src/cache/handlers/file.c
+++ b/src/cache/handlers/file.c
@@ -15,7 +15,7 @@ static void handler_file_maybe_spawn_worker(struct cch_handler *handler, size_t
     (void)index;
 }
 
-static bool handler_file_wait_for_range(struct cch_handler *handler, struct cch_handler_wait *wait)
+static bool handler_file_wait_for_range(struct cch_handler *handler, struct cch_wait *wait)
 {
     (void)handler;
     (void)wait;
@@ -39,7 +39,6 @@ struct cch_entry *cch_handler_file_create(str *path, str *liana)
     struct cch_entry *entry = al_alloc_object(struct cch_entry);
     entry->backing = backing;
     entry->handler = (struct cch_handler *)file;
-    nn_mutex_init(&entry->mutex);
     entry->handler->can_seek = handler_file_can_seek;
     entry->handler->maybe_spawn_worker = handler_file_maybe_spawn_worker;
     entry->handler->wait_for_range = handler_file_wait_for_range;
diff --git a/src/cache/handlers/http.c b/src/cache/handlers/http.c
index 02f656b..e48490b 100644
--- a/src/cache/handlers/http.c
+++ b/src/cache/handlers/http.c
@@ -85,7 +85,7 @@ static void handler_http_maybe_spawn_worker(struct cch_handler *handler, size_t
     log_debug("Spawning worker for %.*s.", al_str_x(&http->url));
 }
 
-static bool handler_http_wait_for_range(struct cch_handler *handler, struct cch_handler_wait *wait)
+static bool handler_http_wait_for_range(struct cch_handler *handler, struct cch_wait *wait)
 {
     struct cch_handler_http *http = (struct cch_handler_http *)handler;
     return cch_threaded_wait_for_range(&http->waits, http->backing, wait);
@@ -116,7 +116,6 @@ struct cch_entry *cch_handler_http_create(str *url, struct nn_event_loop *loop)
     struct cch_entry *entry = al_alloc_object(struct cch_entry);
     entry->backing = backing;
     entry->handler = (struct cch_handler *)http;
-    nn_mutex_init(&entry->mutex);
     entry->handler->can_seek = handler_http_can_seek;
     entry->handler->maybe_spawn_worker = handler_http_maybe_spawn_worker;
     entry->handler->wait_for_range = handler_http_wait_for_range;
diff --git a/src/cache/handlers/http.h b/src/cache/handlers/http.h
index 2b87db9..93efdae 100644
--- a/src/cache/handlers/http.h
+++ b/src/cache/handlers/http.h
@@ -15,7 +15,7 @@ struct cch_handler_http {
     str url;
     off_t pointer;
     array(struct nn_http) requests;
-    struct cch_handler_waits waits;
+    struct cch_threaded_waits waits;
 };
 
 struct cch_entry *cch_handler_http_create(str *url, struct nn_event_loop *loop);
diff --git a/src/cache/threaded_waits.c b/src/cache/threaded_waits.c
index 3acbef1..1626466 100644
--- a/src/cache/threaded_waits.c
+++ b/src/cache/threaded_waits.c
@@ -1,13 +1,13 @@
 #include "threaded_waits.h"
 
-void cch_threaded_waits_init(struct cch_handler_waits *thw)
+void cch_threaded_waits_init(struct cch_threaded_waits *thw)
 {
     thw->disabled = false;
     nn_mutex_init(&thw->lock);
     al_array_init(thw->active);
 }
 
-static bool wait_range_satisfied(struct cch_backing *backing, struct cch_handler_wait *wait)
+static bool wait_range_satisfied(struct cch_backing *backing, struct cch_wait *wait)
 {
     if (wait->end < 0 || (backing->size > 0 && wait->end > backing->size)) {
         return true;
@@ -21,8 +21,8 @@ static bool wait_range_satisfied(struct cch_backing *backing, struct cch_handler
     return false;
 }
 
-bool cch_threaded_wait_for_range(struct cch_handler_waits *thw, struct cch_backing *backing,
-    struct cch_handler_wait *wait)
+bool cch_threaded_wait_for_range(struct cch_threaded_waits *thw, struct cch_backing *backing,
+    struct cch_wait *wait)
 {
     off_t size = backing->get_size_if_known(backing);
 
@@ -59,10 +59,10 @@ bool cch_threaded_wait_for_range(struct cch_handler_waits *thw, struct cch_backi
     return !canceled;
 }
 
-void cch_threaded_waits_signal_anys(struct cch_handler_waits *thw)
+void cch_threaded_waits_signal_anys(struct cch_threaded_waits *thw)
 {
     nn_mutex_lock(&thw->lock);
-    struct cch_handler_wait *wait;
+    struct cch_wait *wait;
     al_array_foreach_rev(thw->active, i, wait) {
         if (wait->end < 0) {
             // This will be considered a successful wait.
@@ -75,11 +75,11 @@ void cch_threaded_waits_signal_anys(struct cch_handler_waits *thw)
     nn_mutex_unlock(&thw->lock);
 }
 
-void cch_threaded_waits_evaluate(struct cch_handler_waits *thw, struct cch_backing *backing)
+void cch_threaded_waits_evaluate(struct cch_threaded_waits *thw, struct cch_backing *backing)
 {
     nn_mutex_lock(&thw->lock);
     backing->lock(backing);
-    struct cch_handler_wait *wait;
+    struct cch_wait *wait;
     al_array_foreach_rev(thw->active, i, wait) {
         if (wait_range_satisfied(backing, wait)) {
             al_array_remove_at(thw->active, i);
@@ -92,7 +92,7 @@ void cch_threaded_waits_evaluate(struct cch_handler_waits *thw, struct cch_backi
     nn_mutex_unlock(&thw->lock);
 }
 
-void cch_threaded_wait_disable(struct cch_handler_wait *wait)
+void cch_threaded_wait_disable(struct cch_wait *wait)
 {
     // If this wait is in active, cond_is_waiting() will be true.
     // So, signaling cond while holding the lock here will ensure it's removed before
@@ -105,14 +105,14 @@ void cch_threaded_wait_disable(struct cch_handler_wait *wait)
     nn_mutex_unlock(&wait->lock);
 }
 
-void cch_threaded_wait_enable(struct cch_handler_wait *wait)
+void cch_threaded_wait_enable(struct cch_wait *wait)
 {
     nn_mutex_lock(&wait->lock);
     wait->disabled = false;
     nn_mutex_unlock(&wait->lock);
 }
 
-void cch_threaded_waits_disable_all(struct cch_handler_waits *thw)
+void cch_threaded_waits_disable_all(struct cch_threaded_waits *thw)
 {
     nn_mutex_lock(&thw->lock);
 
@@ -124,7 +124,7 @@ void cch_threaded_waits_disable_all(struct cch_handler_waits *thw)
     // Disallow any further waits.
     thw->disabled = true;
 
-    struct cch_handler_wait *wait;
+    struct cch_wait *wait;
     al_array_foreach_rev(thw->active, i, wait) {
         nn_mutex_lock(&wait->lock);
         wait->disabled = true;
@@ -135,7 +135,7 @@ void cch_threaded_waits_disable_all(struct cch_handler_waits *thw)
     nn_mutex_unlock(&thw->lock);
 }
 
-void cch_threaded_waits_close(struct cch_handler_waits *thw)
+void cch_threaded_waits_close(struct cch_threaded_waits *thw)
 {
     nn_mutex_destroy(&thw->lock);
     al_array_free(thw->active);
diff --git a/src/cache/threaded_waits.h b/src/cache/threaded_waits.h
index 1f41df2..fd9a8e6 100644
--- a/src/cache/threaded_waits.h
+++ b/src/cache/threaded_waits.h
@@ -6,18 +6,18 @@
 #include "backing.h"
 #include "wait.h"
 
-struct cch_handler_waits {
+struct cch_threaded_waits {
     bool disabled;
     struct nn_mutex lock;
-    array(struct cch_handler_wait *) active;
+    array(struct cch_wait *) active;
 };
 
-void cch_threaded_waits_init(struct cch_handler_waits *thw);
-bool cch_threaded_wait_for_range(struct cch_handler_waits *thw, struct cch_backing *backing,
-    struct cch_handler_wait *wait);
-void cch_threaded_waits_signal_anys(struct cch_handler_waits *thw);
-void cch_threaded_waits_evaluate(struct cch_handler_waits *thw, struct cch_backing *backing);
-void cch_threaded_wait_disable(struct cch_handler_wait *wait);
-void cch_threaded_wait_enable(struct cch_handler_wait *wait);
-void cch_threaded_waits_disable_all(struct cch_handler_waits *thw);
-void cch_threaded_waits_close(struct cch_handler_waits *thw);
+void cch_threaded_waits_init(struct cch_threaded_waits *thw);
+bool cch_threaded_wait_for_range(struct cch_threaded_waits *thw, struct cch_backing *backing,
+    struct cch_wait *wait);
+void cch_threaded_waits_signal_anys(struct cch_threaded_waits *thw);
+void cch_threaded_waits_evaluate(struct cch_threaded_waits *thw, struct cch_backing *backing);
+void cch_threaded_wait_disable(struct cch_wait *wait);
+void cch_threaded_wait_enable(struct cch_wait *wait);
+void cch_threaded_waits_disable_all(struct cch_threaded_waits *thw);
+void cch_threaded_waits_close(struct cch_threaded_waits *thw);
diff --git a/src/cache/wait.h b/src/cache/wait.h
index 143e2b9..7422bc8 100644
--- a/src/cache/wait.h
+++ b/src/cache/wait.h
@@ -2,7 +2,7 @@
 
 #include <nnwt/thread.h>
 
-struct cch_handler_wait {
+struct cch_wait {
     off_t start, end;
     bool disabled;
     struct nn_cond cond;