/* Reference samples have to be sign extended */ \
state->last_out = (state->last_out ^ m) - m; \
} \
- put_##KIND(strm, state->last_out); \
+ put_##KIND(strm, (uint32_t)state->last_out); \
state->flush_start++; \
} \
\
data = xmax - d; \
} \
} \
- put_##KIND(strm, data); \
+ put_##KIND(strm, (uint32_t)data); \
} \
state->last_out = data; \
} else { \
static inline void put_msb_32(struct aec_stream *strm, uint32_t data)
{
- *strm->next_out++ = data >> 24;
- *strm->next_out++ = data >> 16;
- *strm->next_out++ = data >> 8;
- *strm->next_out++ = data;
+ *strm->next_out++ = (unsigned char)(data >> 24);
+ *strm->next_out++ = (unsigned char)(data >> 16);
+ *strm->next_out++ = (unsigned char)(data >> 8);
+ *strm->next_out++ = (unsigned char)data;
}
static inline void put_msb_24(struct aec_stream *strm, uint32_t data)
{
- *strm->next_out++ = data >> 16;
- *strm->next_out++ = data >> 8;
- *strm->next_out++ = data;
+ *strm->next_out++ = (unsigned char)(data >> 16);
+ *strm->next_out++ = (unsigned char)(data >> 8);
+ *strm->next_out++ = (unsigned char)data;
}
static inline void put_msb_16(struct aec_stream *strm, uint32_t data)
{
- *strm->next_out++ = data >> 8;
- *strm->next_out++ = data;
+ *strm->next_out++ = (unsigned char)(data >> 8);
+ *strm->next_out++ = (unsigned char)data;
}
static inline void put_lsb_32(struct aec_stream *strm, uint32_t data)
{
- *strm->next_out++ = data;
- *strm->next_out++ = data >> 8;
- *strm->next_out++ = data >> 16;
- *strm->next_out++ = data >> 24;
+ *strm->next_out++ = (unsigned char)data;
+ *strm->next_out++ = (unsigned char)(data >> 8);
+ *strm->next_out++ = (unsigned char)(data >> 16);
+ *strm->next_out++ = (unsigned char)(data >> 24);
}
static inline void put_lsb_24(struct aec_stream *strm, uint32_t data)
{
- *strm->next_out++ = data;
- *strm->next_out++ = data >> 8;
- *strm->next_out++ = data >> 16;
+ *strm->next_out++ = (unsigned char)data;
+ *strm->next_out++ = (unsigned char)(data >> 8);
+ *strm->next_out++ = (unsigned char)(data >> 16);
}
static inline void put_lsb_16(struct aec_stream *strm, uint32_t data)
{
- *strm->next_out++ = data;
- *strm->next_out++ = data >> 8;
+ *strm->next_out++ = (unsigned char)data;
+ *strm->next_out++ = (unsigned char)(data >> 8);
}
static inline void put_8(struct aec_stream *strm, uint32_t data)
{
- *strm->next_out++ = data;
+ *strm->next_out++ = (unsigned char)data;
}
FLUSH(msb_32)
*/
struct internal_state *state = strm->state;
- if (state->rsip - state->rsi_buffer == state->rsi_size) {
+ if (state->rsi_size == (size_t)(state->rsip - state->rsi_buffer)) {
state->flush_output(strm);
state->flush_start = state->rsi_buffer;
state->rsip = state->rsi_buffer;
}
-static inline uint32_t direct_get(struct aec_stream *strm, unsigned int n)
+static inline uint32_t direct_get(struct aec_stream *strm, int n)
{
/**
Get n bit from input stream
*/
uint32_t fs = 0;
-#if HAVE_DECL___BUILTIN_CLZLL||HAVE_BSR64
- uint32_t lz;
+#if HAVE_DECL___BUILTIN_CLZLL
+ int lz;
+#elif HAVE_BSR64
+ unsigned long lz;
#endif
struct internal_state *state = strm->state;
static int m_split(struct aec_stream *strm)
{
- int i, k;
+ uint32_t i, k;
struct internal_state *state = strm->state;
if (BUFFERSPACE(strm)) {
static int m_zero_block(struct aec_stream *strm)
{
- int i, zero_blocks, b, zero_bytes;
+ uint32_t i, zero_blocks, b, zero_bytes;
struct internal_state *state = strm->state;
if (fs_ask(strm) == 0)
fs_drop(strm);
if (zero_blocks == ROS) {
- b = (state->rsip - state->rsi_buffer) / strm->block_size;
+ b = (int)(state->rsip - state->rsi_buffer) / strm->block_size;
zero_blocks = MIN(strm->rsi - b, 64 - (b % 64));
} else if (zero_blocks > ROS) {
zero_blocks--;
static int m_se(struct aec_stream *strm)
{
- int i;
+ uint32_t i;
int32_t m, d1;
struct internal_state *state = strm->state;
static int m_uncomp(struct aec_stream *strm)
{
- int i;
+ uint32_t i;
struct internal_state *state = strm->state;
if (BUFFERSPACE(strm)) {
}
if (strm->flags & AEC_DATA_SIGNED) {
- state->xmin = -(1ULL << (strm->bits_per_sample - 1));
+ state->xmin = -(1LL << (strm->bits_per_sample - 1));
state->xmax = (1ULL << (strm->bits_per_sample - 1)) - 1;
} else {
state->xmin = 0;
struct internal_state {
int (*mode)(struct aec_stream *);
- int id; /* option ID */
- int id_len; /* bit length of code option identification key */
- int (**id_table)(struct aec_stream *); /* table maps IDs to states */
+
+ /* option ID */
+ int id;
+
+ /* bit length of code option identification key */
+ int id_len;
+
+ /* table maps IDs to states */
+ int (**id_table)(struct aec_stream *);
+
void (*flush_output)(struct aec_stream *);
- int64_t last_out; /* previous output for post-processing */
- int64_t xmin; /* minimum integer for post-processing */
- int64_t xmax; /* maximum integer for post-processing */
- int in_blklen; /* length of uncompressed input block
- should be the longest possible block */
- int out_blklen; /* length of output block in bytes */
- int n, i; /* counter for samples */
- uint64_t acc; /* accumulator for currently used bit sequence */
- int bitp; /* bit pointer to the next unused bit in
- accumulator */
- int fs; /* last fundamental sequence in accumulator */
- int ref; /* 1 if current block has reference sample */
- int pp; /* 1 if postprocessor has to be used */
- int bytes_per_sample; /* storage size of samples in bytes */
- uint32_t *rsi_buffer; /* output buffer holding one reference
- sample interval */
- uint32_t *rsip; /* current position of output in rsi_buffer */
- size_t rsi_size; /* rsi in bytes */
- uint32_t *flush_start; /* first not yet flushed byte in rsi_buffer */
- int se_table[182]; /* table for decoding second extension option */
+
+ /* previous output for post-processing */
+ int64_t last_out;
+
+ /* minimum integer for post-processing */
+ int64_t xmin;
+
+ /* maximum integer for post-processing */
+ int64_t xmax;
+
+ /* length of uncompressed input block should be the longest
+ possible block */
+ uint32_t in_blklen;
+
+ /* length of output block in bytes */
+ uint32_t out_blklen;
+
+ /* counter for samples */
+ uint32_t n, i;
+
+ /* accumulator for currently used bit sequence */
+ uint64_t acc;
+
+ /* bit pointer to the next unused bit in accumulator */
+ int bitp;
+
+ /* last fundamental sequence in accumulator */
+ int fs;
+
+ /* 1 if current block has reference sample */
+ int ref;
+
+ /* 1 if postprocessor has to be used */
+ int pp;
+
+ /* storage size of samples in bytes */
+ uint32_t bytes_per_sample;
+
+ /* output buffer holding one reference sample interval */
+ uint32_t *rsi_buffer;
+
+ /* current position of output in rsi_buffer */
+ uint32_t *rsip;
+
+ /* rsi in bytes */
+ size_t rsi_size;
+
+ /* first not yet flushed byte in rsi_buffer */
+ uint32_t *flush_start;
+
+ /* table for decoding second extension option */
+ int se_table[182];
} decode_state;
#endif /* DECODE_H */
if (bits <= state->bits) {
state->bits -= bits;
- *state->cds += data << state->bits;
+ *state->cds += (uint8_t)(data << state->bits);
} else {
bits -= state->bits;
- *state->cds++ += (uint64_t)data >> bits;
+ *state->cds++ += (uint8_t)((uint64_t)data >> bits);
while (bits > 8) {
bits -= 8;
- *state->cds++ = data >> bits;
+ *state->cds++ = (uint8_t)(data >> bits);
}
state->bits = 8 - bits;
- *state->cds = data << state->bits;
+ *state->cds = (uint8_t)(data << state->bits);
}
}
static inline void copy64(uint8_t *dst, uint64_t src)
{
- dst[0] = src >> 56;
- dst[1] = src >> 48;
- dst[2] = src >> 40;
- dst[3] = src >> 32;
- dst[4] = src >> 24;
- dst[5] = src >> 16;
- dst[6] = src >> 8;
- dst[7] = src;
+ dst[0] = (uint8_t)(src >> 56);
+ dst[1] = (uint8_t)(src >> 48);
+ dst[2] = (uint8_t)(src >> 40);
+ dst[3] = (uint8_t)(src >> 32);
+ dst[4] = (uint8_t)(src >> 24);
+ dst[5] = (uint8_t)(src >> 16);
+ dst[6] = (uint8_t)(src >> 8);
+ dst[7] = (uint8_t)src;
}
static inline void emitblock_fs(struct aec_stream *strm, int k, int ref)
{
- int i;
- int used; /* used bits in 64 bit accumulator */
+ uint32_t i;
+ uint32_t used; /* used bits in 64 bit accumulator */
uint64_t acc; /* accumulator */
struct internal_state *state = strm->state;
switch (p & ~7) {
case 0:
- o[0] = a >> 56;
- o[1] = a >> 48;
- o[2] = a >> 40;
- o[3] = a >> 32;
- o[4] = a >> 24;
- o[5] = a >> 16;
- o[6] = a >> 8;
+ o[0] = (uint8_t)(a >> 56);
+ o[1] = (uint8_t)(a >> 48);
+ o[2] = (uint8_t)(a >> 40);
+ o[3] = (uint8_t)(a >> 32);
+ o[4] = (uint8_t)(a >> 24);
+ o[5] = (uint8_t)(a >> 16);
+ o[6] = (uint8_t)(a >> 8);
o += 7;
break;
case 8:
- o[0] = a >> 56;
- o[1] = a >> 48;
- o[2] = a >> 40;
- o[3] = a >> 32;
- o[4] = a >> 24;
- o[5] = a >> 16;
+ o[0] = (uint8_t)(a >> 56);
+ o[1] = (uint8_t)(a >> 48);
+ o[2] = (uint8_t)(a >> 40);
+ o[3] = (uint8_t)(a >> 32);
+ o[4] = (uint8_t)(a >> 24);
+ o[5] = (uint8_t)(a >> 16);
a >>= 8;
o += 6;
break;
case 16:
- o[0] = a >> 56;
- o[1] = a >> 48;
- o[2] = a >> 40;
- o[3] = a >> 32;
- o[4] = a >> 24;
+ o[0] = (uint8_t)(a >> 56);
+ o[1] = (uint8_t)(a >> 48);
+ o[2] = (uint8_t)(a >> 40);
+ o[3] = (uint8_t)(a >> 32);
+ o[4] = (uint8_t)(a >> 24);
a >>= 16;
o += 5;
break;
case 24:
- o[0] = a >> 56;
- o[1] = a >> 48;
- o[2] = a >> 40;
- o[3] = a >> 32;
+ o[0] = (uint8_t)(a >> 56);
+ o[1] = (uint8_t)(a >> 48);
+ o[2] = (uint8_t)(a >> 40);
+ o[3] = (uint8_t)(a >> 32);
a >>= 24;
o += 4;
break;
case 32:
- o[0] = a >> 56;
- o[1] = a >> 48;
- o[2] = a >> 40;
+ o[0] = (uint8_t)(a >> 56);
+ o[1] = (uint8_t)(a >> 48);
+ o[2] = (uint8_t)(a >> 40);
a >>= 32;
o += 3;
break;
case 40:
- o[0] = a >> 56;
- o[1] = a >> 48;
+ o[0] = (uint8_t)(a >> 56);
+ o[1] = (uint8_t)(a >> 48);
a >>= 40;
o += 2;
break;
case 48:
- *o++ = a >> 56;
+ *o++ = (uint8_t)(a >> 56);
a >>= 48;
break;
default:
}
}
- *o = a;
+ *o = (uint8_t)a;
state->cds = o;
state->bits = p % 8;
}
struct internal_state *state = strm->state;
const uint32_t *restrict x = state->data_raw;
uint32_t *restrict d = state->data_pp;
- uint32_t xmax = state->xmax;
+ uint32_t xmax = (uint32_t)state->xmax;
uint32_t rsi = strm->rsi * strm->block_size - 1;
- int i;
+ unsigned int i;
d[0] = x[0];
for (i = 0; i < rsi; i++) {
struct internal_state *state = strm->state;
uint32_t *restrict d = state->data_pp;
int32_t *restrict x = (int32_t *)state->data_raw;
- uint64_t m = 1ULL << (strm->bits_per_sample - 1);
+ uint32_t m = 1ULL << (strm->bits_per_sample - 1);
int64_t xmax = state->xmax;
int64_t xmin = state->xmin;
uint32_t rsi = strm->rsi * strm->block_size - 1;
- int i;
+ unsigned int i;
d[0] = (uint32_t)x[0];
x[0] = (x[0] ^ m) - m;
if (x[i + 1] < x[i]) {
D = (int64_t)x[i] - x[i + 1];
if (D <= xmax - x[i])
- d[i + 1] = 2 * D - 1;
+ d[i + 1] = 2 * (uint32_t)D - 1;
else
- d[i + 1] = xmax - x[i + 1];
+ d[i + 1] = (uint32_t)xmax - x[i + 1];
} else {
D = (int64_t)x[i + 1] - x[i];
if (D <= x[i] - xmin)
- d[i + 1] = 2 * D;
+ d[i + 1] = 2 * (uint32_t)D;
else
- d[i + 1] = x[i + 1] - xmin;
+ d[i + 1] = x[i + 1] - (uint32_t)xmin;
}
}
state->ref = 1;
Sum FS of all samples in block for given splitting position.
*/
- int i;
+ uint32_t i;
uint64_t fs = 0;
struct internal_state *state = strm->state;
}
state->k = k_min;
- return len_min;
+ return (uint32_t)len_min;
}
static uint32_t assess_se_option(struct aec_stream *strm)
If length is above limit just return UINT32_MAX.
*/
- int i;
- uint64_t d;
+ uint32_t i;
uint32_t len;
+ uint64_t d;
struct internal_state *state = strm->state;
len = 1;
len = UINT32_MAX;
break;
} else {
- len += d * (d + 1) / 2 + state->block[i + 1] + 1;
+ len += (uint32_t)d * ((uint32_t)d + 1)
+ / 2 + state->block[i + 1] + 1;
}
}
return len;
*/
struct internal_state *state = strm->state;
- int n = MIN(state->cds - state->cds_buf - state->i, strm->avail_out);
+ int n = (int)MIN((size_t)(state->cds - state->cds_buf - state->i),
+ strm->avail_out);
memcpy(strm->next_out, state->cds_buf + state->i, n);
strm->next_out += n;
strm->avail_out -= n;
#endif
if (state->direct_out) {
- n = state->cds - strm->next_out;
+ n = (int)(state->cds - strm->next_out);
strm->next_out += n;
strm->avail_out -= n;
state->mode = m_get_block;
static int m_encode_se(struct aec_stream *strm)
{
- int i;
+ uint32_t i;
uint32_t d;
struct internal_state *state = strm->state;
end of a segment or RSI.
*/
- int i;
+ uint32_t i;
struct internal_state *state = strm->state;
uint32_t *p = state->block;
state->rsi_len = strm->rsi * strm->block_size * state->bytes_per_sample;
if (strm->flags & AEC_DATA_SIGNED) {
- state->xmin = -(1ULL << (strm->bits_per_sample - 1));
+ state->xmin = -(1LL << (strm->bits_per_sample - 1));
state->xmax = (1ULL << (strm->bits_per_sample - 1)) - 1;
state->preprocess = preprocess_signed;
} else {
while (state->mode(strm) == M_CONTINUE);
if (state->direct_out) {
- n = state->cds - strm->next_out;
+ n = (int)(state->cds - strm->next_out);
strm->next_out += n;
strm->avail_out -= n;
void (*get_rsi)(struct aec_stream *);
void (*preprocess)(struct aec_stream *);
- int id_len; /* bit length of code option identification key */
- int64_t xmin; /* minimum integer for preprocessing */
- int64_t xmax; /* maximum integer for preprocessing */
- int i; /* counter */
- uint32_t *data_pp; /* RSI blocks of preprocessed input */
- uint32_t *data_raw; /* RSI blocks of input */
- int blocks_avail; /* remaining blocks in buffer */
- uint32_t *block; /* current (preprocessed) input block */
- int rsi_len; /* reference sample interval in byte */
- uint8_t *cds; /* current Coded Data Set output */
- uint8_t cds_buf[CDSLEN];/* buffer for one CDS (only used if
- * strm->next_out cannot hold full CDS) */
- int direct_out; /* cds points to strm->next_out (1)
- * or cds_buf (0) */
- int bits; /* Free bits (LSB) in output buffer or
- * accumulator */
- int ref; /* length of reference sample in current
- * block i.e. 0 or 1 depending on whether
- * the block has a reference sample or
- * not */
- int zero_ref; /* current zero block has a reference sample */
- uint32_t zero_ref_sample;/* reference sample of zero block */
- int bytes_per_sample; /* storage size of samples in bytes */
- int zero_blocks; /* number of contiguous zero blocks */
- int block_nonzero; /* 1 if this is the first non-zero block
- * after one or more zero blocks */
- int k; /* splitting position */
- int kmax; /* maximum number for k depending on id_len */
- int flush; /* flush option copied from argument */
- int flushed; /* 1 if flushing was successful */
- uint32_t uncomp_len; /* length of uncompressed CDS */
+ /* bit length of code option identification key */
+ int id_len;
+
+ /* minimum integer for preprocessing */
+ int64_t xmin;
+
+ /* maximum integer for preprocessing */
+ int64_t xmax;
+
+ uint32_t i;
+
+ /* RSI blocks of preprocessed input */
+ uint32_t *data_pp;
+
+ /* RSI blocks of input */
+ uint32_t *data_raw;
+
+ /* remaining blocks in buffer */
+ int blocks_avail;
+
+ /* current (preprocessed) input block */
+ uint32_t *block;
+
+ /* reference sample interval in byte */
+ uint32_t rsi_len;
+
+ /* current Coded Data Set output */
+ uint8_t *cds;
+
+ /* buffer for one CDS (only used if strm->next_out cannot hold
+ * full CDS) */
+ uint8_t cds_buf[CDSLEN];
+
+ /* cds points to strm->next_out (1) or cds_buf (0) */
+ int direct_out;
+
+ /* Free bits (LSB) in output buffer or accumulator */
+ int bits;
+
+ /* length of reference sample in current block i.e. 0 or 1
+ * depending on whether the block has a reference sample or not */
+ int ref;
+
+ /* current zero block has a reference sample */
+ int zero_ref;
+
+ /* reference sample of zero block */
+ uint32_t zero_ref_sample;
+
+ /* storage size of samples in bytes */
+ uint32_t bytes_per_sample;
+
+ /* number of contiguous zero blocks */
+ int zero_blocks;
+
+ /* 1 if this is the first non-zero block after one or more zero
+ * blocks */
+ int block_nonzero;
+
+ /* splitting position */
+ int k;
+
+ /* maximum number for k depending on id_len */
+ int kmax;
+
+ /* flush option copied from argument */
+ int flush;
+
+ /* 1 if flushing was successful */
+ int flushed;
+
+ /* length of uncompressed CDS */
+ uint32_t uncomp_len;
};
#endif /* ENCODE_H */
struct aec_stream {
const unsigned char *next_in;
- size_t avail_in; /* number of bytes available at
- * next_in
- */
- size_t total_in; /* total number of input bytes read so
- * far
- */
+
+ /* number of bytes available at next_in */
+ size_t avail_in;
+
+ /* total number of input bytes read so far */
+ size_t total_in;
+
unsigned char *next_out;
- size_t avail_out; /* remaining free space at next_out */
- size_t total_out; /* total number of bytes output so far */
- int bits_per_sample; /* resolution in bits per sample (n =
- * 1, ..., 32)
- */
- int block_size; /* block size in samples */
- int rsi; /* Reference sample interval, the
- * number of Coded Data Sets between
- * consecutive reference samples (up
- * to 4096).
- */
- int flags;
+
+ /* remaining free space at next_out */
+ size_t avail_out;
+
+ /* total number of bytes output so far */
+ size_t total_out;
+
+ /* resolution in bits per sample (n = 1, ..., 32) */
+ unsigned int bits_per_sample;
+
+ /* block size in samples */
+ unsigned int block_size;
+
+ /* Reference sample interval, the number of Coded Data Sets
+ * between consecutive reference samples (up to 4096). */
+ unsigned int rsi;
+
+ unsigned int flags;
struct internal_state *state;
};
+/*********************************/
/* Sample data description flags */
-#define AEC_DATA_SIGNED 1 /* Samples are signed. Telling libaec
- * this results in a slightly better
- * compression ratio. Default is
- * unsigned.
- */
-#define AEC_DATA_3BYTE 2 /* 24 bit samples are coded in 3 bytes */
-#define AEC_DATA_MSB 4 /* Samples are stored with their most
- * significant bit first. This has
- * nothing to do with the endianness
- * of the host. Default is LSB.
- */
-#define AEC_DATA_PREPROCESS 8 /* Set if preprocessor should be used */
-
-#define AEC_RESTRICTED 16 /* Use restricted set of code options */
-#define AEC_PAD_RSI 32 /* Pad RSI to byte boundary. Only for
- * decoding CCSDS sample data. */
+/*********************************/
+/* Samples are signed. Telling libaec this results in a slightly
+ * better compression ratio. Default is unsigned. */
+#define AEC_DATA_SIGNED 1
+
+/* 24 bit samples are coded in 3 bytes */
+#define AEC_DATA_3BYTE 2
+
+/* Samples are stored with their most significant bit first. This has
+ * nothing to do with the endianness of the host. Default is LSB. */
+#define AEC_DATA_MSB 4
+
+/* Set if preprocessor should be used */
+#define AEC_DATA_PREPROCESS 8
+
+/* Use restricted set of code options */
+#define AEC_RESTRICTED 16
+
+/* Pad RSI to byte boundary. Only for decoding CCSDS sample data. */
+#define AEC_PAD_RSI 32
+
+/*************************************/
/* Return codes of library functions */
-#define AEC_OK 0
-#define AEC_CONF_ERROR (-1)
+/*************************************/
+#define AEC_OK 0
+#define AEC_CONF_ERROR (-1)
#define AEC_STREAM_ERROR (-2)
-#define AEC_DATA_ERROR (-3)
-#define AEC_MEM_ERROR (-4)
+#define AEC_DATA_ERROR (-3)
+#define AEC_MEM_ERROR (-4)
+/************************/
/* Options for flushing */
-#define AEC_NO_FLUSH 0 /* Do not enforce output
- * flushing. More input may be
- * provided with later calls. So far
- * only relevant for encoding.
- */
-#define AEC_FLUSH 1 /* Flush output and end encoding. The
- * last call to aec_encode() must set
- * AEC_FLUSH to drain all output.
- *
- * It is not possible to continue
- * encoding of the same stream after it
- * has been flushed because the last byte
- * may be padded with fill bits.
- */
+/************************/
+
+/* Do not enforce output flushing. More input may be provided with
+ * later calls. So far only relevant for encoding. */
+#define AEC_NO_FLUSH 0
+
+/* Flush output and end encoding. The last call to aec_encode() must
+ * set AEC_FLUSH to drain all output.
+ *
+ * It is not possible to continue encoding of the same stream after it
+ * has been flushed because the last byte may be padded with fill
+ * bits. */
+#define AEC_FLUSH 1
+/*********************************************/
/* Streaming encoding and decoding functions */
+/*********************************************/
AEC_SCOPE int aec_encode_init(struct aec_stream *strm);
AEC_SCOPE int aec_encode(struct aec_stream *strm, int flush);
AEC_SCOPE int aec_encode_end(struct aec_stream *strm);
AEC_SCOPE int aec_decode(struct aec_stream *strm, int flush);
AEC_SCOPE int aec_decode_end(struct aec_stream *strm);
+/***************************************************************/
/* Utility functions for encoding or decoding a memory buffer. */
+/***************************************************************/
AEC_SCOPE int aec_buffer_encode(struct aec_stream *strm);
AEC_SCOPE int aec_buffer_decode(struct aec_stream *strm);
static void interleave_buffer(void *dest, const void *src,
size_t n, int wordsize)
{
- size_t i, j;
+ size_t i;
+ int j;
const unsigned char *src8;
unsigned char *dest8;
static void deinterleave_buffer(void *dest, const void *src,
size_t n, int wordsize)
{
- size_t i, j;
+ size_t i;
+ int j;
const unsigned char *src8;
unsigned char *dest8;
#include <string.h>
#include "check_aec.h"
-static void out_lsb(unsigned char *dest, unsigned int val, int size)
+static void out_lsb(unsigned char *dest, unsigned long long int val, int size)
{
int i;
for (i = 0; i < size; i++)
- dest[i] = val >> (8 * i);
+ dest[i] = (unsigned char)(val >> (8 * i));
}
-static void out_msb(unsigned char *dest, unsigned int val, int size)
+static void out_msb(unsigned char *dest, unsigned long long int val, int size)
{
int i;
for (i = 0; i < size; i++)
- dest[i] = val >> (8 * (size - 1 - i));
+ dest[i] = (unsigned char)(val >> (8 * (size - 1 - i)));
}
int update_state(struct test_state *state)
state->out = out_lsb;
if (strm->flags & AEC_DATA_SIGNED) {
- state->xmin = -(1ULL << (strm->bits_per_sample - 1));
+ state->xmin = -(1LL << (strm->bits_per_sample - 1));
state->xmax = (1ULL << (strm->bits_per_sample - 1)) - 1;
} else {
state->xmin = 0;
int encode_decode_small(struct test_state *state)
{
- int status, i, compressed_size;
- int n_in, avail_in, avail_out, total_out;
+ int status, i;
+ size_t compressed_size;
+ size_t n_in, avail_in, avail_out, total_out;
struct aec_stream *strm = state->strm;
status = aec_encode_init(strm);
int encode_decode_large(struct test_state *state)
{
- int status, i, to;
+ int status, i;
+ size_t to;
struct aec_stream *strm = state->strm;
strm->avail_in = state->ibuf_len;
size_t cbuf_len;
long long int xmax;
long long int xmin;
- void (*out)(unsigned char *dest, unsigned int val, int size);
+ void (*out)(unsigned char *dest, unsigned long long int val, int size);
struct aec_stream *strm;
};
for (bs = 8; bs <= 64; bs *= 2) {
state->strm->block_size = bs;
- state->strm->rsi = state->buf_len / (bs * state->bytes_per_sample);
+ state->strm->rsi = (int)(state->buf_len
+ / (bs * state->bytes_per_sample));
status = encode_decode_large(state);
if (status)
tmp = state->ibuf_len;
for (bs = 8; bs <= 64; bs *= 2) {
state->strm->block_size = bs;
- state->strm->rsi = state->buf_len / (bs * state->bytes_per_sample);
+ state->strm->rsi = (int)(state->buf_len
+ / (bs * state->bytes_per_sample));
state->ibuf_len = state->buf_len - 2 * bs + 4;
status = encode_decode_large(state);
if (status)
for (bs = 8; bs <= 64; bs *= 2) {
state->strm->block_size = bs;
- max_rsi = state->buf_len / (bs * state->bytes_per_sample);
+ max_rsi = (int)(state->buf_len / (bs * state->bytes_per_sample));
if (max_rsi > 4096)
max_rsi = 4096;
projects / platform / upstream / libaec.git / commitdiff