void buf_dbg(struct buffer *buf)
{
printf("used: %d free: %d get@%d put@%d\n",
buf_used(buf), buf_space(buf),
buf->get - buf->bs, buf->put - buf->bs);
return;
}
int buf_put(struct buffer *buf, void *data, int size)
{
int count;
if(!buf || size<1 || !data)
return -EINVAL;
if(size > buf_space(buf))
size = buf_space(buf);
count = buf->bs + buf->size - buf->put;
if(size > count) {
memcpy(buf->put, data, count);
memcpy(buf->bs, data+count, size-count);
buf->put = buf->bs + size-count;
} else {
memcpy(buf->put, data, size);
buf->put += size;
}
return size;
}
/*****************************************************************************
* Play: play a sound
*****************************************************************************/
static int Play(dtaudio_output_t *aout, uint8_t *buf, int size) {
aout_sys_t *sys = (aout_sys_t *) aout->ao_priv;
int ret = 0;
//__android_log_print(ANDROID_LOG_DEBUG,TAG, "space:%d level:%d size:%d \n",buf_space(&sys->dbt), buf_level(&sys->dbt), size);
if (buf_space(&sys->dbt) > size) {
ret = buf_put(&sys->dbt, buf, size);
}
sys->samples += ret / bytesPerSample(aout);
//__android_log_print(ANDROID_LOG_DEBUG,TAG, "add sampels, %d add %d \n",sys->samples, ret / bytesPerSample(aout));
/* Fill OpenSL buffer */
WriteBuffer(aout); // will read data in callback
return ret;
}
static void *audio_decode_loop (void *arg)
{
int ret;
dtaudio_decoder_t *decoder = (dtaudio_decoder_t *) arg;
dtaudio_para_t *para = &decoder->aparam;
dt_av_frame_t frame;
ad_wrapper_t *wrapper = decoder->wrapper;
dtaudio_context_t *actx = (dtaudio_context_t *) decoder->parent;
dt_buffer_t *out = &actx->audio_decoded_buf;
int declen, fill_size;
//for some type audio, can not read completly frame
uint8_t *frame_data = NULL; // point to frame start
uint8_t *rest_data = NULL;
int frame_size = 0;
int rest_size = 0;
int used; // used size after every decode ops
adec_ctrl_t *pinfo = &decoder->info;
memset(pinfo,0,sizeof(*pinfo));
pinfo->channels = para->channels;
pinfo->samplerate = para->samplerate;
pinfo->outptr = malloc(MAX_ONE_FRAME_OUT_SIZE);
pinfo->outsize = MAX_ONE_FRAME_OUT_SIZE;
dt_info (TAG, "[%s:%d] AUDIO DECODE START \n", __FUNCTION__, __LINE__);
do
{
//maybe receive exit cmd in idle status, so exit prior to idle
if (decoder->status == ADEC_STATUS_EXIT)
{
dt_debug (TAG, "[%s:%d] receive decode loop exit cmd \n", __FUNCTION__, __LINE__);
if (frame_data)
free (frame_data);
if (rest_data)
free (rest_data);
break;
}
if (decoder->status == ADEC_STATUS_IDLE)
{
dt_info (TAG, "[%s:%d] Idle status ,please wait \n", __FUNCTION__, __LINE__);
usleep (100);
continue;
}
/*read frame */
if (!decoder->parent)
{
usleep (10000);
dt_info (TAG, "[%s:%d] decoder parent is NULL \n", __FUNCTION__, __LINE__);
continue;
}
ret = audio_read_frame (decoder->parent, &frame);
if (ret < 0 || frame.size <= 0)
{
usleep (1000);
dt_debug (TAG, "[%s:%d] dtaudio decoder loop read frame failed \n", __FUNCTION__, __LINE__);
continue;
}
//read ok,update current pts, clear the buffer size
if (frame.pts >= 0)
{
if (decoder->pts_first == -1)
{
if(frame.pts == DT_NOPTS_VALUE)
frame.pts = 0;
decoder->pts_first = pts_exchange (decoder, frame.pts);
dt_info (TAG, "first frame pts:%lld dts:%lld duration:%d size:%d\n", decoder->pts_first, frame.dts, frame.duration, frame.size);
}
decoder->pts_current = pts_exchange (decoder, frame.pts);
dt_debug (TAG, "pkt pts:%lld current:%lld duration:%d pts_s:%lld dts:%lld buf_size:%d \n", frame.pts, decoder->pts_current, frame.duration, frame.pts / 90000, frame.dts, decoder->pts_buffer_size);
decoder->pts_last_valid = decoder->pts_current;
decoder->pts_buffer_size = 0;
}
//repack the frame
if (frame_data)
{
free (frame_data);
frame_data = NULL;
frame_size = 0;
}
if (rest_size)
frame_data = malloc (frame.size + rest_size);
else
frame_data = frame.data;
if (!frame_data)
{
dt_error (TAG, "malloc audio frame failed ,we will lost one frame\n");
if (rest_data)
free (rest_data);
rest_size = 0;
continue;
}
if (rest_size) // no rest data
{
dt_debug (TAG, "left %d byet last time\n", rest_size);
memcpy (frame_data, rest_data, rest_size);
free (rest_data);
rest_data = NULL;
memcpy (frame_data + rest_size, frame.data, frame.size);
}
frame_size = frame.size + rest_size;
rest_size = 0;
used = 0;
declen = 0;
pinfo->inptr = frame_data;
pinfo->inlen = frame_size;
pinfo->outlen = 0;
//free pkt
frame.data = NULL;
frame.size = 0;
DECODE_LOOP:
if (decoder->status == ADEC_STATUS_EXIT)
{
dt_info (TAG, "[%s:%d] receive decode loop exit cmd \n", __FUNCTION__, __LINE__);
if (frame_data)
free (frame_data);
break;
}
/*decode frame */
pinfo->consume = declen;
used = wrapper->decode_frame (wrapper, pinfo);
if (used < 0)
{
decoder->decode_err_cnt++;
/*
* if decoder is ffmpeg,do not restore data if decode failed
* if decoder is not ffmpeg, restore raw stream packet if decode failed
* */
if (!strcmp (wrapper->name, "ffmpeg audio decoder"))
{
dt_error (TAG, "[%s:%d] ffmpeg failed to decode this frame, just break\n", __FUNCTION__, __LINE__);
decoder->decode_offset += pinfo->inlen;
}
continue;
}
else if (used == 0 && pinfo->outlen == 0) // used == 0 && out == 0 means need more data
{
//maybe need more data
rest_data = malloc (pinfo->inlen);
if (rest_data == NULL)
{
dt_error ("[%s:%d] rest_data malloc failed\n", __FUNCTION__, __LINE__);
rest_size = 0; //skip this frame
continue;
}
memcpy (rest_data, pinfo->inptr, pinfo->inlen);
rest_size = pinfo->inlen;
dt_info (TAG, "Maybe we need more data\n");
continue;
}
declen += used;
pinfo->inlen -= used;
decoder->decode_offset += used;
decoder->pts_cache_size = pinfo->outlen;
decoder->pts_buffer_size += pinfo->outlen;
if (pinfo->outlen == 0) //get no data, maybe first time for init
dt_info (TAG, "GET NO PCM DECODED OUT,used:%d \n",used);
fill_size = 0;
REFILL_BUFFER:
if (decoder->status == ADEC_STATUS_EXIT)
goto EXIT;
/*write pcm */
if (buf_space (out) < pinfo->outlen)
{
dt_debug (TAG, "[%s:%d] output buffer do not left enough space ,space=%d level:%d outsie:%d \n", __FUNCTION__, __LINE__, buf_space (out), buf_level (out), pinfo->outlen);
usleep (1000);
goto REFILL_BUFFER;
}
ret = buf_put (out, pinfo->outptr + fill_size, pinfo->outlen);
fill_size += ret;
pinfo->outlen -= ret;
decoder->pts_cache_size = pinfo->outlen;
if (pinfo->outlen > 0)
goto REFILL_BUFFER;
if (pinfo->inlen)
goto DECODE_LOOP;
}
while (1);
EXIT:
dt_info (TAG, "[file:%s][%s:%d]decoder loop thread exit ok\n", __FILE__, __FUNCTION__, __LINE__);
/* free adec_ctrl_t buf */
if(pinfo->outptr)
free(pinfo->outptr);
pinfo->outlen = pinfo->outsize = 0;
pthread_exit (NULL);
return NULL;
}