Cleanup

src/layout/blocked.c

@@ -5,7 +5,7 @@
 /* Decodes samples for blocked streams.
  * Data is divided into headered blocks with a bunch of data. The layout calls external helper functions
  * when a block is decoded, and those must parse the new block and move offsets accordingly. */
-void render_vgmstream_blocked(sample_t * buffer, int32_t sample_count, VGMSTREAM * vgmstream) {
+void render_vgmstream_blocked(sample_t* buffer, int32_t sample_count, VGMSTREAM* vgmstream) {
     int samples_written = 0;
     int frame_size, samples_per_frame, samples_this_block;
 
@@ -52,7 +52,7 @@ void render_vgmstream_blocked(sample_t * buffer, int32_t sample_count, VGMSTREAM
             break;
         }
 
-        samples_to_do = vgmstream_samples_to_do(samples_this_block, samples_per_frame, vgmstream);
+        samples_to_do = get_vgmstream_samples_to_do(samples_this_block, samples_per_frame, vgmstream);
         if (samples_to_do > sample_count - samples_written)
             samples_to_do = sample_count - samples_written;
 

src/layout/flat.c

@@ -4,7 +4,7 @@
 
 /* Decodes samples for flat streams.
  * Data forms a single stream, and the decoder may internally skip chunks and move offsets as needed. */
-void render_vgmstream_flat(sample_t * buffer, int32_t sample_count, VGMSTREAM * vgmstream) {
+void render_vgmstream_flat(sample_t* buffer, int32_t sample_count, VGMSTREAM* vgmstream) {
     int samples_written = 0;
     int samples_per_frame, samples_this_block;
 
@@ -20,7 +20,7 @@ void render_vgmstream_flat(sample_t * buffer, int32_t sample_count, VGMSTREAM *
             continue;
         }
 
-        samples_to_do = vgmstream_samples_to_do(samples_this_block, samples_per_frame, vgmstream);
+        samples_to_do = get_vgmstream_samples_to_do(samples_this_block, samples_per_frame, vgmstream);
         if (samples_to_do > sample_count - samples_written)
             samples_to_do = sample_count - samples_written;
 

src/layout/interleave.c

@@ -82,7 +82,7 @@ void render_vgmstream_interleave(sample_t * buffer, int32_t sample_count, VGMSTR
             continue;
         }
 
-        samples_to_do = vgmstream_samples_to_do(samples_this_block, samples_per_frame, vgmstream);
+        samples_to_do = get_vgmstream_samples_to_do(samples_this_block, samples_per_frame, vgmstream);
         if (samples_to_do > sample_count - samples_written)
             samples_to_do = sample_count - samples_written;
 

src/layout/layered.c

@@ -12,9 +12,9 @@
  * Similar to interleave layout, but decodec samples are mixed from complete vgmstreams, each
  * with custom codecs and different number of channels, creating a single super-vgmstream.
  * Usually combined with custom streamfiles to handle data interleaved in weird ways. */
-void render_vgmstream_layered(sample_t * outbuf, int32_t sample_count, VGMSTREAM * vgmstream) {
+void render_vgmstream_layered(sample_t* outbuf, int32_t sample_count, VGMSTREAM* vgmstream) {
     int samples_written = 0;
-    layered_layout_data *data = vgmstream->layout_data;
+    layered_layout_data* data = vgmstream->layout_data;
 
 
     while (samples_written < sample_count) {

src/layout/layout.h

@@ -5,67 +5,67 @@
 #include "../vgmstream.h"
 
 /* blocked layouts */
-void render_vgmstream_blocked(sample_t * buffer, int32_t sample_count, VGMSTREAM * vgmstream);
-void block_update(off_t block_offset, VGMSTREAM * vgmstream);
+void render_vgmstream_blocked(sample_t* buffer, int32_t sample_count, VGMSTREAM* vgmstream);
+void block_update(off_t block_offset, VGMSTREAM* vgmstream);
 
-void block_update_ast(off_t block_ofset, VGMSTREAM * vgmstream);
-void block_update_mxch(off_t block_ofset, VGMSTREAM * vgmstream);
-void block_update_halpst(off_t block_ofset, VGMSTREAM * vgmstream);
-void block_update_xa(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_ea_schl(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_ea_1snh(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_caf(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_wsi(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_str_snds(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_ws_aud(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_matx(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_dec(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_vs(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_mul(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_gsb(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_xvas(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_thp(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_filp(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_ivaud(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_ea_swvr(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_adm(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_bdsp(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_tra(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_ps2_iab(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_vs_str(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_rws(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_hwas(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_ea_sns(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_awc(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_vgs(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_vawx(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_xvag_subsong(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_ea_wve_au00(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_ea_wve_ad10(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_sthd(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_h4m(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_xa_aiff(off_t block_offset, VGMSTREAM * vgmstream);
-void block_update_vs_square(off_t block_offset, VGMSTREAM * vgmstream);
+void block_update_ast(off_t block_ofset, VGMSTREAM* vgmstream);
+void block_update_mxch(off_t block_ofset, VGMSTREAM* vgmstream);
+void block_update_halpst(off_t block_ofset, VGMSTREAM* vgmstream);
+void block_update_xa(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_ea_schl(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_ea_1snh(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_caf(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_wsi(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_str_snds(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_ws_aud(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_matx(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_dec(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_vs(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_mul(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_gsb(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_xvas(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_thp(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_filp(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_ivaud(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_ea_swvr(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_adm(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_bdsp(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_tra(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_ps2_iab(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_vs_str(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_rws(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_hwas(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_ea_sns(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_awc(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_vgs(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_vawx(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_xvag_subsong(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_ea_wve_au00(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_ea_wve_ad10(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_sthd(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_h4m(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_xa_aiff(off_t block_offset, VGMSTREAM* vgmstream);
+void block_update_vs_square(off_t block_offset, VGMSTREAM* vgmstream);
 void block_update_vid1(off_t block_offset, VGMSTREAM* vgmstream);
 void block_update_ubi_sce(off_t block_offset, VGMSTREAM* vgmstream);
 
 /* other layouts */
-void render_vgmstream_interleave(sample_t * buffer, int32_t sample_count, VGMSTREAM * vgmstream);
+void render_vgmstream_interleave(sample_t* buffer, int32_t sample_count, VGMSTREAM* vgmstream);
 
-void render_vgmstream_flat(sample_t * buffer, int32_t sample_count, VGMSTREAM * vgmstream);
+void render_vgmstream_flat(sample_t* buffer, int32_t sample_count, VGMSTREAM* vgmstream);
 
-void render_vgmstream_segmented(sample_t * buffer, int32_t sample_count, VGMSTREAM * vgmstream);
+void render_vgmstream_segmented(sample_t* buffer, int32_t sample_count, VGMSTREAM* vgmstream);
 segmented_layout_data* init_layout_segmented(int segment_count);
 int setup_layout_segmented(segmented_layout_data* data);
-void free_layout_segmented(segmented_layout_data *data);
-void reset_layout_segmented(segmented_layout_data *data);
+void free_layout_segmented(segmented_layout_data* data);
+void reset_layout_segmented(segmented_layout_data* data);
 VGMSTREAM *allocate_segmented_vgmstream(segmented_layout_data* data, int loop_flag, int loop_start_segment, int loop_end_segment);
 
-void render_vgmstream_layered(sample_t * buffer, int32_t sample_count, VGMSTREAM * vgmstream);
+void render_vgmstream_layered(sample_t* buffer, int32_t sample_count, VGMSTREAM* vgmstream);
 layered_layout_data* init_layout_layered(int layer_count);
 int setup_layout_layered(layered_layout_data* data);
-void free_layout_layered(layered_layout_data *data);
-void reset_layout_layered(layered_layout_data *data);
+void free_layout_layered(layered_layout_data* data);
+void reset_layout_layered(layered_layout_data* data);
 VGMSTREAM *allocate_layered_vgmstream(layered_layout_data* data);
 
 #endif

src/layout/segmented.c

@@ -9,9 +9,9 @@
 /* Decodes samples for segmented streams.
  * Chains together sequential vgmstreams, for data divided into separate sections or files
  * (like one part for intro and other for loop segments, which may even use different codecs). */
-void render_vgmstream_segmented(sample_t * outbuf, int32_t sample_count, VGMSTREAM * vgmstream) {
+void render_vgmstream_segmented(sample_t* outbuf, int32_t sample_count, VGMSTREAM* vgmstream) {
     int samples_written = 0, loop_samples_skip = 0;
-    segmented_layout_data *data = vgmstream->layout_data;
+    segmented_layout_data* data = vgmstream->layout_data;
     int use_internal_buffer = 0;
 
 
@@ -59,7 +59,7 @@ void render_vgmstream_segmented(sample_t * outbuf, int32_t sample_count, VGMSTRE
             continue;
         }
 
-        samples_to_do = vgmstream_samples_to_do(samples_this_segment, sample_count, vgmstream);
+        samples_to_do = get_vgmstream_samples_to_do(samples_this_segment, sample_count, vgmstream);
         if (samples_to_do > sample_count - samples_written)
             samples_to_do = sample_count - samples_written;
         if (samples_to_do > VGMSTREAM_SEGMENT_SAMPLE_BUFFER /*&& use_internal_buffer*/) /* always for fade/etc mixes */
@@ -107,7 +107,7 @@ void render_vgmstream_segmented(sample_t * outbuf, int32_t sample_count, VGMSTRE
 
 
 segmented_layout_data* init_layout_segmented(int segment_count) {
-    segmented_layout_data *data = NULL;
+    segmented_layout_data* data = NULL;
 
     if (segment_count <= 0 || segment_count > VGMSTREAM_MAX_SEGMENTS)
         goto fail;
@@ -203,7 +203,7 @@ fail:
     return 0; /* caller is expected to free */
 }
 
-void free_layout_segmented(segmented_layout_data *data) {
+void free_layout_segmented(segmented_layout_data* data) {
     int i, j;
 
     if (!data)
@@ -229,7 +229,7 @@ void free_layout_segmented(segmented_layout_data *data) {
     free(data);
 }
 
-void reset_layout_segmented(segmented_layout_data *data) {
+void reset_layout_segmented(segmented_layout_data* data) {
     int i;
 
     if (!data)

src/vgmstream.h

@@ -1047,7 +1047,7 @@ typedef struct {
 /* -------------------------------------------------------------------------*/
 
 /* do format detection, return pointer to a usable VGMSTREAM, or NULL on failure */
-VGMSTREAM* init_vgmstream(const char * const filename);
+VGMSTREAM* init_vgmstream(const char* const filename);
 
 /* init with custom IO via streamfile */
 VGMSTREAM* init_vgmstream_from_STREAMFILE(STREAMFILE* sf);
@@ -1073,10 +1073,10 @@ int get_vgmstream_average_bitrate(VGMSTREAM* vgmstream);
 
 /* List supported formats and return elements in the list, for plugins that need to know.
  * The list disables some common formats that may conflict (.wav, .ogg, etc). */
-const char ** vgmstream_get_formats(size_t * size);
+const char** vgmstream_get_formats(size_t* size);
 
 /* same, but for common-but-disabled formats in the above list. */
-const char ** vgmstream_get_common_formats(size_t * size);
+const char** vgmstream_get_common_formats(size_t* size);
 
 /* Force enable/disable internal looping. Should be done before playing anything (or after reset),
  * and not all codecs support arbitrary loop values ATM. */
@@ -1111,7 +1111,7 @@ int get_vgmstream_shortframe_size(VGMSTREAM* vgmstream);
 void decode_vgmstream(VGMSTREAM* vgmstream, int samples_written, int samples_to_do, sample_t* buffer);
 
 /* Calculate number of consecutive samples to do (taking into account stopping for loop start and end) */
-int vgmstream_samples_to_do(int samples_this_block, int samples_per_frame, VGMSTREAM* vgmstream);
+int get_vgmstream_samples_to_do(int samples_this_block, int samples_per_frame, VGMSTREAM* vgmstream);
 
 /* Detect loop start and save values, or detect loop end and restore (loop back). Returns 1 if loop was done. */
 int vgmstream_do_loop(VGMSTREAM* vgmstream);