int thread_read_read(struct thread_read *thread, char * buf, int size)
{
int ret = -1;
int readlen = 0;
int retrynum = 100;
while (readlen == 0 && !ISTRYBECLOSED()) {
// streambuf_dumpstates(thread->streambuf);
ret = streambuf_read(thread->streambuf, buf + readlen, size - readlen);
// LOGI("---------thread_read_read=%d,size=%d\n", ret, size);
//streambuf_dumpstates(thread->streambuf);
if (ret > 0) {
readlen += ret;
} else if (ret < 0) {
streambuf_dumpstates(thread->streambuf);
break;
} else if (ret == 0) {
if (thread->fatal_error) {
ret = thread->fatal_error;
break;
}
if (thread->error < 0 && thread->error != -11) {
ret = thread->error;
break;
}
thread_read_readwait(thread, 10 * 1000);
}
if (retrynum <= 0) {
break;
}
}
return readlen > 0 ? readlen : ret;
}
static bool_t decode_pcm_callback(void *data) {
struct decode_pcm *self = (struct decode_pcm *) data;
pcm_read_func_t read_func;
sample_t *write_pos;
u8_t *read_pos;
u32_t s, num_samples;
sample_t sample;
size_t sz;
sz = streambuf_read(self->read_buffer + self->leftover, 0, BLOCKSIZE - self->leftover, NULL);
if (!sz) {
current_decoder_state |= DECODE_STATE_UNDERRUN;
return FALSE;
}
current_decoder_state &= ~DECODE_STATE_UNDERRUN;
sz += self->leftover;
read_func = pcm_read_funcs[(2 * self->sample_size) + self->big_endian];
read_pos = self->read_buffer;
write_pos = self->write_buffer;
num_samples = sz / pcm_sample_widths[self->sample_size];
if (self->stereo) {
/* we need the same number of sample for both channels */
num_samples &= ~0x01;
}
for (s = 0; s < num_samples; s++) {
sample = read_func(read_pos);
*write_pos++ = sample;
if (!self->stereo) {
*write_pos++ = sample;
}
read_pos += pcm_sample_widths[self->sample_size];
}
if (num_samples) {
decode_output_samples(self->write_buffer, self->stereo ? num_samples / 2 : num_samples, self->sample_rate);
}
self->leftover = sz - (read_pos - self->read_buffer);
if (self->leftover) {
memcpy(self->read_buffer, read_pos, self->leftover);
}
return TRUE;
}
/* Read a crypted packet from the stream.
* The buffer is dynamically allocated, so
* calling function has to free it.
*/
static int32 read_packet(u_char **buffer, struct stream_buf *dbuf)
{
int32 length, mod;
/* Read packet length and calculate modulus */
if (streambuf_read(dbuf, (u_char *)&length, 4, STREAM_ATOMIC) == -EINVALID)
return -EINVALID;
length = ntohl(length);
mod = 8 - (length % 8);
/* Allocate the buffer and read the whole packet
* SAFE_CALLOC is not good to handle errors.
*/
*buffer = (u_char *)malloc(length + mod + 4);
if (*buffer == NULL)
return -EINVALID;
if (streambuf_get(dbuf, *buffer, length + mod + 4, STREAM_ATOMIC) == -EINVALID) {
SAFE_FREE(*buffer);
return -EINVALID;
}
return ESUCCESS;
}
