8 files changed, 160 insertions, 161 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;