diff options
Diffstat (limited to 'src')
94 files changed, 1491 insertions, 1393 deletions
diff --git a/src/buffer/audio.c b/src/buffer/audio.c index 2cedcc8..5a956ec 100644 --- a/src/buffer/audio.c +++ b/src/buffer/audio.c @@ -11,7 +11,7 @@ #define BUFFER_SIZE 9.0 #define BUFFER_MARK_MIN 4.3 // Must be a most half of the buffer size. -#define BUFFER_MARK_BUFFERED 2.5 +#define BUFFER_MARK_BUFFERED 2.0 #ifdef CAMU_AUDIO_BUFFER_FADE #define FADE_STEP(fmt) (1.75f / (fmt)->sample_rate) @@ -316,7 +316,7 @@ size_t camu_audio_buffer_read(struct camu_audio_buffer *buf, u8 *data, size_t re pts = -pts; ret = camu_audio_format_sec_to_bytes(&buf->fmt.req, pts); ret = MIN(ret, req); - al_log_info("audio_buffer", "Delaying audio by %fs (%zu bytes).", pts, ret); + al_log_info("audio_buffer", "Delaying audio by %fs.", pts); al_memset(data, 0, ret); data += ret; req -= ret; diff --git a/src/buffer/clock.c b/src/buffer/clock.c index 624c534..cbf63d5 100644 --- a/src/buffer/clock.c +++ b/src/buffer/clock.c @@ -1,5 +1,5 @@ #include <al/lib.h> -#include <aki/thread.h> +#include <nnwt/thread.h> #include "clock.h" @@ -31,13 +31,13 @@ void camu_clock_seek(struct camu_clock *clock, f64 base, u64 target) { clock->base = base; clock->offset = 0.0; - f64 tick = aki_get_tick(); + f64 tick = nn_get_tick(); if (clock->paused_at == -1.0) { // We are safe to directly edit the tick here. if (target == 0) { al_atomic_store(f64)(&clock->tick, -1.0, AL_ATOMIC_RELAXED); } else { - tick = calc_tick_offset(tick, aki_get_timestamp(), target); + tick = calc_tick_offset(tick, nn_get_timestamp(), target); al_atomic_store(f64)(&clock->tick, tick, AL_ATOMIC_RELAXED); } } else { @@ -54,9 +54,9 @@ void camu_clock_offset(struct camu_clock *clock, f64 amount) void camu_clock_pause(struct camu_clock *clock, u64 target) { al_assert(clock->paused_at == -1.0); - f64 tick = aki_get_tick(); + f64 tick = nn_get_tick(); if (target > 0) { - tick = calc_tick_offset(tick, aki_get_timestamp(), target); + tick = calc_tick_offset(tick, nn_get_timestamp(), target); al_atomic_store(f64)(&clock->pause, tick, AL_ATOMIC_RELAXED); } else { al_atomic_store(f64)(&clock->pause, PAUSED, AL_ATOMIC_RELAXED); @@ -67,12 +67,12 @@ void camu_clock_pause(struct camu_clock *clock, u64 target) void camu_clock_resume(struct camu_clock *clock, u64 target) { al_assert(clock->paused_at != -1.0); - f64 tick = aki_get_tick(); + f64 tick = nn_get_tick(); //if (pause != PAUSED && tick < pause) { // tick = pause; //} else if (target > 0) { if (target > 0) { - tick = calc_tick_offset(tick, aki_get_timestamp(), target); + tick = calc_tick_offset(tick, nn_get_timestamp(), target); } if (clock->paused_at == 0.0) { if (target == 0) { @@ -107,7 +107,7 @@ f64 camu_clock_get_pts(struct camu_clock *clock, f64 offset) { f64 pause = al_atomic_load(f64)(&clock->pause, AL_ATOMIC_ACQUIRE); if (pause == PAUSED) return -1.0; - f64 current = aki_get_tick(); + f64 current = nn_get_tick(); f64 tick = al_atomic_load(f64)(&clock->tick, AL_ATOMIC_RELAXED); if (tick == -1.0) { tick = al_atomic_compare_and_swap(f64)(&clock->tick, -1.0, current); diff --git a/src/buffer/peak_buffer.c b/src/buffer/peak_buffer.c index 005e77f..eec031a 100644 --- a/src/buffer/peak_buffer.c +++ b/src/buffer/peak_buffer.c @@ -4,27 +4,27 @@ void camu_peak_buffer_init(struct camu_peak_buffer *buf, size_t size) { - aki_buffer_init(&buf->buf); - aki_buffer_ensure_space(&buf->buf, size); + nn_buffer_init(&buf->buf); + nn_buffer_ensure_space(&buf->buf, size); } void camu_peak_buffer_push(struct camu_peak_buffer *buf, u8 *data, size_t size) { - aki_buffer_append(&buf->buf, data, size); + nn_buffer_append(&buf->buf, data, size); } size_t camu_peak_buffer_size(struct camu_peak_buffer *buf) { - return aki_buffer_get_size(&buf->buf); + return nn_buffer_get_size(&buf->buf); } u8 *camu_peak_buffer_flush(struct camu_peak_buffer *buf) { - aki_buffer_set_size(&buf->buf, 0); - return aki_buffer_get_ptr(&buf->buf, 0); + nn_buffer_set_size(&buf->buf, 0); + return nn_buffer_get_ptr(&buf->buf, 0); } void camu_peak_buffer_free(struct camu_peak_buffer *buf) { - aki_buffer_free(&buf->buf); + nn_buffer_free(&buf->buf); } diff --git a/src/buffer/peak_buffer.h b/src/buffer/peak_buffer.h index c518ade..ebb9939 100644 --- a/src/buffer/peak_buffer.h +++ b/src/buffer/peak_buffer.h @@ -1,10 +1,10 @@ #pragma once #include <al/types.h> -#include <aki/common.h> +#include <nnwt/common.h> struct camu_peak_buffer { - struct aki_buffer buf; + struct nn_buffer buf; }; void camu_peak_buffer_init(struct camu_peak_buffer *buf, size_t size); diff --git a/src/cache/backings/file.c b/src/cache/backings/file.c index a09d535..bf62190 100644 --- a/src/cache/backings/file.c +++ b/src/cache/backings/file.c @@ -6,64 +6,64 @@ static void file_backing_lock(struct cch_backing *backing) { struct cch_backing_file *file = (struct cch_backing_file *)backing; - aki_mutex_lock(&file->mutex); + nn_mutex_lock(&file->mutex); } static void file_backing_write(struct cch_backing *backing, u8 *buf, off_t index, size_t *size) { struct cch_backing_file *file = (struct cch_backing_file *)backing; - aki_mutex_lock(&file->mutex); + nn_mutex_lock(&file->mutex); if (file->u.pointer != index) { - file->u.pointer = aki_file_seek(&file->file, index, SEEK_SET); + file->u.pointer = nn_file_seek(&file->file, index, SEEK_SET); al_assert(file->u.pointer == index); } if (file->size >= 0 && index + ((off_t)*size) >= file->size) { *size = MAX(file->size - index, 0L); } - aki_file_write(&file->file, buf, *size); + nn_file_write(&file->file, buf, *size); file->u.pointer += *size; cch_backing_fill_range(&file->backing, index, *size); - aki_mutex_unlock(&file->mutex); + nn_mutex_unlock(&file->mutex); } static void file_backing_read(struct cch_backing *backing, u8 *buf, off_t index, size_t *size) { struct cch_backing_file *file = (struct cch_backing_file *)backing; - aki_mutex_lock(&file->mutex); + nn_mutex_lock(&file->mutex); if (file->u.pointer != index) { - file->u.pointer = aki_file_seek(&file->file, index, SEEK_SET); + file->u.pointer = nn_file_seek(&file->file, index, SEEK_SET); al_assert(file->u.pointer == index); } if (file->size >= 0 && index + ((off_t)*size) >= file->size) { *size = MAX(file->size - index, 0L); } - aki_file_read(&file->file, buf, *size); + nn_file_read(&file->file, buf, *size); file->u.pointer += *size; - aki_mutex_unlock(&file->mutex); + nn_mutex_unlock(&file->mutex); } static void file_backing_unlock(struct cch_backing *backing) { struct cch_backing_file *file = (struct cch_backing_file *)backing; - aki_mutex_unlock(&file->mutex); + nn_mutex_unlock(&file->mutex); } static void file_backing_resize(struct cch_backing *backing, size_t size) { struct cch_backing_file *file = (struct cch_backing_file *)backing; - aki_mutex_lock(&file->mutex); + nn_mutex_lock(&file->mutex); file->size = size; if ((off_t)size > file->filesize) { - aki_file_truncate(&file->file, size); + nn_file_truncate(&file->file, size); file->filesize = size; } - aki_mutex_unlock(&file->mutex); + nn_mutex_unlock(&file->mutex); } static void file_backing_free(struct cch_backing **backing) { struct cch_backing_file *file = (struct cch_backing_file *)*backing; - aki_file_close(&file->file); + nn_file_close(&file->file); al_array_free(file->backing.available); al_free(file); *backing = NULL; @@ -87,6 +87,6 @@ struct cch_backing *cch_backing_file_create(str *path, size_t size) return NULL; } file->u.pointer = 0; - aki_mutex_init(&file->mutex); + nn_mutex_init(&file->mutex); return (struct cch_backing *)file; } diff --git a/src/cache/backings/file.h b/src/cache/backings/file.h index 3f8437b..8a2bf7a 100644 --- a/src/cache/backings/file.h +++ b/src/cache/backings/file.h @@ -1,22 +1,22 @@ #pragma once #include <al/str.h> -#include <aki/thread.h> -#include <aki/common.h> -#include <aki/file.h> +#include <nnwt/thread.h> +#include <nnwt/common.h> +#include <nnwt/file.h> #include "../backing.h" struct cch_backing_file { struct cch_backing backing; - struct aki_file file; + struct nn_file file; off_t size; off_t filesize; union { void *map; // CACHE_BACKING_MAPPED off_t pointer; // CACHE_BACKING_READ } u; - struct aki_mutex mutex; + struct nn_mutex mutex; }; struct cch_backing *cch_backing_file_create(str *path, size_t filesize); diff --git a/src/cache/backings/file_common.c b/src/cache/backings/file_common.c index 35322fd..3914f95 100644 --- a/src/cache/backings/file_common.c +++ b/src/cache/backings/file_common.c @@ -1,24 +1,24 @@ static off_t file_backing_get_size_estimate(struct cch_backing *backing) { struct cch_backing_file *file = (struct cch_backing_file *)backing; - aki_mutex_lock(&file->mutex); + nn_mutex_lock(&file->mutex); off_t size = file->size; - aki_mutex_unlock(&file->mutex); + nn_mutex_unlock(&file->mutex); return size; } static bool file_open_internal(struct cch_backing_file *file, str *path, size_t size) { - s32 flags = size != 0 ? AKI_FILE_CREATE : 0; - if (!aki_file_open(&file->file, path, flags)) return false; - file->filesize = aki_file_get_filesize(&file->file); + s32 flags = size != 0 ? NNWT_FILE_CREATE : 0; + if (!nn_file_open(&file->file, path, flags)) return false; + file->filesize = nn_file_get_filesize(&file->file); if (!size) { file->size = file->filesize; cch_backing_fill_range(&file->backing, 0, file->size); } else { file->size = -1; if (file->filesize < (off_t)size) { - aki_file_truncate(&file->file, size); + nn_file_truncate(&file->file, size); } } return true; diff --git a/src/cache/backings/file_mapped.c b/src/cache/backings/file_mapped.c index 22f9ae5..35ab267 100644 --- a/src/cache/backings/file_mapped.c +++ b/src/cache/backings/file_mapped.c @@ -6,25 +6,25 @@ static void file_backing_lock(struct cch_backing *backing) { struct cch_backing_file *file = (struct cch_backing_file *)backing; - aki_mutex_lock(&file->mutex); + nn_mutex_lock(&file->mutex); } static void file_backing_write(struct cch_backing *backing, u8 *buf, off_t index, size_t *size) { struct cch_backing_file *file = (struct cch_backing_file *)backing; - aki_mutex_lock(&file->mutex); + nn_mutex_lock(&file->mutex); if (file->size >= 0 && index + (off_t)*size >= file->size) { *size = MAX(file->size - index, 0L); } al_memcpy(file->u.map + index, buf, *size); cch_backing_fill_range(&file->backing, index, *size); - aki_mutex_unlock(&file->mutex); + nn_mutex_unlock(&file->mutex); } static u8 *file_backing_get_ptr(struct cch_backing *backing, off_t index, size_t *size) { struct cch_backing_file *file = (struct cch_backing_file *)backing; - aki_mutex_lock(&file->mutex); + nn_mutex_lock(&file->mutex); if (file->size >= 0 && index + (off_t)*size >= file->size) { *size = MAX(file->size - index, 0L); } @@ -34,28 +34,28 @@ static u8 *file_backing_get_ptr(struct cch_backing *backing, off_t index, size_t static void file_backing_unlock(struct cch_backing *backing) { struct cch_backing_file *file = (struct cch_backing_file *)backing; - aki_mutex_unlock(&file->mutex); + nn_mutex_unlock(&file->mutex); } static void file_backing_resize(struct cch_backing *backing, size_t size) { struct cch_backing_file *file = (struct cch_backing_file *)backing; - aki_mutex_lock(&file->mutex); + nn_mutex_lock(&file->mutex); file->size = size; if ((off_t)size > file->filesize) { - aki_file_munmap(&file->file, file->u.map); - aki_file_truncate(&file->file, size); - file->u.map = aki_file_mmap(&file->file); + nn_file_munmap(&file->file, file->u.map); + nn_file_truncate(&file->file, size); + file->u.map = nn_file_mmap(&file->file); file->filesize = size; } - aki_mutex_unlock(&file->mutex); + nn_mutex_unlock(&file->mutex); } static void file_backing_free(struct cch_backing **backing) { struct cch_backing_file *file = (struct cch_backing_file *)*backing; - aki_file_munmap(&file->file, file->u.map); - aki_file_close(&file->file); + nn_file_munmap(&file->file, file->u.map); + nn_file_close(&file->file); al_array_free(file->backing.available); al_free(file); *backing = NULL; @@ -74,10 +74,10 @@ struct cch_backing *cch_backing_file_create(str *path, size_t size) file->backing.resize = file_backing_resize; file->backing.free = file_backing_free; al_array_init(file->backing.available); - if (!file_open_internal(file, path, size) || !(file->u.map = aki_file_mmap(&file->file))) { + if (!file_open_internal(file, path, size) || !(file->u.map = nn_file_mmap(&file->file))) { al_free(file); return NULL; } - aki_mutex_init(&file->mutex); + nn_mutex_init(&file->mutex); return (struct cch_backing *)file; } diff --git a/src/cache/backings/memory.c b/src/cache/backings/memory.c index 5db2063..aa5c1b4 100644 --- a/src/cache/backings/memory.c +++ b/src/cache/backings/memory.c @@ -13,28 +13,28 @@ static void ensure_alloced(struct cch_backing_memory *mem, size_t size) static void memory_backing_lock(struct cch_backing *backing) { struct cch_backing_memory *mem = (struct cch_backing_memory *)backing; - aki_mutex_lock(&mem->mutex); + nn_mutex_lock(&mem->mutex); } static void memory_backing_write(struct cch_backing *backing, u8 *buf, off_t index, size_t *size) { struct cch_backing_memory *mem = (struct cch_backing_memory *)backing; - aki_mutex_lock(&mem->mutex); + nn_mutex_lock(&mem->mutex); if (mem->size >= 0 && index + (off_t)*size >= mem->size) { - *size = MAX(mem->size - index, 0L); + *size = MAX(mem->size - index, (off_t)0L); } ensure_alloced(mem, index + *size); al_memcpy(mem->data + index, buf, *size); cch_backing_fill_range(&mem->backing, index, *size); - aki_mutex_unlock(&mem->mutex); + nn_mutex_unlock(&mem->mutex); } static u8 *memory_backing_get_ptr(struct cch_backing *backing, off_t index, size_t *size) { struct cch_backing_memory *mem = (struct cch_backing_memory *)backing; - aki_mutex_lock(&mem->mutex); + nn_mutex_lock(&mem->mutex); if (mem->size >= 0 && index + (off_t)*size >= mem->size) { - *size = MAX(mem->size - index, 0L); + *size = MAX(mem->size - index, (off_t)0L); } return (u8 *)(mem->data + index); } @@ -42,32 +42,32 @@ static u8 *memory_backing_get_ptr(struct cch_backing *backing, off_t index, size static void memory_backing_unlock(struct cch_backing *backing) { struct cch_backing_memory *mem = (struct cch_backing_memory *)backing; - aki_mutex_unlock(&mem->mutex); + nn_mutex_unlock(&mem->mutex); } static off_t memory_backing_get_size_estimate(struct cch_backing *backing) { struct cch_backing_memory *mem = (struct cch_backing_memory *)backing; - aki_mutex_lock(&mem->mutex); + nn_mutex_lock(&mem->mutex); off_t size = mem->size; - aki_mutex_unlock(&mem->mutex); + nn_mutex_unlock(&mem->mutex); return size; } static void memory_backing_resize(struct cch_backing *backing, size_t size) { struct cch_backing_memory *mem = (struct cch_backing_memory *)backing; - aki_mutex_lock(&mem->mutex); + nn_mutex_lock(&mem->mutex); ensure_alloced(mem, size); mem->size = size; - aki_mutex_unlock(&mem->mutex); + nn_mutex_unlock(&mem->mutex); } static void memory_backing_free(struct cch_backing **backing) { struct cch_backing_memory *mem = (struct cch_backing_memory *)*backing; al_free(mem->data); - aki_mutex_destroy(&mem->mutex); + nn_mutex_destroy(&mem->mutex); al_array_free(mem->backing.available); al_free(mem); *backing = NULL; @@ -87,7 +87,7 @@ struct cch_backing *cch_backing_memory_create(size_t size) mem->data = al_malloc(size); mem->alloc = size; mem->size = -1; - aki_mutex_init(&mem->mutex); + nn_mutex_init(&mem->mutex); al_array_init(mem->backing.available); return (struct cch_backing *)mem; } diff --git a/src/cache/backings/memory.h b/src/cache/backings/memory.h index 107ae4b..e290b48 100644 --- a/src/cache/backings/memory.h +++ b/src/cache/backings/memory.h @@ -1,7 +1,7 @@ #pragma once #include <al/lib.h> -#include <aki/thread.h> +#include <nnwt/thread.h> #include "../backing.h" @@ -10,7 +10,7 @@ struct cch_backing_memory { u8 *data; size_t alloc; off_t size; - struct aki_mutex mutex; + struct nn_mutex mutex; }; struct cch_backing *cch_backing_memory_create(size_t size); diff --git a/src/cache/entry.c b/src/cache/entry.c index 8068397..c7fb8d2 100644 --- a/src/cache/entry.c +++ b/src/cache/entry.c @@ -7,12 +7,12 @@ bool cch_entry_get_handle(struct cch_entry *entry, struct cch_handle *handle) handle->entry = entry; handle->pointer = 0; handle->prev_pointer = 0; - aki_cond_init(&handle->wait.cond); - aki_mutex_init(&handle->wait.mutex); + nn_cond_init(&handle->wait.cond); + nn_mutex_init(&handle->wait.mutex); handle->wait.disabled = false; - aki_mutex_lock(&entry->mutex); + nn_mutex_lock(&entry->mutex); entry->ref_count++; - aki_mutex_unlock(&entry->mutex); + nn_mutex_unlock(&entry->mutex); return true; } @@ -43,15 +43,15 @@ void cch_entry_return_handle(struct cch_entry *entry, struct cch_handle *handle) { handle->entry = NULL; entry->ref_count--; - aki_mutex_destroy(&handle->wait.mutex); - aki_cond_destroy(&handle->wait.cond); + nn_mutex_destroy(&handle->wait.mutex); + nn_cond_destroy(&handle->wait.cond); } void cch_entry_free(struct cch_entry **entry) { (*entry)->handler->free(&(*entry)->handler); (*entry)->backing->free(&(*entry)->backing); - aki_mutex_destroy(&(*entry)->mutex); + nn_mutex_destroy(&(*entry)->mutex); al_free(*entry); *entry = NULL; } diff --git a/src/cache/entry.h b/src/cache/entry.h index 3196809..4a20058 100644 --- a/src/cache/entry.h +++ b/src/cache/entry.h @@ -19,7 +19,7 @@ struct cch_entry { struct cch_chapter *chapter; struct cch_backing *backing; struct cch_handler *handler; - struct aki_mutex mutex; + struct nn_mutex mutex; }; bool cch_entry_get_handle(struct cch_entry *entry, struct cch_handle *handle); diff --git a/src/cache/handle.h b/src/cache/handle.h index ae936f3..fc84109 100644 --- a/src/cache/handle.h +++ b/src/cache/handle.h @@ -1,7 +1,7 @@ #pragma once #include <al/types.h> -#include <aki/thread.h> +#include <nnwt/thread.h> #include "wait.h" diff --git a/src/cache/handler.h b/src/cache/handler.h index 9dd1896..b4c6975 100644 --- a/src/cache/handler.h +++ b/src/cache/handler.h @@ -3,7 +3,7 @@ #include <al/types.h> #include <al/array.h> #include <al/str.h> -#include <aki/thread.h> +#include <nnwt/thread.h> #include "handle.h" @@ -15,6 +15,6 @@ struct cch_handler { struct cch_entry *entry; str liana; bool disabled; - struct aki_mutex mutex; + struct nn_mutex mutex; array(struct cch_handler_wait *) waits; }; diff --git a/src/cache/handlers/cdio.c b/src/cache/handlers/cdio.c index 23f87b6..b10bbf1 100644 --- a/src/cache/handlers/cdio.c +++ b/src/cache/handlers/cdio.c @@ -31,7 +31,7 @@ static bool handler_cdio_can_seek(struct cch_handler *handler) return true; } -static aki_thread_result AKI_THREADCALL cd_read_thread(void *userdata) +static nn_thread_result NNWT_THREADCALL cd_read_thread(void *userdata) { struct cch_handler_cdio *cdio = (struct cch_handler_cdio *)userdata; while (1) { @@ -41,7 +41,7 @@ static aki_thread_result AKI_THREADCALL cd_read_thread(void *userdata) } // cdio_read() here can block for a very long time so we buffer each read // before writing it to the backing. - long ret = cdio_cddap_read(cdio->drive, aki_buffer_get_ptr(&cdio->buffer, 0), cdio->sector, SECTORS_PER_STEP); + long ret = cdio_cddap_read(cdio->drive, nn_buffer_get_ptr(&cdio->buffer, 0), cdio->sector, SECTORS_PER_STEP); cdio_log_messages(cdio); al_assert(ret <= SECTORS_PER_STEP); off_t pointer = cdio->sector * CDIO_CD_FRAMESIZE_RAW; @@ -53,7 +53,7 @@ static aki_thread_result AKI_THREADCALL cd_read_thread(void *userdata) break; } if (ret == SECTORS_PER_STEP) { - al_memcpy(ptr, aki_buffer_get_ptr(&cdio->buffer, 0), BYTES_PER_STEP); + al_memcpy(ptr, nn_buffer_get_ptr(&cdio->buffer, 0), BYTES_PER_STEP); } else if (ret == -10) { al_log_error("cdio", "I/O error, skipping sector."); al_memset(ptr, 0, BYTES_PER_STEP); @@ -86,12 +86,12 @@ static void handler_cdio_maybe_spawn_worker(struct cch_handler *handler, size_t if (cdio->start == (lsn_t)index) return; if (al_atomic_load(s32)(&cdio->running, AL_ATOMIC_ACQUIRE)) { al_atomic_store(s32)(&cdio->running, 0, AL_ATOMIC_RELEASE); - aki_thread_join(&cdio->thread); + nn_thread_join(&cdio->thread); } cdio->start = index; cdio->sector = cdio->start; al_atomic_store(s32)(&cdio->running, 1, AL_ATOMIC_RELEASE); - aki_thread_create(&cdio->thread, cd_read_thread, cdio); + 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) @@ -106,7 +106,7 @@ static void handler_cdio_free(struct cch_handler **handler) cch_threaded_waits_disable_all(&cdio->handler); if (al_atomic_load(s32)(&cdio->running, AL_ATOMIC_RELAXED)) { al_atomic_store(s32)(&cdio->running, 0, AL_ATOMIC_RELAXED); - aki_thread_join(&cdio->thread); + nn_thread_join(&cdio->thread); } if (cdio->drive) { cdio_log_messages(cdio); @@ -189,7 +189,7 @@ struct cch_entry *cch_handler_cdio_create(void) entry->ref_count = 0; entry->unknown_size = false; entry->hash = 0; - aki_mutex_init(&entry->mutex); + 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; @@ -198,9 +198,9 @@ struct cch_entry *cch_handler_cdio_create(void) al_str_from(&entry->handler->liana, "cdio"); if (!open_cd_drive(cdio)) return NULL; al_atomic_store(s32)(&cdio->running, 0, AL_ATOMIC_RELAXED); - aki_buffer_init(&cdio->buffer); - aki_buffer_ensure_space(&cdio->buffer, BYTES_PER_STEP); - aki_buffer_set_size(&cdio->buffer, BYTES_PER_STEP); + nn_buffer_init(&cdio->buffer); + nn_buffer_ensure_space(&cdio->buffer, BYTES_PER_STEP); + nn_buffer_set_size(&cdio->buffer, BYTES_PER_STEP); cch_threaded_waits_init(&cdio->handler); return entry; } diff --git a/src/cache/handlers/cdio.h b/src/cache/handlers/cdio.h index 953c988..3a3966a 100644 --- a/src/cache/handlers/cdio.h +++ b/src/cache/handlers/cdio.h @@ -1,5 +1,5 @@ #include <al/atomic.h> -#include <aki/common.h> +#include <nnwt/common.h> #include <cdio/paranoia/cdda.h> #include <cdio/cd_types.h> @@ -13,9 +13,9 @@ struct cch_handler_cdio { lsn_t start; lsn_t end; lsn_t sector; + struct nn_buffer buffer; atomic(s32) running; - struct aki_thread thread; - struct aki_buffer buffer; + struct nn_thread thread; }; struct cch_entry *cch_handler_cdio_create(void); diff --git a/src/cache/handlers/file.c b/src/cache/handlers/file.c index 03e2814..c09aac0 100644 --- a/src/cache/handlers/file.c +++ b/src/cache/handlers/file.c @@ -42,7 +42,7 @@ struct cch_entry *cch_handler_file_create(str *path) entry->ref_count = 0; entry->unknown_size = false; entry->hash = 0; - aki_mutex_init(&entry->mutex); + 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 71ae186..308633e 100644 --- a/src/cache/handlers/http.c +++ b/src/cache/handlers/http.c @@ -21,39 +21,37 @@ static size_t http_callback(void *userdata, u8 op, u8 *buf, s64 int0) struct cch_handler_http *http = (struct cch_handler_http *)userdata; size_t ret = (size_t)int0; switch (op) { - case AKI_HTTP_FINISHED: { - al_log_debug("cache_handler_http", "Transfer finished."); - break; - } - case AKI_HTTP_ERROR: { - cch_threaded_waits_disable_all(&http->handler); + case NNWT_HTTP_READ: + al_assert_and_return(0); + case NNWT_HTTP_WRITE: { + // If we got data before a Content-Length, assume the size is unknown. + if (cch_entry_get_size(http->handler.entry) < 0) { + cch_entry_set_size(http->handler.entry, 0); + } + http->backing->write(http->backing, buf, http->pointer, &ret); + http->pointer += ret; + cch_threaded_waits_evaluate(&http->handler, http->backing); break; } - case AKI_HTTP_RESPONSE_CODE: { + case NNWT_HTTP_RESPONSE_CODE: al_log_debug("cache_handler_http", "HTTP %ld.", int0); break; - } - case AKI_HTTP_REDIRECT: { - al_log_debug("cache_handler_http", "Redirect."); - break; - } - case AKI_HTTP_CONTENT_LENGTH: { + case NNWT_HTTP_CONTENT_LENGTH: { off_t content_length = (off_t)int0; al_log_debug("cache_handler_http", "Content-Length: %lld.", content_length); cch_entry_set_size(http->handler.entry, content_length); cch_threaded_waits_signal_any(&http->handler); break; } - case AKI_HTTP_WRITE: { - // If we got data before a Content-Length, assume the size is unknown. - if (cch_entry_get_size(http->handler.entry) < 0) { - cch_entry_set_size(http->handler.entry, 0); - } - http->backing->write(http->backing, buf, http->pointer, &ret); - http->pointer += ret; - cch_threaded_waits_evaluate(&http->handler, http->backing); + case NNWT_HTTP_REDIRECT: + al_log_debug("cache_handler_http", "Redirect %ld.", int0); + break; + case NNWT_HTTP_FINISHED: + al_log_debug("cache_handler_http", "Transfer finished."); + break; + case NNWT_HTTP_ERROR: + cch_threaded_waits_disable_all(&http->handler); break; - } default: break; } @@ -64,12 +62,12 @@ static void handler_http_maybe_spawn_worker(struct cch_handler *handler, size_t { struct cch_handler_http *http = (struct cch_handler_http *)handler; (void)index; - al_array_push(http->requests, (struct aki_http){ 0 }); - struct aki_http *request = &al_array_last(http->requests); - aki_http_init(request); - aki_http_set_url(request, &http->url); - aki_http_set_user_agent(request, USER_AGENT); - aki_http_request_stream(request, AKI_HTTP_GET, http->loop, http_callback, http); + al_array_push(http->requests, (struct nn_http){ 0 }); + struct nn_http *request = &al_array_last(http->requests); + nn_http_init(request); + nn_http_set_url(request, &http->url); + nn_http_set_user_agent(request, USER_AGENT); + nn_http_request_stream(request, NNWT_HTTP_GET, http->loop, http_callback, http); } static bool handler_http_wait_for_range(struct cch_handler *handler, struct cch_handler_wait *wait) @@ -82,9 +80,9 @@ static void handler_http_free(struct cch_handler **handler) { struct cch_handler_http *http = (struct cch_handler_http *)*handler; cch_threaded_waits_disable_all(&http->handler); - struct aki_http *request; + struct nn_http *request; al_array_foreach_ptr(http->requests, i, request) { - aki_http_close(request); + nn_http_close(request); } cch_threaded_waits_close(&http->handler); al_array_free(http->requests); @@ -94,7 +92,7 @@ static void handler_http_free(struct cch_handler **handler) *handler = NULL; } -struct cch_entry *cch_handler_http_create(str *url, struct aki_event_loop *loop) +struct cch_entry *cch_handler_http_create(str *url, struct nn_event_loop *loop) { struct cch_backing *backing = cch_backing_memory_create(1024 * 128); if (!backing) return NULL; @@ -106,7 +104,7 @@ struct cch_entry *cch_handler_http_create(str *url, struct aki_event_loop *loop) entry->ref_count = 0; entry->unknown_size = false; entry->hash = 0; - aki_mutex_init(&entry->mutex); + 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 5f9df86..ef47173 100644 --- a/src/cache/handlers/http.h +++ b/src/cache/handlers/http.h @@ -1,8 +1,8 @@ #pragma once -#include <aki/http.h> -#include <aki/thread.h> -#include <aki/signal.h> +#include <nnwt/http.h> +#include <nnwt/thread.h> +#include <nnwt/signal.h> #include "../handler.h" #include "../entry.h" @@ -12,8 +12,8 @@ struct cch_handler_http { struct cch_backing *backing; str url; off_t pointer; - array(struct aki_http) requests; - struct aki_event_loop *loop; + array(struct nn_http) requests; + struct nn_event_loop *loop; }; -struct cch_entry *cch_handler_http_create(str *url, struct aki_event_loop *loop); +struct cch_entry *cch_handler_http_create(str *url, struct nn_event_loop *loop); diff --git a/src/cache/meson.build b/src/cache/meson.build index 5fb47ae..5b70c3c 100644 --- a/src/cache/meson.build +++ b/src/cache/meson.build @@ -6,6 +6,7 @@ cache_src = [ 'backings/memory.c' ] cache_deps = [] +cache_args = [] cache_have_cdio = false libcdio_paranoia = dependency('libcdio_paranoia', required: false, allow_fallback: true) @@ -13,6 +14,7 @@ libcdio_cdda = dependency('libcdio_cdda', required: false, allow_fallback: true) if libcdio_paranoia.found() and libcdio_cdda.found() cache_src += ['handlers/cdio.c'] cache_deps += [libcdio_paranoia, libcdio_cdda] + cache_args += ['-DCACHE_HAVE_CDIO'] cache_have_cdio = true endif @@ -22,14 +24,15 @@ endif #if libdvdcss.found() and libdvdread.found() and libdvdnav.found() #endif -if akiyo_has_mmap +if naunet_has_mmap cache_src += ['backings/file_mapped.c'] else cache_src += ['backings/file.c'] endif -if akiyo_has_curl +if naunet_has_curl cache_src += ['handlers/http.c'] endif -cache = declare_dependency(sources: cache_src, dependencies: cache_deps) +cache = declare_dependency(sources: cache_src, dependencies: cache_deps, + compile_args: cache_args) diff --git a/src/cache/threaded_waits.c b/src/cache/threaded_waits.c index 10f08f0..3bf67eb 100644 --- a/src/cache/threaded_waits.c +++ b/src/cache/threaded_waits.c @@ -4,7 +4,7 @@ void cch_threaded_waits_init(struct cch_handler *handler) { handler->disabled = false; - aki_mutex_init(&handler->mutex); + nn_mutex_init(&handler->mutex); al_array_init(handler->waits); } @@ -22,104 +22,98 @@ static bool wait_range_satisfied(struct cch_backing *backing, struct cch_handler bool cch_threaded_wait_for_range(struct cch_handler *handler, struct cch_backing *backing, struct cch_handler_wait *wait) { - aki_mutex_lock(&handler->mutex); + nn_mutex_lock(&handler->mutex); bool canceled = handler->disabled; off_t size = cch_entry_get_size(handler->entry); backing->lock(backing); bool satisfied = size >= 0 && wait_range_satisfied(backing, wait); backing->unlock(backing); if (!canceled && !satisfied) { - aki_mutex_lock(&wait->mutex); + nn_mutex_lock(&wait->mutex); if (!wait->disabled) { al_array_push(handler->waits, wait); - aki_mutex_unlock(&handler->mutex); - aki_cond_wait(&wait->cond, &wait->mutex); + nn_mutex_unlock(&handler->mutex); + nn_cond_wait(&wait->cond, &wait->mutex); } else { - aki_mutex_unlock(&wait->mutex); - aki_mutex_unlock(&handler->mutex); + nn_mutex_unlock(&wait->mutex); + nn_mutex_unlock(&handler->mutex); return false; } - aki_mutex_unlock(&wait->mutex); - aki_mutex_lock(&handler->mutex); + nn_mutex_unlock(&wait->mutex); + nn_mutex_lock(&handler->mutex); if (wait->disabled) { - struct cch_handler_wait *rwait; - al_array_foreach(handler->waits, i, rwait) { - if (rwait == wait) { - al_array_remove_at(handler->waits, i); - break; - } - } + al_array_remove(handler->waits, wait); canceled = true; } } - aki_mutex_unlock(&handler->mutex); + nn_mutex_unlock(&handler->mutex); return !canceled; } void cch_threaded_waits_signal_any(struct cch_handler *handler) { - aki_mutex_lock(&handler->mutex); + nn_mutex_lock(&handler->mutex); struct cch_handler_wait *wait; al_array_foreach_rev(handler->waits, i, wait) { if (wait->end < 0) { al_array_remove_at(handler->waits, i); - aki_mutex_lock(&wait->mutex); - aki_cond_signal(&wait->cond); - aki_mutex_unlock(&wait->mutex); + nn_mutex_lock(&wait->mutex); + nn_cond_signal(&wait->cond); + nn_mutex_unlock(&wait->mutex); } } - aki_mutex_unlock(&handler->mutex); + nn_mutex_unlock(&handler->mutex); } void cch_threaded_wait_disable(struct cch_handler_wait *wait) { - aki_mutex_lock(&wait->mutex); + nn_mutex_lock(&wait->mutex); wait->disabled = true; // cond_is_waiting() could be false if the handler is disabled. - if (aki_cond_is_waiting(&wait->cond)) { - aki_cond_signal(&wait->cond); + if (nn_cond_is_waiting(&wait->cond)) { + nn_cond_signal(&wait->cond); } - aki_mutex_unlock(&wait->mutex); + nn_mutex_unlock(&wait->mutex); } void cch_threaded_waits_disable_all(struct cch_handler *handler) { - aki_mutex_lock(&handler->mutex); + nn_mutex_lock(&handler->mutex); if (handler->disabled) { - aki_mutex_unlock(&handler->mutex); + nn_mutex_unlock(&handler->mutex); return; } // Disallow any further waits. handler->disabled = true; struct cch_handler_wait *wait; al_array_foreach(handler->waits, i, wait) { - aki_mutex_lock(&wait->mutex); + nn_mutex_lock(&wait->mutex); wait->disabled = true; - aki_cond_signal(&wait->cond); - aki_mutex_unlock(&wait->mutex); + nn_cond_signal(&wait->cond); + nn_mutex_unlock(&wait->mutex); } - aki_mutex_unlock(&handler->mutex); + nn_mutex_unlock(&handler->mutex); } void cch_threaded_waits_evaluate(struct cch_handler *handler, struct cch_backing *backing) { - aki_mutex_lock(&handler->mutex); + nn_mutex_lock(&handler->mutex); backing->lock(backing); struct cch_handler_wait *wait; al_array_foreach_rev(handler->waits, i, wait) { - aki_mutex_lock(&wait->mutex); + nn_mutex_lock(&wait->mutex); if (wait_range_satisfied(backing, wait)) { - aki_cond_signal(&wait->cond); + nn_cond_signal(&wait->cond); al_array_remove_at(handler->waits, i); } - aki_mutex_unlock(&wait->mutex); + nn_mutex_unlock(&wait->mutex); } backing->unlock(backing); - aki_mutex_unlock(&handler->mutex); + nn_mutex_unlock(&handler->mutex); } void cch_threaded_waits_close(struct cch_handler *handler) { - aki_mutex_destroy(&handler->mutex); + nn_mutex_destroy(&handler->mutex); al_array_free(handler->waits); } diff --git a/src/cache/wait.h b/src/cache/wait.h index 8654362..4c9b228 100644 --- a/src/cache/wait.h +++ b/src/cache/wait.h @@ -1,10 +1,10 @@ #pragma once -#include <aki/thread.h> +#include <nnwt/thread.h> struct cch_handler_wait { off_t start, end; - struct aki_cond cond; - struct aki_mutex mutex; + struct nn_cond cond; + struct nn_mutex mutex; bool disabled; }; diff --git a/src/codec/codec.h b/src/codec/codec.h index a9b188a..697f456 100644 --- a/src/codec/codec.h +++ b/src/codec/codec.h @@ -1,7 +1,7 @@ #pragma once #include <al/array.h> -#include <aki/common.h> +#include <nnwt/common.h> #ifdef CAMU_HAVE_FFMPEG #include <libavutil/pixdesc.h> #include <libavformat/avformat.h> @@ -141,7 +141,7 @@ struct camu_codec_stream { struct camu_codec_packet { u8 mode; - struct aki_buffer *buffer; + struct nn_buffer *buffer; #ifdef CAMU_HAVE_FFMPEG struct { AVPacket *pkt; } av; #endif diff --git a/src/codec/ffmpeg/common.c b/src/codec/ffmpeg/common.c index c147d81..16bbeab 100644 --- a/src/codec/ffmpeg/common.c +++ b/src/codec/ffmpeg/common.c @@ -22,7 +22,7 @@ static void av_log_callback(void *userdata, int level, const char *fmt, va_list if (level < AV_LOG_DEBUG) { pos += al_vsnprintf(&buf[pos], CHUNK_SIZE, fmt, args); if (buf[pos - 1] == '\n' || pos >= CHUNK_SIZE) { - al_log_info("ff_log", buf); + al_log_info("ff", buf); pos = 0; } } diff --git a/src/codec/ffmpeg/encoder.c b/src/codec/ffmpeg/encoder.c index 6e914c8..7c7b010 100644 --- a/src/codec/ffmpeg/encoder.c +++ b/src/codec/ffmpeg/encoder.c @@ -99,7 +99,7 @@ void camu_ff_encoder_push(struct camu_ff_encoder *enc, u8 **data, s32 sample_cou return; } AVPacket pkt = { 0 }; - do { + for (;;) { ret = avcodec_receive_packet(enc->codec_context, &pkt); if (ret < 0) { if (!(ret = AVERROR_EOF || ret == AVERROR(EAGAIN))) { @@ -109,7 +109,7 @@ void camu_ff_encoder_push(struct camu_ff_encoder *enc, u8 **data, s32 sample_cou } enc->callback(enc->userdata, &pkt); enc->frame->pts += SAMPLES_PER_FRAME; - } while (1); + } } void camu_ff_encoder_reset(struct camu_ff_encoder *enc) diff --git a/src/codec/ffmpeg/packet_ext.c b/src/codec/ffmpeg/packet_ext.c index 16f5748..759719b 100644 --- a/src/codec/ffmpeg/packet_ext.c +++ b/src/codec/ffmpeg/packet_ext.c @@ -1,201 +1,201 @@ #include "packet_ext.h" -void aki_packet_write_av_codec_parameters(struct aki_packet *packet, AVCodecParameters *codecpar) +void nn_packet_write_av_codec_parameters(struct nn_packet *packet, AVCodecParameters *codecpar) { - AKI_PACKET_WRITE_TYPE(packet, enum AVMediaType, codecpar->codec_type); - AKI_PACKET_WRITE_TYPE(packet, enum AVCodecID, codecpar->codec_id); - AKI_PACKET_WRITE_TYPE(packet, u32, codecpar->codec_tag); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->extradata_size); - AKI_PACKET_WRITE_DATA(packet, codecpar->extradata, codecpar->extradata_size); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->format); - AKI_PACKET_WRITE_TYPE(packet, s64, codecpar->bit_rate); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->bits_per_coded_sample); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->bits_per_raw_sample); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->profile); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->level); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->width); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->height); - AKI_PACKET_WRITE_TYPE(packet, AVRational, codecpar->sample_aspect_ratio); - AKI_PACKET_WRITE_TYPE(packet, AVRational, codecpar->framerate); - AKI_PACKET_WRITE_TYPE(packet, enum AVFieldOrder, codecpar->field_order); - AKI_PACKET_WRITE_TYPE(packet, enum AVColorRange, codecpar->color_range); - AKI_PACKET_WRITE_TYPE(packet, enum AVColorPrimaries, codecpar->color_primaries); - AKI_PACKET_WRITE_TYPE(packet, enum AVColorTransferCharacteristic, codecpar->color_trc); - AKI_PACKET_WRITE_TYPE(packet, enum AVColorSpace, codecpar->color_space); - AKI_PACKET_WRITE_TYPE(packet, enum AVChromaLocation, codecpar->chroma_location); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->video_delay); - AKI_PACKET_WRITE_TYPE(packet, AVChannelLayout, codecpar->ch_layout); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->sample_rate); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->block_align); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->frame_size); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->initial_padding); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->trailing_padding); - AKI_PACKET_WRITE_TYPE(packet, s32, codecpar->seek_preroll); + NNWT_PACKET_WRITE_TYPE(packet, enum AVMediaType, codecpar->codec_type); + NNWT_PACKET_WRITE_TYPE(packet, enum AVCodecID, codecpar->codec_id); + NNWT_PACKET_WRITE_TYPE(packet, u32, codecpar->codec_tag); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->extradata_size); + NNWT_PACKET_WRITE_DATA(packet, codecpar->extradata, codecpar->extradata_size); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->format); + NNWT_PACKET_WRITE_TYPE(packet, s64, codecpar->bit_rate); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->bits_per_coded_sample); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->bits_per_raw_sample); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->profile); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->level); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->width); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->height); + NNWT_PACKET_WRITE_TYPE(packet, AVRational, codecpar->sample_aspect_ratio); + NNWT_PACKET_WRITE_TYPE(packet, AVRational, codecpar->framerate); + NNWT_PACKET_WRITE_TYPE(packet, enum AVFieldOrder, codecpar->field_order); + NNWT_PACKET_WRITE_TYPE(packet, enum AVColorRange, codecpar->color_range); + NNWT_PACKET_WRITE_TYPE(packet, enum AVColorPrimaries, codecpar->color_primaries); + NNWT_PACKET_WRITE_TYPE(packet, enum AVColorTransferCharacteristic, codecpar->color_trc); + NNWT_PACKET_WRITE_TYPE(packet, enum AVColorSpace, codecpar->color_space); + NNWT_PACKET_WRITE_TYPE(packet, enum AVChromaLocation, codecpar->chroma_location); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->video_delay); + NNWT_PACKET_WRITE_TYPE(packet, AVChannelLayout, codecpar->ch_layout); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->sample_rate); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->block_align); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->frame_size); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->initial_padding); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->trailing_padding); + NNWT_PACKET_WRITE_TYPE(packet, s32, codecpar->seek_preroll); } -void aki_packet_write_av_codec_id(struct aki_packet *packet, enum AVCodecID codec_id) +void nn_packet_write_av_codec_id(struct nn_packet *packet, enum AVCodecID codec_id) { - AKI_PACKET_WRITE_TYPE(packet, enum AVCodecID, codec_id); + NNWT_PACKET_WRITE_TYPE(packet, enum AVCodecID, codec_id); } -void aki_packet_write_av_dictionary(struct aki_packet *packet, AVDictionary *dict) +void nn_packet_write_av_dictionary(struct nn_packet *packet, AVDictionary *dict) { s32 count = av_dict_count(dict); - AKI_PACKET_WRITE_TYPE(packet, s32, count); + NNWT_PACKET_WRITE_TYPE(packet, s32, count); const AVDictionaryEntry *entry = NULL; while ((entry = av_dict_iterate(dict, entry))) { size_t len = al_strlen(entry->key); al_assert(len <= UINT32_MAX); - AKI_PACKET_WRITE_TYPE(packet, u32, len); - AKI_PACKET_WRITE_DATA(packet, entry->key, len); + NNWT_PACKET_WRITE_TYPE(packet, u32, len); + NNWT_PACKET_WRITE_DATA(packet, entry->key, len); len = al_strlen(entry->value); al_assert(len <= UINT32_MAX); - AKI_PACKET_WRITE_TYPE(packet, u32, len); - AKI_PACKET_WRITE_DATA(packet, entry->value, len); + NNWT_PACKET_WRITE_TYPE(packet, u32, len); + NNWT_PACKET_WRITE_DATA(packet, entry->value, len); } } -void aki_packet_write_av_stream(struct aki_packet *packet, AVStream *stream) +void nn_packet_write_av_stream(struct nn_packet *packet, AVStream *stream) { - AKI_PACKET_WRITE_TYPE(packet, s32, stream->index); - aki_packet_write_av_codec_parameters(packet, stream->codecpar); - AKI_PACKET_WRITE_TYPE(packet, AVRational, stream->time_base); - AKI_PACKET_WRITE_TYPE(packet, s64, stream->duration); - AKI_PACKET_WRITE_TYPE(packet, s64, stream->start_time); - AKI_PACKET_WRITE_TYPE(packet, s64, stream->nb_frames); - aki_packet_write_av_dictionary(packet, stream->metadata); + NNWT_PACKET_WRITE_TYPE(packet, s32, stream->index); + nn_packet_write_av_codec_parameters(packet, stream->codecpar); + NNWT_PACKET_WRITE_TYPE(packet, AVRational, stream->time_base); + NNWT_PACKET_WRITE_TYPE(packet, s64, stream->duration); + NNWT_PACKET_WRITE_TYPE(packet, s64, stream->start_time); + NNWT_PACKET_WRITE_TYPE(packet, s64, stream->nb_frames); + nn_packet_write_av_dictionary(packet, stream->metadata); if (stream->avg_frame_rate.den == 0) { - // r_frame_rate.den == 0 handled on the client. - AKI_PACKET_WRITE_TYPE(packet, AVRational, stream->r_frame_rate); + // r_frame_rate.den = 0 handled on the client. + NNWT_PACKET_WRITE_TYPE(packet, AVRational, stream->r_frame_rate); } else { - AKI_PACKET_WRITE_TYPE(packet, AVRational, stream->avg_frame_rate); + NNWT_PACKET_WRITE_TYPE(packet, AVRational, stream->avg_frame_rate); } } -void aki_packet_write_av_packet(struct aki_packet *packet, AVPacket *pkt) +void nn_packet_write_av_packet(struct nn_packet *packet, AVPacket *pkt) { - AKI_PACKET_WRITE_TYPE(packet, s64, pkt->pts); - AKI_PACKET_WRITE_TYPE(packet, s64, pkt->dts); - AKI_PACKET_WRITE_TYPE(packet, s32, pkt->size); - AKI_PACKET_WRITE_DATA(packet, pkt->data, pkt->size); - AKI_PACKET_WRITE_TYPE(packet, s32, pkt->stream_index); - AKI_PACKET_WRITE_TYPE(packet, s32, pkt->flags); - AKI_PACKET_WRITE_TYPE(packet, s32, pkt->side_data_elems); + NNWT_PACKET_WRITE_TYPE(packet, s64, pkt->pts); + NNWT_PACKET_WRITE_TYPE(packet, s64, pkt->dts); + NNWT_PACKET_WRITE_TYPE(packet, s32, pkt->size); + NNWT_PACKET_WRITE_DATA(packet, pkt->data, pkt->size); + NNWT_PACKET_WRITE_TYPE(packet, s32, pkt->stream_index); + NNWT_PACKET_WRITE_TYPE(packet, s32, pkt->flags); + NNWT_PACKET_WRITE_TYPE(packet, s32, pkt->side_data_elems); for (s32 i = 0; i < pkt->side_data_elems; i++) { // Possibly upcast size_t. s64 size = (s64)pkt->side_data[i].size; - AKI_PACKET_WRITE_TYPE(packet, s64, size); - AKI_PACKET_WRITE_DATA(packet, pkt->side_data[i].data, pkt->side_data[i].size); - AKI_PACKET_WRITE_TYPE(packet, enum AVPacketSideDataType, pkt->side_data[i].type); + NNWT_PACKET_WRITE_TYPE(packet, s64, size); + NNWT_PACKET_WRITE_DATA(packet, pkt->side_data[i].data, pkt->side_data[i].size); + NNWT_PACKET_WRITE_TYPE(packet, enum AVPacketSideDataType, pkt->side_data[i].type); } - AKI_PACKET_WRITE_TYPE(packet, s64, pkt->duration); - AKI_PACKET_WRITE_TYPE(packet, s64, pkt->pos); - AKI_PACKET_WRITE_TYPE(packet, AVRational, pkt->time_base); + NNWT_PACKET_WRITE_TYPE(packet, s64, pkt->duration); + NNWT_PACKET_WRITE_TYPE(packet, s64, pkt->pos); + NNWT_PACKET_WRITE_TYPE(packet, AVRational, pkt->time_base); } -void aki_packet_read_av_codec_parameters(struct aki_packet *packet, AVCodecParameters *codecpar) +void nn_packet_read_av_codec_parameters(struct nn_packet *packet, AVCodecParameters *codecpar) { - AKI_PACKET_READ_TYPE(packet, enum AVMediaType, codecpar->codec_type); - AKI_PACKET_READ_TYPE(packet, enum AVCodecID, codecpar->codec_id); - AKI_PACKET_READ_TYPE(packet, u32, codecpar->codec_tag); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->extradata_size); + NNWT_PACKET_READ_TYPE(packet, enum AVMediaType, codecpar->codec_type); + NNWT_PACKET_READ_TYPE(packet, enum AVCodecID, codecpar->codec_id); + NNWT_PACKET_READ_TYPE(packet, u32, codecpar->codec_tag); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->extradata_size); codecpar->extradata = av_malloc(codecpar->extradata_size); u8 *extradata; - AKI_PACKET_READ_DATA(packet, codecpar->extradata_size, extradata); + NNWT_PACKET_READ_DATA(packet, codecpar->extradata_size, extradata); al_memcpy(codecpar->extradata, extradata, codecpar->extradata_size); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->format); - AKI_PACKET_READ_TYPE(packet, s64, codecpar->bit_rate); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->bits_per_coded_sample); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->bits_per_raw_sample); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->profile); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->level); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->width); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->height); - AKI_PACKET_READ_TYPE(packet, AVRational, codecpar->sample_aspect_ratio); - AKI_PACKET_READ_TYPE(packet, AVRational, codecpar->framerate); - AKI_PACKET_READ_TYPE(packet, enum AVFieldOrder, codecpar->field_order); - AKI_PACKET_READ_TYPE(packet, enum AVColorRange, codecpar->color_range); - AKI_PACKET_READ_TYPE(packet, enum AVColorPrimaries, codecpar->color_primaries); - AKI_PACKET_READ_TYPE(packet, enum AVColorTransferCharacteristic, codecpar->color_trc); - AKI_PACKET_READ_TYPE(packet, enum AVColorSpace, codecpar->color_space); - AKI_PACKET_READ_TYPE(packet, enum AVChromaLocation, codecpar->chroma_location); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->video_delay); - AKI_PACKET_READ_TYPE(packet, AVChannelLayout, codecpar->ch_layout); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->sample_rate); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->block_align); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->frame_size); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->initial_padding); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->trailing_padding); - AKI_PACKET_READ_TYPE(packet, s32, codecpar->seek_preroll); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->format); + NNWT_PACKET_READ_TYPE(packet, s64, codecpar->bit_rate); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->bits_per_coded_sample); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->bits_per_raw_sample); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->profile); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->level); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->width); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->height); + NNWT_PACKET_READ_TYPE(packet, AVRational, codecpar->sample_aspect_ratio); + NNWT_PACKET_READ_TYPE(packet, AVRational, codecpar->framerate); + NNWT_PACKET_READ_TYPE(packet, enum AVFieldOrder, codecpar->field_order); + NNWT_PACKET_READ_TYPE(packet, enum AVColorRange, codecpar->color_range); + NNWT_PACKET_READ_TYPE(packet, enum AVColorPrimaries, codecpar->color_primaries); + NNWT_PACKET_READ_TYPE(packet, enum AVColorTransferCharacteristic, codecpar->color_trc); + NNWT_PACKET_READ_TYPE(packet, enum AVColorSpace, codecpar->color_space); + NNWT_PACKET_READ_TYPE(packet, enum AVChromaLocation, codecpar->chroma_location); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->video_delay); + NNWT_PACKET_READ_TYPE(packet, AVChannelLayout, codecpar->ch_layout); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->sample_rate); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->block_align); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->frame_size); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->initial_padding); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->trailing_padding); + NNWT_PACKET_READ_TYPE(packet, s32, codecpar->seek_preroll); } -enum AVCodecID aki_packet_read_av_codec_id(struct aki_packet *packet) +enum AVCodecID nn_packet_read_av_codec_id(struct nn_packet *packet) { enum AVCodecID id; - AKI_PACKET_READ_TYPE(packet, enum AVCodecID, id); + NNWT_PACKET_READ_TYPE(packet, enum AVCodecID, id); return id; } -void aki_packet_read_av_dictionary(struct aki_packet *packet, AVDictionary **dict) +void nn_packet_read_av_dictionary(struct nn_packet *packet, AVDictionary **dict) { s32 count; - AKI_PACKET_READ_TYPE(packet, s32, count); + NNWT_PACKET_READ_TYPE(packet, s32, count); for (s32 i = 0; i < count; i++) { char *key, *value; u32 len; - AKI_PACKET_READ_TYPE(packet, u32, len); - AKI_PACKET_READ_DATA(packet, len, key); + NNWT_PACKET_READ_TYPE(packet, u32, len); + NNWT_PACKET_READ_DATA(packet, len, key); // Key and value MUST be allocated with av_malloc functions // just like all FFmpeg structures. key = av_strndup(key, len); - AKI_PACKET_READ_TYPE(packet, u32, len); - AKI_PACKET_READ_DATA(packet, len, value); + NNWT_PACKET_READ_TYPE(packet, u32, len); + NNWT_PACKET_READ_DATA(packet, len, value); value = av_strndup(value, len); av_dict_set(dict, key, value, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL); } } -AVStream *aki_packet_read_av_stream(AVFormatContext *format_context, const AVCodec *codec, struct aki_packet *packet) +AVStream *nn_packet_read_av_stream(AVFormatContext *format_context, const AVCodec *codec, struct nn_packet *packet) { AVStream *stream = avformat_new_stream(format_context, codec); - AKI_PACKET_READ_TYPE(packet, s32, stream->index); - aki_packet_read_av_codec_parameters(packet, stream->codecpar); - AKI_PACKET_READ_TYPE(packet, AVRational, stream->time_base); - AKI_PACKET_READ_TYPE(packet, s64, stream->duration); - AKI_PACKET_READ_TYPE(packet, s64, stream->start_time); - AKI_PACKET_READ_TYPE(packet, s64, stream->nb_frames); + NNWT_PACKET_READ_TYPE(packet, s32, stream->index); + nn_packet_read_av_codec_parameters(packet, stream->codecpar); + NNWT_PACKET_READ_TYPE(packet, AVRational, stream->time_base); + NNWT_PACKET_READ_TYPE(packet, s64, stream->duration); + NNWT_PACKET_READ_TYPE(packet, s64, stream->start_time); + NNWT_PACKET_READ_TYPE(packet, s64, stream->nb_frames); stream->metadata = NULL; - aki_packet_read_av_dictionary(packet, &stream->metadata); - AKI_PACKET_READ_TYPE(packet, AVRational, stream->avg_frame_rate); + nn_packet_read_av_dictionary(packet, &stream->metadata); + NNWT_PACKET_READ_TYPE(packet, AVRational, stream->avg_frame_rate); return stream; } -AVPacket *aki_packet_read_av_packet(struct aki_packet *packet) +AVPacket *nn_packet_read_av_packet(struct nn_packet *packet) { AVPacket *pkt = av_packet_alloc(); - AKI_PACKET_READ_TYPE(packet, s64, pkt->pts); - AKI_PACKET_READ_TYPE(packet, s64, pkt->dts); - AKI_PACKET_READ_TYPE(packet, s32, pkt->size); - AKI_PACKET_READ_DATA(packet, pkt->size, pkt->data); - AKI_PACKET_READ_TYPE(packet, s32, pkt->stream_index); - AKI_PACKET_READ_TYPE(packet, s32, pkt->flags); + NNWT_PACKET_READ_TYPE(packet, s64, pkt->pts); + NNWT_PACKET_READ_TYPE(packet, s64, pkt->dts); + NNWT_PACKET_READ_TYPE(packet, s32, pkt->size); + NNWT_PACKET_READ_DATA(packet, pkt->size, pkt->data); + NNWT_PACKET_READ_TYPE(packet, s32, pkt->stream_index); + NNWT_PACKET_READ_TYPE(packet, s32, pkt->flags); s32 side_data_elems; - AKI_PACKET_READ_TYPE(packet, s32, side_data_elems); + NNWT_PACKET_READ_TYPE(packet, s32, side_data_elems); pkt->side_data_elems = 0; for (s32 i = 0; i < side_data_elems; i++) { u8 *data; enum AVPacketSideDataType type; s64 storage_for_size; - AKI_PACKET_READ_TYPE(packet, s64, storage_for_size); + NNWT_PACKET_READ_TYPE(packet, s64, storage_for_size); al_assert((sizeof(size_t) > 4 || storage_for_size <= INT32_MAX)); size_t size = (size_t)storage_for_size; - AKI_PACKET_READ_DATA(packet, size, data); - AKI_PACKET_READ_TYPE(packet, enum AVPacketSideDataType, type); + NNWT_PACKET_READ_DATA(packet, size, data); + NNWT_PACKET_READ_TYPE(packet, enum AVPacketSideDataType, type); u8 *side_data = av_packet_new_side_data(pkt, type, size); al_memcpy(side_data, data, size); } - AKI_PACKET_READ_TYPE(packet, s64, pkt->duration); - AKI_PACKET_READ_TYPE(packet, s64, pkt->pos); - AKI_PACKET_READ_TYPE(packet, AVRational, pkt->time_base); + NNWT_PACKET_READ_TYPE(packet, s64, pkt->duration); + NNWT_PACKET_READ_TYPE(packet, s64, pkt->pos); + NNWT_PACKET_READ_TYPE(packet, AVRational, pkt->time_base); return pkt; } diff --git a/src/codec/ffmpeg/packet_ext.h b/src/codec/ffmpeg/packet_ext.h index 26a1392..91254c2 100644 --- a/src/codec/ffmpeg/packet_ext.h +++ b/src/codec/ffmpeg/packet_ext.h @@ -1,19 +1,17 @@ #pragma once -#include <aki/common.h> -#include <aki/event_loop.h> - +#include <nnwt/packet.h> #include <libavcodec/packet.h> #include <libavcodec/codec_par.h> #include <libavformat/avformat.h> #include <libavutil/dict.h> -void aki_packet_write_av_codec_parameters(struct aki_packet *packet, AVCodecParameters *codecpar); -void aki_packet_write_av_codec_id(struct aki_packet *packet, enum AVCodecID codec_id); -void aki_packet_write_av_stream(struct aki_packet *packet, AVStream *stream); -void aki_packet_write_av_packet(struct aki_packet *packet, AVPacket *pkt); +void nn_packet_write_av_codec_parameters(struct nn_packet *packet, AVCodecParameters *codecpar); +void nn_packet_write_av_codec_id(struct nn_packet *packet, enum AVCodecID codec_id); +void nn_packet_write_av_stream(struct nn_packet *packet, AVStream *stream); +void nn_packet_write_av_packet(struct nn_packet *packet, AVPacket *pkt); -void aki_packet_read_av_codec_parameters(struct aki_packet *packet, AVCodecParameters *codecpar); -enum AVCodecID aki_packet_read_av_codec_id(struct aki_packet *packet); -AVStream *aki_packet_read_av_stream(AVFormatContext *format_context, const AVCodec *codec, struct aki_packet *packet); -AVPacket *aki_packet_read_av_packet(struct aki_packet *packet); +void nn_packet_read_av_codec_parameters(struct nn_packet *packet, AVCodecParameters *codecpar); +enum AVCodecID nn_packet_read_av_codec_id(struct nn_packet *packet); +AVStream *nn_packet_read_av_stream(AVFormatContext *format_context, const AVCodec *codec, struct nn_packet *packet); +AVPacket *nn_packet_read_av_packet(struct nn_packet *packet); diff --git a/src/codec/spng/demuxer.h b/src/codec/spng/demuxer.h index 1947bb7..bd89ef1 100644 --- a/src/codec/spng/demuxer.h +++ b/src/codec/spng/demuxer.h @@ -5,7 +5,7 @@ struct camu_spng_demuxer { struct camu_demuxer demux; struct cch_handle *handle; - struct aki_buffer buffer; + struct nn_buffer buffer; bool eof; }; diff --git a/src/codec/spng/impl.c b/src/codec/spng/impl.c index 198d514..58b68f6 100644 --- a/src/codec/spng/impl.c +++ b/src/codec/spng/impl.c @@ -1,5 +1,5 @@ #include <al/lib.h> -#include <aki/common.h> +#include <nnwt/common.h> #include <spng.h> #include "../../cache/entry.h" @@ -14,17 +14,17 @@ static bool spng_demuxer_init(struct camu_demuxer *demux, struct cch_handle *han struct camu_spng_demuxer *spng = (struct camu_spng_demuxer *)demux; spng->handle = handle; - aki_buffer_init(&spng->buffer); + nn_buffer_init(&spng->buffer); spng->eof = false; cch_handle_seek(spng->handle, 0, SEEK_SET); off_t size = cch_entry_get_size(spng->handle->entry); - aki_buffer_ensure_space(&spng->buffer, size); - cch_handle_read(spng->handle, aki_buffer_get_ptr(&spng->buffer, 0), size); + nn_buffer_ensure_space(&spng->buffer, size); + cch_handle_read(spng->handle, nn_buffer_get_ptr(&spng->buffer, 0), size); spng->buffer.size = size; spng_ctx *ctx = spng_ctx_new(SPNG_CTX_IGNORE_ADLER32); - spng_set_png_buffer(ctx, aki_buffer_get_ptr(&spng->buffer, 0), spng->buffer.size); + spng_set_png_buffer(ctx, nn_buffer_get_ptr(&spng->buffer, 0), spng->buffer.size); spng_set_option(ctx, SPNG_CHUNK_COUNT_LIMIT, 6250); spng_set_crc_action(ctx, SPNG_CRC_DISCARD, SPNG_CRC_DISCARD); @@ -73,7 +73,7 @@ static bool spng_demuxer_seek(struct camu_demuxer *demux, u64 pos) static void spng_demuxer_free(struct camu_demuxer **demux) { struct camu_spng_demuxer *spng = (struct camu_spng_demuxer *)*demux; - aki_buffer_free(&spng->buffer); + nn_buffer_free(&spng->buffer); al_array_free(spng->demux.streams); al_free(spng); *demux = NULL; @@ -96,7 +96,7 @@ static s32 spng_decoder_push(struct camu_decoder *dec, struct camu_codec_packet if (!packet) return CAMU_OK; spng_ctx *ctx = spng_ctx_new(SPNG_CTX_IGNORE_ADLER32); - spng_set_png_buffer(ctx, aki_buffer_get_ptr(packet->buffer, 0), packet->buffer->size); + spng_set_png_buffer(ctx, nn_buffer_get_ptr(packet->buffer, 0), packet->buffer->size); spng_set_option(ctx, SPNG_CHUNK_COUNT_LIMIT, 6250); spng_set_crc_action(ctx, SPNG_CRC_DISCARD, SPNG_CRC_DISCARD); diff --git a/src/codec/stb_image/demuxer.h b/src/codec/stb_image/demuxer.h index 52f9256..d64e311 100644 --- a/src/codec/stb_image/demuxer.h +++ b/src/codec/stb_image/demuxer.h @@ -5,7 +5,7 @@ struct camu_stbi_demuxer { struct camu_demuxer demux; struct cch_handle *handle; - struct aki_buffer buffer; + struct nn_buffer buffer; bool eof; }; diff --git a/src/codec/stb_image/impl.c b/src/codec/stb_image/impl.c index ac1cbc5..bb38844 100644 --- a/src/codec/stb_image/impl.c +++ b/src/codec/stb_image/impl.c @@ -1,5 +1,5 @@ #include <al/lib.h> -#include <aki/common.h> +#include <nnwt/common.h> #include "../common.h" #define STB_IMAGE_IMPLEMENTATION #define STB_IMAGE_STATIC @@ -22,17 +22,17 @@ static bool stbi_demuxer_init(struct camu_demuxer *demux, struct cch_handle *han struct camu_stbi_demuxer *stb = (struct camu_stbi_demuxer *)demux; stb->handle = handle; - aki_buffer_init(&stb->buffer); + nn_buffer_init(&stb->buffer); stb->eof = false; cch_handle_seek(stb->handle, 0, SEEK_SET); off_t size = cch_entry_get_size(stb->handle->entry); - aki_buffer_ensure_space(&stb->buffer, size); - cch_handle_read(stb->handle, aki_buffer_get_ptr(&stb->buffer, 0), size); + nn_buffer_ensure_space(&stb->buffer, size); + cch_handle_read(stb->handle, nn_buffer_get_ptr(&stb->buffer, 0), size); stb->buffer.size = size; s32 w, h, channels; - u8 *data = aki_buffer_get_ptr(&stb->buffer, 0); + u8 *data = nn_buffer_get_ptr(&stb->buffer, 0); if (!stbi_info_from_memory(data, stb->buffer.size, &w, &h, &channels)) { goto err; } @@ -80,7 +80,7 @@ static bool stbi_demuxer_seek(struct camu_demuxer *demux, u64 pos) static void stbi_demuxer_free(struct camu_demuxer **demux) { struct camu_stbi_demuxer *stb = (struct camu_stbi_demuxer *)*demux; - aki_buffer_free(&stb->buffer); + nn_buffer_free(&stb->buffer); al_array_free(stb->demux.streams); al_free(stb); *demux = NULL; @@ -104,7 +104,7 @@ static s32 stbi_decoder_push(struct camu_decoder *dec, struct camu_codec_packet if (!packet) return CAMU_OK; s32 w, h, channels; - u8 *data = aki_buffer_get_ptr(packet->buffer, 0); + u8 *data = nn_buffer_get_ptr(packet->buffer, 0); u8 *pixels = stbi_load_from_memory(data, packet->buffer->size, &w, &h, &channels, 0); if (!pixels) return CAMU_ERR_ERROR; struct camu_video_format *fmt = &stb->stream->video.fmt; diff --git a/src/codec/wuffs/demuxer.h b/src/codec/wuffs/demuxer.h index 6e9e391..c2cb8a5 100644 --- a/src/codec/wuffs/demuxer.h +++ b/src/codec/wuffs/demuxer.h @@ -5,7 +5,7 @@ struct camu_wuffs_demuxer { struct camu_demuxer demux; struct cch_handle *handle; - struct aki_buffer buffer; + struct nn_buffer buffer; bool eof; }; diff --git a/src/codec/wuffs/impl.c b/src/codec/wuffs/impl.c index 4d9ea7e..378ac00 100644 --- a/src/codec/wuffs/impl.c +++ b/src/codec/wuffs/impl.c @@ -1,4 +1,4 @@ -#include <aki/common.h> +#include <nnwt/common.h> #define WUFFS_IMPLEMENTATION #define WUFFS_CONFIG__STATIC_FUNCTIONS #define WUFFS_CONFIG__MODULES @@ -22,13 +22,13 @@ static bool wuffs_demuxer_init(struct camu_demuxer *demux, struct cch_handle *ha struct camu_wuffs_demuxer *wfs = (struct camu_wuffs_demuxer *)demux; wfs->handle = handle; - aki_buffer_init(&wfs->buffer); + nn_buffer_init(&wfs->buffer); wfs->eof = false; cch_handle_seek(wfs->handle, 0, SEEK_SET); off_t size = cch_entry_get_size(wfs->handle->entry); - aki_buffer_ensure_space(&wfs->buffer, size); - cch_handle_read(wfs->handle, aki_buffer_get_ptr(&wfs->buffer, 0), size); + nn_buffer_ensure_space(&wfs->buffer, size); + cch_handle_read(wfs->handle, nn_buffer_get_ptr(&wfs->buffer, 0), size); wfs->buffer.size = size; wuffs_png__decoder wf_dec = { 0 }; @@ -38,7 +38,7 @@ static bool wuffs_demuxer_init(struct camu_demuxer *demux, struct cch_handle *ha wuffs_png__decoder__set_quirk(&wf_dec, WUFFS_BASE__QUIRK_IGNORE_CHECKSUM, true); wuffs_base__io_buffer src = { 0 }; - src.data.ptr = aki_buffer_get_ptr(&wfs->buffer, 0); + src.data.ptr = nn_buffer_get_ptr(&wfs->buffer, 0); src.data.len = wfs->buffer.size; src.meta.wi = wfs->buffer.size; src.meta.closed = true; @@ -90,7 +90,7 @@ static bool wuffs_demuxer_seek(struct camu_demuxer *demux, u64 pos) static void wuffs_demuxer_free(struct camu_demuxer **demux) { struct camu_wuffs_demuxer *wfs = (struct camu_wuffs_demuxer *)*demux; - aki_buffer_free(&wfs->buffer); + nn_buffer_free(&wfs->buffer); al_array_free(wfs->demux.streams); al_free(wfs); *demux = NULL; @@ -127,7 +127,7 @@ static s32 wuffs_decoder_push(struct camu_decoder *dec, struct camu_codec_packet wuffs_png__decoder__set_quirk(&wf_dec, WUFFS_BASE__QUIRK_IGNORE_CHECKSUM, true); wuffs_base__io_buffer src = { 0 }; - src.data.ptr = aki_buffer_get_ptr(packet->buffer, 0); + src.data.ptr = nn_buffer_get_ptr(packet->buffer, 0); src.data.len = packet->buffer->size; src.meta.wi = packet->buffer->size; src.meta.closed = true; diff --git a/src/fruits/cmc/cmc.c b/src/fruits/cmc/cmc.c index 3c62ba8..35f2d9b 100644 --- a/src/fruits/cmc/cmc.c +++ b/src/fruits/cmc/cmc.c @@ -1,8 +1,11 @@ -#include <aki/common.h> -#include <aki/event_loop.h> +#include <nnwt/common.h> +#include <nnwt/event_loop.h> +#include <nnwt/packet.h> #include "../../portal/src/packet_ext.h" -#include "../../server/common.c" +#include "../../server/common.h" + +#include "../common.h" #include "cmc.h" @@ -23,16 +26,16 @@ static struct cmc_search *get_search_by_id(struct cmc *c, s32 id) return NULL; } -static void parse_user_state(struct cmc *c, struct aki_packet *packet) +static void parse_user_state(struct cmc *c, struct nn_packet *packet) { - u32 size = aki_packet_read_u32(packet); + u32 size = nn_packet_read_u32(packet); for (u32 i = 0; i < size; i++) { struct cmc_search *search = al_alloc_object(struct cmc_search); - search->id = aki_packet_read_s32(packet); + search->id = nn_packet_read_s32(packet); str s; - aki_packet_read_str(packet, &s); + nn_packet_read_str(packet, &s); al_str_clone(&search->module, &s); - aki_packet_read_str(packet, &s); + nn_packet_read_str(packet, &s); al_str_clone(&search->query, &s); al_array_init(search->pages); al_array_push(c->searches, search); @@ -44,12 +47,12 @@ static void client_callback(void *userdata, u8 op, void *opaque) struct cmc *c = (struct cmc *)userdata; switch (op) { case CAMU_CLIENT_LOGIN: { - struct aki_packet *packet = (struct aki_packet *)opaque; + struct nn_packet *packet = (struct nn_packet *)opaque; switch (c->command) { case CLI_OPEN_UI: parse_user_state(c, packet); if (!cmc_ui_init(&c->ui, &c->loop, c)) { - aki_event_loop_break_one(&c->loop); + nn_event_loop_break_one(&c->loop); } break; case CLI_ADD: { @@ -82,22 +85,22 @@ static void client_callback(void *userdata, u8 op, void *opaque) break; } case CAMU_CLIENT_PAGE_RESULTS: { - struct aki_packet *packet = (struct aki_packet *)opaque; - s32 id = aki_packet_read_s32(packet); + struct nn_packet *packet = (struct nn_packet *)opaque; + s32 id = nn_packet_read_s32(packet); struct cmc_search *search = get_search_by_id(c, id); if (!search) return; struct cmc_search_page *page = al_alloc_object(struct cmc_search_page); - page->num = aki_packet_read_u32(packet); - u32 posts = aki_packet_read_u32(packet); + page->num = nn_packet_read_u32(packet); + u32 posts = nn_packet_read_u32(packet); for (u32 i = 0; i < posts; i++) { struct camu_post post; - aki_packet_read_post(packet, &post); + nn_packet_read_post(packet, &post); camu_post_cache_push(&c->cache, &post); } - u32 ids = aki_packet_read_u32(packet); + u32 ids = nn_packet_read_u32(packet); for (u32 i = 0; i < ids; i++) { str unique_id; - aki_packet_read_str(packet, &unique_id); + nn_packet_read_str(packet, &unique_id); str s; al_str_clone(&s, &unique_id); al_array_push(page->list, s); @@ -154,9 +157,9 @@ s32 main(s32 argc, char *argv[]) s32 wmain(s32 argc, wchar_t **argv) #endif { - if (!aki_common_init()) return EXIT_FAILURE; + if (!nn_common_init()) return EXIT_FAILURE; - aki_event_loop_init(&c.loop); + nn_event_loop_init(&c.loop); al_array_init(c.args); if (!parse_cmd(argc, argv)) return EXIT_FAILURE; @@ -166,11 +169,11 @@ s32 wmain(s32 argc, wchar_t **argv) c.client.callback = client_callback; c.client.userdata = &c; - if (!camu_client_login(&c.client, &c.loop, CAMU_LOCAL_TYPE, CAMU_LOCAL_ADDR, CAMU_PORT, al_str_c("andrew"))) { + if (!camu_client_login(&c.client, &c.loop, CAMU_TEST_TYPE, CAMU_TEST_ADDR, CAMU_PORT, al_str_c("andrew"))) { return EXIT_FAILURE; } - aki_event_loop_run(&c.loop); + nn_event_loop_run(&c.loop); cmc_ui_close(&c.ui); diff --git a/src/fruits/cmc/cmc.h b/src/fruits/cmc/cmc.h index 353bd87..96de27b 100644 --- a/src/fruits/cmc/cmc.h +++ b/src/fruits/cmc/cmc.h @@ -22,7 +22,7 @@ struct cmc_search { }; struct cmc { - struct aki_event_loop loop; + struct nn_event_loop loop; u8 command; array(str) args; struct camu_client client; diff --git a/src/fruits/cmc/ui/ui.c b/src/fruits/cmc/ui/ui.c index 58d630f..b4c196d 100644 --- a/src/fruits/cmc/ui/ui.c +++ b/src/fruits/cmc/ui/ui.c @@ -27,7 +27,7 @@ static void input_poll_callback(void *userdata, s32 revents) if (input.evtype == NCTYPE_PRESS || input.evtype == NCTYPE_UNKNOWN) { switch (input.id) { case 'q': - aki_event_loop_break_one(ui->loop); + nn_event_loop_break_one(ui->loop); break; } } @@ -44,7 +44,7 @@ static void input_poll_callback(void *userdata, s32 revents) } while (1); } -bool cmc_ui_init(struct cmc_ui *ui, struct aki_event_loop *loop, struct cmc *c) +bool cmc_ui_init(struct cmc_ui *ui, struct nn_event_loop *loop, struct cmc *c) { al_memset(ui, 0, sizeof(struct cmc_ui)); ui->c = c; @@ -57,9 +57,9 @@ bool cmc_ui_init(struct cmc_ui *ui, struct aki_event_loop *loop, struct cmc *c) struct ncplane *stdplane = notcurses_stdplane(ui->nc); ncplane_set_resizecb(stdplane, resize_cb); ncplane_set_userptr(stdplane, ui); - aki_poll_init(&ui->input_poll, input_poll_callback, ui); - aki_poll_set(&ui->input_poll, notcurses_inputready_fd(ui->nc), AKI_POLL_READ); - aki_poll_start(&ui->input_poll, ui->loop); + nn_poll_init(&ui->input_poll, input_poll_callback, ui); + nn_poll_set(&ui->input_poll, notcurses_inputready_fd(ui->nc), NNWT_POLL_READ); + nn_poll_start(&ui->input_poll, ui->loop); ui->pane = CMC_PANE_SEARCH; return true; } diff --git a/src/fruits/cmc/ui/ui.h b/src/fruits/cmc/ui/ui.h index 1a49985..1c3b9d9 100644 --- a/src/fruits/cmc/ui/ui.h +++ b/src/fruits/cmc/ui/ui.h @@ -1,7 +1,7 @@ #pragma once #include <al/types.h> -#include <aki/event_loop.h> +#include <nnwt/event_loop.h> #include <notcurses/notcurses.h> enum { @@ -11,11 +11,11 @@ enum { struct cmc; struct cmc_ui { struct notcurses *nc; - struct aki_event_loop *loop; + struct nn_event_loop *loop; u32 term_cols; u32 term_rows; bool pending_layout; - struct aki_poll input_poll; + struct nn_poll input_poll; u8 pane; struct { struct ncplane *n; @@ -24,7 +24,7 @@ struct cmc_ui { struct cmc *c; }; -bool cmc_ui_init(struct cmc_ui *ui, struct aki_event_loop *loop, struct cmc *c); +bool cmc_ui_init(struct cmc_ui *ui, struct nn_event_loop *loop, struct cmc *c); void cmc_ui_close(struct cmc_ui *ui); void cmc_sp_init(struct cmc_ui *ui); diff --git a/src/fruits/cmsrv/cmsrv.c b/src/fruits/cmsrv/cmsrv.c index 5eb9fee..53555d3 100644 --- a/src/fruits/cmsrv/cmsrv.c +++ b/src/fruits/cmsrv/cmsrv.c @@ -1,32 +1,34 @@ #define CAMU_LOCAL_SOCKET #include <al/log.h> -#include <aki/common.h> +#include <nnwt/common.h> #ifdef CAMU_LOCAL_SOCKET -#include <aki/line_processor.h> +#include <nnwt/line_processor.h> #endif -#include <aki/timer.h> +#include <nnwt/timer.h> #include "../../server/server.h" #include "../../server/common.h" #include "../../cache/handlers/cdio.h" #include "../../codec/ffmpeg/common.h" +#include "../common.h" + #include "ui.h" struct cmsrv { - struct aki_event_loop loop; - struct aki_signal quit_signal; + struct nn_event_loop loop; + struct nn_signal quit_signal; struct camu_server server; #ifdef CAMU_LOCAL_SOCKET struct { - struct aki_socket sock; - struct aki_line_processor cli; + struct nn_socket sock; + struct nn_line_processor cli; } local; #endif struct cmsrv_ui ui; - struct aki_poll input_poll; - struct aki_timer render_timer; + struct nn_poll input_poll; + struct nn_timer render_timer; }; #ifdef CAMU_LOCAL_SOCKET @@ -49,25 +51,34 @@ static u8 server_line_callback(void *userdata, str *line) } else if (al_str_eq(line, al_str_c(";CLEAR"))) { lia_list_clear(list); } else { - struct aki_packet *packet = aki_packet_create(); + struct nn_packet *packet = nn_packet_create(); +#ifdef CAMU_HAVE_PORTAL if (al_str_at(line, 0) == ';' || camu_is_url(line, 0)) { - aki_packet_write_u8(packet, CAMU_RESOURCE_SIMPLE_SEARCH); + nn_packet_write_u8(packet, CAMU_RESOURCE_SIMPLE_SEARCH); +#elif defined NAUNET_HAS_CURL + if (camu_is_url(line, 0)) { + nn_packet_write_u8(packet, CAMU_RESOURCE_HTTP); +#endif +#if CACHE_HAVE_CDIO + } else if (al_str_cmp(line, al_str_c("cdda://"), 0, 7) == 0) { + nn_packet_write_u8(packet, CAMU_RESOURCE_CDIO); +#endif } else { - aki_packet_write_u8(packet, CAMU_RESOURCE_FILE); + nn_packet_write_u8(packet, CAMU_RESOURCE_FILE); } - aki_packet_write_str(packet, line); + nn_packet_write_str(packet, line); camu_server_local_add(&s->server, packet); } - return AKI_LINE_PROCESSOR_CONTINUE; + return NNWT_LINE_PROCESSOR_CONTINUE; } #endif -static void render_timer_callback(void *userdata, struct aki_timer *timer) +static void render_timer_callback(void *userdata, struct nn_timer *timer) { struct cmsrv *s = (struct cmsrv *)userdata; (void)timer; cmsrv_ui_render(&s->ui); - aki_timer_again(&s->render_timer); + nn_timer_again(&s->render_timer); } static void input_poll_callback(void *userdata, s32 revents) @@ -80,7 +91,7 @@ static void input_poll_callback(void *userdata, s32 revents) if (input.evtype == NCTYPE_PRESS || input.evtype == NCTYPE_UNKNOWN) { switch (input.id) { case 'q': - aki_event_loop_break_one(&s->loop); + nn_event_loop_break_one(&s->loop); break; case '1': cmsrv_ui_set_pane(&s->ui, CMSRV_UI_LISTS); @@ -99,13 +110,13 @@ static void input_poll_callback(void *userdata, s32 revents) static void quit_signal_callback(void *userdata) { struct cmsrv *s = (struct cmsrv *)userdata; - aki_event_loop_break_one(&s->loop); + nn_event_loop_break_one(&s->loop); } -static s32 log_callback(void *userdata, char *message, const char *color) +static s32 log_callback(void *userdata, u8 level, char *message) { struct cmsrv *s = (struct cmsrv *)userdata; - (void)color; + (void)level; cmsrv_ui_push_message(&s->ui, message); return al_strlen(message); } @@ -115,7 +126,7 @@ static struct cmsrv s = { 0 }; static void sigint_handler(s32 signum) { (void)signum; - aki_signal_send(&s.quit_signal); + nn_signal_send(&s.quit_signal); } #ifndef _WIN32 @@ -126,7 +137,7 @@ s32 wmain(s32 argc, wchar_t **argv) { (void)argc; (void)argv; - if (!aki_common_init() || !cmsrv_ui_init(&s.ui, &s.server)) return EXIT_FAILURE; + if (!nn_common_init() || !cmsrv_ui_init(&s.ui, &s.server)) return EXIT_FAILURE; signal(SIGINT, sigint_handler); @@ -136,36 +147,35 @@ s32 wmain(s32 argc, wchar_t **argv) camu_ff_set_default_log_callback(); #endif - aki_event_loop_init(&s.loop); + nn_event_loop_init(&s.loop); - aki_signal_init(&s.quit_signal, &s.loop, quit_signal_callback, &s); - aki_signal_start(&s.quit_signal); + nn_signal_init(&s.quit_signal, &s.loop, quit_signal_callback, &s); + nn_signal_start(&s.quit_signal); - if (!camu_server_init(&s.server, CAMU_LOCAL_TYPE, &s.loop)) return EXIT_FAILURE; - camu_server_listen(&s.server, CAMU_LOCAL_ADDR, CAMU_PORT); + if (!camu_server_init(&s.server, CAMU_TEST_TYPE, &s.loop)) return EXIT_FAILURE; + camu_server_listen(&s.server, CAMU_TEST_ADDR, CAMU_PORT); #ifdef CAMU_LOCAL_SOCKET - s.local.sock.type = AKI_SOCKET_UNIX; - aki_socket_init(&s.local.sock); - aki_socket_set_blocking(&s.local.sock, false); + s.local.sock.type = NNWT_SOCKET_UNIX; + nn_socket_init(&s.local.sock, NNWT_SOCKET_NONBLOCKING); s.local.cli.callback = server_line_callback; s.local.cli.userdata = &s; - aki_line_processor_init(&s.local.cli, al_str_c("\n")); - aki_line_processor_open_socket(&s.local.cli, &s.local.sock); - if (aki_socket_bind(&s.local.sock, CAMU_UNIX_LOCAL, 0) && aki_socket_listen(&s.local.sock)) { - aki_line_processor_run(&s.local.cli, &s.loop); + nn_line_processor_init(&s.local.cli, al_str_c("\n")); + nn_line_processor_open_socket(&s.local.cli, &s.local.sock); + if (nn_socket_bind(&s.local.sock, CAMU_TEST_CONTROL_PATH, 0) && nn_socket_listen(&s.local.sock)) { + nn_line_processor_run(&s.local.cli, &s.loop); } #endif - aki_poll_init(&s.input_poll, input_poll_callback, &s); - aki_poll_set(&s.input_poll, cmsrv_ui_get_input_fd(&s.ui), AKI_POLL_READ); - aki_poll_start(&s.input_poll, &s.loop); + nn_poll_init(&s.input_poll, input_poll_callback, &s); + nn_poll_set(&s.input_poll, cmsrv_ui_get_input_fd(&s.ui), NNWT_POLL_READ); + nn_poll_start(&s.input_poll, &s.loop); - aki_timer_init(&s.render_timer, &s.loop, render_timer_callback, &s); - aki_timer_set_repeat(&s.render_timer, AKI_TS_FROM_USEC(100000)); - aki_timer_again(&s.render_timer); + nn_timer_init(&s.render_timer, &s.loop, render_timer_callback, &s); + nn_timer_set_repeat(&s.render_timer, NNWT_TS_FROM_USEC(100000)); + nn_timer_again(&s.render_timer); - aki_event_loop_run(&s.loop); + nn_event_loop_run(&s.loop); cmsrv_ui_close(&s.ui); @@ -173,7 +183,7 @@ s32 wmain(s32 argc, wchar_t **argv) camu_ff_free_default_log_callback(); #endif - aki_common_close(); + nn_common_close(); return EXIT_SUCCESS; } diff --git a/src/fruits/cmsrv/ui.c b/src/fruits/cmsrv/ui.c index 0c26881..5d35380 100644 --- a/src/fruits/cmsrv/ui.c +++ b/src/fruits/cmsrv/ui.c @@ -1,6 +1,8 @@ #include <al/lib.h> #include <al/log.h> +#include "../../server/common.h" + #include "ui.h" #define LOG_RATIO 1.5 @@ -145,7 +147,15 @@ static void render_lists(struct cmsrv_ui *ui) ncplane_putchar_yx(n, y, 1, '>'); x += 2; } - putnwstr_maxwidth_yx(n, y, x, max_width - x, &entry->name); + wstr *name = &entry->name; +#ifdef CAMU_HAVE_PORTAL + struct camu_resource *resource = (struct camu_resource *)entry->opaque; + if (resource->type == CAMU_RESOURCE_PORTAL) { + struct camu_resource_portal *portal = (struct camu_resource_portal *)resource; + name = &portal->post->title; + } +#endif + putnwstr_maxwidth_yx(n, y, x, max_width - x, name); if (++current_line >= max_height) break; } } diff --git a/src/fruits/cmv/cmv.c b/src/fruits/cmv/cmv.c index 0fe33ad..8509485 100644 --- a/src/fruits/cmv/cmv.c +++ b/src/fruits/cmv/cmv.c @@ -1,18 +1,21 @@ #include <al/log.h> -#include <aki/event_loop.h> -#include <aki/thread.h> +#include <nnwt/event_loop.h> +#include <nnwt/thread.h> #include "../../sink/desktop.h" #include "../../server/common.h" #include "../../codec/ffmpeg/common.h" #ifndef CAMU_SINK_ONLY #include "../../server/server.h" -#else -#include "../../server/common.c" #endif +#include "../../server/common.h" + +#include "../common.h" + +static str *CMV_UNIX_PATH = al_str_c("/tmp/cmv_sock"); struct cmv { - struct aki_event_loop loop; + struct nn_event_loop loop; struct camu_desktop desktop; #ifndef CAMU_SINK_ONLY struct camu_server server; @@ -28,10 +31,10 @@ static void exit_callback(void *userdata, struct camu_desktop *desktop) } #endif -static aki_thread_result AKI_THREADCALL event_loop_thread(void *userdata) +static nn_thread_result NNWT_THREADCALL event_loop_thread(void *userdata) { struct cmv *c = (struct cmv *)userdata; - aki_event_loop_run(&c->loop); + nn_event_loop_run(&c->loop); return 0; } @@ -53,7 +56,7 @@ s32 main(s32 argc, char *argv[]) s32 wmain(s32 argc, wchar_t **argv) #endif { - if (!aki_common_init() || !stl_global_init(false)) { + if (!nn_common_init() || !stl_global_init(false)) { return EXIT_FAILURE; } @@ -65,22 +68,26 @@ s32 wmain(s32 argc, wchar_t **argv) camu_ff_set_default_log_callback(); #endif - aki_event_loop_init(&c.loop); + nn_event_loop_init(&c.loop); u8 type; str *addr; #ifndef CAMU_SINK_ONLY bool local = argc > 1; if (local) { - type = AKI_SOCKET_UNIX; addr = CAMU_UNIX_LOCAL; +#ifndef _WIN32 + type = NNWT_SOCKET_UNIX; addr = CMV_UNIX_PATH; +#else + type = NNWT_SOCKET_TCP; addr = CAMU_LOCALHOST; +#endif if (!camu_server_init(&c.server, type, &c.loop)) failure(); if (!camu_server_listen(&c.server, addr, CAMU_PORT)) failure(); } else { - type = CAMU_LOCAL_TYPE; - addr = CAMU_LOCAL_ADDR; + type = CAMU_TEST_TYPE; + addr = CAMU_TEST_ADDR; } #else - type = AKI_SOCKET_TCP; addr = CAMU_SERVER_IP; + type = NNWT_SOCKET_TCP; addr = CAMU_SERVER_IP; #endif #ifndef CAMU_SINK_ONLY @@ -90,18 +97,29 @@ s32 wmain(s32 argc, wchar_t **argv) str arg = *al_str_cr(argv[i]); #else str arg; - al_wstr_to_str(al_wstr_cr(argv[i]), &arg); + if (!al_wstr_to_str(al_wstr_cr(argv[i]), &arg)) { + al_log_error("cmv", "Failed to parse argument #%i.", i); + continue; + } +#endif + struct nn_packet *packet = nn_packet_create(); +#ifdef CAMU_HAVE_PORTAL + if (al_str_at(&arg, 0) == ';' || camu_is_url(&arg, 0)) { + nn_packet_write_u8(packet, CAMU_RESOURCE_SIMPLE_SEARCH); +#elif defined NAUNET_HAS_CURL + if (camu_is_url(&arg, 0)) { + nn_packet_write_u8(packet, CAMU_RESOURCE_HTTP); +#endif +#if CACHE_HAVE_CDIO + } else if (al_str_cmp(&arg, al_str_c("cdda://"), 0, 7) == 0) { + nn_packet_write_u8(packet, CAMU_RESOURCE_CDIO); #endif - struct aki_packet *packet = aki_packet_create(); - if (al_str_at(&arg, 0) == ';') { - aki_packet_write_u8(packet, CAMU_RESOURCE_PORTAL); - aki_packet_write_str(packet, al_str_substr(&arg, 1, arg.len)); } else { - aki_packet_write_u8(packet, CAMU_RESOURCE_FILE); - aki_packet_write_str(packet, &arg); + nn_packet_write_u8(packet, CAMU_RESOURCE_FILE); } + nn_packet_write_str(packet, &arg); camu_server_local_add(&c.server, packet); - aki_packet_free(packet); + nn_packet_free(packet); } } #else @@ -118,13 +136,13 @@ s32 wmain(s32 argc, wchar_t **argv) #endif if (!camu_desktop_connect(&c.desktop, type, &c.loop, addr, CAMU_PORT)) failure(); - struct aki_thread thread0; - aki_thread_create(&thread0, event_loop_thread, &c); + struct nn_thread thread0; + nn_thread_create(&thread0, event_loop_thread, &c); while (camu_desktop_tick(&c.desktop)) {} camu_desktop_stop(&c.desktop); - aki_thread_join(&thread0); + nn_thread_join(&thread0); camu_desktop_free(&c.desktop); #ifndef CAMU_SINK_ONLY camu_server_free(&c.server); @@ -132,14 +150,14 @@ s32 wmain(s32 argc, wchar_t **argv) ret = EXIT_SUCCESS; out: - aki_event_loop_destroy(&c.loop); + nn_event_loop_destroy(&c.loop); #ifdef CAMU_HAVE_FFMPEG camu_ff_free_default_log_callback(); #endif stl_global_close(); - aki_common_close(); + nn_common_close(); return ret; } diff --git a/src/fruits/common.h b/src/fruits/common.h new file mode 100644 index 0000000..c7b432a --- /dev/null +++ b/src/fruits/common.h @@ -0,0 +1,17 @@ +#include <al/str.h> +#include <nnwt/socket.h> + +AL_UNUSED_VARIABLE_PUSH + +static str *CAMU_DB_PATH = al_str_c("/home/andrew/c/camu/data/camu_db_test"); + +static str *CAMU_TEST_IP = al_str_c("108.52.160.112"); +static str *CAMU_LOCALHOST = al_str_c("127.0.0.1"); + +static str *CAMU_TEST_PATH = al_str_c("/tmp/camu_sock"); +static str *CAMU_TEST_CONTROL_PATH = al_str_c("/tmp/camu_control_sock"); + +AL_UNUSED_VARIABLE_POP + +#define CAMU_TEST_TYPE NNWT_SOCKET_TCP +#define CAMU_TEST_ADDR CAMU_TEST_IP diff --git a/src/fruits/ctv/ctv.c b/src/fruits/ctv/ctv.c index 5f4a819..c7bd250 100644 --- a/src/fruits/ctv/ctv.c +++ b/src/fruits/ctv/ctv.c @@ -11,12 +11,12 @@ #include "../../server/common.c" struct ctv { - struct aki_event_loop loop; + struct nn_event_loop loop; struct camu_screen scr; struct camu_renderer *renderer; struct camu_mixer mixer; struct camu_sink sink; - struct aki_thread thread; + struct nn_thread thread; bool created; }; @@ -37,10 +37,10 @@ static void screen_callback(void *userdata, u8 op, void *opaque) (void)opaque; } -static aki_thread_result AKI_THREADCALL event_loop_thread(void *userdata) +static nn_thread_result NNWT_THREADCALL event_loop_thread(void *userdata) { struct ctv *c = (struct ctv *)userdata; - aki_event_loop_run(&c->loop); + nn_event_loop_run(&c->loop); return 0; } @@ -66,14 +66,14 @@ static void onSurfaceCreated(GLFMDisplay *display, s32 width, s32 height) c->mixer.audio->configure_stream(c->mixer.audio, NULL); camu_mixer_pick_format(&c->mixer, &c->mixer.fmt); - aki_event_loop_init(&c->loop); + nn_event_loop_init(&c->loop); camu_sink_init(&c->sink, &c->loop, &c->mixer, c->renderer); c->sink.callback = sink_callback; c->sink.userdata = c; - camu_sink_connect(&c->sink, AKI_SOCKET_TCP, CAMU_SERVER_IP, CAMU_PORT, al_str_c("ctv")); + camu_sink_connect(&c->sink, NNWT_SOCKET_TCP, CAMU_SERVER_IP, CAMU_PORT, al_str_c("ctv")); - aki_thread_create(&c->thread, event_loop_thread, c); + nn_thread_create(&c->thread, event_loop_thread, c); c->created = true; } @@ -92,9 +92,10 @@ static void onDraw(GLFMDisplay *display) } } -static s32 log_callback(void *userdata, char *message) +static s32 log_callback(void *userdata, u8 level, char *message) { (void)userdata; + (void)level; __android_log_print(ANDROID_LOG_DEBUG, "CTV", "%s", message); s32 ret = al_strlen(message); al_free(message); diff --git a/src/liana/client.c b/src/liana/client.c index ad365b3..1ba09cc 100644 --- a/src/liana/client.c +++ b/src/liana/client.c @@ -9,24 +9,24 @@ #include "handlers.h" #include "list.h" -static void data_packet_callback(void *userdata, struct aki_packet_stream *stream, struct aki_packet *packet) +static void data_packet_callback(void *userdata, struct nn_packet_stream *stream, struct nn_packet *packet) { struct lia_client *client = (struct lia_client *)userdata; (void)stream; lia_vcr_push_packet(&client->vcr, packet); } -static void parse_info_packet(struct lia_client *client, struct aki_packet *packet) +static void parse_info_packet(struct lia_client *client, struct nn_packet *packet) { str liana; - aki_packet_read_str(packet, &liana); - client->duration = aki_packet_read_u64(packet); - u32 count = aki_packet_read_u32(packet); + nn_packet_read_str(packet, &liana); + client->duration = nn_packet_read_u64(packet); + u32 count = nn_packet_read_u32(packet); for (u32 i = 0; i < count; i++) { - u8 mode = aki_packet_read_u8(packet); - u8 type = aki_packet_read_u8(packet); - u64 duration = aki_packet_read_u64(packet); - s32 index = aki_packet_read_s32(packet); + u8 mode = nn_packet_read_u8(packet); + u8 type = nn_packet_read_u8(packet); + u64 duration = nn_packet_read_u64(packet); + s32 index = nn_packet_read_s32(packet); al_assert(index < 32); struct lia_vcr_track *track = NULL; switch (mode) { @@ -35,17 +35,17 @@ static void parse_info_packet(struct lia_client *client, struct aki_packet *pack track = al_alloc_object(struct lia_vcr_track); if (type == CAMU_STREAM_AUDIO) { struct camu_audio_format *fmt = &track->stream.audio.fmt; - fmt->format = aki_packet_read_s32(packet); - fmt->sample_rate = aki_packet_read_s32(packet); - fmt->channel_count = aki_packet_read_s32(packet); + fmt->format = nn_packet_read_s32(packet); + fmt->sample_rate = nn_packet_read_s32(packet); + fmt->channel_count = nn_packet_read_s32(packet); #ifdef CAMU_HAVE_FFMPEG av_channel_layout_default(&fmt->channel_layout, fmt->channel_count); #endif } else if (type == CAMU_STREAM_VIDEO) { struct camu_video_format *fmt = &track->stream.video.fmt; - fmt->width = aki_packet_read_s32(packet); - fmt->height = aki_packet_read_s32(packet); - fmt->format = aki_packet_read_s32(packet); + fmt->width = nn_packet_read_s32(packet); + fmt->height = nn_packet_read_s32(packet); + fmt->format = nn_packet_read_s32(packet); } break; } @@ -67,10 +67,10 @@ static void parse_info_packet(struct lia_client *client, struct aki_packet *pack default: continue; } - enum AVCodecID codec_id = aki_packet_read_av_codec_id(packet); + enum AVCodecID codec_id = nn_packet_read_av_codec_id(packet); const AVCodec *codec = avcodec_find_decoder(codec_id); AVFormatContext *format_context = avformat_alloc_context(); - AVStream *stream = aki_packet_read_av_stream(format_context, codec, packet); + AVStream *stream = nn_packet_read_av_stream(format_context, codec, packet); if (type == CAMU_STREAM_SUBTITLE && codec_id != AV_CODEC_ID_ASS) { client->mask &= ~(1 << index); continue; @@ -120,30 +120,30 @@ static void parse_info_packet(struct lia_client *client, struct aki_packet *pack } } -static void info_packet_callback(void *userdata, struct aki_packet_stream *stream, struct aki_packet *packet) +static void info_packet_callback(void *userdata, struct nn_packet_stream *stream, struct nn_packet *packet) { struct lia_client *client = (struct lia_client *)userdata; - client->connection_id = aki_packet_read_u32(packet); + client->connection_id = nn_packet_read_u32(packet); parse_info_packet(client, packet); - aki_packet_free(packet); + nn_packet_free(packet); if (client->mask == 0 || lia_vcr_is_empty(&client->vcr)) { client->reconnect = false; - aki_packet_stream_disconnect(&client->data); + nn_packet_stream_disconnect(&client->data); return; } stream->packet_callback = data_packet_callback; - struct aki_packet *rpacket = aki_packet_create(); - aki_packet_write_s32(rpacket, client->mask); - aki_packet_stream_send_packet(stream, rpacket); + struct nn_packet *rpacket = nn_packet_create(); + nn_packet_write_s32(rpacket, client->mask); + nn_packet_stream_send_packet(stream, rpacket); } -static void packet_sent_callback(void *userdata, struct aki_packet *packet) +static void packet_sent_callback(void *userdata, struct nn_packet *packet) { (void)userdata; - aki_packet_free(packet); + nn_packet_free(packet); } -static void connection_callback(void *userdata, struct aki_packet_stream *stream) +static bool connection_callback(void *userdata, struct nn_packet_stream *stream) { struct lia_client *client = (struct lia_client *)userdata; if (client->reconnect) { @@ -164,20 +164,21 @@ static void connection_callback(void *userdata, struct aki_packet_stream *stream } lia_vcr_start(&client->vcr); stream->packet_sent_callback = packet_sent_callback; - struct aki_packet *packet = aki_packet_create(); - aki_packet_write_u32(packet, client->id); - aki_packet_write_u32(packet, 0); - aki_packet_write_s32(packet, client->mask); - aki_packet_write_u64(packet, client->pos); + struct nn_packet *packet = nn_packet_create(); + nn_packet_write_u32(packet, client->id); + nn_packet_write_u32(packet, 0); + nn_packet_write_s32(packet, client->mask); + nn_packet_write_u64(packet, client->pos); if (client->mask == 0) { stream->packet_callback = info_packet_callback; } else { stream->packet_callback = data_packet_callback; } - aki_packet_stream_send_packet(stream, packet); + nn_packet_stream_send_packet(stream, packet); + return true; } -static void connection_closed_callback(void *userdata, struct aki_packet_stream *stream) +static void connection_closed_callback(void *userdata, struct nn_packet_stream *stream) { struct lia_client *client = (struct lia_client *)userdata; if (client->reconnect) { @@ -190,13 +191,13 @@ static void connection_closed_callback(void *userdata, struct aki_packet_stream // any unexpected behavior. client->callback(client->userdata, LIANA_CLIENT_REMOVE_BUFFERS, NULL, &client->reconnect); if (client->reconnect) { - aki_packet_stream_reconnect(stream, &client->addr, client->port); + nn_packet_stream_reconnect(stream, &client->addr, client->port); } else { client->callback(client->userdata, LIANA_CLIENT_CLOSED, NULL, NULL); } } -void lia_client_connect(struct lia_client *client, struct aki_event_loop *loop, u8 type, +void lia_client_connect(struct lia_client *client, struct nn_event_loop *loop, u8 type, str *addr, u16 port, u32 id, u64 pos, struct camu_renderer *renderer) { client->loop = loop; @@ -207,12 +208,12 @@ void lia_client_connect(struct lia_client *client, struct aki_event_loop *loop, lia_vcr_init(&client->vcr, client->loop, &client->data); al_str_clone(&client->addr, addr); client->port = port; - if (!aki_packet_stream_init(&client->data, type, connection_callback, connection_closed_callback, client)) { + if (!nn_packet_stream_init(&client->data, type, connection_callback, connection_closed_callback, client)) { connection_closed_callback(client, &client->data); } - aki_packet_stream_set_multiplex(&client->data, CAMU_MULTIPLEX_LIANA); + nn_packet_stream_set_multiplex(&client->data, CAMU_MULTIPLEX_LIANA); client->renderer = renderer; - aki_packet_stream_connect(&client->data, client->loop, &client->addr, client->port); + nn_packet_stream_connect(&client->data, client->loop, &client->addr, client->port); } void lia_client_set_renderer(struct lia_client *client, struct camu_renderer *renderer) @@ -226,7 +227,7 @@ void lia_client_seek(struct lia_client *client, u64 pos, u64 at) client->at = at; if (!client->reconnect) { client->reconnect = true; - aki_packet_stream_disconnect(&client->data); + nn_packet_stream_disconnect(&client->data); } } @@ -238,12 +239,12 @@ void lia_client_reseek(struct lia_client *client) void lia_client_disconnect(struct lia_client *client) { client->reconnect = false; - aki_packet_stream_disconnect(&client->data); + nn_packet_stream_disconnect(&client->data); } void lia_client_free(struct lia_client *client) { lia_vcr_free(&client->vcr); - aki_packet_stream_free(&client->data); + nn_packet_stream_free(&client->data); al_str_free(&client->addr); } diff --git a/src/liana/client.h b/src/liana/client.h index cd1297e..55c5b3a 100644 --- a/src/liana/client.h +++ b/src/liana/client.h @@ -1,13 +1,13 @@ #pragma once -#include <aki/packet_stream.h> +#include <nnwt/packet_stream.h> #include "../codec/codec.h" #include "vcr.h" struct lia_client { - struct aki_event_loop *loop; + struct nn_event_loop *loop; u32 id; s32 mask; u64 pos; @@ -16,7 +16,7 @@ struct lia_client { str addr; u16 port; u32 connection_id; - struct aki_packet_stream data; + struct nn_packet_stream data; u64 duration; struct lia_vcr vcr; struct camu_renderer *renderer; @@ -24,7 +24,7 @@ struct lia_client { void *userdata; }; -void lia_client_connect(struct lia_client *client, struct aki_event_loop *loop, u8 type, +void lia_client_connect(struct lia_client *client, struct nn_event_loop *loop, u8 type, str *addr, u16 port, u32 id, u64 pos, struct camu_renderer *renderer); void lia_client_seek(struct lia_client *client, u64 pos, u64 at); void lia_client_reseek(struct lia_client *client); diff --git a/src/liana/handler.h b/src/liana/handler.h index 21437c4..9f93e5c 100644 --- a/src/liana/handler.h +++ b/src/liana/handler.h @@ -1,18 +1,18 @@ #pragma once -#include <aki/packet_pool.h> +#include <nnwt/packet_pool.h> #include "../codec/codec.h" #include "../cache/handle.h" struct lia_server_handler { bool (*init)(struct lia_server_handler *, struct cch_handle *); - void (*write_info)(struct lia_server_handler *, struct aki_packet *); + void (*write_info)(struct lia_server_handler *, struct nn_packet *); void (*subscribe)(struct lia_server_handler *, s32); u64 (*get_duration)(struct lia_server_handler *); bool (*seek)(struct lia_server_handler *, u64); void (*step)(struct lia_server_handler *); - void (*write_packet)(struct lia_server_handler *, struct aki_packet *); + void (*write_packet)(struct lia_server_handler *, struct nn_packet *); void (*free)(struct lia_server_handler **); s32 status; }; @@ -49,7 +49,7 @@ struct lia_seek_req { struct lia_client_handler { bool (*init)(struct lia_client_handler *, struct camu_renderer *, struct camu_codec_stream *); - bool (*handle_packet)(struct lia_client_handler *, struct aki_packet *); + bool (*handle_packet)(struct lia_client_handler *, struct nn_packet *); void (*flush)(struct lia_client_handler *); void (*free)(struct lia_client_handler **); struct camu_codec_stream *stream; diff --git a/src/liana/handlers.c b/src/liana/handlers.c index 936f801..1a28024 100644 --- a/src/liana/handlers.c +++ b/src/liana/handlers.c @@ -13,7 +13,7 @@ struct lia_handler_entry liana_handlers[] = { .create_client_handler = lia_codec_client_create #endif }, -#ifdef LIANA_HAVE_CDIO +#ifdef CACHE_HAVE_CDIO { .name = al_str_c("cdio"), #ifdef LIANA_SERVER diff --git a/src/liana/handlers/cdio.h b/src/liana/handlers/cdio.h index 2727616..4c40986 100644 --- a/src/liana/handlers/cdio.h +++ b/src/liana/handlers/cdio.h @@ -6,8 +6,8 @@ struct lia_cdio_server { struct lia_server_handler handler; struct cch_handle *handle; struct camu_audio_format fmt; + struct nn_buffer buffer; f64 pts; - struct aki_buffer buffer; }; struct lia_cdio_client { diff --git a/src/liana/handlers/cdio_client.c b/src/liana/handlers/cdio_client.c index 93b1a27..665858f 100644 --- a/src/liana/handlers/cdio_client.c +++ b/src/liana/handlers/cdio_client.c @@ -9,7 +9,7 @@ static bool cdio_client_init(struct lia_client_handler *handler, struct camu_ren return true; } -static bool cdio_client_handle_packet(struct lia_client_handler *handler, struct aki_packet *packet) +static bool cdio_client_handle_packet(struct lia_client_handler *handler, struct nn_packet *packet) { struct lia_cdio_client *cdio = (struct lia_cdio_client *)handler; if (!packet) { @@ -18,12 +18,12 @@ static bool cdio_client_handle_packet(struct lia_client_handler *handler, struct } struct camu_codec_frame *frame = al_alloc_object(struct camu_codec_frame); frame->mode = CAMU_NORMAL; - frame->pts = aki_packet_read_f64(packet); - frame->audio.sample_count = aki_packet_read_s32(packet); - struct aki_buffer buffer; - aki_packet_read_buffer(packet, &buffer); + frame->pts = nn_packet_read_f64(packet); + frame->audio.sample_count = nn_packet_read_s32(packet); + struct nn_buffer buffer; + nn_packet_read_buffer(packet, &buffer); frame->data = al_malloc(buffer.size); - al_memcpy(frame->data, aki_buffer_get_ptr(&buffer, 0), buffer.size); + al_memcpy(frame->data, nn_buffer_get_ptr(&buffer, 0), buffer.size); cdio->handler.callback(cdio->handler.userdata, LIANA_CLIENT_DATA, cdio->handler.stream, frame); return true; } diff --git a/src/liana/handlers/cdio_server.c b/src/liana/handlers/cdio_server.c index 641ed92..01a9265 100644 --- a/src/liana/handlers/cdio_server.c +++ b/src/liana/handlers/cdio_server.c @@ -15,8 +15,8 @@ static bool cdio_server_init(struct lia_server_handler *handler, struct cch_hand cdio->fmt.format = CAMU_SAMPLE_FORMAT_S16; cdio->fmt.sample_rate = 44100; cdio->fmt.channel_count = 2; + nn_buffer_init(&cdio->buffer); cdio->pts = 0.0; - aki_buffer_init(&cdio->buffer); if (handle->entry->chapter) { cch_handle_seek(handle, handle->entry->chapter->start * CDIO_CD_FRAMESIZE_RAW, SEEK_SET); @@ -25,18 +25,18 @@ static bool cdio_server_init(struct lia_server_handler *handler, struct cch_hand return true; } -static void cdio_server_write_info(struct lia_server_handler *handler, struct aki_packet *packet) +static void cdio_server_write_info(struct lia_server_handler *handler, struct nn_packet *packet) { struct lia_cdio_server *cdio = (struct lia_cdio_server *)handler; - aki_packet_write_u64(packet, 0); - aki_packet_write_u32(packet, 1); - aki_packet_write_u8(packet, CAMU_NORMAL); - aki_packet_write_u8(packet, CAMU_STREAM_AUDIO); - aki_packet_write_u64(packet, cdio->handler.get_duration(&cdio->handler)); - aki_packet_write_s32(packet, 0); - aki_packet_write_s32(packet, cdio->fmt.format); - aki_packet_write_s32(packet, cdio->fmt.sample_rate); - aki_packet_write_s32(packet, cdio->fmt.channel_count); + nn_packet_write_u64(packet, 0); + nn_packet_write_u32(packet, 1); + nn_packet_write_u8(packet, CAMU_NORMAL); + nn_packet_write_u8(packet, CAMU_STREAM_AUDIO); + nn_packet_write_u64(packet, cdio->handler.get_duration(&cdio->handler)); + nn_packet_write_s32(packet, 0); + nn_packet_write_s32(packet, cdio->fmt.format); + nn_packet_write_s32(packet, cdio->fmt.sample_rate); + nn_packet_write_s32(packet, cdio->fmt.channel_count); } static void cdio_server_subscribe(struct lia_server_handler *handler, s32 mask) @@ -69,26 +69,26 @@ static void cdio_server_step(struct lia_server_handler *handler) (void)cdio; } -static void cdio_server_write_packet(struct lia_server_handler *handler, struct aki_packet *packet) +static void cdio_server_write_packet(struct lia_server_handler *handler, struct nn_packet *packet) { struct lia_cdio_server *cdio = (struct lia_cdio_server *)handler; off_t size = CDIO_CD_FRAMESIZE_RAW * SECTORS_PER_PACKET; - aki_buffer_ensure_space(&cdio->buffer, size); - s32 ret = cch_handle_read(cdio->handle, aki_buffer_get_ptr(&cdio->buffer, 0), size); + nn_buffer_ensure_space(&cdio->buffer, size); + s32 ret = cch_handle_read(cdio->handle, nn_buffer_get_ptr(&cdio->buffer, 0), size); if (ret == CAMU_ERR_EOF) { cdio->handler.status = CAMU_ERR_EOF; - aki_packet_write_u8(packet, LIANA_PACKET_EOF); + nn_packet_write_u8(packet, LIANA_PACKET_EOF); return; } cdio->handler.status = CAMU_OK; - aki_packet_write_u8(packet, LIANA_PACKET_DATA); - aki_packet_write_s32(packet, 0); - aki_packet_write_f64(packet, cdio->pts); + nn_packet_write_u8(packet, LIANA_PACKET_DATA); + nn_packet_write_s32(packet, 0); + nn_packet_write_f64(packet, cdio->pts); s32 sample_count = ret / (camu_audio_format_bytes_per_sample(&cdio->fmt) * cdio->fmt.channel_count); + nn_packet_write_s32(packet, sample_count); + nn_buffer_set_size(&cdio->buffer, ret); + nn_packet_write_buffer(packet, &cdio->buffer); cdio->pts += camu_audio_format_samples_to_sec(&cdio->fmt, sample_count); - aki_packet_write_s32(packet, sample_count); - aki_buffer_set_size(&cdio->buffer, ret); - aki_packet_write_buffer(packet, &cdio->buffer); } static void cdio_server_free(struct lia_server_handler **handler) diff --git a/src/liana/handlers/codec_client.c b/src/liana/handlers/codec_client.c index dc53129..3722197 100644 --- a/src/liana/handlers/codec_client.c +++ b/src/liana/handlers/codec_client.c @@ -44,7 +44,7 @@ static bool push_av_packet(struct lia_codec_client *codec, AVPacket *pkt) } #endif -static bool push_packet(struct lia_codec_client *codec, struct aki_buffer *buffer) +static bool push_packet(struct lia_codec_client *codec, struct nn_buffer *buffer) { struct camu_codec_packet packet; packet.buffer = buffer; @@ -52,7 +52,7 @@ static bool push_packet(struct lia_codec_client *codec, struct aki_buffer *buffe return ret == CAMU_OK; } -static bool codec_client_handle_packet(struct lia_client_handler *handler, struct aki_packet *packet) +static bool codec_client_handle_packet(struct lia_client_handler *handler, struct nn_packet *packet) { struct lia_codec_client *codec = (struct lia_codec_client *)handler; @@ -72,12 +72,12 @@ static bool codec_client_handle_packet(struct lia_client_handler *handler, struc // Push packet. bool success; - u8 type = aki_packet_read_u8(packet); + u8 type = nn_packet_read_u8(packet); switch (type) { case CAMU_NORMAL: { if (codec->dec) { - struct aki_buffer buffer; - aki_packet_read_buffer(packet, &buffer); + struct nn_buffer buffer; + nn_packet_read_buffer(packet, &buffer); success = push_packet(codec, &buffer); } else { success = true; @@ -86,7 +86,7 @@ static bool codec_client_handle_packet(struct lia_client_handler *handler, struc } #ifdef CAMU_HAVE_FFMPEG case CAMU_FFMPEG_COMPAT: { - AVPacket *pkt = aki_packet_read_av_packet(packet); + AVPacket *pkt = nn_packet_read_av_packet(packet); if (codec->dec) { success = push_av_packet(codec, pkt); } else { diff --git a/src/liana/handlers/codec_server.c b/src/liana/handlers/codec_server.c index 94b18df..7167f97 100644 --- a/src/liana/handlers/codec_server.c +++ b/src/liana/handlers/codec_server.c @@ -33,30 +33,30 @@ static bool codec_server_init(struct lia_server_handler *handler, struct cch_han return true; } -static void codec_server_write_info(struct lia_server_handler *handler, struct aki_packet *packet) +static void codec_server_write_info(struct lia_server_handler *handler, struct nn_packet *packet) { struct lia_codec_server *codec = (struct lia_codec_server *)handler; u64 duration = codec->demux->get_duration(codec->demux); - aki_packet_write_u64(packet, duration); - aki_packet_write_u32(packet, codec->demux->streams.size); + nn_packet_write_u64(packet, duration); + nn_packet_write_u32(packet, codec->demux->streams.size); struct camu_codec_stream *stream; al_array_foreach_ptr(codec->demux->streams, i, stream) { - aki_packet_write_u8(packet, stream->mode); - aki_packet_write_u8(packet, stream->type); - aki_packet_write_u64(packet, stream->duration); - aki_packet_write_s32(packet, i); + nn_packet_write_u8(packet, stream->mode); + nn_packet_write_u8(packet, stream->type); + nn_packet_write_u64(packet, stream->duration); + nn_packet_write_s32(packet, i); switch (stream->mode) { case CAMU_NORMAL: { struct camu_video_format *fmt = &stream->video.fmt; - aki_packet_write_s32(packet, fmt->width); - aki_packet_write_s32(packet, fmt->height); - aki_packet_write_s32(packet, fmt->format); + nn_packet_write_s32(packet, fmt->width); + nn_packet_write_s32(packet, fmt->height); + nn_packet_write_s32(packet, fmt->format); break; } #ifdef CAMU_HAVE_FFMPEG case CAMU_FFMPEG_COMPAT: - aki_packet_write_av_codec_id(packet, stream->av.stream->codecpar->codec_id); - aki_packet_write_av_stream(packet, stream->av.stream); + nn_packet_write_av_codec_id(packet, stream->av.stream->codecpar->codec_id); + nn_packet_write_av_stream(packet, stream->av.stream); break; #endif } @@ -87,33 +87,33 @@ static void codec_server_step(struct lia_server_handler *handler) codec->handler.status = codec->demux->get_packet(codec->demux, &codec->packet); } -static void codec_server_write_packet(struct lia_server_handler *handler, struct aki_packet *packet) +static void codec_server_write_packet(struct lia_server_handler *handler, struct nn_packet *packet) { struct lia_codec_server *codec = (struct lia_codec_server *)handler; if (codec->handler.status == CAMU_OK) { - aki_packet_write_u8(packet, LIANA_PACKET_DATA); + nn_packet_write_u8(packet, LIANA_PACKET_DATA); switch (codec->packet.mode) { case CAMU_NORMAL: { - aki_packet_write_s32(packet, 0); - aki_packet_write_u8(packet, codec->packet.mode); - aki_packet_write_buffer(packet, codec->packet.buffer); + nn_packet_write_s32(packet, 0); + nn_packet_write_u8(packet, codec->packet.mode); + nn_packet_write_buffer(packet, codec->packet.buffer); break; } #ifdef CAMU_HAVE_FFMPEG case CAMU_FFMPEG_COMPAT: { AVPacket *pkt = codec->packet.av.pkt; - aki_packet_write_s32(packet, pkt->stream_index); - aki_packet_write_u8(packet, codec->packet.mode); - aki_packet_write_av_packet(packet, pkt); + nn_packet_write_s32(packet, pkt->stream_index); + nn_packet_write_u8(packet, codec->packet.mode); + nn_packet_write_av_packet(packet, pkt); av_packet_unref(pkt); break; } #endif } } else if (codec->handler.status == CAMU_ERR_EOF) { - aki_packet_write_u8(packet, LIANA_PACKET_EOF); + nn_packet_write_u8(packet, LIANA_PACKET_EOF); } else { - aki_packet_write_u8(packet, LIANA_PACKET_ERROR); + nn_packet_write_u8(packet, LIANA_PACKET_ERROR); } } diff --git a/src/liana/list.c b/src/liana/list.c index 073cdf0..7c4979b 100644 --- a/src/liana/list.c +++ b/src/liana/list.c @@ -1,4 +1,4 @@ -#include <aki/thread.h> +#include <nnwt/thread.h> #include <al/random.h> #include <al/lib.h> #include <al/log.h> @@ -112,7 +112,7 @@ static bool handle_add_sink(struct lia_list *list, struct lia_list_sink *sink) if (error) pump_queue(list); return false; } - u64 now = aki_get_timestamp(); + u64 now = nn_get_timestamp(); u8 pause; u64 at = LIANA_TIMESTAMP_INVALID; u64 seek_pos = current->offset; @@ -168,7 +168,7 @@ static bool handle_add(struct lia_list *list, struct lia_list_entry *entry) } list->current++; list->idle = false; - entry->start = aki_get_timestamp() + LIANA_BASE_DELAY; + entry->start = nn_get_timestamp() + LIANA_BASE_DELAY; struct lia_timing time = { .at = entry->start, .seek_pos = entry->offset, @@ -299,7 +299,7 @@ static bool handle_skipto(struct lia_list *list, s32 sequence, s32 index) return false; } - u64 now = aki_get_timestamp(); + u64 now = nn_get_timestamp(); u64 at = now + LIANA_BASE_DELAY; u8 pause; @@ -405,7 +405,7 @@ static void handle_toggle_pause(struct lia_list *list, s32 sequence, f64 pts) struct lia_list_entry *entry = get_entry_from_sequence(list, sequence); al_assert(entry && !entry->held); - u64 now = aki_get_timestamp(); + u64 now = nn_get_timestamp(); u8 pause = entry->paused_at == LIANA_TIMESTAMP_INVALID ? LIANA_PAUSE_PAUSE : LIANA_PAUSE_RESUME; u64 at; bool ended = assume_ended(entry, now); @@ -461,7 +461,7 @@ static void handle_seek(struct lia_list *list, s32 sequence, u32 id, f64 percent } entry->ended = false; - u64 now = aki_get_timestamp(); + u64 now = nn_get_timestamp(); u64 pos = (u64)(entry->duration * percent); u64 at = now + LIANA_BASE_DELAY; u8 pause = entry->paused_at == LIANA_TIMESTAMP_INVALID ? LIANA_PAUSE_RESUME : LIANA_PAUSE_NONE; @@ -527,10 +527,12 @@ static bool handle_end(struct lia_list *list, s32 id) return false; } else { list->idle = true; + /* struct lia_list_sink *sink; al_array_foreach(list->sinks, i, sink) { sink->set = -1; } + */ } } diff --git a/src/liana/meson.build b/src/liana/meson.build index 32e6a00..b68ba8b 100644 --- a/src/liana/meson.build +++ b/src/liana/meson.build @@ -16,7 +16,6 @@ liana_args = [] if cache_have_cdio liana_server_src += ['handlers/cdio_server.c'] liana_client_src += ['handlers/cdio_client.c'] - liana_args += ['-DLIANA_HAVE_CDIO'] endif liana_server = declare_dependency(sources: liana_server_src, diff --git a/src/liana/server.c b/src/liana/server.c index 44b3f12..27c253b 100644 --- a/src/liana/server.c +++ b/src/liana/server.c @@ -5,7 +5,7 @@ #include "handlers.h" #include "list.h" -bool lia_server_init(struct lia_server *server, struct aki_event_loop *loop) +bool lia_server_init(struct lia_server *server, struct nn_event_loop *loop) { server->loop = loop; server->increment = 1; @@ -14,52 +14,46 @@ bool lia_server_init(struct lia_server *server, struct aki_event_loop *loop) return true; } -static void remove_zombie(struct lia_server *server, struct aki_packet_stream *stream) +static void remove_zombie(struct lia_server *server, struct nn_packet_stream *stream) { - struct aki_packet_stream *zombie; - al_array_foreach(server->zombies, i, zombie) { - if (zombie == stream) { - al_array_remove_at(server->zombies, i); - break; - } - } + al_array_remove(server->zombies, stream); } -static void data_packet_sent_callback(void *userdata, struct aki_packet *packet) +static void data_packet_sent_callback(void *userdata, struct nn_packet *packet) { struct lia_node_connection *conn = (struct lia_node_connection *)userdata; - aki_packet_pool_return(&conn->pool, packet); + nn_packet_pool_return(&conn->pool, packet); } -static u8 packet_pool_callback(void *userdata, struct aki_packet *packet) +static u8 packet_pool_callback(void *userdata, struct nn_packet *packet) { struct lia_node_connection *conn = (struct lia_node_connection *)userdata; - if (!aki_packet_stream_send_packet(conn->stream, packet)) { - return AKI_PACKET_POOL_RETURN; + if (!nn_packet_stream_send_packet(conn->stream, packet)) { + return NNWT_PACKET_POOL_RETURN; } - return AKI_PACKET_POOL_KEEP; + return NNWT_PACKET_POOL_KEEP; } -static aki_thread_result AKI_THREADCALL handler_thread(void *userdata) +static nn_thread_result NNWT_THREADCALL handler_thread(void *userdata) { struct lia_node_connection *conn = (struct lia_node_connection *)userdata; do { - struct aki_packet *packet = aki_packet_pool_get(&conn->pool); + struct nn_packet *packet = nn_packet_pool_get(&conn->pool); if (!packet) break; conn->handler->step(conn->handler); conn->handler->write_packet(conn->handler, packet); - aki_packet_pool_submit(&conn->pool, packet); + nn_packet_pool_submit(&conn->pool, packet); if (conn->handler->status != CAMU_OK) break; } while (1); - aki_packet_pool_flush(&conn->pool); + nn_packet_pool_flush(&conn->pool); return 0; } -static void discard_packet_callback(void *userdata, struct aki_packet_stream *stream, struct aki_packet *packet) +static void discard_packet_callback(void *userdata, struct nn_packet_stream *stream, struct nn_packet *packet) { (void)userdata; (void)stream; - aki_packet_free(packet); + nn_packet_free(packet); // We should never be here. Although, we also shouldn't assert because // any erroneous connection can bring us here. al_assert(false); @@ -70,83 +64,83 @@ static void close_connection_internal(struct lia_node_connection *conn) al_assert(conn->handler); conn->handler->free(&conn->handler); cch_entry_return_handle(conn->node->entry, &conn->handle); - aki_packet_stream_free(conn->stream); + nn_packet_stream_free(conn->stream); al_free(conn->stream); conn->stream = NULL; } -static void data_connection_closed_callback(void *userdata, struct aki_packet_stream *stream) +static void data_connection_closed_callback(void *userdata, struct nn_packet_stream *stream) { struct lia_node_connection *conn = (struct lia_node_connection *)userdata; (void)stream; - aki_packet_pool_disable(&conn->pool); + nn_packet_pool_disable(&conn->pool); cch_handle_disable(&conn->handle); // This is joining handler_thread(), we will never be here if init_thread() blocks or fails. - aki_thread_join(&conn->thread); + nn_thread_join(&conn->thread); close_connection_internal(conn); - aki_packet_pool_free(&conn->pool); + nn_packet_pool_free(&conn->pool); } -static void subscribe_packet_callback(void *userdata, struct aki_packet_stream *stream, struct aki_packet *packet) +static void subscribe_packet_callback(void *userdata, struct nn_packet_stream *stream, struct nn_packet *packet) { struct lia_node_connection *conn = (struct lia_node_connection *)userdata; - s32 mask = aki_packet_read_s32(packet); + s32 mask = nn_packet_read_s32(packet); conn->handler->subscribe(conn->handler, mask); stream->packet_callback = discard_packet_callback; stream->packet_sent_callback = data_packet_sent_callback; stream->connection_closed_callback = data_connection_closed_callback; - aki_thread_create(&conn->thread, handler_thread, conn); - aki_packet_free(packet); + nn_thread_create(&conn->thread, handler_thread, conn); + nn_packet_free(packet); } -static void subscribe_packet_sent_callback(void *userdata, struct aki_packet *packet) +static void subscribe_packet_sent_callback(void *userdata, struct nn_packet *packet) { (void)userdata; - aki_packet_free(packet); + nn_packet_free(packet); } -static void subscribe_connection_closed_callback(void *userdata, struct aki_packet_stream *stream) +static void subscribe_connection_closed_callback(void *userdata, struct nn_packet_stream *stream) { struct lia_node_connection *conn = (struct lia_node_connection *)userdata; (void)stream; close_connection_internal(conn); - aki_packet_pool_free(&conn->pool); + nn_packet_pool_free(&conn->pool); } -static void handle_connection(struct lia_node_connection *conn, struct aki_packet *packet) +static void handle_connection(struct lia_node_connection *conn, struct nn_packet *packet) { - struct aki_packet_stream *stream = conn->stream; + struct nn_packet_stream *stream = conn->stream; - s32 mask = aki_packet_read_s32(packet); - u64 seek_pos = aki_packet_read_u64(packet); + s32 mask = nn_packet_read_s32(packet); + u64 seek_pos = nn_packet_read_u64(packet); // Besides being wasteful, seeking to 0 on a new stream can skip data. if (seek_pos > 0) conn->handler->seek(conn->handler, seek_pos); if (mask == 0) { - struct aki_packet *rpacket = aki_packet_create(); - aki_packet_write_u32(rpacket, conn->id); - aki_packet_write_str(rpacket, cch_entry_get_liana(conn->node->entry)); + struct nn_packet *rpacket = nn_packet_create(); + nn_packet_write_u32(rpacket, conn->id); + nn_packet_write_str(rpacket, cch_entry_get_liana(conn->node->entry)); conn->handler->write_info(conn->handler, rpacket); stream->packet_callback = subscribe_packet_callback; stream->packet_sent_callback = subscribe_packet_sent_callback; stream->connection_closed_callback = subscribe_connection_closed_callback; - aki_packet_stream_send_packet(stream, rpacket); + nn_packet_stream_send_packet(stream, rpacket); } else { conn->handler->subscribe(conn->handler, mask); stream->packet_callback = discard_packet_callback; stream->packet_sent_callback = data_packet_sent_callback; stream->connection_closed_callback = data_connection_closed_callback; - aki_thread_create(&conn->thread, handler_thread, conn); + nn_thread_create(&conn->thread, handler_thread, conn); } } -static void connection_closed_callback(void *userdata, struct aki_packet_stream *stream) +static void connection_closed_callback(void *userdata, struct nn_packet_stream *stream) { struct lia_server *server = (struct lia_server *)userdata; // This connection might no longer be a zombie, but that's fine. remove_zombie(server, stream); - aki_packet_stream_free(stream); + nn_packet_stream_free(stream); al_free(stream); } @@ -155,9 +149,9 @@ static void signal_callback(void *userdata) struct lia_node_connection *conn = (struct lia_node_connection *)userdata; struct lia_node *node = conn->node; struct lia_server *server = node->server; - aki_signal_stop(&conn->signal); - aki_thread_join(&conn->thread); - struct aki_packet *packet = conn->packet; + nn_signal_stop(&conn->signal); + nn_thread_join(&conn->thread); + struct nn_packet *packet = conn->packet; if (!packet) { // Connection was closed before init was done. close_connection_internal(conn); @@ -166,30 +160,30 @@ static void signal_callback(void *userdata) if (!conn->errored) { conn->id = server->increment; server->increment = al_u32_inc_wrap(server->increment); - aki_packet_pool_init(&conn->pool, 96, server->loop, packet_pool_callback, conn); + nn_packet_pool_init(&conn->pool, 96, server->loop, packet_pool_callback, conn); al_array_push(node->connections, conn); handle_connection(conn, packet); } else { conn->handler->free(&conn->handler); cch_entry_return_handle(node->entry, &conn->handle); - struct aki_packet_stream *stream = conn->stream; + struct nn_packet_stream *stream = conn->stream; al_free(conn); conn = NULL; // This connection is now nothing but a packet stream. stream->userdata = server; stream->connection_closed_callback = connection_closed_callback; - aki_packet_stream_disconnect(stream); + nn_packet_stream_disconnect(stream); } - aki_packet_free(packet); + nn_packet_free(packet); } -static aki_thread_result AKI_THREADCALL init_thread(void *userdata) +static nn_thread_result NNWT_THREADCALL init_thread(void *userdata) { struct lia_node_connection *conn = (struct lia_node_connection *)userdata; if (!conn->handler->init(conn->handler, &conn->handle)) { conn->errored = true; } - aki_signal_send(&conn->signal); + nn_signal_send(&conn->signal); return 0; } @@ -211,24 +205,24 @@ static struct lia_node *get_node_from_id(struct lia_server *server, u32 id) return NULL; } -static void pre_init_connection_closed_callback(void *userdata, struct aki_packet_stream *stream) +static void pre_init_connection_closed_callback(void *userdata, struct nn_packet_stream *stream) { struct lia_node_connection *conn = (struct lia_node_connection *)userdata; (void)stream; - aki_packet_free(conn->packet); + nn_packet_free(conn->packet); // Checked in signal_callback and will signal to cleanup the connection. conn->packet = NULL; } -static void packet_callback(void *userdata, struct aki_packet_stream *stream, struct aki_packet *packet) +static void packet_callback(void *userdata, struct nn_packet_stream *stream, struct nn_packet *packet) { struct lia_server *server = (struct lia_server *)userdata; // We got a packet, this connection is no longer a zombie. remove_zombie(server, stream); - u32 node_id = aki_packet_read_u32(packet); - u32 connection_id = aki_packet_read_u32(packet); + u32 node_id = nn_packet_read_u32(packet); + u32 connection_id = nn_packet_read_u32(packet); struct lia_node *node = get_node_from_id(server, node_id); struct lia_node_connection *conn = NULL; @@ -238,46 +232,47 @@ static void packet_callback(void *userdata, struct aki_packet_stream *stream, st conn->node = node; conn->stream = stream; conn->packet = packet; - aki_signal_init(&conn->signal, server->loop, signal_callback, conn); - aki_signal_start(&conn->signal); + nn_signal_init(&conn->signal, server->loop, signal_callback, conn); + nn_signal_start(&conn->signal); cch_entry_get_handle(node->entry, &conn->handle); conn->handler = lia_handler_by_name(cch_entry_get_liana(node->entry))->create_server_handler(); conn->errored = false; stream->packet_callback = discard_packet_callback; stream->connection_closed_callback = pre_init_connection_closed_callback; - aki_thread_create(&conn->thread, init_thread, conn); + nn_thread_create(&conn->thread, init_thread, conn); } else { // This is completely unused and connections never get removed from node->connection. if ((conn = get_connection_from_id(node, connection_id))) { handle_connection(conn, packet); } else { - aki_packet_stream_disconnect(stream); + nn_packet_stream_disconnect(stream); } - aki_packet_free(packet); + nn_packet_free(packet); } } -static void packet_sent_callback(void *userdata, struct aki_packet *packet) +static void packet_sent_callback(void *userdata, struct nn_packet *packet) { (void)userdata; - aki_packet_free(packet); + nn_packet_free(packet); } -static void connection_callback(void *userdata, struct aki_packet_stream *stream) +static bool connection_callback(void *userdata, struct nn_packet_stream *stream) { struct lia_server *server = (struct lia_server *)userdata; stream->packet_callback = packet_callback; stream->packet_sent_callback = packet_sent_callback; al_array_push(server->zombies, stream); + return true; } -void lia_server_add_socket(struct lia_server *server, struct aki_socket *sock) +void lia_server_add_socket(struct lia_server *server, struct nn_socket *sock) { - struct aki_packet_stream *stream = al_alloc_object(struct aki_packet_stream); + struct nn_packet_stream *stream = al_alloc_object(struct nn_packet_stream); stream->connection_callback = connection_callback; stream->connection_closed_callback = connection_closed_callback; stream->userdata = server; - aki_packet_stream_from_socket(stream, server->loop, sock); + nn_packet_stream_from_socket(stream, server->loop, sock); } struct lia_node *lia_server_create_node(struct lia_server *server, struct cch_entry *entry) @@ -292,7 +287,7 @@ struct lia_node *lia_server_create_node(struct lia_server *server, struct cch_en return node; } -static aki_thread_result AKI_THREADCALL init_duration_thread(void *userdata) +static nn_thread_result NNWT_THREADCALL init_duration_thread(void *userdata) { struct lia_node *node = (struct lia_node *)userdata; if (!node->handler->init(node->handler, &node->handle)) { @@ -301,15 +296,15 @@ static aki_thread_result AKI_THREADCALL init_duration_thread(void *userdata) } else { node->duration = node->handler->get_duration(node->handler); } - aki_signal_send(&node->signal); + nn_signal_send(&node->signal); return 0; } static void duration_signal_callback(void *userdata) { struct lia_node *node = (struct lia_node *)userdata; - aki_signal_stop(&node->signal); - aki_thread_join(&node->thread); + nn_signal_stop(&node->signal); + nn_thread_join(&node->thread); node->handler->free(&node->handler); cch_entry_return_handle(node->entry, &node->handle); node->callback(node->userdata, LIANA_NODE_DURATION, node->duration); @@ -317,11 +312,11 @@ static void duration_signal_callback(void *userdata) void lia_node_get_duration(struct lia_node *node) { - aki_signal_init(&node->signal, node->server->loop, duration_signal_callback, node); - aki_signal_start(&node->signal); + nn_signal_init(&node->signal, node->server->loop, duration_signal_callback, node); + nn_signal_start(&node->signal); cch_entry_get_handle(node->entry, &node->handle); node->handler = lia_handler_by_name(cch_entry_get_liana(node->entry))->create_server_handler(); - aki_thread_create(&node->thread, init_duration_thread, node); + nn_thread_create(&node->thread, init_duration_thread, node); } void lia_server_close(struct lia_server *server) @@ -331,13 +326,13 @@ void lia_server_close(struct lia_server *server) struct lia_node_connection *connection; al_array_foreach(node->connections, j, connection) { if (connection->stream) { - aki_packet_stream_disconnect(connection->stream); + nn_packet_stream_disconnect(connection->stream); } } } - struct aki_packet_stream *zombie; + struct nn_packet_stream *zombie; al_array_foreach_rev(server->zombies, i, zombie) { - aki_packet_stream_disconnect(zombie); + nn_packet_stream_disconnect(zombie); } } @@ -353,7 +348,7 @@ void lia_server_free(struct lia_server *server) al_free(node); } al_array_free(server->nodes); - struct aki_packet_stream *zombie; + struct nn_packet_stream *zombie; al_array_foreach(server->zombies, i, zombie) { al_free(zombie); } diff --git a/src/liana/server.h b/src/liana/server.h index c62eb29..b4ada58 100644 --- a/src/liana/server.h +++ b/src/liana/server.h @@ -1,23 +1,23 @@ #pragma once -#include <aki/event_loop.h> -#include <aki/packet_stream.h> -#include <aki/packet_pool.h> -#include <aki/socket.h> -#include <aki/signal.h> +#include <nnwt/event_loop.h> +#include <nnwt/packet_stream.h> +#include <nnwt/packet_pool.h> +#include <nnwt/socket.h> +#include <nnwt/signal.h> #include "../cache/entry.h" struct lia_node_connection { u32 id; - struct aki_packet *packet; - struct aki_packet_stream *stream; + struct nn_packet *packet; + struct nn_packet_stream *stream; struct lia_server_handler *handler; bool errored; struct cch_handle handle; - struct aki_thread thread; - struct aki_signal signal; - struct aki_packet_pool pool; + struct nn_thread thread; + struct nn_signal signal; + struct nn_packet_pool pool; struct lia_node *node; }; @@ -36,21 +36,21 @@ struct lia_node { struct lia_server_handler *handler; bool errored; struct cch_handle handle; - struct aki_thread thread; - struct aki_signal signal; + struct nn_thread thread; + struct nn_signal signal; void (*callback)(void *, u8, u64); void *userdata; }; struct lia_server { - struct aki_event_loop *loop; + struct nn_event_loop *loop; u32 increment; array(struct lia_node *) nodes; - array(struct aki_packet_stream *) zombies; + array(struct nn_packet_stream *) zombies; }; -bool lia_server_init(struct lia_server *server, struct aki_event_loop *loop); -void lia_server_add_socket(struct lia_server *server, struct aki_socket *sock); +bool lia_server_init(struct lia_server *server, struct nn_event_loop *loop); +void lia_server_add_socket(struct lia_server *server, struct nn_socket *sock); struct lia_node *lia_server_create_node(struct lia_server *server, struct cch_entry *entry); void lia_node_get_duration(struct lia_node *node); void lia_server_close(struct lia_server *server); diff --git a/src/liana/vcr.c b/src/liana/vcr.c index c4bf583..4131c80 100644 --- a/src/liana/vcr.c +++ b/src/liana/vcr.c @@ -19,7 +19,7 @@ enum { static void signal_callback(void *userdata) { struct lia_vcr *vcr = (struct lia_vcr *)userdata; - aki_packet_stream_cork(vcr->data, false); + nn_packet_stream_cork(vcr->data, false); } static void reset_metrics(struct lia_vcr *vcr) @@ -28,7 +28,7 @@ static void reset_metrics(struct lia_vcr *vcr) vcr->metric.last_report_ts = 0Lu; } -void lia_vcr_init(struct lia_vcr *vcr, struct aki_event_loop *loop, struct aki_packet_stream *data) +void lia_vcr_init(struct lia_vcr *vcr, struct nn_event_loop *loop, struct nn_packet_stream *data) { al_array_init(vcr->tracks); al_atomic_store(u64)(&vcr->count, 0, AL_ATOMIC_RELAXED); @@ -36,25 +36,25 @@ void lia_vcr_init(struct lia_vcr *vcr, struct aki_event_loop *loop, struct aki_p vcr->mark.low = 0; vcr->expand = VCR_EXPAND_UNTOUCHED; vcr->data = data; - aki_signal_init(&vcr->signal, loop, signal_callback, vcr); + nn_signal_init(&vcr->signal, loop, signal_callback, vcr); reset_metrics(vcr); } void lia_vcr_start(struct lia_vcr *vcr) { - aki_signal_start(&vcr->signal); + nn_signal_start(&vcr->signal); } -static aki_thread_result AKI_THREADCALL vcr_track_thread(void *userdata) +static nn_thread_result NNWT_THREADCALL vcr_track_thread(void *userdata) { struct lia_vcr_track *track = (struct lia_vcr_track *)userdata; struct lia_vcr *vcr = track->vcr; u32 packets; - struct aki_packet *packet = NULL; - while (aki_packet_cache_wait(&track->cache, &packets)) { + struct nn_packet *packet = NULL; + while (nn_packet_cache_wait(&track->cache, &packets)) { s32 state = 0; for (u32 i = 0; i < packets; i++) { - packet = aki_packet_cache_pop(&track->cache); + packet = nn_packet_cache_pop(&track->cache); state = 0; if (packet) { state = al_atomic_load(s32)(&track->state, AL_ATOMIC_RELAXED); @@ -62,11 +62,11 @@ static aki_thread_result AKI_THREADCALL vcr_track_thread(void *userdata) // We were signaled to close, exit thread. goto out; } - u32 size = aki_packet_get_size(packet); + u32 size = nn_packet_get_size(packet); u8 buffered = al_atomic_load(u8)(&track->buffered, AL_ATOMIC_RELAXED); u64 buffer = al_atomic_sub(u64)(&vcr->count, size, AL_ATOMIC_RELAXED); if (buffered && buffer <= vcr->mark.low) { - aki_signal_send(&vcr->signal); + nn_signal_send(&vcr->signal); } } if (!track->client->handle_packet(track->client, packet)) { @@ -74,14 +74,14 @@ static aki_thread_result AKI_THREADCALL vcr_track_thread(void *userdata) goto out; } if (packet) { - aki_packet_free(packet); + nn_packet_free(packet); packet = NULL; if (state == LIANA_STREAM_STOPPED) { // Unlock here to accumulate packets while waiting. - aki_packet_cache_unlock(&track->cache); - aki_mutex_lock(&track->mutex); - aki_cond_wait(&track->cond, &track->mutex); - aki_mutex_unlock(&track->mutex); + nn_packet_cache_unlock(&track->cache); + nn_mutex_lock(&track->mutex); + nn_cond_wait(&track->cond, &track->mutex); + nn_mutex_unlock(&track->mutex); break; } } else { @@ -91,25 +91,25 @@ static aki_thread_result AKI_THREADCALL vcr_track_thread(void *userdata) } if (state != LIANA_STREAM_STOPPED) { // If state = STOPPED, we already unlocked. - aki_packet_cache_unlock(&track->cache); + nn_packet_cache_unlock(&track->cache); } } // packet_cache_wait() returned false. return 0; out: // packet_cache_wait() returned true and we are jumping out of the loop. - if (packet) aki_packet_free(packet); - aki_packet_cache_unlock(&track->cache); + if (packet) nn_packet_free(packet); + nn_packet_cache_unlock(&track->cache); return 0; } void lia_vcr_add_track(struct lia_vcr *vcr, struct lia_vcr_track *track) { track->vcr = vcr; - aki_cond_init(&track->cond); - aki_mutex_init(&track->mutex); + nn_cond_init(&track->cond); + nn_mutex_init(&track->mutex); al_atomic_store(u8)(&track->buffered, TRACK_IGNORE_BUFFERED(track), AL_ATOMIC_RELAXED); - aki_packet_cache_init(&track->cache, 256); + nn_packet_cache_init(&track->cache, 256); al_array_push(vcr->tracks, track); al_atomic_store(s32)(&track->state, LIANA_STREAM_RUNNING, AL_ATOMIC_RELAXED); } @@ -145,9 +145,9 @@ static void cork_if_buffered(struct lia_vcr *vcr, u64 buffer) vcr->mark.low = vcr->mark.buffered - MB(2); vcr->expand = VCR_EXPAND_COMPLETE; } - aki_packet_stream_cork(vcr->data, true); + nn_packet_stream_cork(vcr->data, true); al_array_foreach(vcr->tracks, i, track) { - aki_packet_cache_flush(&track->cache); + nn_packet_cache_flush(&track->cache); } } } @@ -155,7 +155,7 @@ static void cork_if_buffered(struct lia_vcr *vcr, u64 buffer) static void update_metrics(struct lia_vcr *vcr, u32 size) { vcr->metric.current_frame += size; - u64 now = aki_get_timestamp(); + u64 now = nn_get_timestamp(); if (!vcr->metric.last_report_ts) { vcr->metric.last_report_ts = now; return; @@ -166,6 +166,7 @@ static void update_metrics(struct lia_vcr *vcr, u32 size) u64 frame = vcr->metric.current_frame; vcr->metric.current_frame = 0Lu; if (diff > 2500000Lu) { + // We are buffering fast enough for it to not matter. al_log_debug("vcr", "Ignoring %lu bytes in metrics.", frame); return; } @@ -174,25 +175,25 @@ static void update_metrics(struct lia_vcr *vcr, u32 size) } } -void lia_vcr_push_packet(struct lia_vcr *vcr, struct aki_packet *packet) +void lia_vcr_push_packet(struct lia_vcr *vcr, struct nn_packet *packet) { struct lia_vcr_track *track; - u8 op = aki_packet_read_u8(packet); + u8 op = nn_packet_read_u8(packet); switch (op) { case LIANA_PACKET_DATA: - track = get_track_from_index(vcr, aki_packet_read_s32(packet)); + track = get_track_from_index(vcr, nn_packet_read_s32(packet)); if (!track) { al_log_warn("liana", "Received data from errored or unknown track."); - aki_packet_free(packet); + nn_packet_free(packet); return; } if (!track->running) { - aki_thread_create(&track->thread, vcr_track_thread, track); + nn_thread_create(&track->thread, vcr_track_thread, track); track->running = true; } - u32 size = aki_packet_get_size(packet); - if (!aki_packet_cache_send_packet(&track->cache, packet)) { - aki_packet_free(packet); + u32 size = nn_packet_get_size(packet); + if (!nn_packet_cache_send_packet(&track->cache, packet)) { + nn_packet_free(packet); return; } u64 buffer; @@ -203,14 +204,14 @@ void lia_vcr_push_packet(struct lia_vcr *vcr, struct aki_packet *packet) break; case LIANA_PACKET_EOF: al_array_foreach(vcr->tracks, i, track) { - aki_packet_cache_send_packet(&track->cache, NULL); + nn_packet_cache_send_packet(&track->cache, NULL); } - aki_packet_free(packet); - aki_signal_stop(&vcr->signal); + nn_packet_free(packet); + nn_signal_stop(&vcr->signal); break; case LIANA_PACKET_ERROR: al_log_warn("liana", "Unhandled error packet."); - aki_packet_free(packet); + nn_packet_free(packet); break; default: al_assert(false); @@ -230,29 +231,29 @@ void lia_vcr_uncork(struct lia_vcr_track *track) // sense is up for consideration. } al_atomic_store(s32)(&track->state, LIANA_STREAM_RUNNING, AL_ATOMIC_RELAXED); - aki_mutex_lock(&track->mutex); - if (aki_cond_is_waiting(&track->cond)) { - aki_cond_signal(&track->cond); + nn_mutex_lock(&track->mutex); + if (nn_cond_is_waiting(&track->cond)) { + nn_cond_signal(&track->cond); } - aki_mutex_unlock(&track->mutex); + nn_mutex_unlock(&track->mutex); } static void vcr_track_close_internal(struct lia_vcr_track *track) { al_atomic_store(s32)(&track->state, LIANA_STREAM_CLOSED, AL_ATOMIC_RELAXED); - aki_packet_cache_disable(&track->cache); - aki_mutex_lock(&track->mutex); - if (aki_cond_is_waiting(&track->cond)) { - aki_cond_signal(&track->cond); + nn_packet_cache_disable(&track->cache); + nn_mutex_lock(&track->mutex); + if (nn_cond_is_waiting(&track->cond)) { + nn_cond_signal(&track->cond); } - aki_mutex_unlock(&track->mutex); + nn_mutex_unlock(&track->mutex); if (track->running) { - aki_thread_join(&track->thread); + nn_thread_join(&track->thread); track->running = false; } - struct aki_packet *packet; - while ((packet = aki_packet_cache_pop(&track->cache))) { - aki_packet_free(packet); + struct nn_packet *packet; + while ((packet = nn_packet_cache_pop(&track->cache))) { + nn_packet_free(packet); } } @@ -262,11 +263,11 @@ void lia_vcr_flush(struct lia_vcr *vcr) al_array_foreach(vcr->tracks, i, track) { vcr_track_close_internal(track); track->client->flush(track->client); - aki_packet_cache_enable(&track->cache); + nn_packet_cache_enable(&track->cache); al_atomic_store(u8)(&track->buffered, TRACK_IGNORE_BUFFERED(track), AL_ATOMIC_RELAXED); al_atomic_store(s32)(&track->state, LIANA_STREAM_RUNNING, AL_ATOMIC_RELAXED); } - aki_signal_stop(&vcr->signal); + nn_signal_stop(&vcr->signal); al_atomic_store(u64)(&vcr->count, 0, AL_ATOMIC_RELAXED); reset_metrics(vcr); if (vcr->expand == VCR_EXPAND_COMPLETE) { @@ -281,14 +282,14 @@ void lia_vcr_close_all(struct lia_vcr *vcr) al_array_foreach(vcr->tracks, i, track) { vcr_track_close_internal(track); } - aki_signal_stop(&vcr->signal); + nn_signal_stop(&vcr->signal); } void lia_vcr_free(struct lia_vcr *vcr) { struct lia_vcr_track *track; al_array_foreach(vcr->tracks, i, track) { - aki_packet_cache_free(&track->cache); + nn_packet_cache_free(&track->cache); track->client->free(&track->client); #ifdef CAMU_HAVE_FFMPEG if (track->stream.mode == CAMU_FFMPEG_COMPAT) { diff --git a/src/liana/vcr.h b/src/liana/vcr.h index 8041d96..ce47104 100644 --- a/src/liana/vcr.h +++ b/src/liana/vcr.h @@ -1,9 +1,9 @@ #pragma once #include <al/atomic.h> -#include <aki/packet_cache.h> -#include <aki/packet_stream.h> -#include <aki/signal.h> +#include <nnwt/packet_cache.h> +#include <nnwt/packet_stream.h> +#include <nnwt/signal.h> #include "../codec/codec.h" @@ -19,11 +19,11 @@ struct lia_vcr_track { struct lia_client_handler *client; atomic(s32) state; atomic(u8) buffered; - struct aki_packet_cache cache; - struct aki_cond cond; - struct aki_mutex mutex; + struct nn_packet_cache cache; + struct nn_cond cond; + struct nn_mutex mutex; bool running; - struct aki_thread thread; + struct nn_thread thread; struct lia_vcr *vcr; }; @@ -32,19 +32,19 @@ struct lia_vcr { atomic(u64) count; struct { u64 buffered, low; } mark; u8 expand; - struct aki_packet_stream *data; - struct aki_signal signal; + struct nn_packet_stream *data; + struct nn_signal signal; struct { u64 current_frame; u64 last_report_ts; } metric; }; -void lia_vcr_init(struct lia_vcr *vcr, struct aki_event_loop *loop, struct aki_packet_stream *data); +void lia_vcr_init(struct lia_vcr *vcr, struct nn_event_loop *loop, struct nn_packet_stream *data); void lia_vcr_start(struct lia_vcr *vcr); void lia_vcr_add_track(struct lia_vcr *vcr, struct lia_vcr_track *track); bool lia_vcr_is_empty(struct lia_vcr *vcr); -void lia_vcr_push_packet(struct lia_vcr *vcr, struct aki_packet *packet); +void lia_vcr_push_packet(struct lia_vcr *vcr, struct nn_packet *packet); void lia_vcr_cork(struct lia_vcr_track *track); void lia_vcr_uncork(struct lia_vcr_track *track); void lia_vcr_flush(struct lia_vcr *vcr); diff --git a/src/libclient/client.c b/src/libclient/client.c index 4b9f46a..b4e44da 100644 --- a/src/libclient/client.c +++ b/src/libclient/client.c @@ -3,17 +3,17 @@ #include "../server/common.h" -static bool results_callback(void *userdata, struct aki_rpc_connection *conn, - struct aki_packet *packet, struct aki_packet *rpacket) +static bool results_callback(void *userdata, struct nn_rpc_connection *conn, + struct nn_packet *packet, struct nn_packet *rpacket) { struct camu_client *client = (struct camu_client *)userdata; (void)conn; (void)rpacket; - u8 op = aki_packet_read_u8(packet); + u8 op = nn_packet_read_u8(packet); switch (op) { case CAMU_CLIENT_CREATE_SEARCH: { - s32 id = aki_packet_read_s32(packet); + s32 id = nn_packet_read_s32(packet); client->callback(client->userdata, CAMU_CLIENT_SEARCH_CREATED, &id); break; } @@ -22,115 +22,115 @@ static bool results_callback(void *userdata, struct aki_rpc_connection *conn, break; } - aki_packet_free(packet); + nn_packet_free(packet); return false; } -static struct aki_rpc_command commands[] = { +static struct nn_rpc_command commands[] = { { .op = CAMU_CLIENT_RESULTS, .callback = results_callback, .userdata = NULL } }; -static void idd_callback(void *userdata, struct aki_packet *packet) +static void idd_callback(void *userdata, struct nn_packet *packet) { struct camu_client *client = (struct camu_client *)userdata; client->callback(client->userdata, CAMU_CLIENT_LOGIN, packet); } -static void connection_callback(void *userdata, struct aki_rpc_connection *conn) +static void connection_callback(void *userdata, struct nn_rpc_connection *conn) { struct camu_client *client = (struct camu_client *)userdata; client->conn = conn; - struct aki_packet *packet = aki_rpc_get_packet(&client->client, CAMU_SERVER_IDENTIFY); - aki_packet_write_u8(packet, CAMU_CLIENT); - aki_packet_write_str(packet, &client->username); - aki_rpc_connection_command(client->conn, packet, idd_callback, client); + struct nn_packet *packet = nn_rpc_get_packet(&client->client, CAMU_SERVER_IDENTIFY); + nn_packet_write_u8(packet, CAMU_CLIENT); + nn_packet_write_str(packet, &client->username); + nn_rpc_connection_command(client->conn, packet, idd_callback, client); } -static void connection_closed_callback(void *userdata, struct aki_rpc_connection *conn) +static void connection_closed_callback(void *userdata, struct nn_rpc_connection *conn) { struct camu_client *client = (struct camu_client *)userdata; al_assert(client->conn == NULL || client->conn == conn); client->conn = NULL; } -bool camu_client_login(struct camu_client *client, struct aki_event_loop *loop, +bool camu_client_login(struct camu_client *client, struct nn_event_loop *loop, u8 type, str *addr, u16 port, str *username) { client->loop = loop; al_str_clone(&client->username, username); client->conn = NULL; - aki_rpc_init(&client->client, client->loop, connection_callback, connection_closed_callback, client); + nn_rpc_init(&client->client, client->loop, connection_callback, connection_closed_callback, client); for (u32 i = 0; i < ARRAY_SIZE(commands); i++) { commands[i].userdata = client; - aki_rpc_add_command(&client->client, &commands[i]); + nn_rpc_add_command(&client->client, &commands[i]); } - if (!aki_rpc_prepare_client(&client->client, type, CAMU_MULTIPLEX_RPC)) { + if (!nn_rpc_prepare_client(&client->client, type, CAMU_MULTIPLEX_RPC)) { return false; } - aki_rpc_connect(&client->client, addr, port); + nn_rpc_connect(&client->client, addr, port); return true; } void camu_client_create_list(struct camu_client *client, str *name, - void (*callback)(void *, struct aki_packet *), void *userdata) + void (*callback)(void *, struct nn_packet *), void *userdata) { - struct aki_packet *packet = aki_rpc_get_packet(&client->client, CAMU_SERVER_CLIENT_COMMAND); - aki_packet_write_u8(packet, CAMU_CLIENT_CREATE_LIST); - aki_packet_write_str(packet, name); - aki_rpc_connection_command(client->conn, packet, callback, userdata); + struct nn_packet *packet = nn_rpc_get_packet(&client->client, CAMU_SERVER_CLIENT_COMMAND); + nn_packet_write_u8(packet, CAMU_CLIENT_CREATE_LIST); + nn_packet_write_str(packet, name); + nn_rpc_connection_command(client->conn, packet, callback, userdata); } void camu_client_toggle_sink(struct camu_client *client, str *sink, str *list, bool enable, - void (*callback)(void *, struct aki_packet *), void *userdata) + void (*callback)(void *, struct nn_packet *), void *userdata) { - struct aki_packet *packet = aki_rpc_get_packet(&client->client, CAMU_SERVER_CLIENT_COMMAND); - aki_packet_write_u8(packet, CAMU_CLIENT_TOGGLE_SINK); - aki_packet_write_str(packet, sink); - aki_packet_write_str(packet, list); - aki_packet_write_bool(packet, enable); - aki_rpc_connection_command(client->conn, packet, callback, userdata); + struct nn_packet *packet = nn_rpc_get_packet(&client->client, CAMU_SERVER_CLIENT_COMMAND); + nn_packet_write_u8(packet, CAMU_CLIENT_TOGGLE_SINK); + nn_packet_write_str(packet, sink); + nn_packet_write_str(packet, list); + nn_packet_write_bool(packet, enable); + nn_rpc_connection_command(client->conn, packet, callback, userdata); } void camu_client_create_search(struct camu_client *client, str *module, str *query) { - struct aki_packet *packet = aki_rpc_get_packet(&client->client, CAMU_SERVER_CLIENT_COMMAND); - aki_packet_write_u8(packet, CAMU_CLIENT_CREATE_SEARCH); - aki_packet_write_str(packet, module); - aki_packet_write_str(packet, query); - aki_rpc_connection_command(client->conn, packet, NULL, NULL); + struct nn_packet *packet = nn_rpc_get_packet(&client->client, CAMU_SERVER_CLIENT_COMMAND); + nn_packet_write_u8(packet, CAMU_CLIENT_CREATE_SEARCH); + nn_packet_write_str(packet, module); + nn_packet_write_str(packet, query); + nn_rpc_connection_command(client->conn, packet, NULL, NULL); } void camu_client_get_page(struct camu_client *client, s32 id, u32 num) { - struct aki_packet *packet = aki_rpc_get_packet(&client->client, CAMU_SERVER_CLIENT_COMMAND); - aki_packet_write_u8(packet, CAMU_CLIENT_GET_PAGE); - aki_packet_write_s32(packet, id); - aki_packet_write_u32(packet, num); - aki_rpc_connection_command(client->conn, packet, NULL, NULL); + struct nn_packet *packet = nn_rpc_get_packet(&client->client, CAMU_SERVER_CLIENT_COMMAND); + nn_packet_write_u8(packet, CAMU_CLIENT_GET_PAGE); + nn_packet_write_s32(packet, id); + nn_packet_write_u32(packet, num); + nn_rpc_connection_command(client->conn, packet, NULL, NULL); } void camu_client_add_from_path(struct camu_client *client, str *list, str *path) { - struct aki_packet *packet = aki_rpc_get_packet(&client->client, CAMU_SERVER_LIST_ACTION); - aki_packet_write_str(packet, list); - aki_packet_write_u8(packet, CAMU_LIST_ADD); - aki_packet_write_u8(packet, CAMU_RESOURCE_FILE); - aki_packet_write_str(packet, path); - aki_rpc_connection_command(client->conn, packet, NULL, NULL); + struct nn_packet *packet = nn_rpc_get_packet(&client->client, CAMU_SERVER_LIST_ACTION); + nn_packet_write_str(packet, list); + nn_packet_write_u8(packet, CAMU_LIST_ADD); + nn_packet_write_u8(packet, CAMU_RESOURCE_FILE); + nn_packet_write_str(packet, path); + nn_rpc_connection_command(client->conn, packet, NULL, NULL); } void camu_client_add_from_post(struct camu_client *client, str *list, str *unique_id, u32 index) { - struct aki_packet *packet = aki_rpc_get_packet(&client->client, CAMU_SERVER_LIST_ACTION); - aki_packet_write_str(packet, list); - aki_packet_write_u8(packet, CAMU_LIST_ADD); - aki_packet_write_u8(packet, CAMU_RESOURCE_PORTAL); - aki_packet_write_str(packet, unique_id); - aki_packet_write_u32(packet, index); - aki_rpc_connection_command(client->conn, packet, NULL, NULL); + struct nn_packet *packet = nn_rpc_get_packet(&client->client, CAMU_SERVER_LIST_ACTION); + nn_packet_write_str(packet, list); + nn_packet_write_u8(packet, CAMU_LIST_ADD); + nn_packet_write_u8(packet, CAMU_RESOURCE_PORTAL); + nn_packet_write_str(packet, unique_id); + nn_packet_write_u32(packet, index); + nn_rpc_connection_command(client->conn, packet, NULL, NULL); } void camu_client_disconnect(struct camu_client *client) { - aki_rpc_conn_flush(client->conn); + nn_rpc_conn_flush(client->conn); } diff --git a/src/libclient/client.h b/src/libclient/client.h index c073c9e..63d877d 100644 --- a/src/libclient/client.h +++ b/src/libclient/client.h @@ -1,6 +1,6 @@ #pragma once -#include <aki/rpc2.h> +#include <nnwt/rpc2.h> enum { CAMU_CLIENT_LOGIN = 0, @@ -9,21 +9,21 @@ enum { }; struct camu_client { - struct aki_event_loop *loop; + struct nn_event_loop *loop; str username; - struct aki_rpc client; - struct aki_rpc_connection *conn; + struct nn_rpc client; + struct nn_rpc_connection *conn; void (*callback)(void *, u8, void *); void *userdata; }; -bool camu_client_login(struct camu_client *client, struct aki_event_loop *loop, +bool camu_client_login(struct camu_client *client, struct nn_event_loop *loop, u8 type, str *addr, u16 port, str *username); void camu_client_create_list(struct camu_client *client, str *name, - void (*callback)(void *, struct aki_packet *), void *userdata); + void (*callback)(void *, struct nn_packet *), void *userdata); void camu_client_toggle_sink(struct camu_client *client, str *sink, str *list, bool enable, - void (*callback)(void *, struct aki_packet *), void *userdata); + void (*callback)(void *, struct nn_packet *), void *userdata); void camu_client_create_search(struct camu_client *client, str *module, str *query); void camu_client_get_page(struct camu_client *client, s32 id, u32 num); diff --git a/src/libsink/sink.c b/src/libsink/sink.c index bd33f46..984a41c 100644 --- a/src/libsink/sink.c +++ b/src/libsink/sink.c @@ -50,7 +50,7 @@ enum { }; // Number of entries to keep buffered at one time. -#define ENTRY_MAX_AGE 6 +#define ENTRY_MAX_AGE 7 // If a buffer is still INIT or QUEUED after an entry is configured, it's "empty". #define BUFFER_EMPTY(buf) ((buf)->state == BUFFER_INIT || (buf)->state == BUFFER_QUEUED) @@ -82,9 +82,9 @@ enum { #endif #if defined CAMU_SCREEN_THREADED && defined CAMU_MIXER_THREADED -#define BLOCKING_SLEEP(delay) aki_thread_sleep(delay) +#define BLOCKING_SLEEP(delay) nn_thread_sleep(delay) #else -#define BLOCKING_SLEEP(delay) aki_event_loop_sleep(sink->loop, delay) +#define BLOCKING_SLEEP(delay) nn_event_loop_sleep(sink->loop, delay) #endif static inline bool entry_audio_buffer_held(struct camu_sink_entry *entry) @@ -223,7 +223,7 @@ static void handle_sink_cmd(struct camu_sink *sink, struct camu_sink_cmd *cmd) { switch (cmd->op) { case START: { - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); switch (cmd->value.i) { case CAMU_SINK_AUDIO: if (sink->audio.state == SINK_PAUSED) { @@ -240,11 +240,11 @@ static void handle_sink_cmd(struct camu_sink *sink, struct camu_sink_cmd *cmd) break; #endif } - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); break; } case STOP: { - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); switch (cmd->value.i) { case CAMU_SINK_AUDIO: if (sink->audio.state == SINK_PLAYING) { @@ -261,25 +261,25 @@ static void handle_sink_cmd(struct camu_sink *sink, struct camu_sink_cmd *cmd) break; #endif } - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); break; } case SKIP: { if (!sink->conn) return; - struct aki_packet *packet = aki_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION); - aki_packet_write_str(packet, &sink->default_list); - aki_packet_write_u8(packet, CAMU_LIST_SKIP); - aki_packet_write_s32(packet, get_sequence_for_command(sink)); - aki_packet_write_s32(packet, (s32)cmd->value.i); - aki_rpc_connection_command(sink->conn, packet, NULL, NULL); + struct nn_packet *packet = nn_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION); + nn_packet_write_str(packet, &sink->default_list); + nn_packet_write_u8(packet, CAMU_LIST_SKIP); + nn_packet_write_s32(packet, get_sequence_for_command(sink)); + nn_packet_write_s32(packet, (s32)cmd->value.i); + nn_rpc_connection_command(sink->conn, packet, NULL, NULL); break; } case SHUFFLE: { if (!sink->conn) return; - struct aki_packet *packet = aki_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION); - aki_packet_write_str(packet, &sink->default_list); - aki_packet_write_u8(packet, CAMU_LIST_SHUFFLE); - aki_rpc_connection_command(sink->conn, packet, NULL, NULL); + struct nn_packet *packet = nn_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION); + nn_packet_write_str(packet, &sink->default_list); + nn_packet_write_u8(packet, CAMU_LIST_SHUFFLE); + nn_rpc_connection_command(sink->conn, packet, NULL, NULL); break; } case TOGGLE_PAUSE: { @@ -287,30 +287,30 @@ static void handle_sink_cmd(struct camu_sink *sink, struct camu_sink_cmd *cmd) sink_local_pause(sink, (struct camu_sink_entry *)cmd->opaque); #else if (!sink->conn) return; - struct aki_packet *packet = aki_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION); - aki_packet_write_str(packet, &sink->default_list); - aki_packet_write_u8(packet, CAMU_LIST_TOGGLE_PAUSE); - aki_packet_write_s32(packet, get_sequence_for_command(sink)); - aki_packet_write_f64(packet, cmd->value.f); - aki_rpc_connection_command(sink->conn, packet, NULL, NULL); + struct nn_packet *packet = nn_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION); + nn_packet_write_str(packet, &sink->default_list); + nn_packet_write_u8(packet, CAMU_LIST_TOGGLE_PAUSE); + nn_packet_write_s32(packet, get_sequence_for_command(sink)); + nn_packet_write_f64(packet, cmd->value.f); + nn_rpc_connection_command(sink->conn, packet, NULL, NULL); #endif break; } case SEEK: { if (!sink->conn) return; - struct aki_packet *packet = aki_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION); - aki_packet_write_str(packet, &sink->default_list); - aki_packet_write_u8(packet, CAMU_LIST_SEEK); + struct nn_packet *packet = nn_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION); + nn_packet_write_str(packet, &sink->default_list); + nn_packet_write_u8(packet, CAMU_LIST_SEEK); struct camu_sink_entry *entry = (struct camu_sink_entry *)cmd->opaque; if (entry) { - aki_packet_write_s32(packet, entry->sequence); - aki_packet_write_u32(packet, entry->id); + nn_packet_write_s32(packet, entry->sequence); + nn_packet_write_u32(packet, entry->id); } else { - aki_packet_write_s32(packet, LIANA_SEQUENCE_ANY); - aki_packet_write_u32(packet, 0); + nn_packet_write_s32(packet, LIANA_SEQUENCE_ANY); + nn_packet_write_u32(packet, 0); } - aki_packet_write_f64(packet, cmd->value.f); - aki_rpc_connection_command(sink->conn, packet, NULL, NULL); + nn_packet_write_f64(packet, cmd->value.f); + nn_rpc_connection_command(sink->conn, packet, NULL, NULL); break; } case RESEEK: { @@ -320,23 +320,23 @@ static void handle_sink_cmd(struct camu_sink *sink, struct camu_sink_cmd *cmd) } case UNSET: { if (!sink->conn) return; - struct aki_packet *packet = aki_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION); - aki_packet_write_str(packet, &sink->default_list); - aki_packet_write_u8(packet, CAMU_LIST_UNSET); - aki_rpc_connection_command(sink->conn, packet, NULL, NULL); + struct nn_packet *packet = nn_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION); + nn_packet_write_str(packet, &sink->default_list); + nn_packet_write_u8(packet, CAMU_LIST_UNSET); + nn_rpc_connection_command(sink->conn, packet, NULL, NULL); break; } case END: { if (!sink->conn) return; - struct aki_packet *packet = aki_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION); - aki_packet_write_str(packet, &sink->default_list); - aki_packet_write_u8(packet, CAMU_LIST_END); - aki_packet_write_u32(packet, (u32)cmd->value.u); - aki_rpc_connection_command(sink->conn, packet, NULL, NULL); + struct nn_packet *packet = nn_rpc_get_packet(&sink->client, CAMU_SERVER_LIST_ACTION); + nn_packet_write_str(packet, &sink->default_list); + nn_packet_write_u8(packet, CAMU_LIST_END); + nn_packet_write_u32(packet, (u32)cmd->value.u); + nn_rpc_connection_command(sink->conn, packet, NULL, NULL); break; } case CLOSE: { - aki_signal_stop(&sink->queue_signal); + nn_signal_stop(&sink->queue_signal); sink->callback(sink->userdata, CAMU_SINK_EXIT, 0, NULL); return; } @@ -358,7 +358,7 @@ static void queue_signal_callback(void *userdata) static void queue_cmd(struct camu_sink *sink, struct camu_sink_cmd cmd) { camu_queue_push(sink->queue, cmd); - aki_signal_send(&sink->queue_signal); + nn_signal_send(&sink->queue_signal); } static void mixer_callback(void *userdata, u8 op) @@ -373,7 +373,7 @@ static void mixer_callback(void *userdata, u8 op) } } -bool camu_sink_init(struct camu_sink *sink, struct aki_event_loop *loop, +bool camu_sink_init(struct camu_sink *sink, struct nn_event_loop *loop, struct camu_mixer *mixer #ifndef CAMU_SINK_NO_VIDEO , struct camu_renderer *renderer @@ -381,9 +381,9 @@ bool camu_sink_init(struct camu_sink *sink, struct aki_event_loop *loop, ) { sink->loop = loop; - aki_mutex_init(&sink->mutex); - aki_signal_init(&sink->queue_signal, sink->loop, queue_signal_callback, sink); - aki_signal_start(&sink->queue_signal); + nn_mutex_init(&sink->mutex); + nn_signal_init(&sink->queue_signal, sink->loop, queue_signal_callback, sink); + nn_signal_start(&sink->queue_signal); camu_queue_init(sink->queue); sink->queued = NULL; sink->current = NULL; @@ -415,13 +415,7 @@ static void maybe_remove_previous(struct camu_sink *sink) // An obvious example of this is at the point an entry gets freed. See LIANA_CLIENT_REMOVE_BUFFERS. static void maybe_remove_from_previous(struct camu_sink *sink, struct camu_sink_entry *entry) { - struct camu_sink_entry *rentry; - // al_array_remove_all() - al_array_foreach_rev(sink->previous, i, rentry) { - if (rentry == entry) { - al_array_remove_at(sink->previous, i); - } - } + al_array_remove_all(sink->previous, entry); } // Every call to maybe_add_to_previous() must map to a remove_entry_buffers(). @@ -430,10 +424,10 @@ static void maybe_add_to_previous(struct camu_sink *sink, struct camu_sink_entry { al_assert(previous != target && !previous->ended); - struct camu_sink_entry *rentry; - al_array_foreach_rev(sink->previous, i, rentry) { + struct camu_sink_entry *entry; + al_array_foreach_rev(sink->previous, i, entry) { // If the entry we are about to set is in previous, run the queue. - if (rentry == target) { + if (entry == target) { maybe_remove_previous(sink); break; } @@ -441,7 +435,12 @@ static void maybe_add_to_previous(struct camu_sink *sink, struct camu_sink_entry // If neither the entries audio or video buffer is ADDED, we don't care about adding it // to previous (waiting for the next added entry to remove it). - if (!(previous->audio.state == BUFFER_ADDED || previous->video.state == BUFFER_ADDED)) { +#ifndef CAMU_SINK_NO_VIDEO + if (!(previous->audio.state == BUFFER_ADDED || previous->video.state == BUFFER_ADDED)) +#else + if (!(previous->audio.state == BUFFER_ADDED)) +#endif + { remove_entry_buffers(sink, previous); return; } @@ -500,7 +499,7 @@ static void maybe_cleanup_old_entries(struct camu_sink *sink) void add_audio_if_set_and_buffered(struct camu_sink_entry *entry) { al_assert(!entry->ended); - al_assert(entry->audio.state != BUFFER_ADDED && entry->audio.state != BUFFER_QUEUED); + al_assert(entry->audio.state != BUFFER_ADDED); if (entry->audio.state == BUFFER_ENDED) { al_log_warn("sink", "Tried to add an ended audio buffer."); return; @@ -548,7 +547,7 @@ void add_audio_if_set_and_buffered(struct camu_sink_entry *entry) #ifndef CAMU_SINK_NO_VIDEO void add_video_if_set_and_buffered(struct camu_sink_entry *entry) { - al_assert(entry->video.state != BUFFER_ADDED && entry->video.state != BUFFER_QUEUED); + al_assert(entry->video.state != BUFFER_ADDED); if (entry->video.state == BUFFER_ENDED) { al_log_warn("sink", "Tried to add an ended video buffer."); return; @@ -585,6 +584,7 @@ static void switch_to(struct camu_sink *sink, struct camu_sink_entry *target) if (sink->current) { struct camu_sink_entry *current = sink->current; al_assert(current != target); + if (!current->ended) { if (target->ended) { remove_entry_buffers(sink, current); @@ -599,8 +599,9 @@ static void switch_to(struct camu_sink *sink, struct camu_sink_entry *target) #endif al_assert(AUDIO_REMOVED_OR_EMPTY(current) && VIDEO_REMOVED_OR_EMPTY(current)); } + if (sink->reconnecting) { - al_assert(sink->reconnecting == sink->current); + al_assert(sink->reconnecting == current); sink->reconnecting = NULL; } } @@ -656,9 +657,9 @@ static void audio_buffer_callback(void *userdata, u8 op) struct camu_sink *sink = entry->sink; switch (op) { case CAMU_BUFFER_BUFFERED: - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); add_audio_if_set_and_buffered(entry); - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); break; case CAMU_BUFFER_CORK: lia_vcr_cork(entry->audio.track); @@ -667,7 +668,7 @@ static void audio_buffer_callback(void *userdata, u8 op) lia_vcr_uncork(entry->audio.track); break; case CAMU_BUFFER_PAUSED: - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); al_log_info("sink", "Audio buffer paused."); if (!entry->audio.ignore_paused) { queue_cmd(sink, (struct camu_sink_cmd){ @@ -675,11 +676,11 @@ static void audio_buffer_callback(void *userdata, u8 op) .value.i = CAMU_SINK_AUDIO }); } - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); break; case CAMU_BUFFER_EOF: { lia_vcr_cork(entry->audio.track); - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); al_log_info("sink", "Audio EOF."); if (entry->audio.state == BUFFER_ADDED) { remove_entry_audio_buffer(sink, entry); @@ -694,7 +695,7 @@ static void audio_buffer_callback(void *userdata, u8 op) if (run_queue) { end_entry_and_advance_queue(sink, entry); } - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); break; } } @@ -707,9 +708,9 @@ static void video_buffer_callback(void *userdata, u8 op) struct camu_sink *sink = entry->sink; switch (op) { case CAMU_BUFFER_BUFFERED: { - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); add_video_if_set_and_buffered(entry); - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); break; } case CAMU_BUFFER_CORK: @@ -721,7 +722,7 @@ static void video_buffer_callback(void *userdata, u8 op) case CAMU_BUFFER_EOF: { lia_vcr_cork(entry->video.track); bool swapped = false; - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); al_log_info("sink", "Video EOF."); if (!ENTRY_IS_SINGLE_FRAME(entry)) { if (entry->video.state == BUFFER_ADDED) { @@ -733,7 +734,7 @@ static void video_buffer_callback(void *userdata, u8 op) swapped = end_entry_and_advance_queue(sink, entry); } } - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); if (!swapped) { queue_cmd(sink, (struct camu_sink_cmd){ .op = STOP, @@ -762,14 +763,12 @@ static void clock_callback(void *userdata, u8 op) struct camu_sink_entry *entry = (struct camu_sink_entry *)userdata; struct camu_sink *sink = entry->sink; if (op == CAMU_CLOCK_PAUSED) { - aki_mutex_lock(&sink->mutex); - if (entry == sink->current) { - if (sink->target) { - switch_to(sink, sink->target); - sink->target = NULL; - } + nn_mutex_lock(&sink->mutex); + if (entry == sink->current && sink->target) { + switch_to(sink, sink->target); + sink->target = NULL; } - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); } } @@ -817,7 +816,7 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str lia_client_disconnect(&entry->client); return; } - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); if (entry->audio.state == BUFFER_QUEUED) { entry->audio.state = BUFFER_SET_OR_BUFFERED; } else if (entry->audio.state == BUFFER_INIT) { @@ -826,7 +825,7 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str assert(false); } if (VIDEO_ADDED_OR_EMPTY(entry)) evaluate_latency(sink, entry); - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); break; #ifndef CAMU_SINK_NO_VIDEO case CAMU_STREAM_VIDEO: @@ -836,7 +835,7 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str lia_client_disconnect(&entry->client); return; } - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); if (entry->video.state == BUFFER_QUEUED) { entry->video.state = BUFFER_SET_OR_BUFFERED; } else if (entry->video.state == BUFFER_INIT) { @@ -845,7 +844,7 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str assert(false); } if (AUDIO_ADDED_OR_EMPTY(entry)) evaluate_latency(sink, entry); - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); break; case CAMU_STREAM_SUBTITLE: #ifdef CAMU_HAVE_FFMPEG @@ -907,7 +906,7 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str case LIANA_CLIENT_REMOVE_BUFFERS: { bool reconnect = *(bool *)opaque; - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); // We need to call this if entry was added to previous then, // - it's being cleaned up after (ENTRY_MAX_AGE - 1) entries were added but none buffered. @@ -917,11 +916,10 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str if (reconnect) { entry->ended = false; if (entry == sink->current) { + sink->reconnecting = entry; if (sink->target) { switch_to(sink, sink->target); sink->target = NULL; - } else { - sink->reconnecting = sink->current; } } } @@ -949,7 +947,7 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str } #endif - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); while ( // Block until buffers are removed. #ifndef CAMU_SINK_NO_VIDEO @@ -957,7 +955,7 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str #else (!skip_audio && entry_audio_buffer_held(entry)) #endif - ) { BLOCKING_SLEEP(AKI_TS_FROM_USEC(2500)); } + ) { BLOCKING_SLEEP(NNWT_TS_FROM_USEC(2500)); } if (reconnect) { if (BUFFER_NOT_EMPTY(&entry->audio)) { @@ -974,13 +972,13 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str } case LIANA_CLIENT_RESUME_AT: { struct lia_timing *time = (struct lia_timing *)opaque; - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); camu_clock_seek(&entry->clock, time->seek_pos / 1000000.0, time->at); - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); break; } case LIANA_CLIENT_RECONNECTED: { - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); if (entry == sink->reconnecting) { if (entry->audio.state > BUFFER_QUEUED) { add_audio_if_set_and_buffered(entry); @@ -991,7 +989,7 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str } #endif } - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); break; } case LIANA_CLIENT_EOF: { @@ -1015,11 +1013,16 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str break; } case LIANA_CLIENT_CLOSED: { - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); + if (entry == sink->target) { maybe_unset_current(sink); sink->target = NULL; } else if (entry == sink->current) { + if (sink->reconnecting) { + al_assert(sink->reconnecting == sink->current); + sink->reconnecting = NULL; + } // current's buffers will already be removed. sink->current = NULL; if (sink->target) { @@ -1031,26 +1034,17 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str }/* else if (entry == sink->queued) { sink->queued = NULL; }*/ + lia_client_free(&entry->client); camu_audio_buffer_free(&entry->audio.buf); #ifndef CAMU_SINK_NO_VIDEO camu_video_buffer_free(&entry->video.buf); #endif - bool removed = false; - struct camu_sink_entry *rentry; - al_array_foreach(sink->entries, i, rentry) { - if (rentry == entry) { - al_array_remove_at(sink->entries, i); - removed = true; - al_log_info("sink", "Entry closed by disconnect."); - break; - } - } + bool removed; + al_array_check_remove(sink->entries, entry, removed); + nn_mutex_unlock(&sink->mutex); al_free(entry); - if (!removed) { - al_log_info("sink", "Entry closed by cleanup."); - } - aki_mutex_unlock(&sink->mutex); + al_log_info("sink", "Entry closed by %s.", removed ? "disconnect" : "cleanup"); break; } } @@ -1097,16 +1091,16 @@ static struct camu_sink_entry *get_entry_from_id(struct camu_sink *sink, u32 id) return NULL; } -static bool set_command_callback(void *userdata, struct aki_rpc_connection *conn, - struct aki_packet *packet, struct aki_packet *rpacket) +static bool set_command_callback(void *userdata, struct nn_rpc_connection *conn, + struct nn_packet *packet, struct nn_packet *rpacket) { struct camu_sink *sink = (struct camu_sink *)userdata; (void)conn; (void)rpacket; - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); - u8 op = aki_packet_read_u8(packet); + u8 op = nn_packet_read_u8(packet); if (op == LIANA_SINK_UNSET) { maybe_unset_current(sink); goto out; @@ -1114,18 +1108,18 @@ static bool set_command_callback(void *userdata, struct aki_rpc_connection *conn // Liana node info. str addr; - aki_packet_read_str(packet, &addr); - u16 port = aki_packet_read_u16(packet); - u32 node_id = aki_packet_read_u32(packet); + nn_packet_read_str(packet, &addr); + u16 port = nn_packet_read_u16(packet); + u32 node_id = nn_packet_read_u32(packet); // List entry info. - u32 id = aki_packet_read_u32(packet); - s32 sequence = aki_packet_read_s32(packet); - u64 at = aki_packet_read_u64(packet); - u64 seek_pos = aki_packet_read_u64(packet); - u8 pause = aki_packet_read_u8(packet); - bool previous_ended = aki_packet_read_bool(packet); - bool ended = aki_packet_read_bool(packet); + u32 id = nn_packet_read_u32(packet); + s32 sequence = nn_packet_read_s32(packet); + u64 at = nn_packet_read_u64(packet); + u64 seek_pos = nn_packet_read_u64(packet); + u8 pause = nn_packet_read_u8(packet); + bool previous_ended = nn_packet_read_bool(packet); + bool ended = nn_packet_read_bool(packet); (void)previous_ended; bool created = false; @@ -1177,7 +1171,7 @@ static bool set_command_callback(void *userdata, struct aki_rpc_connection *conn if (sink->target) { sink->target = NULL; } else { - al_assert(sink->current != entry); + al_assert(entry != sink->current); } if (entry != sink->current) { switch_to(sink, entry); @@ -1188,7 +1182,7 @@ static bool set_command_callback(void *userdata, struct aki_rpc_connection *conn if (sink->target) { sink->target = NULL; } else { - al_assert(sink->current != entry); + al_assert(entry != sink->current); } if (entry != sink->current) { switch_to(sink, entry); @@ -1240,32 +1234,32 @@ static bool set_command_callback(void *userdata, struct aki_rpc_connection *conn #endif out: - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); if (op != LIANA_SINK_BUFFER) { maybe_cleanup_old_entries(sink); } - aki_packet_free(packet); + nn_packet_free(packet); return false; } -static bool pause_command_callback(void *userdata, struct aki_rpc_connection *conn, - struct aki_packet *packet, struct aki_packet *rpacket) +static bool pause_command_callback(void *userdata, struct nn_rpc_connection *conn, + struct nn_packet *packet, struct nn_packet *rpacket) { struct camu_sink *sink = (struct camu_sink *)userdata; (void)conn; (void)rpacket; - u32 id = aki_packet_read_u32(packet); - s32 sequence = aki_packet_read_s32(packet); - u64 at = aki_packet_read_u64(packet); - u8 pause = aki_packet_read_u8(packet); + u32 id = nn_packet_read_u32(packet); + s32 sequence = nn_packet_read_s32(packet); + u64 at = nn_packet_read_u64(packet); + u8 pause = nn_packet_read_u8(packet); struct camu_sink_entry *entry = get_entry_from_id(sink, id); if (!entry) goto out; al_assert(entry->sequence == sequence); - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); #ifdef CAMU_SINK_LOCAL (void)at; (void)pause; @@ -1287,25 +1281,25 @@ static bool pause_command_callback(void *userdata, struct aki_rpc_connection *co break; } #endif - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); out: - aki_packet_free(packet); + nn_packet_free(packet); return false; } -static bool seek_command_callback(void *userdata, struct aki_rpc_connection *conn, - struct aki_packet *packet, struct aki_packet *rpacket) +static bool seek_command_callback(void *userdata, struct nn_rpc_connection *conn, + struct nn_packet *packet, struct nn_packet *rpacket) { struct camu_sink *sink = (struct camu_sink *)userdata; (void)conn; (void)rpacket; - u32 id = aki_packet_read_u32(packet); - s32 sequence = aki_packet_read_s32(packet); + u32 id = nn_packet_read_u32(packet); + s32 sequence = nn_packet_read_s32(packet); (void)sequence; - u64 at = aki_packet_read_u64(packet); - u64 pos = aki_packet_read_u64(packet); + u64 at = nn_packet_read_u64(packet); + u64 pos = nn_packet_read_u64(packet); struct camu_sink_entry *entry = get_entry_from_id(sink, id); if (!entry) goto out; @@ -1317,81 +1311,81 @@ static bool seek_command_callback(void *userdata, struct aki_rpc_connection *con lia_client_seek(&entry->client, pos, at); out: - aki_packet_free(packet); + nn_packet_free(packet); return false; } -static struct aki_rpc_command commands[] = { +static struct nn_rpc_command commands[] = { { .op = CAMU_SINK_SET, .callback = set_command_callback, .userdata = NULL }, { .op = CAMU_SINK_PAUSE, .callback = pause_command_callback, .userdata = NULL }, { .op = CAMU_SINK_SEEK, .callback = seek_command_callback, .userdata = NULL } }; -static void idd_callback(void *userdata, struct aki_packet *packet) +static void idd_callback(void *userdata, struct nn_packet *packet) { struct camu_sink *sink = (struct camu_sink *)userdata; (void)sink; - aki_packet_free(packet); + nn_packet_free(packet); } -static void connection_callback(void *userdata, struct aki_rpc_connection *conn) +static void connection_callback(void *userdata, struct nn_rpc_connection *conn) { struct camu_sink *sink = (struct camu_sink *)userdata; sink->conn = conn; - aki_timer_stop(&sink->reconnect_timer); - struct aki_packet *packet = aki_rpc_get_packet(&sink->client, CAMU_SERVER_IDENTIFY); - aki_packet_write_u8(packet, CAMU_SINK); - aki_packet_write_str(packet, &sink->name); - aki_rpc_connection_command(sink->conn, packet, idd_callback, sink); + nn_timer_stop(&sink->reconnect_timer); + struct nn_packet *packet = nn_rpc_get_packet(&sink->client, CAMU_SERVER_IDENTIFY); + nn_packet_write_u8(packet, CAMU_SINK); + nn_packet_write_str(packet, &sink->name); + nn_rpc_connection_command(sink->conn, packet, idd_callback, sink); } -static void reconnect_timer_callback(void *userdata, struct aki_timer *timer) +static void reconnect_timer_callback(void *userdata, struct nn_timer *timer) { struct camu_sink *sink = (struct camu_sink *)userdata; (void)timer; - aki_rpc_reconnect(&sink->client, &sink->addr, sink->port); + nn_rpc_reconnect(&sink->client, &sink->addr, sink->port); } -static void connection_closed_callback(void *userdata, struct aki_rpc_connection *conn) +static void connection_closed_callback(void *userdata, struct nn_rpc_connection *conn) { struct camu_sink *sink = (struct camu_sink *)userdata; if (sink->conn) { al_assert(sink->conn == conn); sink->conn = NULL; } - aki_timer_again(&sink->reconnect_timer); + nn_timer_again(&sink->reconnect_timer); } bool camu_sink_connect(struct camu_sink *sink, u8 type, str *addr, u16 port, str *name) { al_str_clone(&sink->name, name); sink->type = type; - aki_timer_init(&sink->reconnect_timer, sink->loop, reconnect_timer_callback, sink); - aki_timer_set_repeat(&sink->reconnect_timer, AKI_TS_FROM_USEC(1000000)); - aki_rpc_init(&sink->client, sink->loop, connection_callback, connection_closed_callback, sink); + nn_timer_init(&sink->reconnect_timer, sink->loop, reconnect_timer_callback, sink); + nn_timer_set_repeat(&sink->reconnect_timer, NNWT_TS_FROM_USEC(1000000)); + nn_rpc_init(&sink->client, sink->loop, connection_callback, connection_closed_callback, sink); for (u32 i = 0; i < ARRAY_SIZE(commands); i++) { commands[i].userdata = sink; al_assert(sink->callback); - aki_rpc_add_command(&sink->client, &commands[i]); + nn_rpc_add_command(&sink->client, &commands[i]); } - if (!aki_rpc_prepare_client(&sink->client, sink->type, CAMU_MULTIPLEX_RPC)) { + if (!nn_rpc_prepare_client(&sink->client, sink->type, CAMU_MULTIPLEX_RPC)) { return false; } al_str_clone(&sink->addr, addr); sink->port = port; - aki_rpc_connect(&sink->client, &sink->addr, sink->port); + nn_rpc_connect(&sink->client, &sink->addr, sink->port); return true; } struct camu_sink_entry *camu_sink_get_current(struct camu_sink *sink) { - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); return sink->current; } void camu_sink_return_current(struct camu_sink *sink) { - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); } void camu_sink_skip(struct camu_sink *sink, s32 n) @@ -1411,9 +1405,9 @@ void camu_sink_shuffle(struct camu_sink *sink) void camu_sink_toggle_pause(struct camu_sink *sink) { - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); struct camu_sink_entry *current = sink->current; - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); if (current) { queue_cmd(sink, (struct camu_sink_cmd){ .op = TOGGLE_PAUSE, @@ -1425,9 +1419,9 @@ void camu_sink_toggle_pause(struct camu_sink *sink) void camu_sink_seek(struct camu_sink *sink, f64 precent) { - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); struct camu_sink_entry *current = sink->current; - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); queue_cmd(sink, (struct camu_sink_cmd){ .op = SEEK, .value.f = precent, @@ -1437,9 +1431,9 @@ void camu_sink_seek(struct camu_sink *sink, f64 precent) void camu_sink_reseek(struct camu_sink *sink) { - aki_mutex_lock(&sink->mutex); + nn_mutex_lock(&sink->mutex); struct camu_sink_entry *current = sink->current; - aki_mutex_unlock(&sink->mutex); + nn_mutex_unlock(&sink->mutex); queue_cmd(sink, (struct camu_sink_cmd){ .op = RESEEK, .opaque = current @@ -1471,9 +1465,9 @@ void camu_sink_stop(struct camu_sink *sink) void camu_sink_close(struct camu_sink *sink) { - aki_timer_stop(&sink->reconnect_timer); - aki_timer_disable(&sink->reconnect_timer); - if (sink->conn) aki_rpc_conn_disconnect(sink->conn); + nn_timer_stop(&sink->reconnect_timer); + nn_timer_disable(&sink->reconnect_timer); + if (sink->conn) nn_rpc_conn_disconnect(sink->conn); struct camu_sink_entry *entry; al_array_foreach_rev(sink->entries, i, entry) { al_array_remove_at(sink->entries, i); @@ -1488,9 +1482,9 @@ void camu_sink_free(struct camu_sink *sink) al_free(entry); } al_array_free(sink->entries); - aki_rpc_free(&sink->client); + nn_rpc_free(&sink->client); camu_queue_free(sink->queue); - aki_mutex_destroy(&sink->mutex); + nn_mutex_destroy(&sink->mutex); al_str_free(&sink->addr); al_str_free(&sink->name); } diff --git a/src/libsink/sink.h b/src/libsink/sink.h index 48b2b87..4f719d2 100644 --- a/src/libsink/sink.h +++ b/src/libsink/sink.h @@ -2,9 +2,9 @@ #include <al/str.h> #include <al/array.h> -#include <aki/rpc2.h> -#include <aki/signal.h> -#include <aki/timer.h> +#include <nnwt/rpc2.h> +#include <nnwt/signal.h> +#include <nnwt/timer.h> #include "../util/queue.h" @@ -69,16 +69,16 @@ struct camu_sink_cmd { }; struct camu_sink { - struct aki_event_loop *loop; + struct nn_event_loop *loop; str name; u8 type; str addr; u16 port; - struct aki_rpc client; - struct aki_rpc_connection *conn; - struct aki_mutex mutex; - struct aki_timer reconnect_timer; - struct aki_signal queue_signal; + struct nn_rpc client; + struct nn_rpc_connection *conn; + struct nn_mutex mutex; + struct nn_timer reconnect_timer; + struct nn_signal queue_signal; queue(struct camu_sink_cmd) queue; str default_list; struct camu_sink_entry *current; @@ -102,7 +102,7 @@ struct camu_sink { void *userdata; }; -bool camu_sink_init(struct camu_sink *sink, struct aki_event_loop *loop, +bool camu_sink_init(struct camu_sink *sink, struct nn_event_loop *loop, struct camu_mixer *mixer #ifndef CAMU_SINK_NO_VIDEO , struct camu_renderer *renderer diff --git a/src/mixer/audio_miniaudio.c b/src/mixer/audio_miniaudio.c index 526e464..f0afeee 100644 --- a/src/mixer/audio_miniaudio.c +++ b/src/mixer/audio_miniaudio.c @@ -130,7 +130,7 @@ static s32 camu_sample_format_from_miniaudio(s32 fmt) return CAMU_SAMPLE_FORMAT_FLT; case ma_format_unknown: default: - al_assert_and_return(false); + al_assert_and_return(CAMU_SAMPLE_FORMAT_NONE); } } diff --git a/src/mixer/audio_miniaudio.h b/src/mixer/audio_miniaudio.h index 5bae185..c067024 100644 --- a/src/mixer/audio_miniaudio.h +++ b/src/mixer/audio_miniaudio.h @@ -1,9 +1,9 @@ #pragma once -// Include <aki/thread.h> here to ensure OS related headers +// Include <nnwt/thread.h> here to ensure OS related headers // get included the way we want. // Specifically, on Windows we want to include <winsock2.h> before <windows.h>. -#include <aki/thread.h> +#include <nnwt/thread.h> #include <al/macros.h> #include <miniaudio.h> diff --git a/src/mixer/mixer.c b/src/mixer/mixer.c index 086498e..18d6b8a 100644 --- a/src/mixer/mixer.c +++ b/src/mixer/mixer.c @@ -76,7 +76,7 @@ bool camu_mixer_init(struct camu_mixer *mixer, struct camu_audio *audio) al_array_init(mixer->add_queue); al_array_init(mixer->rem_queue); al_atomic_store(u8)(&mixer->queued, 0, AL_ATOMIC_RELAXED); - aki_mutex_init(&mixer->mutex); + nn_mutex_init(&mixer->mutex); #endif return true; } @@ -89,7 +89,7 @@ void camu_mixer_pick_format(struct camu_mixer *mixer, struct camu_resampler_form void camu_mixer_set_volume(struct camu_mixer *mixer, f32 volume) { #ifdef CAMU_MIXER_THREADED - aki_mutex_lock(&mixer->mutex); + nn_mutex_lock(&mixer->mutex); #endif mixer->volume = volume; struct camu_audio_buffer *buf; @@ -97,14 +97,14 @@ void camu_mixer_set_volume(struct camu_mixer *mixer, f32 volume) camu_audio_buffer_set_volume(buf, mixer->volume); } #ifdef CAMU_MIXER_THREADED - aki_mutex_unlock(&mixer->mutex); + nn_mutex_unlock(&mixer->mutex); #endif } void camu_mixer_offset_volume(struct camu_mixer *mixer, f32 amount) { #ifdef CAMU_MIXER_THREADED - aki_mutex_lock(&mixer->mutex); + nn_mutex_lock(&mixer->mutex); #endif if (FLT_MAX - mixer->volume < amount) { mixer->volume = FLT_MAX; @@ -116,7 +116,7 @@ void camu_mixer_offset_volume(struct camu_mixer *mixer, f32 amount) camu_audio_buffer_set_volume(buf, mixer->volume); } #ifdef CAMU_MIXER_THREADED - aki_mutex_unlock(&mixer->mutex); + nn_mutex_unlock(&mixer->mutex); #endif } @@ -152,15 +152,19 @@ static void remove_buffer_internal(struct camu_mixer *mixer, struct camu_audio_b static void run_queue_internal(struct camu_mixer *mixer) { struct camu_audio_buffer *buf; - al_array_foreach(mixer->rem_queue, i, buf) { - remove_buffer_internal(mixer, buf); + if (mixer->rem_queue.size > 0) { + al_array_foreach(mixer->rem_queue, i, buf) { + remove_buffer_internal(mixer, buf); + } + mixer->rem_queue.size = 0; } - mixer->rem_queue.size = 0; - al_array_reserve(mixer->buffers, mixer->buffers.size + mixer->add_queue.size); - al_array_foreach(mixer->add_queue, i, buf) { - add_buffer_internal(mixer, buf); + if (mixer->add_queue.size > 0) { + al_array_reserve(mixer->buffers, mixer->buffers.size + mixer->add_queue.size); + al_array_foreach(mixer->add_queue, i, buf) { + add_buffer_internal(mixer, buf); + } + mixer->add_queue.size = 0; } - mixer->add_queue.size = 0; al_atomic_store(u8)(&mixer->queued, 0, AL_ATOMIC_RELAXED); if (al_array_is_empty(mixer->buffers)) { mixer->empty_after = MIXER_TRAILING_SILENCE; @@ -173,11 +177,11 @@ static void run_queue_internal(struct camu_mixer *mixer) void camu_mixer_add_buffer(struct camu_mixer *mixer, struct camu_audio_buffer *buf) { #ifdef CAMU_MIXER_THREADED - aki_mutex_lock(&mixer->mutex); + nn_mutex_lock(&mixer->mutex); struct camu_audio_buffer *rbuf; al_array_foreach(mixer->add_queue, i, rbuf) { if (rbuf == buf) { - aki_mutex_unlock(&mixer->mutex); + nn_mutex_unlock(&mixer->mutex); return; } } @@ -188,13 +192,13 @@ void camu_mixer_add_buffer(struct camu_mixer *mixer, struct camu_audio_buffer *b if (queue_empty) { al_atomic_store(u8)(&mixer->queued, 0, AL_ATOMIC_RELAXED); } - aki_mutex_unlock(&mixer->mutex); + nn_mutex_unlock(&mixer->mutex); return; } } al_array_push(mixer->add_queue, buf); al_atomic_store(u8)(&mixer->queued, 1, AL_ATOMIC_RELAXED); - aki_mutex_unlock(&mixer->mutex); + nn_mutex_unlock(&mixer->mutex); #else add_buffer_internal(mixer, buf); mixer->empty_after = 0; @@ -204,11 +208,11 @@ void camu_mixer_add_buffer(struct camu_mixer *mixer, struct camu_audio_buffer *b void camu_mixer_remove_buffer(struct camu_mixer *mixer, struct camu_audio_buffer *buf) { #ifdef CAMU_MIXER_THREADED - aki_mutex_lock(&mixer->mutex); + nn_mutex_lock(&mixer->mutex); struct camu_audio_buffer *rbuf; al_array_foreach(mixer->rem_queue, i, rbuf) { if (rbuf == buf) { - aki_mutex_unlock(&mixer->mutex); + nn_mutex_unlock(&mixer->mutex); return; } } @@ -219,7 +223,7 @@ void camu_mixer_remove_buffer(struct camu_mixer *mixer, struct camu_audio_buffer if (queue_empty) { al_atomic_store(u8)(&mixer->queued, 0, AL_ATOMIC_RELAXED); } - aki_mutex_unlock(&mixer->mutex); + nn_mutex_unlock(&mixer->mutex); return; } } @@ -228,7 +232,7 @@ void camu_mixer_remove_buffer(struct camu_mixer *mixer, struct camu_audio_buffer if (mixer->paused) { run_queue_internal(mixer); } - aki_mutex_unlock(&mixer->mutex); + nn_mutex_unlock(&mixer->mutex); #else remove_buffer_internal(mixer, buf); if (al_array_is_empty(mixer->buffers)) { @@ -240,9 +244,9 @@ void camu_mixer_remove_buffer(struct camu_mixer *mixer, struct camu_audio_buffer #ifdef CAMU_MIXER_THREADED void camu_mixer_run_queue(struct camu_mixer *mixer) { - aki_mutex_lock(&mixer->mutex); + nn_mutex_lock(&mixer->mutex); run_queue_internal(mixer); - aki_mutex_unlock(&mixer->mutex); + nn_mutex_unlock(&mixer->mutex); } void camu_mixer_clear(struct camu_mixer *mixer) @@ -257,7 +261,7 @@ void camu_mixer_clear(struct camu_mixer *mixer) void camu_mixer_pause(struct camu_mixer *mixer) { #ifdef CAMU_MIXER_THREADED - aki_mutex_lock(&mixer->mutex); + nn_mutex_lock(&mixer->mutex); #endif if (!mixer->paused) { mixer->audio->stop(mixer->audio); @@ -265,14 +269,14 @@ void camu_mixer_pause(struct camu_mixer *mixer) } #ifdef CAMU_MIXER_THREADED run_queue_internal(mixer); - aki_mutex_unlock(&mixer->mutex); + nn_mutex_unlock(&mixer->mutex); #endif } void camu_mixer_resume(struct camu_mixer *mixer) { #ifdef CAMU_MIXER_THREADED - aki_mutex_lock(&mixer->mutex); + nn_mutex_lock(&mixer->mutex); #endif if (mixer->paused) { // start() can internally call data_callback once before returning. @@ -283,7 +287,7 @@ void camu_mixer_resume(struct camu_mixer *mixer) mixer->paused = false; } #ifdef CAMU_MIXER_THREADED - aki_mutex_unlock(&mixer->mutex); + nn_mutex_unlock(&mixer->mutex); #endif } @@ -293,7 +297,7 @@ void camu_mixer_close(struct camu_mixer *mixer) #ifdef CAMU_MIXER_THREADED al_array_free(mixer->add_queue); al_array_free(mixer->rem_queue); - aki_mutex_destroy(&mixer->mutex); + nn_mutex_destroy(&mixer->mutex); #endif mixer->audio->free(&mixer->audio); } diff --git a/src/mixer/mixer.h b/src/mixer/mixer.h index a925e0c..16ec924 100644 --- a/src/mixer/mixer.h +++ b/src/mixer/mixer.h @@ -4,7 +4,7 @@ #include <al/array.h> #ifdef CAMU_MIXER_THREADED #include <al/atomic.h> -#include <aki/thread.h> +#include <nnwt/thread.h> #endif #include "../codec/codec.h" @@ -24,7 +24,7 @@ struct camu_mixer { array(struct camu_audio_buffer *) add_queue; array(struct camu_audio_buffer *) rem_queue; atomic(u8) queued; - struct aki_mutex mutex; + struct nn_mutex mutex; #endif void (*callback)(void *, u8); void *userdata; diff --git a/src/portal/meson.build b/src/portal/meson.build index d3904ea..e87b588 100644 --- a/src/portal/meson.build +++ b/src/portal/meson.build @@ -10,7 +10,7 @@ portal_args = ['-DCAMU_HAVE_PORTAL'] cpy_dir = join_paths(meson.current_source_dir(), 'cpy') run_command('sh', join_paths(cpy_dir, 'build.sh'), cpy_dir, check: false) -python3_embed = import('python').find_installation('python3.12').dependency(embed: true) +python3_embed = import('python').find_installation('python3').dependency(embed: true) portal_deps += [python3_embed] portal = declare_dependency(sources: portal_src, dependencies: portal_deps, compile_args: portal_args) diff --git a/src/portal/py/modules/__init__.py b/src/portal/py/modules/__init__.py index c44e571..cc34b82 100644 --- a/src/portal/py/modules/__init__.py +++ b/src/portal/py/modules/__init__.py @@ -14,11 +14,11 @@ ALL_MODULES = { # config.TWITTER_ACCESS_TOKEN, config.TWITTER_ACCESS_TOKEN_SECRET, # config.TWITTER_CONSUMER_TOKEN, config.TWITTER_CONSUMER_TOKEN_SECRET), []), # 'twitter': (TwitterScrapeModule(config.TWITTER_COOKIES_PATH), []), - 'pixiv_web': (PixivWebModule(config.PIXIV_SESSID, config.PIXIV_USERID), []), +# 'pixiv_web': (PixivWebModule(config.PIXIV_SESSID, config.PIXIV_USERID), []), # 'pixiv_app': (PixivAppModule(config.PIXIV_REFRESH_TOKEN), []), 'fanbox': (FanboxModule(config.FANBOX_SESSID, config.FANBOX_CF_CLEARANCE), []), - 'instagram': (InstagramModule( - config.INSTAGRAM_USER_AGENT, config.INSTAGRAM_SETTINGS_PATH, - config.INSTAGRAM_SESSION_ID), []), +# 'instagram': (InstagramModule( +# config.INSTAGRAM_USER_AGENT, config.INSTAGRAM_SETTINGS_PATH, +# config.INSTAGRAM_SESSION_ID), []), # 'patreon': (PatreonModule(config.PATREON_SESSION_ID, config.PATREON_UUID, config.PATREON_USER_ID), []) } diff --git a/src/portal/py/modules/youtube.py b/src/portal/py/modules/youtube.py index 5125f85..582a16c 100644 --- a/src/portal/py/modules/youtube.py +++ b/src/portal/py/modules/youtube.py @@ -26,7 +26,8 @@ ydl_opts = { 'quiet': False, 'logger': YDLLogger(), 'cachedir': False, - 'socket_timeout': 10 + 'socket_timeout': 10, + 'extractor_args': {'youtube': {'skip': ['hls'], 'player_client': ['android_vr']}} # 'cookiefile': '' } @@ -94,7 +95,7 @@ class YoutubeBase(Search): if info.get('direct'): url = info['url'] else: - url = get_playback_url(info, video=True) + url = get_playback_url(info, video=False) if not url: return False unique_id = f'youtube:v:{info['id']}' diff --git a/src/portal/py/tests/archive_query.py b/src/portal/py/tests/archive_query.py index cff5e5d..1ed9db4 100644 --- a/src/portal/py/tests/archive_query.py +++ b/src/portal/py/tests/archive_query.py @@ -9,10 +9,12 @@ sys.path.append('../') from base import Method from post import PostEncoder, PostType, DateType, User from modules import ALL_MODULES -from logger import Logger +from tests.logger import Logger +#mode = 'pixiv_web' mode = 'fanbox' cmd = 'user' +#cmd = 'bookmarks' module = ALL_MODULES[mode][0] if not module.init(): sys.exit(1) @@ -170,8 +172,8 @@ class QueryDownloadThread(threading.Thread): #RUNTIME_PATH = "./run" RUNTIME_PATH = "/mnt/store/files/tmp/run" -LOG_FILE = f'{RUNTIME_PATH}/archive3.log' -ARG_FILE = f'{RUNTIME_PATH}/completed_args3.log' +LOG_FILE = f'{RUNTIME_PATH}/archive4.log' +ARG_FILE = f'{RUNTIME_PATH}/completed_args4.log' def read_completed_args(path): args = [] @@ -204,7 +206,23 @@ def download_args(): os.mkdir(output_dir) #args = module.search(f'following:{22781328}') - args = ['anoh223'] + #args = ['22781328'] + #args = ['anoh223'] + #args = ['532891', '1324074',] + #args = ['6600030', '163436'] + #args = ['85117546', '29506', '3298353', '21674944', '2034628', '3085731'] + #args = ['6827013', '11742', '4671', '36323560', '5128785', '30970895'] + #args = ['mugi49'] + #args = ['71598064', '9204502', '689283', '19956185', '42987864', '103682732', '4675776', '7780', '160755', '250142', '3444594', '1995476', '357647'] + #args = ['10473280'] + #args = ['178217', '106414', '882896', '3040749'] + #args = ['21245269'] + #args = ['1969907', '292644', '746841'] + #args = ['1319954', '43718238', '2721319', '53459337'] + # TODO: + args = ['yzr'] + #args = ['11187954'] + # twitter test: butcha_u, sep__rina threads = [] start = True diff --git a/src/portal/requirements.txt b/src/portal/requirements.txt index f4982dc..c2e2915 100644 --- a/src/portal/requirements.txt +++ b/src/portal/requirements.txt @@ -1,4 +1,3 @@ httpx[http2,brotli,zstd] blake3 pillow -notcurses diff --git a/src/portal/scripts/create_vendor.sh b/src/portal/scripts/create_vendor.sh index 414a4c2..833d143 100755 --- a/src/portal/scripts/create_vendor.sh +++ b/src/portal/scripts/create_vendor.sh @@ -24,13 +24,13 @@ cd instagrapi/ pip3 install . --upgrade --target=../vendor cd ../ -cd CyberDropDownloader/ -pip3 install . --upgrade --target=../vendor -cd ../ - -cd gallery-dl/ -pip3 install . --upgrade --target=../vendor -cd ../ +#cd CyberDropDownloader/ +#pip3 install . --upgrade --target=../vendor +#cd ../ +# +#cd gallery-dl/ +#pip3 install . --upgrade --target=../vendor +#cd ../ cd ../ rm -r venv diff --git a/src/portal/scripts/run_py.sh b/src/portal/scripts/run_py.sh index 4414f93..e745a72 100755 --- a/src/portal/scripts/run_py.sh +++ b/src/portal/scripts/run_py.sh @@ -1,5 +1,6 @@ #! /usr/bin/env sh export CURL_CA_BUNDLE=/etc/ssl/certs/ca-bundle.crt export PYTHONDONTWRITEBYTECODE=1 +export PYTHONOPTIMIZE=2 export PYTHONPATH=$HOME/c/camu/src/portal/vendor/vendor $@ diff --git a/src/portal/src/packet_ext.c b/src/portal/src/packet_ext.c index 833e7d9..9b6d6be 100644 --- a/src/portal/src/packet_ext.c +++ b/src/portal/src/packet_ext.c @@ -1,102 +1,102 @@ #include "packet_ext.h" -static void aki_packet_write_optional_int(struct aki_packet *packet, optional_int *o) +static void nn_packet_write_optional_int(struct nn_packet *packet, optional_int *o) { - AKI_PACKET_WRITE_TYPE(packet, s64, o->i); - AKI_PACKET_WRITE_TYPE(packet, bool, o->set); + NNWT_PACKET_WRITE_TYPE(packet, s64, o->i); + NNWT_PACKET_WRITE_TYPE(packet, bool, o->set); } -void aki_packet_write_post(struct aki_packet *packet, struct camu_post *post) +void nn_packet_write_post(struct nn_packet *packet, struct camu_post *post) { - AKI_PACKET_WRITE_TYPE(packet, u16, post->version); - AKI_PACKET_WRITE_TYPE(packet, u8, post->type); - aki_packet_write_str(packet, &post->unique_id); - aki_packet_write_str(packet, &post->url); - AKI_PACKET_WRITE_TYPE(packet, u32, post->dates.size); + NNWT_PACKET_WRITE_TYPE(packet, u16, post->version); + NNWT_PACKET_WRITE_TYPE(packet, u8, post->type); + nn_packet_write_str(packet, &post->unique_id); + nn_packet_write_str(packet, &post->url); + NNWT_PACKET_WRITE_TYPE(packet, u32, post->dates.size); struct camu_post_date *date; al_array_foreach_ptr(post->dates, i, date) { - AKI_PACKET_WRITE_TYPE(packet, u8, date->type); - AKI_PACKET_WRITE_TYPE(packet, f32, date->range_start); - AKI_PACKET_WRITE_TYPE(packet, f32, date->range_end); - AKI_PACKET_WRITE_TYPE(packet, u32, date->meta); + NNWT_PACKET_WRITE_TYPE(packet, u8, date->type); + NNWT_PACKET_WRITE_TYPE(packet, f32, date->range_start); + NNWT_PACKET_WRITE_TYPE(packet, f32, date->range_end); + NNWT_PACKET_WRITE_TYPE(packet, u32, date->meta); } - aki_packet_write_str(packet, &post->author.unique_id); - aki_packet_write_wstr(packet, &post->author.username); - aki_packet_write_wstr(packet, &post->author.display_name); - aki_packet_write_str(packet, &post->author.profile_picture_url); - aki_packet_write_wstr(packet, &post->title); - aki_packet_write_wstr(packet, &post->text); - aki_packet_write_optional_int(packet, &post->likes); - aki_packet_write_optional_int(packet, &post->bookmarks); - aki_packet_write_optional_int(packet, &post->reposts); - aki_packet_write_optional_int(packet, &post->quotes); - aki_packet_write_optional_int(packet, &post->comments); - aki_packet_write_optional_int(packet, &post->views); - AKI_PACKET_WRITE_TYPE(packet, u32, post->media.size); + nn_packet_write_str(packet, &post->author.unique_id); + nn_packet_write_wstr(packet, &post->author.username); + nn_packet_write_wstr(packet, &post->author.display_name); + nn_packet_write_str(packet, &post->author.profile_picture_url); + nn_packet_write_wstr(packet, &post->title); + nn_packet_write_wstr(packet, &post->text); + nn_packet_write_optional_int(packet, &post->likes); + nn_packet_write_optional_int(packet, &post->bookmarks); + nn_packet_write_optional_int(packet, &post->reposts); + nn_packet_write_optional_int(packet, &post->quotes); + nn_packet_write_optional_int(packet, &post->comments); + nn_packet_write_optional_int(packet, &post->views); + NNWT_PACKET_WRITE_TYPE(packet, u32, post->media.size); struct camu_post_media *media; al_array_foreach_ptr(post->media, i, media) { - AKI_PACKET_WRITE_TYPE(packet, u8, media->type); - aki_packet_write_str(packet, &media->key); - aki_packet_write_str(packet, &media->url); - aki_packet_write_str(packet, &media->ext); - aki_packet_write_str(packet, &media->thumbnail_url); - aki_packet_write_str(packet, &media->thumbnail_ext); + NNWT_PACKET_WRITE_TYPE(packet, u8, media->type); + nn_packet_write_str(packet, &media->key); + nn_packet_write_str(packet, &media->url); + nn_packet_write_str(packet, &media->ext); + nn_packet_write_str(packet, &media->thumbnail_url); + nn_packet_write_str(packet, &media->thumbnail_ext); } - aki_packet_write_str(packet, &post->post.unique_id); - aki_packet_write_str(packet, &post->quoted.unique_id); - aki_packet_write_str(packet, &post->in_reply_to.unique_id); + nn_packet_write_str(packet, &post->post.unique_id); + nn_packet_write_str(packet, &post->quoted.unique_id); + nn_packet_write_str(packet, &post->in_reply_to.unique_id); } -static void aki_packet_read_optional_int(struct aki_packet *packet, optional_int *o) +static void nn_packet_read_optional_int(struct nn_packet *packet, optional_int *o) { - AKI_PACKET_READ_TYPE(packet, s64, o->i); - AKI_PACKET_READ_TYPE(packet, bool, o->set); + NNWT_PACKET_READ_TYPE(packet, s64, o->i); + NNWT_PACKET_READ_TYPE(packet, bool, o->set); } -void aki_packet_read_post(struct aki_packet *packet, struct camu_post *post) +void nn_packet_read_post(struct nn_packet *packet, struct camu_post *post) { camu_post_reset(post); - AKI_PACKET_READ_TYPE(packet, u16, post->version); - AKI_PACKET_READ_TYPE(packet, u8, post->type); - aki_packet_read_str(packet, &post->unique_id); - aki_packet_read_str(packet, &post->url); + NNWT_PACKET_READ_TYPE(packet, u16, post->version); + NNWT_PACKET_READ_TYPE(packet, u8, post->type); + nn_packet_read_str(packet, &post->unique_id); + nn_packet_read_str(packet, &post->url); u32 dates_size; - AKI_PACKET_READ_TYPE(packet, u32, dates_size); + NNWT_PACKET_READ_TYPE(packet, u32, dates_size); al_array_reserve(post->dates, dates_size); for (u32 i = 0; i < dates_size; i++) { struct camu_post_date date; - AKI_PACKET_READ_TYPE(packet, u8, date.type); - AKI_PACKET_READ_TYPE(packet, f32, date.range_start); - AKI_PACKET_READ_TYPE(packet, f32, date.range_end); - AKI_PACKET_READ_TYPE(packet, u32, date.meta); + NNWT_PACKET_READ_TYPE(packet, u8, date.type); + NNWT_PACKET_READ_TYPE(packet, f32, date.range_start); + NNWT_PACKET_READ_TYPE(packet, f32, date.range_end); + NNWT_PACKET_READ_TYPE(packet, u32, date.meta); al_array_push(post->dates, date); } - aki_packet_read_str(packet, &post->author.unique_id); - aki_packet_read_wstr(packet, &post->author.username); - aki_packet_read_wstr(packet, &post->author.display_name); - aki_packet_read_str(packet, &post->author.profile_picture_url); - aki_packet_read_wstr(packet, &post->title); - aki_packet_read_wstr(packet, &post->text); - aki_packet_read_optional_int(packet, &post->likes); - aki_packet_read_optional_int(packet, &post->bookmarks); - aki_packet_read_optional_int(packet, &post->reposts); - aki_packet_read_optional_int(packet, &post->quotes); - aki_packet_read_optional_int(packet, &post->comments); - aki_packet_read_optional_int(packet, &post->views); + nn_packet_read_str(packet, &post->author.unique_id); + nn_packet_read_wstr(packet, &post->author.username); + nn_packet_read_wstr(packet, &post->author.display_name); + nn_packet_read_str(packet, &post->author.profile_picture_url); + nn_packet_read_wstr(packet, &post->title); + nn_packet_read_wstr(packet, &post->text); + nn_packet_read_optional_int(packet, &post->likes); + nn_packet_read_optional_int(packet, &post->bookmarks); + nn_packet_read_optional_int(packet, &post->reposts); + nn_packet_read_optional_int(packet, &post->quotes); + nn_packet_read_optional_int(packet, &post->comments); + nn_packet_read_optional_int(packet, &post->views); u32 media_size; - AKI_PACKET_READ_TYPE(packet, u32, media_size); + NNWT_PACKET_READ_TYPE(packet, u32, media_size); al_array_reserve(post->media, media_size); for (u32 i = 0; i < media_size; i++) { struct camu_post_media media; - AKI_PACKET_READ_TYPE(packet, u8, media.type); - aki_packet_read_str(packet, &media.key); - aki_packet_read_str(packet, &media.url); - aki_packet_read_str(packet, &media.ext); - aki_packet_read_str(packet, &media.thumbnail_url); - aki_packet_read_str(packet, &media.thumbnail_ext); + NNWT_PACKET_READ_TYPE(packet, u8, media.type); + nn_packet_read_str(packet, &media.key); + nn_packet_read_str(packet, &media.url); + nn_packet_read_str(packet, &media.ext); + nn_packet_read_str(packet, &media.thumbnail_url); + nn_packet_read_str(packet, &media.thumbnail_ext); al_array_push(post->media, media); } - aki_packet_read_str(packet, &post->post.unique_id); - aki_packet_read_str(packet, &post->quoted.unique_id); - aki_packet_read_str(packet, &post->in_reply_to.unique_id); + nn_packet_read_str(packet, &post->post.unique_id); + nn_packet_read_str(packet, &post->quoted.unique_id); + nn_packet_read_str(packet, &post->in_reply_to.unique_id); } diff --git a/src/portal/src/packet_ext.h b/src/portal/src/packet_ext.h index eae1e07..6da61fc 100644 --- a/src/portal/src/packet_ext.h +++ b/src/portal/src/packet_ext.h @@ -1,10 +1,9 @@ #pragma once #include <al/types.h> -#include <aki/common.h> -#include <aki/event_loop.h> +#include <nnwt/packet.h> #include "post.h" -void aki_packet_write_post(struct aki_packet *packet, struct camu_post *post); -void aki_packet_read_post(struct aki_packet *packet, struct camu_post *post); +void nn_packet_write_post(struct nn_packet *packet, struct camu_post *post); +void nn_packet_read_post(struct nn_packet *packet, struct camu_post *post); diff --git a/src/portal/src/search.c b/src/portal/src/search.c index e8f30c0..88cf1f1 100644 --- a/src/portal/src/search.c +++ b/src/portal/src/search.c @@ -8,26 +8,35 @@ bool camu_python_init(void) { - PyPreConfig config; - PyPreConfig_InitPythonConfig(&config); - config.dev_mode = 0; - config.utf8_mode = 1; - PyStatus status = Py_PreInitialize(&config); + PyPreConfig pre_config; + PyPreConfig_InitPythonConfig(&pre_config); + + pre_config.dev_mode = 0; + pre_config.utf8_mode = 1; + pre_config.isolated = 0; + pre_config.parse_argv = 0; + pre_config.use_environment = 1; + + PyStatus status = Py_PreInitialize(&pre_config); if (PyStatus_Exception(status)) { al_log_error("portal", "Preinitialization failed."); return false; } + if (PyImport_AppendInittab("portal", PyInit_portal) == -1) { al_log_error("portal", "Could not extend in-built modules table."); return false; } + Py_Initialize(); + PyObject *module = PyImport_ImportModule("portal"); if (!module) { PyErr_Print(); al_log_error("portal", "Could not import module."); goto err; } + return true; err: Py_Finalize(); @@ -48,14 +57,14 @@ static struct camu_search *get_search_by_id(struct camu_portal_bridge *bridge, s return NULL; } -static aki_thread_result AKI_THREADCALL queue_thread(void *userdata) +static nn_thread_result NNWT_THREADCALL queue_thread(void *userdata) { struct camu_portal_bridge *bridge = (struct camu_portal_bridge *)userdata; - aki_thread_setcanceltype(AKI_THREAD_CANCEL_ASYNCHRONOUS); + nn_thread_setcanceltype(NNWT_THREAD_CANCEL_ASYNCHRONOUS); bool have_python = false; - aki_mutex_lock(&bridge->mutex); + nn_mutex_lock(&bridge->mutex); do { - aki_cond_wait(&bridge->cond, &bridge->mutex); + nn_cond_wait(&bridge->cond, &bridge->mutex); if (bridge->quit) break; if (!have_python) { // Defer python init. @@ -117,9 +126,9 @@ static aki_thread_result AKI_THREADCALL queue_thread(void *userdata) camu_queue_push(bridge->results, result); } bridge->queue.size = 0; - aki_signal_send(&bridge->results_signal); + nn_signal_send(&bridge->results_signal); } while (1); - aki_mutex_unlock(&bridge->mutex); + nn_mutex_unlock(&bridge->mutex); if (have_python) camu_python_close(); return 0; } @@ -137,19 +146,19 @@ static void results_signal_callback(void *userdata) } void camu_portal_init(struct camu_portal_bridge *bridge, struct camu_post_cache *cache, - struct aki_event_loop *loop, void *userdata) + struct nn_event_loop *loop, void *userdata) { al_array_init(bridge->searches); bridge->cache = cache; bridge->quit = 0; - aki_mutex_init(&bridge->mutex); - aki_cond_init(&bridge->cond); + nn_mutex_init(&bridge->mutex); + nn_cond_init(&bridge->cond); al_array_init(bridge->queue); camu_queue_init(bridge->results); - aki_signal_init(&bridge->results_signal, loop, results_signal_callback, bridge); - aki_signal_start(&bridge->results_signal); + nn_signal_init(&bridge->results_signal, loop, results_signal_callback, bridge); + nn_signal_start(&bridge->results_signal); bridge->userdata = userdata; - aki_thread_create(&bridge->thread, queue_thread, bridge); + nn_thread_create(&bridge->thread, queue_thread, bridge); } void camu_portal_create_search(struct camu_portal_bridge *bridge, str *module, str *query, @@ -161,12 +170,12 @@ void camu_portal_create_search(struct camu_portal_bridge *bridge, str *module, s al_str_clone(&cmd.query, query); cmd.callback = callback; cmd.userdata = userdata; - aki_mutex_lock(&bridge->mutex); + nn_mutex_lock(&bridge->mutex); al_array_push(bridge->queue, cmd); - if (aki_cond_is_waiting(&bridge->cond)) { - aki_cond_signal(&bridge->cond); + if (nn_cond_is_waiting(&bridge->cond)) { + nn_cond_signal(&bridge->cond); } - aki_mutex_unlock(&bridge->mutex); + nn_mutex_unlock(&bridge->mutex); } void camu_portal_get_page(struct camu_portal_bridge *bridge, s32 id, u32 num, @@ -178,28 +187,28 @@ void camu_portal_get_page(struct camu_portal_bridge *bridge, s32 id, u32 num, cmd.num = num; cmd.callback = callback; cmd.userdata = userdata; - aki_mutex_lock(&bridge->mutex); + nn_mutex_lock(&bridge->mutex); al_array_push(bridge->queue, cmd); - if (aki_cond_is_waiting(&bridge->cond)) { - aki_cond_signal(&bridge->cond); + if (nn_cond_is_waiting(&bridge->cond)) { + nn_cond_signal(&bridge->cond); } - aki_mutex_unlock(&bridge->mutex); + nn_mutex_unlock(&bridge->mutex); } void camu_portal_close(struct camu_portal_bridge *bridge) { - aki_mutex_lock(&bridge->mutex); + nn_mutex_lock(&bridge->mutex); bridge->quit = 1; - if (aki_cond_is_waiting(&bridge->cond)) { - aki_cond_signal(&bridge->cond); + if (nn_cond_is_waiting(&bridge->cond)) { + nn_cond_signal(&bridge->cond); } - aki_mutex_unlock(&bridge->mutex); - aki_thread_join(&bridge->thread); - aki_signal_stop(&bridge->results_signal); + nn_mutex_unlock(&bridge->mutex); + nn_thread_join(&bridge->thread); + nn_signal_stop(&bridge->results_signal); camu_queue_free(bridge->results); al_array_free(bridge->queue); - aki_cond_destroy(&bridge->cond); - aki_mutex_destroy(&bridge->mutex); + nn_cond_destroy(&bridge->cond); + nn_mutex_destroy(&bridge->mutex); } /* diff --git a/src/portal/src/search.h b/src/portal/src/search.h index 199f491..f870522 100644 --- a/src/portal/src/search.h +++ b/src/portal/src/search.h @@ -1,7 +1,7 @@ #pragma once -#include <aki/thread.h> -#include <aki/signal.h> +#include <nnwt/thread.h> +#include <nnwt/signal.h> #include "post.h" #include "post_cache.h" @@ -45,12 +45,12 @@ struct camu_portal_bridge { array(struct camu_search *) searches; struct camu_post_cache *cache; u8 quit; - struct aki_thread thread; - struct aki_mutex mutex; - struct aki_cond cond; + struct nn_thread thread; + struct nn_mutex mutex; + struct nn_cond cond; array(struct camu_portal_cmd) queue; queue(struct camu_portal_result) results; - struct aki_signal results_signal; + struct nn_signal results_signal; void *userdata; }; @@ -58,7 +58,7 @@ bool camu_python_init(void); void camu_python_close(void); void camu_portal_init(struct camu_portal_bridge *bridge, struct camu_post_cache *cache, - struct aki_event_loop *loop, void *userdata); + struct nn_event_loop *loop, void *userdata); void camu_portal_create_search(struct camu_portal_bridge *bridge, str *module, str *query, void (*callback)(void *, void *, struct camu_portal_result *), void *userdata); diff --git a/src/render/queue_libplacebo.c b/src/render/queue_libplacebo.c index 8ecf9ce..07ce379 100644 --- a/src/render/queue_libplacebo.c +++ b/src/render/queue_libplacebo.c @@ -234,13 +234,7 @@ static void unmap_av_frame(pl_gpu gpu, struct pl_frame *frame, const struct pl_s } al_free((struct pl_overlay_part *)current->parts); } - struct camu_overlay_lp *roverlay; - al_array_foreach(lq->overlays, i, roverlay) { - if (roverlay == overlay) { - al_array_remove_at(lq->overlays, i); - break; - } - } + al_array_remove(lq->overlays, overlay); al_free(overlay); } } diff --git a/src/render/renderer_libplacebo.c b/src/render/renderer_libplacebo.c index 49addb0..9fedc5f 100644 --- a/src/render/renderer_libplacebo.c +++ b/src/render/renderer_libplacebo.c @@ -1,6 +1,6 @@ #include <al/lib.h> #include <al/log.h> -#include <aki/file.h> +#include <nnwt/file.h> #ifdef CAMU_HAVE_FFMPEG #include <libplacebo/utils/libav.h> #endif @@ -129,9 +129,9 @@ static bool renderer_lp_create_renderer(struct camu_renderer *renderer, s32 *wid pl_swapchain_resize(lr->swapchain, width, height); al_memset(&lr->params, 0, sizeof(struct pl_render_params)); - lr->params = pl_render_fast_params; + //lr->params = pl_render_fast_params; //lr->params.upscaler = &pl_filter_nearest; - //lr->params = pl_render_default_params; + lr->params = pl_render_default_params; //lr->params = pl_render_high_quality_params; lr->params.deband_params = NULL; @@ -139,14 +139,14 @@ static bool renderer_lp_create_renderer(struct camu_renderer *renderer, s32 *wid lr->params.skip_caching_single_frame = true; // Clear manually so we can draw multiple images per frame. lr->params.border = PL_CLEAR_SKIP; - // Prioritize a more consistant image. + // Prioritize a more consistent image. lr->params.correct_subpixel_offsets = true; #if 0 - struct aki_file file; - if (aki_file_open(&file, al_str_c(""), 0)) { + struct nn_file file; + if (nn_file_open(&file, al_str_c(""), 0)) { char *str; - size_t len = aki_file_read_as_c_str(&file, &str); + size_t len = nn_file_read_as_c_str(&file, &str); const struct pl_hook *hook = pl_mpv_user_shader_parse(lr->gpu, (const char *)str, len); const struct pl_hook **hooks = al_malloc(sizeof(struct pl_hook *)); hooks[0] = al_malloc(sizeof(struct pl_hook)); diff --git a/src/screen/screen.c b/src/screen/screen.c index 5b5d175..17f4e3b 100644 --- a/src/screen/screen.c +++ b/src/screen/screen.c @@ -1,5 +1,5 @@ #include <al/log.h> -#include <aki/thread.h> +#include <nnwt/thread.h> #include "view.h" #include "screen.h" @@ -79,11 +79,11 @@ static bool mouse_button_callback(void *userdata, u8 state, u8 button) switch (state) { case STELA_BUTTON_PRESSED: scr->flags |= CAMU_SCREEN_DRAGGING; - scr->last_click_ts = aki_get_timestamp(); + scr->last_click_ts = nn_get_timestamp(); break; case STELA_BUTTON_RELEASED: scr->flags &= ~CAMU_SCREEN_DRAGGING; - if (scr->last_click_ts && aki_get_timestamp() - scr->last_click_ts <= 300000) { + if (scr->last_click_ts && nn_get_timestamp() - scr->last_click_ts <= 300000) { if (scr->flags & CAMU_SCREEN_MODIFIER) { f64 percent = scr->last_mouse_x / scr->width; percent = CLAMP(percent, 0.0, 100.0); @@ -285,7 +285,7 @@ bool camu_screen_init(struct camu_screen *scr, void *context) al_array_init(scr->add_queue); al_array_init(scr->rem_queue); al_atomic_store(u8)(&scr->queued, 0, AL_ATOMIC_RELAXED); - aki_mutex_init(&scr->mutex); + nn_mutex_init(&scr->mutex); #endif scr->last_mouse_x = 0.0; scr->last_mouse_y = 0.0; @@ -294,7 +294,7 @@ bool camu_screen_init(struct camu_screen *scr, void *context) } #ifdef STELA_EVENT_BUFFER -static aki_thread_result AKI_THREADCALL event_thread(void *userdata) +static nn_thread_result NNWT_THREADCALL event_thread(void *userdata) { struct camu_screen *scr = (struct camu_screen *)userdata; while (scr->window->poll(scr->window, true) && al_atomic_load(s32)(&scr->state, AL_ATOMIC_RELAXED) != CAMU_SCREEN_STOPPED) { @@ -313,7 +313,7 @@ bool camu_screen_create_window(struct camu_screen *scr, const char *name) scr->width = scr->window->width; scr->height = scr->window->height; #ifdef STELA_EVENT_BUFFER - aki_thread_create(&scr->thread, event_thread, scr); + nn_thread_create(&scr->thread, event_thread, scr); #endif return true; } @@ -407,11 +407,11 @@ static void run_queue_internal(struct camu_screen *scr) void camu_screen_add_buffer(struct camu_screen *scr, struct camu_video_buffer *buf) { #ifdef CAMU_SCREEN_THREADED - aki_mutex_lock(&scr->mutex); + nn_mutex_lock(&scr->mutex); struct camu_video_buffer *rbuf; al_array_foreach(scr->add_queue, i, rbuf) { if (rbuf == buf) { - aki_mutex_unlock(&scr->mutex); + nn_mutex_unlock(&scr->mutex); return; } } @@ -422,13 +422,13 @@ void camu_screen_add_buffer(struct camu_screen *scr, struct camu_video_buffer *b if (queue_empty) { al_atomic_store(u8)(&scr->queued, 0, AL_ATOMIC_RELAXED); } - aki_mutex_unlock(&scr->mutex); + nn_mutex_unlock(&scr->mutex); return; } } al_array_push(scr->add_queue, buf); al_atomic_store(u8)(&scr->queued, 1, AL_ATOMIC_RELAXED); - aki_mutex_unlock(&scr->mutex); + nn_mutex_unlock(&scr->mutex); #else add_buffer_internal(scr, buf); #endif @@ -438,11 +438,11 @@ void camu_screen_add_buffer(struct camu_screen *scr, struct camu_video_buffer *b void camu_screen_remove_buffer(struct camu_screen *scr, struct camu_video_buffer *buf) { #ifdef CAMU_SCREEN_THREADED - aki_mutex_lock(&scr->mutex); + nn_mutex_lock(&scr->mutex); struct camu_video_buffer *rbuf; al_array_foreach(scr->rem_queue, i, rbuf) { if (rbuf == buf) { - aki_mutex_unlock(&scr->mutex); + nn_mutex_unlock(&scr->mutex); return; } } @@ -453,13 +453,13 @@ void camu_screen_remove_buffer(struct camu_screen *scr, struct camu_video_buffer if (queue_empty) { al_atomic_store(u8)(&scr->queued, 0, AL_ATOMIC_RELAXED); } - aki_mutex_unlock(&scr->mutex); + nn_mutex_unlock(&scr->mutex); return; } } al_array_push(scr->rem_queue, buf); al_atomic_store(u8)(&scr->queued, 1, AL_ATOMIC_RELAXED); - aki_mutex_unlock(&scr->mutex); + nn_mutex_unlock(&scr->mutex); #else remove_buffer_internal(scr, buf); #endif @@ -469,21 +469,21 @@ void camu_screen_remove_buffer(struct camu_screen *scr, struct camu_video_buffer #ifdef CAMU_SCREEN_THREADED void camu_screen_run_queue(struct camu_screen *scr) { - aki_mutex_lock(&scr->mutex); + nn_mutex_lock(&scr->mutex); run_queue_internal(scr); al_atomic_store(u8)(&scr->queued, 0, AL_ATOMIC_RELAXED); - aki_mutex_unlock(&scr->mutex); + nn_mutex_unlock(&scr->mutex); } void camu_screen_clear(struct camu_screen *scr) { - aki_mutex_lock(&scr->mutex); + nn_mutex_lock(&scr->mutex); struct camu_screen_video *video; al_array_foreach_ptr(scr->videos, i, video) { struct camu_video_buffer *buf = video->buf; al_atomic_store(u8)(&buf->ref, 0, AL_ATOMIC_RELAXED); } - aki_mutex_unlock(&scr->mutex); + nn_mutex_unlock(&scr->mutex); } #endif @@ -498,7 +498,7 @@ bool camu_screen_poll(struct camu_screen *scr, bool block) { #ifdef STELA_EVENT_BUFFER if (block) { - aki_thread_sleep(AKI_TS_FROM_USEC(1000000/CAMU_SCREEN_POLL_HZ)); + nn_thread_sleep(NNWT_TS_FROM_USEC(1000000/CAMU_SCREEN_POLL_HZ)); } stl_window_read_events(scr->window); #else @@ -534,12 +534,12 @@ void camu_screen_close(struct camu_screen *scr) #ifdef CAMU_SCREEN_THREADED al_array_free(scr->add_queue); al_array_free(scr->rem_queue); - aki_mutex_destroy(&scr->mutex); + nn_mutex_destroy(&scr->mutex); #endif al_array_free(scr->videos); al_atomic_store(s32)(&scr->state, CAMU_SCREEN_STOPPED, AL_ATOMIC_RELAXED); #ifdef STELA_EVENT_BUFFER - aki_thread_join(&scr->thread); + nn_thread_join(&scr->thread); #endif scr->window->free(&scr->window); } diff --git a/src/screen/screen.h b/src/screen/screen.h index 349d41f..80f888c 100644 --- a/src/screen/screen.h +++ b/src/screen/screen.h @@ -3,7 +3,7 @@ #include <al/array.h> #include <al/atomic.h> #ifdef CAMU_SCREEN_THREADED -#include <aki/thread.h> +#include <nnwt/thread.h> #endif #include <stl/window.h> @@ -53,7 +53,7 @@ struct camu_screen { u32 flags; struct stl_window *window; #ifdef STELA_EVENT_BUFFER - struct aki_thread thread; + struct nn_thread thread; #endif struct camu_renderer *renderer; s32 width; @@ -66,7 +66,7 @@ struct camu_screen { array(struct camu_video_buffer *) add_queue; array(struct camu_video_buffer *) rem_queue; atomic(u8) queued; - struct aki_mutex mutex; + struct nn_mutex mutex; #endif void (*callback)(void *, u8, void *); void *userdata; diff --git a/src/server/common.c b/src/server/common.c deleted file mode 100644 index 765418c..0000000 --- a/src/server/common.c +++ /dev/null @@ -1,10 +0,0 @@ -#include "common.h" - -//const str *CAMU_DB_PATH = al_str_c("/mnt/store/files/camu_db"); -str *CAMU_DB_PATH = al_str_c("/home/andrew/c/camu/data/camu_db_test"); - -str *CAMU_SERVER_IP = al_str_c("108.52.160.112"); -//str *CAMU_SERVER_IP = al_str_c("127.0.0.1"); - -str *CAMU_UNIX_PATH = al_str_c("/tmp/camu_sock"); -str *CAMU_UNIX_LOCAL = al_str_c("/tmp/cmv_sock"); diff --git a/src/server/common.h b/src/server/common.h index b6ee7a1..b4c6344 100644 --- a/src/server/common.h +++ b/src/server/common.h @@ -2,19 +2,10 @@ #include <al/str.h> -extern str *CAMU_DB_PATH; - #define CAMU_PORT 14356 #define CAMU_MULTIPLEX_RPC 0x53 #define CAMU_MULTIPLEX_LIANA 0x85 -extern str *CAMU_SERVER_IP; -extern str *CAMU_UNIX_PATH; -extern str *CAMU_UNIX_LOCAL; - -#define CAMU_LOCAL_TYPE AKI_SOCKET_TCP -#define CAMU_LOCAL_ADDR CAMU_SERVER_IP - enum { CAMU_NODE = 0, CAMU_CLIENT, @@ -47,9 +38,16 @@ enum { enum { CAMU_RESOURCE_FILE = 0, +#ifdef NAUNET_HAS_CURL + CAMU_RESOURCE_HTTP, +#endif +#ifdef CACHE_HAVE_CDIO CAMU_RESOURCE_CDIO, +#endif +#ifdef CAMU_HAVE_PORTAL CAMU_RESOURCE_PORTAL, CAMU_RESOURCE_SIMPLE_SEARCH +#endif }; AL_UNUSED_FUNCTION_PUSH @@ -57,8 +55,7 @@ AL_UNUSED_FUNCTION_PUSH static bool camu_is_url(str *s, u32 i) { return al_str_cmp(s, al_str_c("https://"), i, 8) == 0 - || al_str_cmp(s, al_str_c("http://"), i, 7) == 0 - || al_str_cmp(s, al_str_c("cdda://"), i, 7) == 0; + || al_str_cmp(s, al_str_c("http://"), i, 7) == 0; } AL_UNUSED_FUNCTION_POP diff --git a/src/server/db.c b/src/server/db.c index 6f76864..ce4c99e 100644 --- a/src/server/db.c +++ b/src/server/db.c @@ -1,17 +1,17 @@ #include <al/log.h> -#include <aki/file.h> +#include <nnwt/file.h> #include <jansson.h> #include "server.h" -static bool open_user(struct camu_server *server, struct aki_dir_entry *dir) +static bool open_user(struct camu_server *server, struct nn_dir_entry *dir) { - struct aki_file file; - if (!aki_file_open(&file, &dir->path, 0)) { + struct nn_file file; + if (!nn_file_open(&file, &dir->path, 0)) { return false; } str s; - aki_file_read_as_str(&file, &s); + nn_file_read_as_str(&file, &s); json_error_t error; json_t *root = json_loadb(s.data, s.len, 0, &error); if (!root) { @@ -30,28 +30,28 @@ static bool open_user(struct camu_server *server, struct aki_dir_entry *dir) bool camu_db_open(struct camu_server *server, str *path) { - struct aki_dir camu_db; - if (!aki_dir_open(&camu_db, path)) { + struct nn_dir camu_db; + if (!nn_dir_open(&camu_db, path)) { return false; } - struct aki_dir_entry entry; - while (aki_dir_read(&camu_db, &entry)) { + struct nn_dir_entry entry; + while (nn_dir_read(&camu_db, &entry)) { if (al_str_eq(&entry.name, al_str_c("users"))) { - struct aki_dir users; - if (aki_dir_open(&users, &entry.path)) { - struct aki_dir_entry user; - while (aki_dir_read(&users, &user)) { - if (user.type == AKI_ENTRY_FILE) { + struct nn_dir users; + if (nn_dir_open(&users, &entry.path)) { + struct nn_dir_entry user; + while (nn_dir_read(&users, &user)) { + if (user.type == NNWT_ENTRY_FILE) { open_user(server, &user); } - aki_dir_entry_free(&user); + nn_dir_entry_free(&user); } - aki_dir_close(&users); + nn_dir_close(&users); } } - aki_dir_entry_free(&entry); + nn_dir_entry_free(&entry); } - aki_dir_close(&camu_db); + nn_dir_close(&camu_db); return true; } diff --git a/src/server/meson.build b/src/server/meson.build index ab100e1..52c993f 100644 --- a/src/server/meson.build +++ b/src/server/meson.build @@ -1,8 +1,7 @@ server_src = [ 'server.c', - 'common.c', 'user.c', - 'db.c', + 'db.c' ] server_deps = [cache, liana_server] if get_option('portal').enabled() diff --git a/src/server/resource.h b/src/server/resource.h index 559e2b4..1cd00fc 100644 --- a/src/server/resource.h +++ b/src/server/resource.h @@ -17,6 +17,11 @@ struct camu_resource_file { str path; }; +struct camu_resource_http { + struct camu_resource r; + str url; +}; + struct camu_resource_portal { struct camu_resource r; struct camu_post *post; diff --git a/src/server/server.c b/src/server/server.c index 4ec61da..7d0b2fe 100644 --- a/src/server/server.c +++ b/src/server/server.c @@ -3,7 +3,9 @@ #include "../cache/handlers/file.h" #include "../cache/handlers/http.h" +#ifdef CACHE_HAVE_CDIO #include "../cache/handlers/cdio.h" +#endif #include "../libclient/common.h" #include "../libsink/common.h" #ifdef CAMU_HAVE_PORTAL @@ -25,7 +27,7 @@ static struct camu_user *get_user_by_username(struct camu_server *server, str *u return NULL; } -static struct camu_server_client *get_client_by_connection(struct camu_server *server, struct aki_rpc_connection *conn) +static struct camu_server_client *get_client_by_connection(struct camu_server *server, struct nn_rpc_connection *conn) { struct camu_server_client *client; al_array_foreach(server->clients, i, client) { @@ -52,26 +54,30 @@ static struct camu_server_sink *get_sink_from_name(struct camu_server *server, s return NULL; } -static void write_user_state(struct camu_server *server, struct camu_user *user, struct aki_packet *packet) +static void write_user_state(struct camu_server *server, struct camu_user *user, struct nn_packet *packet) { (void)user; +#ifdef CAMU_HAVE_PORTAL + nn_packet_write_u32(packet, server->bridge.searches.size); struct camu_search *search; - aki_packet_write_u32(packet, server->bridge.searches.size); al_array_foreach(server->bridge.searches, i, search) { - aki_packet_write_s32(packet, search->id); - aki_packet_write_str(packet, &search->module); - aki_packet_write_str(packet, &search->query); + nn_packet_write_s32(packet, search->id); + nn_packet_write_str(packet, &search->module); + nn_packet_write_str(packet, &search->query); } +#else + nn_packet_write_u32(packet, 0); +#endif } static void handle_toggle_sink(struct camu_server *server, str *name, struct camu_server_sink *sink, bool enable); -static bool identify_callback(void *userdata, struct aki_rpc_connection *conn, - struct aki_packet *packet, struct aki_packet *rpacket) +static bool identify_callback(void *userdata, struct nn_rpc_connection *conn, + struct nn_packet *packet, struct nn_packet *rpacket) { struct camu_server *server = (struct camu_server *)userdata; - u8 op = aki_packet_read_u8(packet); + u8 op = nn_packet_read_u8(packet); switch (op) { case CAMU_NODE: { struct camu_server_node *node = al_alloc_object(struct camu_server_node); @@ -84,7 +90,7 @@ static bool identify_callback(void *userdata, struct aki_rpc_connection *conn, struct camu_server_client *client = al_alloc_object(struct camu_server_client); client->conn = conn; str username; - aki_packet_read_str(packet, &username); + nn_packet_read_str(packet, &username); struct camu_user *user = get_user_by_username(server, &username); if (!user) { user = al_alloc_object(struct camu_user); @@ -101,7 +107,7 @@ static bool identify_callback(void *userdata, struct aki_rpc_connection *conn, struct camu_server_sink *sink = al_alloc_object(struct camu_server_sink); sink->conn = conn; str name; - aki_packet_read_str(packet, &name); + nn_packet_read_str(packet, &name); al_str_clone(&sink->name, &name); sink->server = server; al_array_push(server->sinks, sink); @@ -111,21 +117,10 @@ static bool identify_callback(void *userdata, struct aki_rpc_connection *conn, } } - aki_packet_free(packet); + nn_packet_free(packet); return true; } -static bool client_still_connected(struct camu_server *server, struct aki_rpc_connection *conn) -{ - struct camu_server_client *client; - al_array_foreach(server->clients, i, client) { - if (client->conn == conn) { - return true; - } - } - return false; -} - static void list_sink_callback(void *userdata, u8 op, struct lia_list_entry *entry, s32 sequence, struct lia_timing *timing) { struct camu_server_sink *sink = (struct camu_server_sink *)userdata; @@ -134,44 +129,44 @@ static void list_sink_callback(void *userdata, u8 op, struct lia_list_entry *ent case LIANA_SINK_BUFFER: case LIANA_SINK_BUFFER_AND_QUEUE: { struct camu_resource *resource = (struct camu_resource *)entry->opaque; - struct aki_packet *packet = aki_rpc_get_packet(sink->conn->rpc, CAMU_SINK_SET); - aki_packet_write_u8(packet, op); - aki_packet_write_str(packet, &sink->server->addr); - aki_packet_write_u16(packet, CAMU_PORT); - aki_packet_write_u32(packet, resource->node->id); - aki_packet_write_u32(packet, entry->id); - aki_packet_write_s32(packet, sequence); - aki_packet_write_u64(packet, timing->at); + struct nn_packet *packet = nn_rpc_get_packet(sink->conn->rpc, CAMU_SINK_SET); + nn_packet_write_u8(packet, op); + nn_packet_write_str(packet, &sink->server->addr); + nn_packet_write_u16(packet, CAMU_PORT); + nn_packet_write_u32(packet, resource->node->id); + nn_packet_write_u32(packet, entry->id); + nn_packet_write_s32(packet, sequence); + nn_packet_write_u64(packet, timing->at); al_assert(timing->seek_pos <= INT64_MAX); - aki_packet_write_u64(packet, timing->seek_pos); - aki_packet_write_u8(packet, timing->pause); - aki_packet_write_bool(packet, timing->previous_ended); - aki_packet_write_bool(packet, timing->ended); - aki_rpc_connection_command(sink->conn, packet, NULL, NULL); + nn_packet_write_u64(packet, timing->seek_pos); + nn_packet_write_u8(packet, timing->pause); + nn_packet_write_bool(packet, timing->previous_ended); + nn_packet_write_bool(packet, timing->ended); + nn_rpc_connection_command(sink->conn, packet, NULL, NULL); break; } case LIANA_SINK_UNSET: { - struct aki_packet *packet = aki_rpc_get_packet(sink->conn->rpc, CAMU_SINK_SET); - aki_packet_write_u8(packet, op); - aki_rpc_connection_command(sink->conn, packet, NULL, NULL); + struct nn_packet *packet = nn_rpc_get_packet(sink->conn->rpc, CAMU_SINK_SET); + nn_packet_write_u8(packet, op); + nn_rpc_connection_command(sink->conn, packet, NULL, NULL); break; } case LIANA_SINK_PAUSE: { - struct aki_packet *packet = aki_rpc_get_packet(sink->conn->rpc, CAMU_SINK_PAUSE); - aki_packet_write_u32(packet, entry->id); - aki_packet_write_s32(packet, sequence); - aki_packet_write_u64(packet, timing->at); - aki_packet_write_u8(packet, timing->pause); - aki_rpc_connection_command(sink->conn, packet, NULL, NULL); + struct nn_packet *packet = nn_rpc_get_packet(sink->conn->rpc, CAMU_SINK_PAUSE); + nn_packet_write_u32(packet, entry->id); + nn_packet_write_s32(packet, sequence); + nn_packet_write_u64(packet, timing->at); + nn_packet_write_u8(packet, timing->pause); + nn_rpc_connection_command(sink->conn, packet, NULL, NULL); break; } case LIANA_SINK_SEEK: { - struct aki_packet *packet = aki_rpc_get_packet(sink->conn->rpc, CAMU_SINK_SEEK); - aki_packet_write_u32(packet, entry->id); - aki_packet_write_s32(packet, sequence); - aki_packet_write_u64(packet, timing->at); - aki_packet_write_u64(packet, timing->seek_pos); - aki_rpc_connection_command(sink->conn, packet, NULL, NULL); + struct nn_packet *packet = nn_rpc_get_packet(sink->conn->rpc, CAMU_SINK_SEEK); + nn_packet_write_u32(packet, entry->id); + nn_packet_write_s32(packet, sequence); + nn_packet_write_u64(packet, timing->at); + nn_packet_write_u64(packet, timing->seek_pos); + nn_rpc_connection_command(sink->conn, packet, NULL, NULL); break; } } @@ -188,7 +183,7 @@ void handle_toggle_sink(struct camu_server *server, str *name, struct camu_serve static void process_pending(struct camu_resource *resource) { array(struct lia_list_entry *) pending; - // resource->pending may be edited in a list_pump() call. + // resource->pending may be edited during a list_pump() call. al_array_clone(pending, resource->pending); resource->pending.size = 0; struct lia_list_entry *entry; @@ -244,42 +239,54 @@ static void list_callback(void *userdata, u8 op, struct lia_list_entry *entry, v } break; } +} +#ifdef CAMU_HAVE_PORTAL +static bool client_still_connected(struct camu_server *server, struct nn_rpc_connection *conn) +{ + struct camu_server_client *client; + al_array_foreach(server->clients, i, client) { + if (client->conn == conn) { + return true; + } + } + return false; } static void client_portal_callback(void *userdata0, void *userdata1, struct camu_portal_result *result) { struct camu_server *server = (struct camu_server *)userdata0; - struct aki_rpc_connection *conn = (struct aki_rpc_connection *)userdata1; + struct nn_rpc_connection *conn = (struct nn_rpc_connection *)userdata1; if (!client_still_connected(server, conn)) return; - struct aki_packet *packet = aki_rpc_get_packet(conn->rpc, CAMU_CLIENT_RESULTS); - aki_packet_write_u8(packet, result->op); - aki_packet_write_s32(packet, result->id); + struct nn_packet *packet = nn_rpc_get_packet(conn->rpc, CAMU_CLIENT_RESULTS); + nn_packet_write_u8(packet, result->op); + nn_packet_write_s32(packet, result->id); switch (result->op) { case CAMU_CLIENT_CREATE_SEARCH: { break; } case CAMU_CLIENT_GET_PAGE: { struct camu_result_page *page = result->page; - aki_packet_write_u32(packet, page->num); - aki_packet_write_u32(packet, page->posts.size); + nn_packet_write_u32(packet, page->num); + nn_packet_write_u32(packet, page->posts.size); struct camu_post *post; al_array_foreach_ptr(page->posts, i, post) { - aki_packet_write_post(packet, post); + nn_packet_write_post(packet, post); } - aki_packet_write_u32(packet, page->list.size); + nn_packet_write_u32(packet, page->list.size); str *unique_id; al_array_foreach_ptr(page->list, i, unique_id) { - aki_packet_write_str(packet, unique_id); + nn_packet_write_str(packet, unique_id); } break; } } - aki_rpc_connection_command(conn, packet, NULL, NULL); + nn_rpc_connection_command(conn, packet, NULL, NULL); } +#endif -static bool client_command_callback(void *userdata, struct aki_rpc_connection *conn, - struct aki_packet *packet, struct aki_packet *rpacket) +static bool client_command_callback(void *userdata, struct nn_rpc_connection *conn, + struct nn_packet *packet, struct nn_packet *rpacket) { struct camu_server *server = (struct camu_server *)userdata; (void)rpacket; @@ -287,11 +294,11 @@ static bool client_command_callback(void *userdata, struct aki_rpc_connection *c struct camu_server_client *client = get_client_by_connection(server, conn); if (!client) goto out; - u8 op = aki_packet_read_u8(packet); + u8 op = nn_packet_read_u8(packet); switch (op) { case CAMU_CLIENT_CREATE_LIST: { str name; - aki_packet_read_str(packet, &name); + nn_packet_read_str(packet, &name); struct lia_list *list = al_alloc_object(struct lia_list); lia_list_init(list, &name); list->callback = list_callback; @@ -301,35 +308,38 @@ static bool client_command_callback(void *userdata, struct aki_rpc_connection *c } case CAMU_CLIENT_TOGGLE_SINK: { str name; - aki_packet_read_str(packet, &name); + nn_packet_read_str(packet, &name); struct camu_server_sink *sink = get_sink_from_name(server, &name); if (!sink) goto out; - aki_packet_read_str(packet, &name); // list name. - bool enable = aki_packet_read_bool(packet); + nn_packet_read_str(packet, &name); // list name. + bool enable = nn_packet_read_bool(packet); handle_toggle_sink(server, &name, sink, enable); break; } +#ifdef CAMU_HAVE_PORTAL case CAMU_CLIENT_CREATE_SEARCH: { str module; str query; - aki_packet_read_str(packet, &module); - aki_packet_read_str(packet, &query); + nn_packet_read_str(packet, &module); + nn_packet_read_str(packet, &query); camu_portal_create_search(&server->bridge, &module, &query, client_portal_callback, conn); break; } case CAMU_CLIENT_GET_PAGE: { - s32 id = aki_packet_read_s32(packet); - u32 num = aki_packet_read_u32(packet); + s32 id = nn_packet_read_s32(packet); + u32 num = nn_packet_read_u32(packet); camu_portal_get_page(&server->bridge, id, num, client_portal_callback, conn); break; } +#endif } out: - aki_packet_free(packet); + nn_packet_free(packet); return true; } +#ifdef CAMU_HAVE_PORTAL static struct cch_entry *entry_from_post(struct camu_server *server, struct camu_post *post, u32 index) { struct cch_entry *entry = NULL; @@ -378,17 +388,18 @@ static void simple_search_portal_callback(void *userdata0, void *userdata1, stru al_log_warn("server", "Server resource failed to load."); resource->load = LIANA_ENTRY_ERRORED; } +#endif -static void handle_add_command(struct camu_server *server, struct lia_list *list, struct aki_packet *packet) +static void handle_add_command(struct camu_server *server, struct lia_list *list, struct nn_packet *packet) { - u8 op = aki_packet_read_u8(packet); + u8 op = nn_packet_read_u8(packet); struct cch_entry *entry = NULL; struct camu_resource *resource = NULL; wstr name; switch (op) { case CAMU_RESOURCE_FILE: { str path; - aki_packet_read_str(packet, &path); + nn_packet_read_str(packet, &path); entry = cch_handler_file_create(&path); if (!entry) return; struct camu_resource_file *file = al_alloc_object(struct camu_resource_file); @@ -399,12 +410,36 @@ static void handle_add_command(struct camu_server *server, struct lia_list *list resource->load = LIANA_ENTRY_PREPARED; break; } +#ifdef NAUNET_HAS_CURL + case CAMU_RESOURCE_HTTP: { + str url; + nn_packet_read_str(packet, &url); + entry = cch_handler_http_create(&url, server->loop); + if (!entry) return; + entry->handler->maybe_spawn_worker(entry->handler, 0); + struct camu_resource_http *http = al_alloc_object(struct camu_resource_http); + al_str_clone(&http->url, &url); + al_wstr_from_str(&name, &url); + resource = (struct camu_resource *)http; + resource->type = CAMU_RESOURCE_HTTP; + resource->load = LIANA_ENTRY_PREPARED; + break; + } +#endif +#ifdef CACHE_HAVE_CDIO case CAMU_RESOURCE_CDIO: { - u32 track = aki_packet_read_u32(packet); entry = cch_handler_cdio_create(); if (!entry) return; - struct cch_chapter *chapter = &al_array_at(entry->chapters, track); - entry->handler->maybe_spawn_worker(entry->handler, chapter->start); + str url; + nn_packet_read_str(packet, &url); + u32 track = 0; + if (url.len > 7) { + s64 index = al_str_to_long(al_str_substr(&url, 7, url.len), 10); + if (index > 0 && index <= entry->chapters.size) + track = (u32)index - 1; + } + entry->chapter = &al_array_at(entry->chapters, track); + entry->handler->maybe_spawn_worker(entry->handler, entry->chapter->start); struct camu_resource_cdio *cdio = al_alloc_object(struct camu_resource_cdio); cdio->track = track; al_wstr_from_cstr(&name, "cdio"); @@ -413,10 +448,12 @@ static void handle_add_command(struct camu_server *server, struct lia_list *list resource->load = LIANA_ENTRY_PREPARED; break; } +#endif +#ifdef CAMU_HAVE_PORTAL case CAMU_RESOURCE_PORTAL: { str unique_id; - aki_packet_read_str(packet, &unique_id); - u32 index = aki_packet_read_u32(packet); + nn_packet_read_str(packet, &unique_id); + u32 index = nn_packet_read_u32(packet); struct camu_post *post = camu_post_cache_get(&server->cache, &unique_id); entry = entry_from_post(server, post, index); if (!entry) return; @@ -430,7 +467,7 @@ static void handle_add_command(struct camu_server *server, struct lia_list *list } case CAMU_RESOURCE_SIMPLE_SEARCH: { str search; - aki_packet_read_str(packet, &search); + nn_packet_read_str(packet, &search); struct camu_resource_portal *portal = al_alloc_object(struct camu_resource_portal); portal->post = NULL; al_wstr_from_str(&name, &search); @@ -448,6 +485,7 @@ static void handle_add_command(struct camu_server *server, struct lia_list *list al_str_free(&query); break; } +#endif } al_assert(resource); if (entry) { @@ -462,34 +500,34 @@ static void handle_add_command(struct camu_server *server, struct lia_list *list al_wstr_free(&name); } -static bool list_action_callback(void *userdata, struct aki_rpc_connection *conn, - struct aki_packet *packet, struct aki_packet *rpacket) +static bool list_action_callback(void *userdata, struct nn_rpc_connection *conn, + struct nn_packet *packet, struct nn_packet *rpacket) { struct camu_server *server = (struct camu_server *)userdata; (void)conn; (void)rpacket; str name; - aki_packet_read_str(packet, &name); + nn_packet_read_str(packet, &name); struct lia_list *list = get_list_from_name(server, &name); if (!list) goto out; - u8 op = aki_packet_read_u8(packet); + u8 op = nn_packet_read_u8(packet); switch (op) { case CAMU_LIST_ADD: { handle_add_command(server, list, packet); break; } case CAMU_LIST_SKIP: { - s32 sequence = aki_packet_read_s32(packet); - s32 n = aki_packet_read_s32(packet); + s32 sequence = nn_packet_read_s32(packet); + s32 n = nn_packet_read_s32(packet); lia_list_skip(list, sequence, n); break; } case CAMU_LIST_SKIPTO: { - s32 sequence = aki_packet_read_s32(packet); - s32 i = aki_packet_read_s32(packet); + s32 sequence = nn_packet_read_s32(packet); + s32 i = nn_packet_read_s32(packet); lia_list_skipto(list, sequence, i); break; } @@ -498,15 +536,15 @@ static bool list_action_callback(void *userdata, struct aki_rpc_connection *conn break; } case CAMU_LIST_TOGGLE_PAUSE: { - s32 sequence = aki_packet_read_s32(packet); - f64 pts = aki_packet_read_f64(packet); + s32 sequence = nn_packet_read_s32(packet); + f64 pts = nn_packet_read_f64(packet); lia_list_toggle_pause(list, sequence, pts); break; } case CAMU_LIST_SEEK: { - s32 sequence = aki_packet_read_s32(packet); - u32 id = aki_packet_read_u32(packet); - f64 percent = aki_packet_read_f64(packet); + s32 sequence = nn_packet_read_s32(packet); + u32 id = nn_packet_read_u32(packet); + f64 percent = nn_packet_read_f64(packet); lia_list_seek(list, sequence, id, percent); break; } @@ -515,24 +553,24 @@ static bool list_action_callback(void *userdata, struct aki_rpc_connection *conn break; } case CAMU_LIST_END: { - u32 id = aki_packet_read_u32(packet); + u32 id = nn_packet_read_u32(packet); lia_list_end(list, id); break; } } out: - aki_packet_free(packet); + nn_packet_free(packet); return false; } -static struct aki_rpc_command commands[] = { +static struct nn_rpc_command commands[] = { { .op = CAMU_SERVER_IDENTIFY, .callback = identify_callback, .userdata = NULL }, { .op = CAMU_SERVER_CLIENT_COMMAND, .callback = client_command_callback, .userdata = NULL }, { .op = CAMU_SERVER_LIST_ACTION, .callback = list_action_callback, .userdata = NULL } }; -static void connection_callback(void *userdata, struct aki_rpc_connection *conn) +static void connection_callback(void *userdata, struct nn_rpc_connection *conn) { // TODO: Cleanup zombie connections. (void)userdata; @@ -555,7 +593,7 @@ static void cleanup_sink(struct camu_server_sink *sink) al_free(sink); } -static void connection_closed_callback(void *userdata, struct aki_rpc_connection *conn) +static void connection_closed_callback(void *userdata, struct nn_rpc_connection *conn) { struct camu_server *server = (struct camu_server *)userdata; @@ -594,12 +632,12 @@ static void connection_closed_callback(void *userdata, struct aki_rpc_connection } } -static bool multiplex_callback(void *userdata, u8 id, struct aki_socket *sock) +static bool multiplex_callback(void *userdata, u8 id, struct nn_socket *sock) { struct camu_server *server = (struct camu_server *)userdata; switch (id) { case CAMU_MULTIPLEX_RPC: - aki_rpc_add_socket(&server->server, sock); + nn_rpc_add_socket(&server->server, sock); return true; case CAMU_MULTIPLEX_LIANA: lia_server_add_socket(&server->data.server, sock); @@ -610,7 +648,7 @@ static bool multiplex_callback(void *userdata, u8 id, struct aki_socket *sock) return false; } -bool camu_server_init(struct camu_server *server, u8 type, struct aki_event_loop *loop) +bool camu_server_init(struct camu_server *server, u8 type, struct nn_event_loop *loop) { server->loop = loop; server->addr = al_str_zero(); @@ -626,10 +664,10 @@ bool camu_server_init(struct camu_server *server, u8 type, struct aki_event_loop list->userdata = server; al_array_push(server->lists, list); - aki_rpc_init(&server->server, server->loop, connection_callback, connection_closed_callback, server); + nn_rpc_init(&server->server, server->loop, connection_callback, connection_closed_callback, server); for (u32 i = 0; i < ARRAY_SIZE(commands); i++) { commands[i].userdata = server; - aki_rpc_add_command(&server->server, &commands[i]); + nn_rpc_add_command(&server->server, &commands[i]); } lia_server_init(&server->data.server, server->loop); @@ -639,14 +677,14 @@ bool camu_server_init(struct camu_server *server, u8 type, struct aki_event_loop camu_portal_init(&server->bridge, &server->cache, server->loop, server); #endif - return aki_multiplex_socket_init(&server->multi, type, multiplex_callback, server); + return nn_multiplex_socket_init(&server->multi, type, multiplex_callback, server); } bool camu_server_listen(struct camu_server *server, str *addr, u16 port) { al_str_clone(&server->addr, addr); - if (server->multi.sock.type == AKI_SOCKET_TCP) addr = NULL; // any - return aki_multiplex_socket_listen(&server->multi, server->loop, addr, port); + if (server->multi.sock.type == NNWT_SOCKET_TCP) addr = NULL; // any + return nn_multiplex_socket_listen(&server->multi, server->loop, addr, port); } void camu_server_close(struct camu_server *server) @@ -655,7 +693,7 @@ void camu_server_close(struct camu_server *server) camu_portal_close(&server->bridge); #endif lia_server_close(&server->data.server); - aki_multiplex_socket_close(&server->multi); + nn_multiplex_socket_close(&server->multi); } void camu_server_free(struct camu_server *server) @@ -668,11 +706,11 @@ void camu_server_free(struct camu_server *server) //} al_array_free(server->data.resources); lia_server_free(&server->data.server); - aki_rpc_free(&server->server); + nn_rpc_free(&server->server); al_str_free(&server->addr); } -void camu_server_local_add(struct camu_server *server, struct aki_packet *packet) +void camu_server_local_add(struct camu_server *server, struct nn_packet *packet) { handle_add_command(server, al_array_last(server->lists), packet); } diff --git a/src/server/server.h b/src/server/server.h index ec0f85b..ab96e80 100644 --- a/src/server/server.h +++ b/src/server/server.h @@ -1,7 +1,7 @@ #pragma once -#include <aki/multiplex.h> -#include <aki/rpc2.h> +#include <nnwt/multiplex.h> +#include <nnwt/rpc2.h> #include "../liana/server.h" #include "../liana/list.h" @@ -13,25 +13,25 @@ #include "resource.h" struct camu_server_node { - struct aki_rpc_connection *conn; + struct nn_rpc_connection *conn; }; struct camu_server_client { - struct aki_rpc_connection *conn; + struct nn_rpc_connection *conn; struct camu_user *user; }; struct camu_server_sink { - struct aki_rpc_connection *conn; + struct nn_rpc_connection *conn; str name; struct camu_server *server; }; struct camu_server { - struct aki_event_loop *loop; + struct nn_event_loop *loop; str addr; - struct aki_multiplex_socket multi; - struct aki_rpc server; + struct nn_multiplex_socket multi; + struct nn_rpc server; array(struct camu_server_node *) nodes; array(struct camu_server_client *) clients; array(struct camu_server_sink *) sinks; @@ -49,9 +49,9 @@ struct camu_server { void *userdata; }; -bool camu_server_init(struct camu_server *server, u8 type, struct aki_event_loop *loop); +bool camu_server_init(struct camu_server *server, u8 type, struct nn_event_loop *loop); bool camu_server_listen(struct camu_server *server, str *addr, u16 port); void camu_server_close(struct camu_server *server); void camu_server_free(struct camu_server *server); -void camu_server_local_add(struct camu_server *server, struct aki_packet *packet); +void camu_server_local_add(struct camu_server *server, struct nn_packet *packet); diff --git a/src/sink/desktop.c b/src/sink/desktop.c index ccd2e11..4a1b9ca 100644 --- a/src/sink/desktop.c +++ b/src/sink/desktop.c @@ -101,7 +101,7 @@ bool camu_desktop_init(struct camu_desktop *c, const char *name) return true; } -bool camu_desktop_connect(struct camu_desktop *c, u8 type, struct aki_event_loop *loop, str *addr, u16 port) +bool camu_desktop_connect(struct camu_desktop *c, u8 type, struct nn_event_loop *loop, str *addr, u16 port) { c->loop = loop; camu_sink_init(&c->sink, c->loop, &c->mixer, c->renderer); diff --git a/src/sink/desktop.h b/src/sink/desktop.h index efc1c34..2b3ec94 100644 --- a/src/sink/desktop.h +++ b/src/sink/desktop.h @@ -2,14 +2,14 @@ #include <al/types.h> #include <al/str.h> -#include <aki/event_loop.h> +#include <nnwt/event_loop.h> #include "../libsink/sink.h" #include "../screen/screen.h" struct camu_desktop { - struct aki_event_loop *loop; + struct nn_event_loop *loop; s32 should_quit; struct camu_screen scr; struct camu_renderer *renderer; @@ -20,7 +20,7 @@ struct camu_desktop { }; bool camu_desktop_init(struct camu_desktop *c, const char *name); -bool camu_desktop_connect(struct camu_desktop *c, u8 type, struct aki_event_loop *loop, str *addr, u16 port); +bool camu_desktop_connect(struct camu_desktop *c, u8 type, struct nn_event_loop *loop, str *addr, u16 port); bool camu_desktop_tick(struct camu_desktop *c); void camu_desktop_stop(struct camu_desktop *c); void camu_desktop_free(struct camu_desktop *c); diff --git a/src/sink/input_simulator.c b/src/sink/input_simulator.c index af0105d..773ac95 100644 --- a/src/sink/input_simulator.c +++ b/src/sink/input_simulator.c @@ -1,28 +1,28 @@ #include "../screen/screen.h" #ifdef CAMU_SCREEN_DEBUG_KEY -#include <aki/thread.h> +#include <nnwt/thread.h> #include <al/random.h> #include "input_simulator.h" // This is ignoring all thread-safety. static s32 quit = 1; -static struct aki_thread thread; +static struct nn_thread thread; enum { SKIP, BACKSKIP, - SHUFFLE, TOGGLE_PAUSE, + SHUFFLE, SEEK, MARK, // count }; -static aki_thread_result AKI_THREADCALL input_simulation_thread(void *userdata) +static nn_thread_result NNWT_THREADCALL input_simulation_thread(void *userdata) { struct camu_sink *sink = (struct camu_sink *)userdata; while (!quit) { - aki_thread_sleep(AKI_TS_FROM_USEC(30000)); + nn_thread_sleep(NNWT_TS_FROM_USEC(30000)); switch (al_rand() % MARK) { case SKIP: camu_sink_skip(sink, (al_rand() % 5)); @@ -47,7 +47,7 @@ static aki_thread_result AKI_THREADCALL input_simulation_thread(void *userdata) void camu_input_simulator_run(struct camu_sink *sink) { quit = 0; - aki_thread_create(&thread, input_simulation_thread, sink); + nn_thread_create(&thread, input_simulation_thread, sink); } bool camu_input_simulator_running(void) @@ -58,6 +58,6 @@ bool camu_input_simulator_running(void) void camu_input_simulator_stop(void) { quit = 1; - aki_thread_join(&thread); + nn_thread_join(&thread); } #endif diff --git a/src/util/blocking_ring_buffer.c b/src/util/blocking_ring_buffer.c index 5cc3325..ec6cbb8 100644 --- a/src/util/blocking_ring_buffer.c +++ b/src/util/blocking_ring_buffer.c @@ -4,17 +4,17 @@ #define LOCK(n) \ buffer->req_start = n; \ - aki_cond_wait(&buffer->cond, &buffer->mutex); + nn_cond_wait(&buffer->cond, &buffer->mutex); #define SIGNAL() \ - aki_cond_signal(&buffer->cond); + nn_cond_signal(&buffer->cond); void camu_ring_buffer_init(struct camu_ring_buffer *buffer, s32 size) { buffer->size = size; buffer->data = (u8 *)al_malloc(buffer->size); - aki_mutex_init(&buffer->mutex); - aki_cond_init(&buffer->cond); + nn_mutex_init(&buffer->mutex); + nn_cond_init(&buffer->cond); camu_ring_buffer_reset(buffer); buffer->reset_unlock = false; buffer->enabled = true; @@ -23,71 +23,71 @@ void camu_ring_buffer_init(struct camu_ring_buffer *buffer, s32 size) // TODO: does locking here actually prevent this from messing something up. void camu_ring_buffer_reset(struct camu_ring_buffer *buffer) { - aki_mutex_lock(&buffer->mutex); + nn_mutex_lock(&buffer->mutex); buffer->valid_size = 0; buffer->start = 0; buffer->end = 0; // If get_chunk was waiting it doesn't matter where req_start // was, there should be room now. - if (aki_cond_is_waiting(&buffer->cond)) { + if (nn_cond_is_waiting(&buffer->cond)) { buffer->reset_unlock = true; SIGNAL(); } buffer->wrap = false; - aki_mutex_unlock(&buffer->mutex); + nn_mutex_unlock(&buffer->mutex); } void camu_ring_buffer_disable(struct camu_ring_buffer *buffer) { - aki_mutex_lock(&buffer->mutex); + nn_mutex_lock(&buffer->mutex); buffer->enabled = false; // No state on the buffer will be edited by the time a get_chunk // returns because of this. So, the next call to get_chunk after // the buffer is re-enabled should be correct. - if (aki_cond_is_waiting(&buffer->cond)) { + if (nn_cond_is_waiting(&buffer->cond)) { buffer->reset_unlock = true; SIGNAL(); } - aki_mutex_unlock(&buffer->mutex); + nn_mutex_unlock(&buffer->mutex); } void camu_ring_buffer_enable(struct camu_ring_buffer *buffer) { - aki_mutex_lock(&buffer->mutex); + nn_mutex_lock(&buffer->mutex); buffer->enabled = true; - aki_mutex_unlock(&buffer->mutex); + nn_mutex_unlock(&buffer->mutex); } s32 camu_ring_buffer_space(struct camu_ring_buffer *buffer) { s32 available = 0; - aki_mutex_lock(&buffer->mutex); + nn_mutex_lock(&buffer->mutex); if (buffer->end < buffer->start) { available = buffer->start - buffer->end; } else { available = buffer->size - buffer->end; } - aki_mutex_unlock(&buffer->mutex); + nn_mutex_unlock(&buffer->mutex); return available; } s32 camu_ring_buffer_occupied(struct camu_ring_buffer *buffer) { s32 filled = 0; - aki_mutex_lock(&buffer->mutex); + nn_mutex_lock(&buffer->mutex); if (buffer->end < buffer->start) { filled = (buffer->valid_size - buffer->start) + buffer->end; } else { // If the buffer is empty this will equate to 0. filled = buffer->end - buffer->start; } - aki_mutex_unlock(&buffer->mutex); + nn_mutex_unlock(&buffer->mutex); return filled; } u8 *camu_ring_buffer_get_chunk(struct camu_ring_buffer *buffer, s32 n) { - aki_mutex_lock(&buffer->mutex); + nn_mutex_lock(&buffer->mutex); if (!buffer->enabled) return NULL; @@ -136,7 +136,7 @@ u8 *camu_ring_buffer_get_chunk(struct camu_ring_buffer *buffer, s32 n) s32 camu_ring_buffer_read(struct camu_ring_buffer *buffer, u8 **data, s32 n) { - aki_mutex_lock(&buffer->mutex); + nn_mutex_lock(&buffer->mutex); // Set data even if we are going to read 0 bytes to avoid possible issues // with data being NULL after a call to read. @@ -164,11 +164,11 @@ s32 camu_ring_buffer_read(struct camu_ring_buffer *buffer, u8 **data, s32 n) buffer->start = 0; buffer->valid_size = 0; // We wrapped and aren't specifically waiting for a position after the wrap, so unlock. - if (aki_cond_is_waiting(&buffer->cond) && !buffer->wrap) { + if (nn_cond_is_waiting(&buffer->cond) && !buffer->wrap) { SIGNAL(); } buffer->wrap = false; - } else if (aki_cond_is_waiting(&buffer->cond) && (!buffer->wrap && buffer->start > buffer->req_start)) { + } else if (nn_cond_is_waiting(&buffer->cond) && (!buffer->wrap && buffer->start > buffer->req_start)) { // We read past the position we were waiting for, so unlock. SIGNAL(); } @@ -182,12 +182,12 @@ s32 camu_ring_buffer_read(struct camu_ring_buffer *buffer, u8 **data, s32 n) // only after the pointer has been used. void camu_ring_buffer_unlock(struct camu_ring_buffer *buffer) { - aki_mutex_unlock(&buffer->mutex); + nn_mutex_unlock(&buffer->mutex); } void camu_ring_buffer_free(struct camu_ring_buffer *buffer) { if (buffer->data) al_free(buffer->data); - aki_mutex_destroy(&buffer->mutex); - aki_cond_destroy(&buffer->cond); + nn_mutex_destroy(&buffer->mutex); + nn_cond_destroy(&buffer->cond); } diff --git a/src/util/blocking_ring_buffer.h b/src/util/blocking_ring_buffer.h index ff3521e..a5288d0 100644 --- a/src/util/blocking_ring_buffer.h +++ b/src/util/blocking_ring_buffer.h @@ -1,7 +1,7 @@ #pragma once #include <al/types.h> -#include <aki/thread.h> +#include <nnwt/thread.h> // Ring buffer with blocking write and non-blocking read. // - Write can block and always returns the exact amount requested. @@ -20,8 +20,8 @@ struct camu_ring_buffer { // True if we need to wait for the start to wrap around // to the begining before considering signaling. bool wrap; - struct aki_mutex mutex; - struct aki_cond cond; + struct nn_mutex mutex; + struct nn_cond cond; // Signal get_chunk to return null and not modifiy the buffer // if it was blocking and reset was called. bool reset_unlock; diff --git a/src/util/color_palette.c b/src/util/color_palette.c index cc7f5b5..b67f1bb 100644 --- a/src/util/color_palette.c +++ b/src/util/color_palette.c @@ -1,7 +1,7 @@ #include "color_palette.h" -#ifdef AKIYO_HAS_JSON -#include <aki/file.h> +#ifdef NAUNET_HAS_JSON +#include <nnwt/file.h> #include <jansson.h> static char *special_colors[2] = { @@ -33,14 +33,14 @@ struct camu_color_palette global_color_palette = { 0 }; bool camu_color_palette_init(str *path) { -#ifdef AKIYO_HAS_JSON - struct aki_file file; - if (!aki_file_open(&file, path, 0)) { +#ifdef NAUNET_HAS_JSON + struct nn_file file; + if (!nn_file_open(&file, path, 0)) { return false; } str s; - aki_file_read_as_str(&file, &s); - aki_file_close(&file); + nn_file_read_as_str(&file, &s); + nn_file_close(&file); json_error_t error; json_t *root = json_loadb(s.data, s.len, 0, &error); if (!root) return false; diff --git a/src/util/queue.h b/src/util/queue.h index 4f184ba..ac0dfec 100644 --- a/src/util/queue.h +++ b/src/util/queue.h @@ -1,53 +1,53 @@ #pragma once #include <al/array.h> -#include <aki/thread.h> +#include <nnwt/thread.h> #define queue(type) \ struct { \ array(type) a; \ - struct aki_mutex mutex; \ + struct nn_mutex mutex; \ } #define camu_queue_size(q, r) \ do { \ - aki_mutex_lock(&(q).mutex); \ + nn_mutex_lock(&(q).mutex); \ r = (q).a.size; \ - aki_mutex_unlock(&(q).mutex); \ + nn_mutex_unlock(&(q).mutex); \ } while (0) #define camu_queue_init(q) \ do { \ al_array_init((q).a); \ - aki_mutex_init(&(q).mutex); \ + nn_mutex_init(&(q).mutex); \ } while (0) #define camu_queue_push(q, item) \ do { \ - aki_mutex_lock(&(q).mutex); \ + nn_mutex_lock(&(q).mutex); \ al_array_push((q).a, item); \ - aki_mutex_unlock(&(q).mutex); \ + nn_mutex_unlock(&(q).mutex); \ } while (0) #define camu_queue_pop(q, r) \ do { \ - aki_mutex_lock(&(q).mutex); \ + nn_mutex_lock(&(q).mutex); \ al_array_pop_at((q).a, 0, r); \ - aki_mutex_unlock(&(q).mutex); \ + nn_mutex_unlock(&(q).mutex); \ } while (0) #define camu_queue_try_pop(q, s, r) \ do { \ - aki_mutex_lock(&(q).mutex); \ + nn_mutex_lock(&(q).mutex); \ s = (q).a.size; \ if (s > 0) { \ al_array_pop_at((q).a, 0, r); \ } \ - aki_mutex_unlock(&(q).mutex); \ + nn_mutex_unlock(&(q).mutex); \ } while (0) #define camu_queue_free(q) \ do { \ - aki_mutex_destroy(&(q).mutex); \ + nn_mutex_destroy(&(q).mutex); \ al_array_free((q).a); \ } while (0) |