Prepare for cch_handle_write(), cue testing

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

22 files changed, 85 insertions, 69 deletions

diff --git a/src/buffer/audio.c b/src/buffer/audio.c
index 28209d7..37aff4a 100644
--- a/src/buffer/audio.c
+++ b/src/buffer/audio.c
@@ -307,7 +307,7 @@ ptrdiff_t camu_audio_buffer_read(struct camu_audio_buffer *buf, u8 *data, ptrdif
 
     if (!buf->ignore_desync && al_atomic_load(u32)(&buf->unpause, AL_ATOMIC_ACQUIRE) > 0) {
         // Queuing multiple resyncs before resuming the stream will cause pops!
-        log_info("Forcing resync.");
+        log_debug("Forcing resync.");
         buf->pause = PAUSE_PAUSED;
         al_atomic_sub(u32)(&buf->unpause, 1, AL_ATOMIC_RELEASE);
     }
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;
diff --git a/src/codec/codec.h b/src/codec/codec.h
index 1c7c21f..48f83c7 100644
--- a/src/codec/codec.h
+++ b/src/codec/codec.h
@@ -186,7 +186,7 @@ struct camu_demuxer {
     bool (*init)(struct camu_demuxer *, struct cch_handle *);
     s32 (*get_packet)(struct camu_demuxer *, struct camu_codec_packet *);
     u64 (*get_duration)(struct camu_demuxer *);
-    bool (*seek)(struct camu_demuxer *, u64);
+    bool (*seek)(struct camu_demuxer *, u64, bool);
     void (*free)(struct camu_demuxer **);
     array(struct camu_codec_stream) streams;
     u32 subscribed;
diff --git a/src/codec/ffmpeg/avio.c b/src/codec/ffmpeg/avio.c
index 855a4de..154152e 100644
--- a/src/codec/ffmpeg/avio.c
+++ b/src/codec/ffmpeg/avio.c
@@ -2,10 +2,16 @@
 
 #include "../../cache/handle.h"
 
-s32 camu_avio_read(void *data, u8 *buf, s32 size)
+s32 camu_avio_read(void *data, u8 *buf, s32 count)
 {
     struct cch_handle *handle = (struct cch_handle *)data;
-    return cch_handle_read(handle, buf, size);
+    return cch_handle_read(handle, buf, count);
+}
+
+s32 camu_avio_write(void *data, const u8 *buf, s32 count)
+{
+    struct cch_handle *handle = (struct cch_handle *)data;
+    return cch_handle_write(handle, buf, count);
 }
 
 s64 camu_avio_seek(void *data, s64 offset, s32 whence)
diff --git a/src/codec/ffmpeg/common.c b/src/codec/ffmpeg/common.c
index d96dc76..259ba90 100644
--- a/src/codec/ffmpeg/common.c
+++ b/src/codec/ffmpeg/common.c
@@ -38,7 +38,7 @@ static void av_log_callback(void *userdata, s32 level, const char *fmt, va_list
     log_context.pos += ret;
 
     if ((log_context.pos > 0 && *(offset - 1) == '\n') || log_context.pos >= AV_LOG_MAX_CHUNK) {
-        if (level <= AV_LOG_INFO) {
+        if (level < AV_LOG_WARNING) {
             log_info(log_context.buf);
         } else {
             log_debug(log_context.buf);
diff --git a/src/codec/ffmpeg/demuxer.c b/src/codec/ffmpeg/demuxer.c
index d45a970..c5ca20c 100644
--- a/src/codec/ffmpeg/demuxer.c
+++ b/src/codec/ffmpeg/demuxer.c
@@ -95,7 +95,7 @@ static bool ff_demuxer_init(struct camu_demuxer *demux, struct cch_handle *handl
                 if (stream->duration < 0) {
                     stream->duration = av_rescale_q(default_duration, AV_TIME_BASE_Q, stream->time_base);
                     al_assert(stream->duration >= 0);
-                    log_warn("Stream #%u has an invalid duration, defaulting to %.3fs.",
+                    log_debug("Stream #%u has an invalid duration, defaulting to %.3fs.",
                         i, stream->duration * av_q2d(stream->time_base));
                 }
                 duration = (u64)av_rescale_q(stream->duration, stream->time_base, AV_TIME_BASE_Q);
@@ -162,19 +162,23 @@ static u64 ff_demuxer_get_duration(struct camu_demuxer *demux)
     return av->duration;
 }
 
-static bool ff_demuxer_seek(struct camu_demuxer *demux, u64 pos)
+static bool ff_demuxer_seek(struct camu_demuxer *demux, u64 pos, bool bytes)
 {
     struct camu_ff_demuxer *av = (struct camu_ff_demuxer *)demux;
-    al_assert(pos <= INT64_MAX);
-    if (pos > av->duration) pos = av->duration;
     if (av->eof) {
         // avio_flush() here probably does nothing.
         avio_flush(av->io_context);
         avformat_flush(av->format_context);
         av->eof = false;
     }
+    al_assert(pos <= INT64_MAX);
+    al_assert(!(bytes && av->format_context->flags & AVFMT_NO_BYTE_SEEK));
+    if (!bytes && pos > av->duration) pos = av->duration;
     s64 ts = (s64)pos;
-    if (avformat_seek_file(av->format_context, -1, INT64_MIN, ts, ts, 0) < 0) {
+    s32 flags = bytes ? AVSEEK_FLAG_BYTE : 0;
+    s32 ret = avformat_seek_file(av->format_context, -1, INT64_MIN, ts, ts, flags);
+    if (ret < 0) {
+        log_error("Failed to seek resource (%s).", av_err2str(ret));
         return false;
     }
     return true;
diff --git a/src/codec/stb_image/server.c b/src/codec/stb_image/server.c
index e2d26e8..ba50360 100644
--- a/src/codec/stb_image/server.c
+++ b/src/codec/stb_image/server.c
@@ -58,10 +58,11 @@ static u64 stbi_demuxer_get_duration(struct camu_demuxer *demux)
     return 0;
 }
 
-static bool stbi_demuxer_seek(struct camu_demuxer *demux, u64 pos)
+static bool stbi_demuxer_seek(struct camu_demuxer *demux, u64 pos, bool bytes)
 {
     (void)demux;
     (void)pos;
+    (void)bytes;
     return true;
 }
 
diff --git a/src/liana/handlers/codec_server.c b/src/liana/handlers/codec_server.c
index 99db398..042c05b 100644
--- a/src/liana/handlers/codec_server.c
+++ b/src/liana/handlers/codec_server.c
@@ -98,7 +98,7 @@ static bool codec_server_seek(struct lia_server_handler *handler, u64 pos)
 #ifdef LIANA_SERVER_LOOP
     codec->pts_offset = 0;
 #endif
-    return codec->demux->seek(codec->demux, pos);
+    return codec->demux->seek(codec->demux, pos, false);
 }
 
 static void codec_server_step(struct lia_server_handler *handler)
diff --git a/src/liana/process.c b/src/liana/process.c
index 9a70210..0a9f030 100644
--- a/src/liana/process.c
+++ b/src/liana/process.c
@@ -50,18 +50,16 @@ bool lia_prepare_visual_data(struct cch_handle *handle, struct lia_visual_data *
     }
 
     struct camu_codec_stream *stream;
-    struct camu_codec_stream *selected = NULL;
     al_array_foreach_ptr(demux->streams, i, stream) {
         if (stream->type == CAMU_STREAM_AUDIO) {
-            selected = stream;
+            demux->subscribed = 1 << stream->index;
             break;
         }
     }
-    if (!selected) goto out;
-    demux->subscribed = 1 << selected->index;
+    if (demux->subscribed == 0) goto out;
 
     struct camu_resampler_format fmt;
-    AVCodecParameters *codecpar = selected->av.stream->codecpar;
+    AVCodecParameters *codecpar = stream->av.stream->codecpar;
     fmt.in.format = codecpar->format;
     fmt.req.format = CAMU_SAMPLE_FORMAT_S16;
     fmt.in.sample_rate = codecpar->sample_rate;
@@ -78,7 +76,7 @@ bool lia_prepare_visual_data(struct cch_handle *handle, struct lia_visual_data *
     nn_buffer_init(&raw.buf);
     raw.index = 0;
 
-    if (!dec->init(dec, NULL, selected, data_callback, &raw)) {
+    if (!dec->init(dec, NULL, stream, data_callback, &raw)) {
         goto out;
     }
 
diff --git a/src/libsink/sink.c b/src/libsink/sink.c
index b9b3aa6..c95096d 100644
--- a/src/libsink/sink.c
+++ b/src/libsink/sink.c
@@ -748,7 +748,7 @@ static void pause_and_swap_to(struct camu_sink *sink, struct camu_sink_entry *ta
 
 static bool end_entry_and_advance_queue(struct camu_sink *sink, struct camu_sink_entry *entry)
 {
-    log_info("Entry ("ENTRY_FMT") ended.", ENTRY_ARG(entry));
+    log_debug("Entry ("ENTRY_FMT") ended.", ENTRY_ARG(entry));
     remove_previous_if_contains(sink, entry);
 #ifdef CAMU_SINK_ONESHOT
     sink->callback(sink->userdata, CAMU_SINK_MOCK_CLOSE, 0, NULL);
@@ -807,7 +807,7 @@ static void audio_buffer_callback(void *userdata, u8 op)
         nn_mutex_unlock(&sink->lock);
         break;
     case CAMU_BUFFER_EOF:
-        log_info("Audio EOF.");
+        log_debug("Audio EOF.");
         nn_mutex_lock(&sink->lock);
         // Having threaded outputs means anything could have happened while waiting
         // on the lock above. If we were locked in CLIENT_REMOVE_BUFFERS, state could very
@@ -849,7 +849,7 @@ static void video_buffer_callback(void *userdata, u8 op)
         lia_vcr_uncork(entry->video.track);
         break;
     case CAMU_BUFFER_EOF:
-        log_info("Video EOF.");
+        log_debug("Video EOF.");
         bool single_frame = VIDEO_IS_SINGLE_FRAME(entry);
         bool swapped = false;
         nn_mutex_lock(&sink->lock);
@@ -1234,7 +1234,7 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str
         lia_client_free(&entry->client);
         camu_audio_buffer_free(&entry->audio.buf);
         camu_video_buffer_free(&entry->video.buf);
-        log_info("Entry ("ENTRY_FMT") closed by %s.", ENTRY_ARG(entry), removed ? "force" : "cleanup");
+        log_debug("Entry ("ENTRY_FMT") closed by %s.", ENTRY_ARG(entry), removed ? "force" : "cleanup");
         al_free(entry);
 
         break;