Updated VGMStream to r1980-95-g551c0787

Signed-off-by: Christopher Snowhill <[email protected]>

Frameworks/vgmstream/vgmstream/src/base/api_decode_base.c

@@ -1,6 +1,5 @@
 #include "api_internal.h"
 #include "mixing.h"
-#if LIBVGMSTREAM_ENABLE
 
 #define INTERNAL_BUF_SAMPLES  1024
 
@@ -104,5 +103,3 @@ int api_get_sample_size(libvgmstream_sample_t sample_type) {
             return 0x02;
     }
 }
-
-#endif

Frameworks/vgmstream/vgmstream/src/base/api_decode_open.c

@@ -1,7 +1,6 @@
 #include "api_internal.h"
 #include "sbuf.h"
 #include "mixing.h"
-#if LIBVGMSTREAM_ENABLE
 
 
 static void load_vgmstream(libvgmstream_priv_t* priv, libvgmstream_options_t* opt) {
@@ -106,14 +105,14 @@ static void update_format_info(libvgmstream_priv_t* priv) {
     }
 }
 
-LIBVGMSTREAM_API int libvgmstream_open_song(libvgmstream_t* lib, libvgmstream_options_t* opt) {
+LIBVGMSTREAM_API int libvgmstream_open_stream(libvgmstream_t* lib, libvgmstream_options_t* opt) {
     if (!lib ||!lib->priv)
         return LIBVGMSTREAM_ERROR_GENERIC;
     if (!opt || !opt->libsf || opt->subsong_index < 0)
         return LIBVGMSTREAM_ERROR_GENERIC;
 
     // close loaded song if any + reset
-    libvgmstream_close_song(lib);
+    libvgmstream_close_stream(lib);
 
     libvgmstream_priv_t* priv = lib->priv;
 
@@ -131,7 +130,7 @@ LIBVGMSTREAM_API int libvgmstream_open_song(libvgmstream_t* lib, libvgmstream_op
 }
 
 
-LIBVGMSTREAM_API void libvgmstream_close_song(libvgmstream_t* lib) {
+LIBVGMSTREAM_API void libvgmstream_close_stream(libvgmstream_t* lib) {
     if (!lib || !lib->priv)
         return;
 
@@ -142,5 +141,3 @@ LIBVGMSTREAM_API void libvgmstream_close_song(libvgmstream_t* lib) {
 
     libvgmstream_priv_reset(priv, true);
 }
-
-#endif

Frameworks/vgmstream/vgmstream/src/base/api_decode_play.c

@@ -2,8 +2,6 @@
 #include "mixing.h"
 #include "render.h"
 
-#if LIBVGMSTREAM_ENABLE
-
 
 static bool reset_buf(libvgmstream_priv_t* priv) {
     // state reset
@@ -98,24 +96,45 @@ LIBVGMSTREAM_API int libvgmstream_fill(libvgmstream_t* lib, void* buf, int buf_s
         return LIBVGMSTREAM_ERROR_GENERIC;
 
     libvgmstream_priv_t* priv = lib->priv;
-    if (priv->decode_done)
-        return LIBVGMSTREAM_ERROR_GENERIC;
 
-    if (priv->buf.consumed >= priv->buf.samples) {
-        int err = libvgmstream_render(lib);
-        if (err < 0) return err;
-    }
+    bool done = false;
+    int buf_copied = 0;
+    while (buf_copied < buf_samples) {
+
+        // decode if no samples in internal buf
+        if (priv->buf.consumed >= priv->buf.samples) {
+            if (priv->decode_done) {
+                done = true;
+                break;
+            }
+
+            int err = libvgmstream_render(lib);
+            if (err < 0) return err;
+        }
 
-    int copy_samples = priv->buf.samples;
-    if (copy_samples > buf_samples)
-        copy_samples = buf_samples;
-    int copy_bytes = priv->buf.sample_size * priv->buf.channels * copy_samples;
-    int skip_bytes = priv->buf.sample_size * priv->buf.channels * priv->buf.consumed;
+        // copy from partial decode src to partial dst
+        int buf_left = buf_samples - buf_copied;
+        int copy_samples = priv->buf.samples - priv->buf.consumed;
+        if (copy_samples > buf_left)
+            copy_samples = buf_left;
 
-    memcpy(buf, ((uint8_t*)priv->buf.data) + skip_bytes, copy_bytes);
-    priv->buf.consumed += copy_samples;
+        int copy_bytes = priv->buf.sample_size * priv->buf.channels * copy_samples;
+        int skip_bytes = priv->buf.sample_size * priv->buf.channels * priv->buf.consumed;
+        int copied_bytes = priv->buf.sample_size * priv->buf.channels * buf_copied;
 
-    return copy_samples;
+        memcpy( ((uint8_t*)buf) + copied_bytes, ((uint8_t*)priv->buf.data) + skip_bytes, copy_bytes);
+        priv->buf.consumed += copy_samples;
+
+        buf_copied += copy_samples;
+    }
+
+    // TODO improve
+    priv->dec.buf = buf;
+    priv->dec.buf_samples = buf_copied;
+    priv->dec.buf_bytes = buf_copied * priv->buf.sample_size * priv->buf.channels;
+    priv->dec.done = done;
+
+    return 0;
 }
 
 
@@ -155,5 +174,3 @@ LIBVGMSTREAM_API void libvgmstream_reset(libvgmstream_t* lib) {
     }
     libvgmstream_priv_reset(priv, false);
 }
-
-#endif

Frameworks/vgmstream/vgmstream/src/base/api_helpers.c

@@ -1,5 +1,4 @@
 #include "api_internal.h"
-#if LIBVGMSTREAM_ENABLE
 
 
 static int get_internal_log_level(libvgmstream_loglevel_t level) {
@@ -60,7 +59,7 @@ LIBVGMSTREAM_API bool libvgmstream_is_valid(const char* filename, libvgmstream_v
 
     vgmstream_ctx_valid_cfg icfg = {
         .is_extension = cfg->is_extension,
-        .skip_standard = cfg->skip_default,
+        .skip_standard = cfg->skip_standard,
         .reject_extensionless = cfg->reject_extensionless,
         .accept_unknown = cfg->accept_unknown,
         .accept_common = cfg->accept_common
@@ -91,5 +90,3 @@ LIBVGMSTREAM_API int libvgmstream_get_title(libvgmstream_t* lib, libvgmstream_ti
 LIBVGMSTREAM_API bool libvgmstream_is_virtual_filename(const char* filename) {
     return vgmstream_is_virtual_filename(filename);
 }
-
-#endif

Frameworks/vgmstream/vgmstream/src/base/api_internal.h

@@ -5,7 +5,6 @@
 #include "../vgmstream.h"
 #include "plugins.h"
 
-#if LIBVGMSTREAM_ENABLE
 
 #define LIBVGMSTREAM_OK  0
 #define LIBVGMSTREAM_ERROR_GENERIC  -1
@@ -63,4 +62,3 @@ int api_get_sample_size(libvgmstream_sample_t sample_type);
 STREAMFILE* open_api_streamfile(libstreamfile_t* libsf);
 
 #endif
-#endif

Frameworks/vgmstream/vgmstream/src/base/api_libsf.c

@@ -1,5 +1,4 @@
 #include "api_internal.h"
-#if LIBVGMSTREAM_ENABLE
 
 static libstreamfile_t* libstreamfile_from_streamfile(STREAMFILE* sf);
 
@@ -8,75 +7,75 @@ static libstreamfile_t* libstreamfile_from_streamfile(STREAMFILE* sf);
 typedef struct {
     int64_t offset;
     int64_t size;
-    STREAMFILE* inner_sf;
+    STREAMFILE* sf;
     char name[PATH_LIMIT];
-} libsf_data_t;
+} libsf_priv_t;
 
 static int libsf_read(void* user_data, uint8_t* dst, int dst_size) {
-    libsf_data_t* data = user_data;
-    if (!data || !dst)
+    libsf_priv_t* priv = user_data;
+    if (!priv || !dst)
         return 0;
 
-    int bytes = data->inner_sf->read(data->inner_sf, dst, data->offset, dst_size);
-    data->offset += bytes;
+    int bytes = priv->sf->read(priv->sf, dst, priv->offset, dst_size);
+    priv->offset += bytes;
 
     return bytes;
 }
 
 static int64_t libsf_seek(void* user_data, int64_t offset, int whence) {
-    libsf_data_t* data = user_data;
-    if (!data)
+    libsf_priv_t* priv = user_data;
+    if (!priv)
         return -1;
 
     switch (whence) {
         case LIBSTREAMFILE_SEEK_SET: /* absolute */
             break;
         case LIBSTREAMFILE_SEEK_CUR: /* relative to current */
-            offset += data->offset;
+            offset += priv->offset;
             break;
         case LIBSTREAMFILE_SEEK_END: /* relative to file end (should be negative) */
-            offset += data->size;
+            offset += priv->size;
             break;
         default:
             break;
     }
 
     /* clamp offset like fseek */
-    if (offset > data->size)
-        offset = data->size;
+    if (offset > priv->size)
+        offset = priv->size;
     else if (offset < 0)
         offset = 0;
 
     /* main seek */
-    data->offset = offset;
+    priv->offset = offset;
     return 0;
 }
 
 static int64_t libsf_get_size(void* user_data) {
-    libsf_data_t* data = user_data;
-    if (!data)
+    libsf_priv_t* priv = user_data;
+    if (!priv)
         return 0;
-    return data->size;
+    return priv->size;
 }
 
 static const char* libsf_get_name(void* user_data) {
-    libsf_data_t* data = user_data;
-    if (!data)
+    libsf_priv_t* priv = user_data;
+    if (!priv)
         return NULL;
 
-    if (data->name[0] == '\0') {
-        data->inner_sf->get_name(data->inner_sf, data->name, sizeof(data->name));
+    if (priv->name[0] == '\0') {
+        priv->sf->get_name(priv->sf, priv->name, sizeof(priv->name));
     }
 
-    return data->name;
+    return priv->name;
 }
 
 static libstreamfile_t* libsf_open(void* user_data, const char* filename) {
-    libsf_data_t* data = user_data;
-    if (!data || !data->inner_sf || !filename)
+    libsf_priv_t* priv = user_data;
+    if (!priv || !priv->sf || !filename)
         return NULL;
 
-    STREAMFILE* sf = data->inner_sf->open(data->inner_sf, filename, 0);
+    STREAMFILE* sf = priv->sf->open(priv->sf, filename, 0);
     if (!sf)
         return NULL;
 
@@ -93,11 +92,11 @@ static void libsf_close(libstreamfile_t* libsf) {
     if (!libsf)
         return;
 
-    libsf_data_t* data = libsf->user_data;
-    if (data && data->inner_sf) {
-        data->inner_sf->close(data->inner_sf);
+    libsf_priv_t* priv = libsf->user_data;
+    if (priv && priv->sf) {
+        priv->sf->close(priv->sf);
     }
-    free(data);
+    free(priv);
     free(libsf);
 }
 
@@ -106,7 +105,7 @@ static libstreamfile_t* libstreamfile_from_streamfile(STREAMFILE* sf) {
         return NULL;
 
     libstreamfile_t* libsf = NULL;
-    libsf_data_t* data = NULL;
+    libsf_priv_t* priv = NULL;
 
     libsf = calloc(1, sizeof(libstreamfile_t));
     if (!libsf) goto fail;
@@ -118,12 +117,12 @@ static libstreamfile_t* libstreamfile_from_streamfile(STREAMFILE* sf) {
     libsf->open = libsf_open;
     libsf->close = libsf_close;
 
-    libsf->user_data = calloc(1, sizeof(libsf_data_t));
+    libsf->user_data = calloc(1, sizeof(libsf_priv_t));
     if (!libsf->user_data) goto fail;
 
-    data = libsf->user_data;
-    data->inner_sf = sf;
-    data->size = get_streamfile_size(sf);
+    priv = libsf->user_data;
+    priv->sf = sf;
+    priv->size = get_streamfile_size(sf);
 
     return libsf;
 fail:
@@ -145,4 +144,18 @@ LIBVGMSTREAM_API libstreamfile_t* libstreamfile_open_from_stdio(const char* file
 
     return libsf;
 }
-#endif
+
+LIBVGMSTREAM_API libstreamfile_t* libstreamfile_open_from_file(void* file_, const char* filename) {
+    FILE* file = file_;
+    STREAMFILE* sf = open_stdio_streamfile_by_file(file, filename);
+    if (!sf)
+        return NULL;
+
+    libstreamfile_t* libsf = libstreamfile_from_streamfile(sf);
+    if (!libsf) {
+        close_streamfile(sf);
+        return NULL;
+    }
+
+    return libsf;
+}