From 0ad19c7262f987691d04051648e71d6f30892d5f Mon Sep 17 00:00:00 2001
From: Dave Bryant <bryant@rockbox.org>
Date: Sun, 26 Mar 2006 22:54:15 +0000
Subject: Eliminate references to "long" types for 64-bit compiles; return
 audio data in Rockbox standard S3.28 format

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@9272 a1c6a512-1295-4272-9138-f99709370657
---
 apps/codecs/libwavpack/bits.c     | 20 ++++++------
 apps/codecs/libwavpack/float.c    |  4 +--
 apps/codecs/libwavpack/metadata.c | 12 +++----
 apps/codecs/libwavpack/pack.c     | 48 +++++++++++++--------------
 apps/codecs/libwavpack/unpack.c   | 68 +++++++++++++++++++--------------------
 apps/codecs/libwavpack/wavpack.h  | 67 +++++++++++++++++++-------------------
 apps/codecs/libwavpack/words.c    | 44 ++++++++++++-------------
 apps/codecs/libwavpack/wputils.c  | 58 ++++++++++++++++-----------------
 apps/codecs/wavpack.c             | 14 ++++----
 apps/plugins/wav2wv.c             | 48 +++++++++++++--------------
 10 files changed, 191 insertions(+), 192 deletions(-)

diff --git a/apps/codecs/libwavpack/bits.c b/apps/codecs/libwavpack/bits.c
index bf056a9392..0a148e123f 100644
--- a/apps/codecs/libwavpack/bits.c
+++ b/apps/codecs/libwavpack/bits.c
@@ -24,7 +24,7 @@
 
 static void bs_read (Bitstream *bs);
 
-void bs_open_read (Bitstream *bs, uchar *buffer_start, uchar *buffer_end, read_stream file, ulong file_bytes)
+void bs_open_read (Bitstream *bs, uchar *buffer_start, uchar *buffer_end, read_stream file, uint32_t file_bytes)
 {
     CLEAR (*bs);
     bs->buf = buffer_start;
@@ -49,7 +49,7 @@ void bs_open_read (Bitstream *bs, uchar *buffer_start, uchar *buffer_end, read_s
 static void bs_read (Bitstream *bs)
 {
     if (bs->file && bs->file_bytes) {
-        ulong bytes_read, bytes_to_read = bs->end - bs->buf;
+        uint32_t bytes_read, bytes_to_read = bs->end - bs->buf;
 
         if (bytes_to_read > bs->file_bytes)
             bytes_to_read = bs->file_bytes;
@@ -100,12 +100,12 @@ static void bs_write (Bitstream *bs)
 // This function forces a flushing write of the specified BitStream, and
 // returns the total number of bytes written into the buffer.
 
-ulong bs_close_write (Bitstream *bs)
+uint32_t bs_close_write (Bitstream *bs)
 {
-    ulong bytes_written;
+    uint32_t bytes_written;
 
     if (bs->error)
-        return (ulong) -1;
+        return (uint32_t) -1;
 
     while (bs->bc || ((bs->ptr - bs->buf) & 1)) putbit_1 (bs);
     bytes_written = bs->ptr - bs->buf;
@@ -118,13 +118,13 @@ ulong bs_close_write (Bitstream *bs)
 void little_endian_to_native (void *data, char *format)
 {
     uchar *cp = (uchar *) data;
-    long temp;
+    int32_t temp;
 
     while (*format) {
         switch (*format) {
             case 'L':
-                temp = cp [0] + ((long) cp [1] << 8) + ((long) cp [2] << 16) + ((long) cp [3] << 24);
-                * (long *) cp = temp;
+                temp = cp [0] + ((int32_t) cp [1] << 8) + ((int32_t) cp [2] << 16) + ((int32_t) cp [3] << 24);
+                * (int32_t *) cp = temp;
                 cp += 4;
                 break;
 
@@ -148,12 +148,12 @@ void little_endian_to_native (void *data, char *format)
 void native_to_little_endian (void *data, char *format)
 {
     uchar *cp = (uchar *) data;
-    long temp;
+    int32_t temp;
 
     while (*format) {
         switch (*format) {
             case 'L':
-                temp = * (long *) cp;
+                temp = * (int32_t *) cp;
                 *cp++ = (uchar) temp;
                 *cp++ = (uchar) (temp >> 8);
                 *cp++ = (uchar) (temp >> 16);
diff --git a/apps/codecs/libwavpack/float.c b/apps/codecs/libwavpack/float.c
index 2208e616d8..9d3a82c001 100644
--- a/apps/codecs/libwavpack/float.c
+++ b/apps/codecs/libwavpack/float.c
@@ -25,7 +25,7 @@ int read_float_info (WavpackStream *wps, WavpackMetadata *wpmd)
     return TRUE;
 }
 
-void float_values (WavpackStream *wps, long *values, long num_values)
+void float_values (WavpackStream *wps, int32_t *values, int32_t num_values)
 {
     while (num_values--) {
         int shift_count = 0, exp = wps->float_max_exp;
@@ -60,7 +60,7 @@ void float_values (WavpackStream *wps, long *values, long num_values)
     }
 }
 
-void float_normalize (long *values, long num_values, int delta_exp)
+void float_normalize (int32_t *values, int32_t num_values, int delta_exp)
 {
     f32 *fvalues = (f32 *) values, fzero = { 0, 0, 0 };
     int exp;
diff --git a/apps/codecs/libwavpack/metadata.c b/apps/codecs/libwavpack/metadata.c
index ebc7dcf99d..b7d1e950bf 100644
--- a/apps/codecs/libwavpack/metadata.c
+++ b/apps/codecs/libwavpack/metadata.c
@@ -29,12 +29,12 @@ int read_metadata_buff (WavpackContext *wpc, WavpackMetadata *wpmd)
         if (!wpc->infile (&tchar, 1))
             return FALSE;
 
-        wpmd->byte_length += (long) tchar << 9; 
+        wpmd->byte_length += (int32_t) tchar << 9; 
 
         if (!wpc->infile (&tchar, 1))
             return FALSE;
 
-        wpmd->byte_length += (long) tchar << 17;
+        wpmd->byte_length += (int32_t) tchar << 17;
     }
 
     if (wpmd->id & ID_ODD_SIZE) {
@@ -42,10 +42,10 @@ int read_metadata_buff (WavpackContext *wpc, WavpackMetadata *wpmd)
         wpmd->byte_length--;
     }
 
-    if (wpmd->byte_length && wpmd->byte_length <= (long)sizeof (wpc->read_buffer)) {
-        ulong bytes_to_read = wpmd->byte_length + (wpmd->byte_length & 1);
+    if (wpmd->byte_length && wpmd->byte_length <= (int32_t)sizeof (wpc->read_buffer)) {
+        uint32_t bytes_to_read = wpmd->byte_length + (wpmd->byte_length & 1);
 
-        if (wpc->infile (wpc->read_buffer, bytes_to_read) != (long) bytes_to_read) {
+        if (wpc->infile (wpc->read_buffer, bytes_to_read) != (int32_t) bytes_to_read) {
             wpmd->data = NULL;
             return FALSE;
         }
@@ -108,7 +108,7 @@ int process_metadata (WavpackContext *wpc, WavpackMetadata *wpmd)
 
 int copy_metadata (WavpackMetadata *wpmd, uchar *buffer_start, uchar *buffer_end)
 {
-    ulong mdsize = wpmd->byte_length + (wpmd->byte_length & 1);
+    uint32_t mdsize = wpmd->byte_length + (wpmd->byte_length & 1);
     WavpackHeader *wphdr = (WavpackHeader *) buffer_start;
 
     if (wpmd->byte_length & 1)
diff --git a/apps/codecs/libwavpack/pack.c b/apps/codecs/libwavpack/pack.c
index 588efccc6f..9ccfa07261 100644
--- a/apps/codecs/libwavpack/pack.c
+++ b/apps/codecs/libwavpack/pack.c
@@ -39,7 +39,7 @@ static const signed char fast_terms [] = { 17,17,0 };
 void pack_init (WavpackContext *wpc)
 {
     WavpackStream *wps = &wpc->stream;
-    ulong flags = wps->wphdr.flags;
+    uint32_t flags = wps->wphdr.flags;
     struct decorr_pass *dpp;
     const signed char *term_string;
     int ti;
@@ -264,19 +264,19 @@ int pack_start_block (WavpackContext *wpc)
     return TRUE;
 }
 
-static void decorr_stereo_pass (struct decorr_pass *dpp, long *bptr, long *eptr, int m);
-static void decorr_stereo_pass_18 (struct decorr_pass *dpp, long *bptr, long *eptr);
-static void decorr_stereo_pass_17 (struct decorr_pass *dpp, long *bptr, long *eptr);
-static void decorr_stereo_pass_m2 (struct decorr_pass *dpp, long *bptr, long *eptr);
+static void decorr_stereo_pass (struct decorr_pass *dpp, int32_t *bptr, int32_t *eptr, int m);
+static void decorr_stereo_pass_18 (struct decorr_pass *dpp, int32_t *bptr, int32_t *eptr);
+static void decorr_stereo_pass_17 (struct decorr_pass *dpp, int32_t *bptr, int32_t *eptr);
+static void decorr_stereo_pass_m2 (struct decorr_pass *dpp, int32_t *bptr, int32_t *eptr);
 
-int pack_samples (WavpackContext *wpc, long *buffer, ulong sample_count)
+int pack_samples (WavpackContext *wpc, int32_t *buffer, uint32_t sample_count)
 {
     WavpackStream *wps = &wpc->stream;
-    ulong flags = wps->wphdr.flags;
+    uint32_t flags = wps->wphdr.flags;
     struct decorr_pass *dpp;
-    long *bptr, *eptr;
+    int32_t *bptr, *eptr;
     int tcount, m;
-    ulong crc;
+    uint32_t crc;
 
     if (!sample_count)
         return TRUE;
@@ -289,12 +289,12 @@ int pack_samples (WavpackContext *wpc, long *buffer, ulong sample_count)
 
     if (!(flags & HYBRID_FLAG) && (flags & MONO_FLAG))
         for (bptr = buffer; bptr < eptr;) {
-            long code;
+            int32_t code;
 
             crc = crc * 3 + (code = *bptr);
 
             for (tcount = wps->num_terms, dpp = wps->decorr_passes; tcount--; dpp++) {
-                long sam;
+                int32_t sam;
 
                 if (dpp->term > MAX_TERM) {
                     if (dpp->term & 1)
@@ -350,10 +350,10 @@ int pack_samples (WavpackContext *wpc, long *buffer, ulong sample_count)
     return TRUE;
 }
 
-static void decorr_stereo_pass (struct decorr_pass *dpp, long *bptr, long *eptr, int m)
+static void decorr_stereo_pass (struct decorr_pass *dpp, int32_t *bptr, int32_t *eptr, int m)
 {
     int k = (m + dpp->term) & (MAX_TERM - 1);
-    long sam;
+    int32_t sam;
 
     while (bptr < eptr) {
         dpp->samples_A [k] = bptr [0];
@@ -369,9 +369,9 @@ static void decorr_stereo_pass (struct decorr_pass *dpp, long *bptr, long *eptr,
     }
 }
 
-static void decorr_stereo_pass_18 (struct decorr_pass *dpp, long *bptr, long *eptr)
+static void decorr_stereo_pass_18 (struct decorr_pass *dpp, int32_t *bptr, int32_t *eptr)
 {
-    long sam;
+    int32_t sam;
 
     while (bptr < eptr) {
         sam = (3 * dpp->samples_A [0] - dpp->samples_A [1]) >> 1;
@@ -389,9 +389,9 @@ static void decorr_stereo_pass_18 (struct decorr_pass *dpp, long *bptr, long *ep
     }
 }
 
-static void decorr_stereo_pass_m2 (struct decorr_pass *dpp, long *bptr, long *eptr)
+static void decorr_stereo_pass_m2 (struct decorr_pass *dpp, int32_t *bptr, int32_t *eptr)
 {
-    long sam_A, sam_B;
+    int32_t sam_A, sam_B;
 
     for (; bptr < eptr; bptr += 2) {
         sam_A = bptr [1];
@@ -404,18 +404,18 @@ static void decorr_stereo_pass_m2 (struct decorr_pass *dpp, long *bptr, long *ep
     }
 }
 
-static void decorr_stereo_pass_17 (struct decorr_pass *dpp, long *bptr, long *eptr)
+static void decorr_stereo_pass_17 (struct decorr_pass *dpp, int32_t *bptr, int32_t *eptr)
 {
-    long sam;
+    int32_t sam;
 
     while (bptr < eptr) {
-		sam = 2 * dpp->samples_A [0] - dpp->samples_A [1];
+	sam = 2 * dpp->samples_A [0] - dpp->samples_A [1];
         dpp->samples_A [1] = dpp->samples_A [0];
         dpp->samples_A [0] = bptr [0];
         bptr [0] -= apply_weight_i (dpp->weight_A, sam);
         update_weight (dpp->weight_A, 2, sam, bptr [0]);
         bptr++;
-		sam = 2 * dpp->samples_B [0] - dpp->samples_B [1];
+	sam = 2 * dpp->samples_B [0] - dpp->samples_B [1];
         dpp->samples_B [1] = dpp->samples_B [0];
         dpp->samples_B [0] = bptr [0];
         bptr [0] -= apply_weight_i (dpp->weight_B, sam);
@@ -428,7 +428,7 @@ int pack_finish_block (WavpackContext *wpc)
 {
     WavpackStream *wps = &wpc->stream;
     struct decorr_pass *dpp;
-    ulong data_count;
+    uint32_t data_count;
     int tcount, m;
 
     m = ((WavpackHeader *) wps->blockbuff)->block_samples & (MAX_TERM - 1);
@@ -436,7 +436,7 @@ int pack_finish_block (WavpackContext *wpc)
     if (m)
         for (tcount = wps->num_terms, dpp = wps->decorr_passes; tcount--; dpp++)
             if (dpp->term > 0 && dpp->term <= MAX_TERM) {
-                long temp_A [MAX_TERM], temp_B [MAX_TERM];
+                int32_t temp_A [MAX_TERM], temp_B [MAX_TERM];
                 int k;
 
                 memcpy (temp_A, dpp->samples_A, sizeof (dpp->samples_A));
@@ -453,7 +453,7 @@ int pack_finish_block (WavpackContext *wpc)
     data_count = bs_close_write (&wps->wvbits);
 
     if (data_count) {
-        if (data_count != (ulong) -1) {
+        if (data_count != (uint32_t) -1) {
             uchar *cptr = wps->blockbuff + ((WavpackHeader *) wps->blockbuff)->ckSize + 8;
 
             *cptr++ = ID_WV_BITSTREAM | ID_LARGE;
diff --git a/apps/codecs/libwavpack/unpack.c b/apps/codecs/libwavpack/unpack.c
index af5d71585e..dcc9bf5bf9 100644
--- a/apps/codecs/libwavpack/unpack.c
+++ b/apps/codecs/libwavpack/unpack.c
@@ -35,7 +35,7 @@ int unpack_init (WavpackContext *wpc)
     WavpackStream *wps = &wpc->stream;
     WavpackMetadata wpmd;
 
-    if (wps->wphdr.block_samples && wps->wphdr.block_index != (ulong) -1)
+    if (wps->wphdr.block_samples && wps->wphdr.block_index != (uint32_t) -1)
         wps->sample_index = wps->wphdr.block_index;
 
     wps->mute_error = FALSE;
@@ -237,7 +237,7 @@ int read_channel_info (WavpackContext *wpc, WavpackMetadata *wpmd)
 {
     int bytecnt = wpmd->byte_length, shift = 0;
     char *byteptr = wpmd->data;
-    ulong mask = 0;
+    uint32_t mask = 0;
 
     if (!bytecnt || bytecnt > 5)
         return FALSE;
@@ -245,7 +245,7 @@ int read_channel_info (WavpackContext *wpc, WavpackMetadata *wpmd)
     wpc->config.num_channels = *byteptr++;
 
     while (--bytecnt) {
-        mask |= (ulong) *byteptr++ << shift;
+        mask |= (uint32_t) *byteptr++ << shift;
         shift += 8;
     }
 
@@ -262,9 +262,9 @@ int read_config_info (WavpackContext *wpc, WavpackMetadata *wpmd)
 
     if (bytecnt >= 3) {
         wpc->config.flags &= 0xff;
-        wpc->config.flags |= (long) *byteptr++ << 8;
-        wpc->config.flags |= (long) *byteptr++ << 16;
-        wpc->config.flags |= (long) *byteptr << 24;
+        wpc->config.flags |= (int32_t) *byteptr++ << 8;
+        wpc->config.flags |= (int32_t) *byteptr++ << 16;
+        wpc->config.flags |= (int32_t) *byteptr << 24;
     }
 
     return TRUE;
@@ -273,7 +273,7 @@ int read_config_info (WavpackContext *wpc, WavpackMetadata *wpmd)
 // This monster actually unpacks the WavPack bitstream(s) into the specified
 // buffer as 32-bit integers or floats (depending on orignal data). Lossy
 // samples will be clipped to their original limits (i.e. 8-bit samples are
-// clipped to -128/+127) but are still returned in longs. It is up to the
+// clipped to -128/+127) but are still returned in int32_ts. It is up to the
 // caller to potentially reformat this for the final output including any
 // multichannel distribution, block alignment or endian compensation. The
 // function unpack_init() must have been called and the entire WavPack block
@@ -287,25 +287,25 @@ int read_config_info (WavpackContext *wpc, WavpackMetadata *wpmd)
 // occurs or the end of the block is reached.
 
 #if defined(CPU_COLDFIRE) && !defined(SIMULATOR)
-extern void decorr_stereo_pass_cont_mcf5249 (struct decorr_pass *dpp, long *buffer, long sample_count);
+extern void decorr_stereo_pass_cont_mcf5249 (struct decorr_pass *dpp, int32_t *buffer, int32_t sample_count);
 #elif defined(CPU_ARM) && !defined(SIMULATOR)
-extern void decorr_stereo_pass_cont_arm (struct decorr_pass *dpp, long *buffer, long sample_count);
-extern void decorr_stereo_pass_cont_arml (struct decorr_pass *dpp, long *buffer, long sample_count);
+extern void decorr_stereo_pass_cont_arm (struct decorr_pass *dpp, int32_t *buffer, int32_t sample_count);
+extern void decorr_stereo_pass_cont_arml (struct decorr_pass *dpp, int32_t *buffer, int32_t sample_count);
 #else
-static void decorr_stereo_pass_cont (struct decorr_pass *dpp, long *buffer, long sample_count);
+static void decorr_stereo_pass_cont (struct decorr_pass *dpp, int32_t *buffer, int32_t sample_count);
 #endif
 
-static void decorr_mono_pass (struct decorr_pass *dpp, long *buffer, long sample_count);
-static void decorr_stereo_pass (struct decorr_pass *dpp, long *buffer, long sample_count);
-static void fixup_samples (WavpackStream *wps, long *buffer, ulong sample_count);
+static void decorr_mono_pass (struct decorr_pass *dpp, int32_t *buffer, int32_t sample_count);
+static void decorr_stereo_pass (struct decorr_pass *dpp, int32_t *buffer, int32_t sample_count);
+static void fixup_samples (WavpackStream *wps, int32_t *buffer, uint32_t sample_count);
 
-long unpack_samples (WavpackContext *wpc, long *buffer, ulong sample_count)
+int32_t unpack_samples (WavpackContext *wpc, int32_t *buffer, uint32_t sample_count)
 {
     WavpackStream *wps = &wpc->stream;
-    ulong flags = wps->wphdr.flags, crc = wps->crc, i;
-    long mute_limit = (1L << ((flags & MAG_MASK) >> MAG_LSB)) + 2;
+    uint32_t flags = wps->wphdr.flags, crc = wps->crc, i;
+    int32_t mute_limit = (1L << ((flags & MAG_MASK) >> MAG_LSB)) + 2;
     struct decorr_pass *dpp;
-    long *bptr, *eptr;
+    int32_t *bptr, *eptr;
     int tcount;
 
     if (wps->sample_index + sample_count > wps->wphdr.block_index + wps->wphdr.block_samples)
@@ -403,10 +403,10 @@ long unpack_samples (WavpackContext *wpc, long *buffer, ulong sample_count)
     return i;
 }
 
-static void decorr_stereo_pass (struct decorr_pass *dpp, long *buffer, long sample_count)
+static void decorr_stereo_pass (struct decorr_pass *dpp, int32_t *buffer, int32_t sample_count)
 {
-    long delta = dpp->delta, weight_A = dpp->weight_A, weight_B = dpp->weight_B;
-    long *bptr, *eptr = buffer + (sample_count * 2), sam_A, sam_B;
+    int32_t delta = dpp->delta, weight_A = dpp->weight_A, weight_B = dpp->weight_B;
+    int32_t *bptr, *eptr = buffer + (sample_count * 2), sam_A, sam_B;
     int m, k;
 
     switch (dpp->term) {
@@ -462,7 +462,7 @@ static void decorr_stereo_pass (struct decorr_pass *dpp, long *buffer, long samp
             }
 
             if (m) {
-                long temp_samples [MAX_TERM];
+                int32_t temp_samples [MAX_TERM];
 
                 memcpy (temp_samples, dpp->samples_A, sizeof (dpp->samples_A));
 
@@ -520,10 +520,10 @@ static void decorr_stereo_pass (struct decorr_pass *dpp, long *buffer, long samp
 
 #if (!defined(CPU_COLDFIRE) && !defined(CPU_ARM)) || defined(SIMULATOR)
 
-static void decorr_stereo_pass_cont (struct decorr_pass *dpp, long *buffer, long sample_count)
+static void decorr_stereo_pass_cont (struct decorr_pass *dpp, int32_t *buffer, int32_t sample_count)
 {
-    long delta = dpp->delta, weight_A = dpp->weight_A, weight_B = dpp->weight_B;
-    long *bptr, *tptr, *eptr = buffer + (sample_count * 2), sam_A, sam_B;
+    int32_t delta = dpp->delta, weight_A = dpp->weight_A, weight_B = dpp->weight_B;
+    int32_t *bptr, *tptr, *eptr = buffer + (sample_count * 2), sam_A, sam_B;
     int k, i;
 
     switch (dpp->term) {
@@ -619,10 +619,10 @@ static void decorr_stereo_pass_cont (struct decorr_pass *dpp, long *buffer, long
 
 #endif
 
-static void decorr_mono_pass (struct decorr_pass *dpp, long *buffer, long sample_count)
+static void decorr_mono_pass (struct decorr_pass *dpp, int32_t *buffer, int32_t sample_count)
 {
-    long delta = dpp->delta, weight_A = dpp->weight_A;
-    long *bptr, *eptr = buffer + sample_count, sam_A;
+    int32_t delta = dpp->delta, weight_A = dpp->weight_A;
+    int32_t *bptr, *eptr = buffer + sample_count, sam_A;
     int m, k;
 
     switch (dpp->term) {
@@ -660,7 +660,7 @@ static void decorr_mono_pass (struct decorr_pass *dpp, long *buffer, long sample
             }
 
             if (m) {
-                long temp_samples [MAX_TERM];
+                int32_t temp_samples [MAX_TERM];
 
                 memcpy (temp_samples, dpp->samples_A, sizeof (dpp->samples_A));
 
@@ -687,12 +687,12 @@ static void decorr_mono_pass (struct decorr_pass *dpp, long *buffer, long sample
 // as 28-bits, and clipping (for lossy mode) has been eliminated because this
 // now happens in the dsp module.
 
-static void fixup_samples (WavpackStream *wps, long *buffer, ulong sample_count)
+static void fixup_samples (WavpackStream *wps, int32_t *buffer, uint32_t sample_count)
 {
-    ulong flags = wps->wphdr.flags;
+    uint32_t flags = wps->wphdr.flags;
     int shift = (flags & SHIFT_MASK) >> SHIFT_LSB;
 
-    shift += 20 - (flags & BYTES_STORED) * 8;   // this provides RockBox with 28-bit data
+    shift += 21 - (flags & BYTES_STORED) * 8;   // this provides RockBox with 28-bit (+sign)
 
     if (flags & FLOAT_DATA) {
         float_values (wps, buffer, (flags & MONO_FLAG) ? sample_count : sample_count * 2);
@@ -700,10 +700,10 @@ static void fixup_samples (WavpackStream *wps, long *buffer, ulong sample_count)
     }
 
     if (flags & INT32_DATA) {
-        ulong count = (flags & MONO_FLAG) ? sample_count : sample_count * 2;
+        uint32_t count = (flags & MONO_FLAG) ? sample_count : sample_count * 2;
         int sent_bits = wps->int32_sent_bits, zeros = wps->int32_zeros;
         int ones = wps->int32_ones, dups = wps->int32_dups;
-        long *dptr = buffer;
+        int32_t *dptr = buffer;
 
         if (!(flags & HYBRID_FLAG) && !sent_bits && (zeros + ones + dups))
             while (count--) {
diff --git a/apps/codecs/libwavpack/wavpack.h b/apps/codecs/libwavpack/wavpack.h
index e26cac353a..593af7831d 100644
--- a/apps/codecs/libwavpack/wavpack.h
+++ b/apps/codecs/libwavpack/wavpack.h
@@ -16,7 +16,6 @@
 
 typedef unsigned char   uchar;
 typedef unsigned short  ushort;
-typedef unsigned long   ulong;
 typedef unsigned int    uint;
 
 // This structure is used to access the individual fields of 32-bit ieee
@@ -43,10 +42,10 @@ typedef struct {
 
 typedef struct {
     char ckID [4];
-    ulong ckSize;
+    uint32_t ckSize;
     short version;
     uchar track_no, index_no;
-    ulong total_samples, block_index, block_samples, flags, crc;
+    uint32_t total_samples, block_index, block_samples, flags, crc;
 } WavpackHeader;
 
 #define WavpackHeaderFormat "4LS2LLLLL"
@@ -88,7 +87,7 @@ typedef struct {
 
 typedef struct {
     uchar temp_data [64];
-    long byte_length;
+    int32_t byte_length;
     void *data;
     uchar id;
 } WavpackMetadata;
@@ -128,7 +127,7 @@ typedef struct {
 typedef struct {
     int bits_per_sample, bytes_per_sample;
     int flags, num_channels, float_norm_exp;
-    ulong sample_rate, channel_mask;
+    uint32_t sample_rate, channel_mask;
 } WavpackConfig;
 
 #define CONFIG_BYTES_STORED     3       // 1-4 bytes/sample
@@ -169,12 +168,12 @@ typedef struct {
 // pointers to hold a complete allocated block of WavPack data, although it's
 // possible to decode WavPack blocks without buffering an entire block.
 
-typedef long (*read_stream)(void *, long);
+typedef int32_t (*read_stream)(void *, int32_t);
 
 typedef struct bs {
     uchar *buf, *end, *ptr;
     void (*wrap)(struct bs *bs);
-    ulong file_bytes, sr;
+    uint32_t file_bytes, sr;
     int error, bc;
     read_stream file;
 } Bitstream;
@@ -184,16 +183,16 @@ typedef struct bs {
 
 struct decorr_pass {
     short term, delta, weight_A, weight_B;
-    long samples_A [MAX_TERM], samples_B [MAX_TERM];
+    int32_t samples_A [MAX_TERM], samples_B [MAX_TERM];
 };
 
 struct entropy_data {
-    ulong median [3], slow_level, error_limit;
+    uint32_t median [3], slow_level, error_limit;
 };
 
 struct words_data {
-    ulong bitrate_delta [2], bitrate_acc [2];
-    ulong pend_data, holding_one, zeros_acc;
+    uint32_t bitrate_delta [2], bitrate_acc [2];
+    uint32_t pend_data, holding_one, zeros_acc;
     int holding_zero, pend_count;
     struct entropy_data c [2];
 };
@@ -205,7 +204,7 @@ typedef struct {
     struct words_data w;
 
     int num_terms, mute_error;
-    ulong sample_index, crc;
+    uint32_t sample_index, crc;
 
     uchar int32_sent_bits, int32_zeros, int32_ones, int32_dups;
     uchar float_flags, float_shift, float_max_exp, float_norm_exp;
@@ -241,7 +240,7 @@ typedef struct {
     char error_message [80];
 
     read_stream infile;
-    ulong total_samples, crc_errors, first_flags;
+    uint32_t total_samples, crc_errors, first_flags;
     int open_flags, norm_offset, reduced_channels, lossy_blocks;
 
 } WavpackContext;
@@ -252,9 +251,9 @@ typedef struct {
 
 // bits.c
 
-void bs_open_read (Bitstream *bs, uchar *buffer_start, uchar *buffer_end, read_stream file, ulong file_bytes);
+void bs_open_read (Bitstream *bs, uchar *buffer_start, uchar *buffer_end, read_stream file, uint32_t file_bytes);
 void bs_open_write (Bitstream *bs, uchar *buffer_start, uchar *buffer_end);
-ulong bs_close_write (Bitstream *bs);
+uint32_t bs_close_write (Bitstream *bs);
 
 #define bs_is_open(bs) ((bs)->ptr != NULL)
 
@@ -270,7 +269,7 @@ ulong bs_close_write (Bitstream *bs);
 #define getbits(value, nbits, bs) { \
     while ((nbits) > (bs)->bc) { \
         if (++((bs)->ptr) == (bs)->end) (bs)->wrap (bs); \
-        (bs)->sr |= (long)*((bs)->ptr) << (bs)->bc; \
+        (bs)->sr |= (int32_t)*((bs)->ptr) << (bs)->bc; \
         (bs)->bc += 8; \
     } \
     *(value) = (bs)->sr; \
@@ -300,7 +299,7 @@ ulong bs_close_write (Bitstream *bs);
     }}
 
 #define putbits(value, nbits, bs) { \
-    (bs)->sr |= (long)(value) << (bs)->bc; \
+    (bs)->sr |= (int32_t)(value) << (bs)->bc; \
     if (((bs)->bc += (nbits)) >= 8) \
         do { \
             *((bs)->ptr) = (bs)->sr; \
@@ -354,14 +353,14 @@ int read_float_info (WavpackStream *wps, WavpackMetadata *wpmd);
 int read_int32_info (WavpackStream *wps, WavpackMetadata *wpmd);
 int read_channel_info (WavpackContext *wpc, WavpackMetadata *wpmd);
 int read_config_info (WavpackContext *wpc, WavpackMetadata *wpmd);
-long unpack_samples (WavpackContext *wpc, long *buffer, ulong sample_count);
+int32_t unpack_samples (WavpackContext *wpc, int32_t *buffer, uint32_t sample_count);
 int check_crc_error (WavpackContext *wpc);
 
 // pack.c
 
 void pack_init (WavpackContext *wpc);
 int pack_start_block (WavpackContext *wpc);
-int pack_samples (WavpackContext *wpc, long *buffer, ulong sample_count);
+int pack_samples (WavpackContext *wpc, int32_t *buffer, uint32_t sample_count);
 int pack_finish_block (WavpackContext *wpc);
 
 // metadata.c stuff
@@ -377,15 +376,15 @@ void init_words (WavpackStream *wps);
 int read_entropy_vars (WavpackStream *wps, WavpackMetadata *wpmd);
 void write_entropy_vars (WavpackStream *wps, WavpackMetadata *wpmd);
 int read_hybrid_profile (WavpackStream *wps, WavpackMetadata *wpmd);
-long get_words (long *buffer, int nsamples, ulong flags,
+int32_t get_words (int32_t *buffer, int nsamples, uint32_t flags,
                 struct words_data *w, Bitstream *bs);
-void send_word_lossless (long value, int chan,
+void send_word_lossless (int32_t value, int chan,
                          struct words_data *w, Bitstream *bs);
-void send_words (long *buffer, int nsamples, ulong flags,
+void send_words (int32_t *buffer, int nsamples, uint32_t flags,
                  struct words_data *w, Bitstream *bs);
 void flush_word (struct words_data *w, Bitstream *bs);
-int log2s (long value);
-long exp2s (int log);
+int log2s (int32_t value);
+int32_t exp2s (int log);
 signed char store_weight (int weight);
 int restore_weight (signed char weight);
 
@@ -394,8 +393,8 @@ int restore_weight (signed char weight);
 // float.c
 
 int read_float_info (WavpackStream *wps, WavpackMetadata *wpmd);
-void float_values (WavpackStream *wps, long *values, long num_values);
-void float_normalize (long *values, long num_values, int delta_exp);
+void float_values (WavpackStream *wps, int32_t *values, int32_t num_values);
+void float_normalize (int32_t *values, int32_t num_values, int delta_exp);
 
 // wputils.c
 
@@ -411,21 +410,21 @@ int WavpackGetMode (WavpackContext *wpc);
 #define MODE_HIGH       0x20
 #define MODE_FAST       0x40
 
-ulong WavpackUnpackSamples (WavpackContext *wpc, long *buffer, ulong samples);
-ulong WavpackGetNumSamples (WavpackContext *wpc);
-ulong WavpackGetSampleIndex (WavpackContext *wpc);
+uint32_t WavpackUnpackSamples (WavpackContext *wpc, int32_t *buffer, uint32_t samples);
+uint32_t WavpackGetNumSamples (WavpackContext *wpc);
+uint32_t WavpackGetSampleIndex (WavpackContext *wpc);
 int WavpackGetNumErrors (WavpackContext *wpc);
 int WavpackLossyBlocks (WavpackContext *wpc);
-ulong WavpackGetSampleRate (WavpackContext *wpc);
+uint32_t WavpackGetSampleRate (WavpackContext *wpc);
 int WavpackGetBitsPerSample (WavpackContext *wpc);
 int WavpackGetBytesPerSample (WavpackContext *wpc);
 int WavpackGetNumChannels (WavpackContext *wpc);
 int WavpackGetReducedChannels (WavpackContext *wpc);
 WavpackContext *WavpackOpenFileOutput (void);
-int WavpackSetConfiguration (WavpackContext *wpc, WavpackConfig *config, ulong total_samples);
-void WavpackAddWrapper (WavpackContext *wpc, void *data, ulong bcount);
+int WavpackSetConfiguration (WavpackContext *wpc, WavpackConfig *config, uint32_t total_samples);
+void WavpackAddWrapper (WavpackContext *wpc, void *data, uint32_t bcount);
 int WavpackStartBlock (WavpackContext *wpc, uchar *begin, uchar *end);
-int WavpackPackSamples (WavpackContext *wpc, long *sample_buffer, ulong sample_count);
-ulong WavpackFinishBlock (WavpackContext *wpc);
+int WavpackPackSamples (WavpackContext *wpc, int32_t *sample_buffer, uint32_t sample_count);
+uint32_t WavpackFinishBlock (WavpackContext *wpc);
 
 
diff --git a/apps/codecs/libwavpack/words.c b/apps/codecs/libwavpack/words.c
index 96e3b60ebb..ccbd77f8f9 100644
--- a/apps/codecs/libwavpack/words.c
+++ b/apps/codecs/libwavpack/words.c
@@ -141,7 +141,7 @@ void init_words (WavpackStream *wps)
     CLEAR (wps->w);
 }
 
-static int mylog2 (unsigned long avalue);
+static int mylog2 (unsigned int32_t avalue);
 
 // Read the median log2 values from the specifed metadata structure, convert
 // them back to 32-bit unsigned values and store them. If length is not
@@ -221,11 +221,11 @@ int read_hybrid_profile (WavpackStream *wps, WavpackMetadata *wpmd)
         }
     }
 
-    wps->w.bitrate_acc [0] = (long)(byteptr [0] + (byteptr [1] << 8)) << 16;
+    wps->w.bitrate_acc [0] = (int32_t)(byteptr [0] + (byteptr [1] << 8)) << 16;
     byteptr += 2;
 
     if (!(wps->wphdr.flags & MONO_FLAG)) {
-        wps->w.bitrate_acc [1] = (long)(byteptr [0] + (byteptr [1] << 8)) << 16;
+        wps->w.bitrate_acc [1] = (int32_t)(byteptr [0] + (byteptr [1] << 8)) << 16;
         byteptr += 2;
     }
 
@@ -253,7 +253,7 @@ int read_hybrid_profile (WavpackStream *wps, WavpackMetadata *wpmd)
 // currently implemented) this is calculated from the slow_level values and the
 // bitrate accumulators. Note that the bitrate accumulators can be changing.
 
-void update_error_limit (struct words_data *w, ulong flags)
+void update_error_limit (struct words_data *w, uint32_t flags)
 {
     int bitrate_0 = (w->bitrate_acc [0] += w->bitrate_delta [0]) >> 16;
 
@@ -310,7 +310,7 @@ void update_error_limit (struct words_data *w, ulong flags)
     }
 }
 
-static ulong read_code (Bitstream *bs, ulong maxcode);
+static uint32_t read_code (Bitstream *bs, uint32_t maxcode);
 
 // Read the next word from the bitstream "wvbits" and return the value. This
 // function can be used for hybrid or lossless streams, but since an
@@ -320,7 +320,7 @@ static ulong read_code (Bitstream *bs, ulong maxcode);
 // of WORD_EOF indicates that the end of the bitstream was reached (all 1s) or
 // some other error occurred.
 
-long get_words (long *buffer, int nsamples, ulong flags,
+int32_t get_words (int32_t *buffer, int nsamples, uint32_t flags,
                 struct words_data *w, Bitstream *bs)
 {
     register struct entropy_data *c = w->c;
@@ -330,13 +330,13 @@ long get_words (long *buffer, int nsamples, ulong flags,
         nsamples *= 2;
 
     for (csamples = 0; csamples < nsamples; ++csamples) {
-        ulong ones_count, low, mid, high;
+        uint32_t ones_count, low, mid, high;
 
         if (!(flags & MONO_FLAG))
             c = w->c + (csamples & 1);
 
         if (!(w->c [0].median [0] & ~1) && !w->holding_zero && !w->holding_one && !(w->c [1].median [0] & ~1)) {
-            ulong mask;
+            uint32_t mask;
             int cbits;
 
             if (w->zeros_acc) {
@@ -397,7 +397,7 @@ long get_words (long *buffer, int nsamples, ulong flags,
                     break;
 
                 if (ones_count == LIMIT_ONES) {
-                    ulong mask;
+                    uint32_t mask;
                     int cbits;
 
                     for (cbits = 0; cbits < 33 && getbit (bs); ++cbits);
@@ -493,10 +493,10 @@ long get_words (long *buffer, int nsamples, ulong flags,
 // minimum number of bits and then determines whether another bit is needed
 // to define the code.
 
-static ulong read_code (Bitstream *bs, ulong maxcode)
+static uint32_t read_code (Bitstream *bs, uint32_t maxcode)
 {
     int bitcount = count_bits (maxcode);
-    ulong extras = (1L << bitcount) - maxcode - 1, code;
+    uint32_t extras = (1L << bitcount) - maxcode - 1, code;
 
     if (!bitcount)
         return 0;
@@ -514,7 +514,7 @@ static ulong read_code (Bitstream *bs, ulong maxcode)
     return code;
 }
 
-void send_words (long *buffer, int nsamples, ulong flags,
+void send_words (int32_t *buffer, int nsamples, uint32_t flags,
                  struct words_data *w, Bitstream *bs)
 {
     register struct entropy_data *c = w->c;
@@ -523,9 +523,9 @@ void send_words (long *buffer, int nsamples, ulong flags,
         nsamples *= 2;
 
     while (nsamples--) {
-        long value = *buffer++;
+        int32_t value = *buffer++;
         int sign = (value < 0) ? 1 : 0;
-        ulong ones_count, low, high;
+        uint32_t ones_count, low, high;
 
         if (!(flags & MONO_FLAG))
             c = w->c + (~nsamples & 1);
@@ -553,7 +553,7 @@ void send_words (long *buffer, int nsamples, ulong flags,
         if (sign)
             value = ~value;
 
-        if ((unsigned long) value < GET_MED (0)) {
+        if ((unsigned int32_t) value < GET_MED (0)) {
             ones_count = low = 0;
             high = GET_MED (0) - 1;
             DEC_MED0 ();
@@ -604,9 +604,9 @@ void send_words (long *buffer, int nsamples, ulong flags,
         w->holding_one = ones_count * 2;
 
         if (high != low) {  
-            ulong maxcode = high - low, code = value - low;
+            uint32_t maxcode = high - low, code = value - low;
             int bitcount = count_bits (maxcode);
-            ulong extras = (1L << bitcount) - maxcode - 1;
+            uint32_t extras = (1L << bitcount) - maxcode - 1;
 
             if (code < extras) {
                 w->pend_data |= code << w->pend_count;
@@ -619,7 +619,7 @@ void send_words (long *buffer, int nsamples, ulong flags,
             }
         }
 
-        w->pend_data |= ((long) sign << w->pend_count++);
+        w->pend_data |= ((int32_t) sign << w->pend_count++);
 
         if (!w->holding_zero)
             flush_word (w, bs);
@@ -709,7 +709,7 @@ void flush_word (struct words_data *w, Bitstream *bs)
 // This function returns the log2 for the specified 32-bit unsigned value.
 // The maximum value allowed is about 0xff800000 and returns 8447.
 
-static int mylog2 (unsigned long avalue)
+static int mylog2 (unsigned int32_t avalue)
 {
     int dbits;
 
@@ -733,7 +733,7 @@ static int mylog2 (unsigned long avalue)
 // All input values are valid and the return values are in the range of
 // +/- 8192.
 
-int log2s (long value)
+int log2s (int32_t value)
 {
     return (value < 0) ? -mylog2 (-value) : mylog2 (value);
 }
@@ -743,9 +743,9 @@ int log2s (long value)
 // but since a full 32-bit value is returned this can be used for unsigned
 // conversions as well (i.e. the input range is -8192 to +8447).
 
-long exp2s (int log)
+int32_t exp2s (int log)
 {
-    ulong value;
+    uint32_t value;
 
     if (log < 0)
         return -exp2s (-log);
diff --git a/apps/codecs/libwavpack/wputils.c b/apps/codecs/libwavpack/wputils.c
index 549cd8a4fa..7a6cc44ad4 100644
--- a/apps/codecs/libwavpack/wputils.c
+++ b/apps/codecs/libwavpack/wputils.c
@@ -23,12 +23,12 @@ static void strcpy_loc (char *dst, char *src) { while ((*dst++ = *src++) != 0);
 
 ///////////////////////////// local table storage ////////////////////////////
 
-const ulong sample_rates [] = { 6000, 8000, 9600, 11025, 12000, 16000, 22050,
+const uint32_t sample_rates [] = { 6000, 8000, 9600, 11025, 12000, 16000, 22050,
     24000, 32000, 44100, 48000, 64000, 88200, 96000, 192000 };
 
 ///////////////////////////// executable code ////////////////////////////////
 
-static ulong read_next_header (read_stream infile, WavpackHeader *wphdr);
+static uint32_t read_next_header (read_stream infile, WavpackHeader *wphdr);
         
 // This function reads data from the specified stream in search of a valid
 // WavPack 4.0 audio block. If this fails in 1 megabyte (or an invalid or
@@ -50,11 +50,11 @@ static WavpackContext wpc IBSS_ATTR;
 WavpackContext *WavpackOpenFileInput (read_stream infile, char *error)
 {
     WavpackStream *wps = &wpc.stream;
-    ulong bcount;
+    uint32_t bcount;
 
     CLEAR (wpc);
     wpc.infile = infile;
-    wpc.total_samples = (ulong) -1;
+    wpc.total_samples = (uint32_t) -1;
     wpc.norm_offset = 0;
     wpc.open_flags = 0;
 
@@ -64,7 +64,7 @@ WavpackContext *WavpackOpenFileInput (read_stream infile, char *error)
 
         bcount = read_next_header (wpc.infile, &wps->wphdr);
 
-        if (bcount == (ulong) -1) {
+        if (bcount == (uint32_t) -1) {
             strcpy_loc (error, "invalid WavPack file!");
             return NULL;
         }
@@ -74,7 +74,7 @@ WavpackContext *WavpackOpenFileInput (read_stream infile, char *error)
             return NULL;
         }
 
-        if (wps->wphdr.block_samples && wps->wphdr.total_samples != (ulong) -1)
+        if (wps->wphdr.block_samples && wps->wphdr.total_samples != (uint32_t) -1)
             wpc.total_samples = wps->wphdr.total_samples;
 
         if (!unpack_init (&wpc)) {
@@ -148,18 +148,18 @@ int WavpackGetMode (WavpackContext *wpc)
 
 // Unpack the specified number of samples from the current file position.
 // Note that "samples" here refers to "complete" samples, which would be
-// 2 longs for stereo files. The audio data is returned right-justified in
-// 32-bit longs in the endian mode native to the executing processor. So,
+// 2 int32_t's for stereo files. The audio data is returned right-justified in
+// 32-bit int32_t's in the endian mode native to the executing processor. So,
 // if the original data was 16-bit, then the values returned would be
 // +/-32k. Floating point data can also be returned if the source was
 // floating point data (and this is normalized to +/-1.0). The actual number
 // of samples unpacked is returned, which should be equal to the number
 // requested unless the end of fle is encountered or an error occurs.
 
-ulong WavpackUnpackSamples (WavpackContext *wpc, long *buffer, ulong samples)
+uint32_t WavpackUnpackSamples (WavpackContext *wpc, int32_t *buffer, uint32_t samples)
 {
     WavpackStream *wps = &wpc->stream;
-    ulong bcount, samples_unpacked = 0, samples_to_unpack;
+    uint32_t bcount, samples_unpacked = 0, samples_to_unpack;
     int num_channels = wpc->config.num_channels;
 
     while (samples) {
@@ -167,7 +167,7 @@ ulong WavpackUnpackSamples (WavpackContext *wpc, long *buffer, ulong samples)
             wps->sample_index >= wps->wphdr.block_index + wps->wphdr.block_samples) {
                 bcount = read_next_header (wpc->infile, &wps->wphdr);
 
-                if (bcount == (ulong) -1)
+                if (bcount == (uint32_t) -1)
                     break;
 
                 if (wps->wphdr.version < 0x402 || wps->wphdr.version > 0x40f) {
@@ -234,19 +234,19 @@ ulong WavpackUnpackSamples (WavpackContext *wpc, long *buffer, ulong samples)
 
 // Get total number of samples contained in the WavPack file, or -1 if unknown
 
-ulong WavpackGetNumSamples (WavpackContext *wpc)
+uint32_t WavpackGetNumSamples (WavpackContext *wpc)
 {
-    return wpc ? wpc->total_samples : (ulong) -1;
+    return wpc ? wpc->total_samples : (uint32_t) -1;
 }
 
 // Get the current sample index position, or -1 if unknown
 
-ulong WavpackGetSampleIndex (WavpackContext *wpc)
+uint32_t WavpackGetSampleIndex (WavpackContext *wpc)
 {
     if (wpc)
         return wpc->stream.sample_index;
 
-    return (ulong) -1;
+    return (uint32_t) -1;
 }
 
 // Get the number of errors encountered so far
@@ -265,7 +265,7 @@ int WavpackLossyBlocks (WavpackContext *wpc)
 
 // Returns the sample rate of the specified WavPack file
 
-ulong WavpackGetSampleRate (WavpackContext *wpc)
+uint32_t WavpackGetSampleRate (WavpackContext *wpc)
 {
     return wpc ? wpc->config.sample_rate : 44100;
 }
@@ -284,7 +284,7 @@ int WavpackGetNumChannels (WavpackContext *wpc)
 // always has 32 bits, integers may be from 1 to 32 bits each. When this
 // value is not a multiple of 8, then the "extra" bits are located in the
 // LSBs of the results. That is, values are right justified when unpacked
-// into longs, but are left justified in the number of bytes used by the
+// into int32_t's, but are left justified in the number of bytes used by the
 // original data.
 
 int WavpackGetBitsPerSample (WavpackContext *wpc)
@@ -294,8 +294,8 @@ int WavpackGetBitsPerSample (WavpackContext *wpc)
 
 // Returns the number of bytes used for each sample (1 to 4) in the original
 // file. This is required information for the user of this module because the
-// audio data is returned in the LOWER bytes of the long buffer and must be
-// left-shifted 8, 16, or 24 bits if normalized longs are required.
+// audio data is returned in the LOWER bytes of the int32_t buffer and must be
+// left-shifted 8, 16, or 24 bits if normalized int32_t's are required.
 
 int WavpackGetBytesPerSample (WavpackContext *wpc)
 {
@@ -321,10 +321,10 @@ int WavpackGetReducedChannels (WavpackContext *wpc)
 // to indicate the error. No additional bytes are read past the header and it
 // is returned in the processor's native endian mode. Seeking is not required.
 
-static ulong read_next_header (read_stream infile, WavpackHeader *wphdr)
+static uint32_t read_next_header (read_stream infile, WavpackHeader *wphdr)
 {
     char buffer [sizeof (*wphdr)], *sp = buffer + sizeof (*wphdr), *ep = sp;
-    ulong bytes_skipped = 0;
+    uint32_t bytes_skipped = 0;
     int bleft;
 
     while (1) {
@@ -335,7 +335,7 @@ static ulong read_next_header (read_stream infile, WavpackHeader *wphdr)
         else
             bleft = 0;
 
-        if (infile (buffer + bleft, sizeof (*wphdr) - bleft) != (long) sizeof (*wphdr) - bleft)
+        if (infile (buffer + bleft, sizeof (*wphdr) - bleft) != (int32_t) sizeof (*wphdr) - bleft)
             return -1;
 
         sp = buffer;
@@ -407,10 +407,10 @@ WavpackContext *WavpackOpenFileOutput (void)
 // WavPack file will not be directly unpackable to a valid wav file (although
 // it will still be usable by itself). A return of FALSE indicates an error.
 
-int WavpackSetConfiguration (WavpackContext *wpc, WavpackConfig *config, ulong total_samples)
+int WavpackSetConfiguration (WavpackContext *wpc, WavpackConfig *config, uint32_t total_samples)
 {
     WavpackStream *wps = &wpc->stream;
-    ulong flags = (config->bytes_per_sample - 1), shift = 0;
+    uint32_t flags = (config->bytes_per_sample - 1), shift = 0;
     int num_chans = config->num_channels;
     int i;
 
@@ -467,7 +467,7 @@ int WavpackSetConfiguration (WavpackContext *wpc, WavpackConfig *config, ulong t
 // first block written and update the header directly. An example of this can
 // be found in the Audition filter.
 
-void WavpackAddWrapper (WavpackContext *wpc, void *data, ulong bcount)
+void WavpackAddWrapper (WavpackContext *wpc, void *data, uint32_t bcount)
 {
     wpc->wrapper_data = data;
     wpc->wrapper_bytes = bcount;
@@ -484,7 +484,7 @@ int WavpackStartBlock (WavpackContext *wpc, uchar *begin, uchar *end)
     return pack_start_block (wpc);
 }
 
-// Pack the specified samples. Samples must be stored in longs in the native
+// Pack the specified samples. Samples must be stored in int32_ts in the native
 // endian format of the executing processor. The number of samples specified
 // indicates composite samples (sometimes called "frames"). So, the actual
 // number of data points would be this "sample_count" times the number of
@@ -493,7 +493,7 @@ int WavpackStartBlock (WavpackContext *wpc, uchar *begin, uchar *end)
 // many times as desired to build the final block (and performs the actual
 // compression during the call). A return of FALSE indicates an error.
 
-int WavpackPackSamples (WavpackContext *wpc, long *sample_buffer, ulong sample_count)
+int WavpackPackSamples (WavpackContext *wpc, int32_t *sample_buffer, uint32_t sample_count)
 {
     if (!sample_count || pack_samples (wpc, sample_buffer, sample_count))
         return TRUE;
@@ -506,10 +506,10 @@ int WavpackPackSamples (WavpackContext *wpc, long *sample_buffer, ulong sample_c
 // block in bytes. Note that the possible conversion of the WavPack header to
 // little-endian takes place here.
 
-ulong WavpackFinishBlock (WavpackContext *wpc)
+uint32_t WavpackFinishBlock (WavpackContext *wpc)
 {
     WavpackStream *wps = &wpc->stream;
-    ulong bcount;
+    uint32_t bcount;
 
     pack_finish_block (wpc);
     bcount = ((WavpackHeader *) wps->blockbuff)->ckSize + 8;
diff --git a/apps/codecs/wavpack.c b/apps/codecs/wavpack.c
index ee21347b73..febea1e705 100644
--- a/apps/codecs/wavpack.c
+++ b/apps/codecs/wavpack.c
@@ -26,11 +26,11 @@ static struct codec_api *ci;
 
 #define BUFFER_SIZE 4096
 
-static long temp_buffer [BUFFER_SIZE] IBSS_ATTR;
+static int32_t temp_buffer [BUFFER_SIZE] IBSS_ATTR;
 
-static long read_callback (void *buffer, long bytes)
+static int32_t read_callback (void *buffer, int32_t bytes)
 {
-    long retval = ci->read_filebuf (buffer, bytes);
+    int32_t retval = ci->read_filebuf (buffer, bytes);
     ci->id3->offset = ci->curpos;
     return retval;
 }
@@ -63,7 +63,7 @@ enum codec_status codec_start(struct codec_api* api)
     ci->configure(CODEC_SET_FILEBUF_CHUNKSIZE, (int *)(1024*128));
   
     ci->configure(DSP_DITHER, (bool *)false);
-    ci->configure(DSP_SET_SAMPLE_DEPTH, (int *)(27));   // should be 28...
+    ci->configure(DSP_SET_SAMPLE_DEPTH, (int *)(28));
 
     next_track:
 
@@ -97,7 +97,7 @@ enum codec_status codec_start(struct codec_api* api)
     /* The main decoder loop */
 
     while (1) {
-        long nsamples;  
+        int32_t nsamples;  
 
         if (ci->seek_time && ci->taginfo_ready && ci->id3->length) {
             ci->seek_time--;
@@ -107,13 +107,13 @@ enum codec_status codec_start(struct codec_api* api)
             if (ci->seek_time > curpos_ms) {
                 n = ci->seek_time - curpos_ms;
                 d = ci->id3->length - curpos_ms;
-                skip = (int)((long long)(ci->filesize - ci->curpos) * n / d);
+                skip = (int)((int64_t)(ci->filesize - ci->curpos) * n / d);
                 ci->seek_buffer (ci->curpos + skip);
             }
             else {
                 n = curpos_ms - ci->seek_time;
                 d = curpos_ms;
-                skip = (int)((long long) ci->curpos * n / d);
+                skip = (int)((int64_t) ci->curpos * n / d);
                 ci->seek_buffer (ci->curpos - skip);
             }
 
diff --git a/apps/plugins/wav2wv.c b/apps/plugins/wav2wv.c
index 7e85572d78..5b71e7e759 100644
--- a/apps/plugins/wav2wv.c
+++ b/apps/plugins/wav2wv.c
@@ -42,42 +42,42 @@ static int audiobuflen;
 
 static struct wav_header {
     char ckID [4];                      /* RIFF chuck header */
-    long ckSize;
+    int32_t ckSize;
     char formType [4];
 
     char fmt_ckID [4];                 /* format chunk header */
-    long fmt_ckSize;
+    int32_t fmt_ckSize;
     ushort FormatTag, NumChannels;
-    ulong SampleRate, BytesPerSecond;
+    uint32_t SampleRate, BytesPerSecond;
     ushort BlockAlign, BitsPerSample;
 
     char data_ckID [4];                 /* data chunk header */
-    long data_ckSize;
+    int32_t data_ckSize;
 } raw_header, native_header;
 
 #define WAV_HEADER_FORMAT "4L44LSSLLSS4L"
 
-static void wvupdate (long start_tick,
-                      long sample_rate,
-                      ulong total_samples,
-                      ulong samples_converted,
-                      ulong bytes_read,
-                      ulong bytes_written)
+static void wvupdate (int32_t start_tick,
+                      int32_t sample_rate,
+                      uint32_t total_samples,
+                      uint32_t samples_converted,
+                      uint32_t bytes_read,
+                      uint32_t bytes_written)
 {
-    long elapsed_ticks = *rb->current_tick - start_tick;
+    int32_t elapsed_ticks = *rb->current_tick - start_tick;
     int compression = 0, progress = 0, realtime = 0;
     char buf[32];
 
     if (total_samples)
-        progress = (int)(((long long) samples_converted * 100 +
+        progress = (int)(((int64_t) samples_converted * 100 +
             (total_samples/2)) / total_samples);
 
     if (elapsed_ticks)
-        realtime = (int)(((long long) samples_converted * 100 * HZ /
+        realtime = (int)(((int64_t) samples_converted * 100 * HZ /
             sample_rate + (elapsed_ticks/2)) / elapsed_ticks);
 
     if (bytes_read)
-        compression = (int)(((long long)(bytes_read - bytes_written) * 100 +
+        compression = (int)(((int64_t)(bytes_read - bytes_written) * 100 +
             (bytes_read/2)) / bytes_read);
 
     rb->snprintf(buf, 32, "elapsed time: %d secs", (elapsed_ticks + (HZ/2)) / HZ);
@@ -99,19 +99,19 @@ static void wvupdate (long start_tick,
 
 #define TEMP_SAMPLES 4096
 
-static long temp_buffer [TEMP_SAMPLES] IDATA_ATTR;
+static int32_t temp_buffer [TEMP_SAMPLES] IDATA_ATTR;
 
 static int wav2wv (char *filename)
 {
     int in_fd, out_fd, num_chans, error = false, last_buttons;
-    unsigned long total_bytes_read = 0, total_bytes_written = 0;
-    unsigned long total_samples, samples_remaining;
-    long *input_buffer = (long *) audiobuf;
+    unsigned int32_t total_bytes_read = 0, total_bytes_written = 0;
+    unsigned int32_t total_samples, samples_remaining;
+    int32_t *input_buffer = (int32_t *) audiobuf;
     unsigned char *output_buffer = (unsigned char *)(audiobuf + 0x100000);
     char *extension, save_a;
     WavpackConfig config;
     WavpackContext *wpc;
-    long start_tick;
+    int32_t start_tick;
 
     rb->lcd_clear_display();
     rb->lcd_puts_scroll(0, 0, (unsigned char *)filename);
@@ -188,9 +188,9 @@ static int wav2wv (char *filename)
     wvupdate (start_tick, native_header.SampleRate, total_samples, 0, 0, 0);
 
     for (samples_remaining = total_samples; samples_remaining;) {
-        unsigned long samples_count, samples_to_pack, bytes_count;
+        unsigned int32_t samples_count, samples_to_pack, bytes_count;
         int cnt, buttons;
-        long value, *lp;
+        int32_t value, *lp;
         signed char *cp;
  
         samples_count = SAMPLES_PER_BLOCK;
@@ -200,7 +200,7 @@ static int wav2wv (char *filename)
 
         bytes_count = samples_count * num_chans * 2;
 
-        if (rb->read (in_fd, input_buffer, bytes_count) != (long) bytes_count) {
+        if (rb->read (in_fd, input_buffer, bytes_count) != (int32_t) bytes_count) {
             rb->splash(HZ*2, true, "could not read file!");
             error = true;
             break;
@@ -212,7 +212,7 @@ static int wav2wv (char *filename)
         cp = (signed char *) input_buffer;
 
         while (samples_to_pack) {
-            unsigned long samples_this_pass = TEMP_SAMPLES / num_chans;
+            unsigned int32_t samples_this_pass = TEMP_SAMPLES / num_chans;
 
             if (samples_this_pass > samples_to_pack)
                 samples_this_pass = samples_to_pack;
@@ -250,7 +250,7 @@ static int wav2wv (char *filename)
 
         bytes_count = WavpackFinishBlock (wpc);
 
-        if (rb->write (out_fd, output_buffer, bytes_count) != (long) bytes_count) {
+        if (rb->write (out_fd, output_buffer, bytes_count) != (int32_t) bytes_count) {
             rb->splash(HZ*2, true, "could not write file!");
             error = true;
             break;
-- 
cgit v1.2.3