static int dt_transport_event (event_t * event, dt_server_mgt_t * mgt)
{
dt_lock (&mgt->server_lock);
event_server_t *entry = mgt->server;
int ret = 0;
while (entry->id != event->server_id)
{
entry = entry->next;
if (!entry)
break;
}
if (!entry)
{
dt_error (TAG, "Could not found server for:%d \n ", event->server_id);
ret = -1;
goto FAIL;
}
ret = dt_add_event (event, entry);
if (ret < 0) //we need to free this event
{
dt_error (TAG, "we can not transport this event, id:%d type:%d\n ", event->server_id, event->type);
free (event);
ret = -1;
goto FAIL;
}
dt_unlock (&mgt->server_lock);
return ret;
FAIL:
dt_unlock (&mgt->server_lock);
return ret;
}
int dt_send_event (event_t * event)
{
dt_server_mgt_t *mgt = &server_mgt;
event_server_t *server_hub = mgt->server;
if (!server_hub)
{
dt_error (TAG, "EVENT SEND FAILED \n");
return -1;
}
dt_lock (&server_hub->event_lock);
if (server_hub->event_count == 0)
server_hub->event = event;
else
{
event_t *entry = server_hub->event;
while (entry->next)
entry = entry->next;
entry->next = event;
}
server_hub->event_count++;
dt_unlock (&server_hub->event_lock);
dt_debug (TAG, "EVENT:%d SEND OK, event count:%d \n", event->type, server_hub->event_count);
return 0;
}
static int cache_reset(stream_cache_t *cache)
{
dt_lock (&cache->mutex);
cache->rp = cache->wp = cache->pre_rp =0;
cache->pre_size = cache->level = 0;
dt_unlock (&cache->mutex);
return 0;
}
static int release_cache(stream_cache_t *cache)
{
if(!cache)
return 0;
dt_lock (&cache->mutex);
if(cache->data)
free(cache->data);
free(cache);
return 0;
}
int dtap_change_effect(ao_wrapper_t *wrapper, int id)
{
audio_effect_t *ae = (audio_effect_t *)wrapper->ao_priv;
__android_log_print(ANDROID_LOG_INFO, TAG, "change audio effect from: %d to %d \n", ae->ap.para.item, id);
dt_lock(&ae->lock);
ae->ap.para.item = id;
dtap_update(&ae->ap);
dtap_init(&ae->ap);
dt_unlock(&ae->lock);
return 0;
}
event_t *dt_peek_event (event_server_t * server)
{
event_t *entry = NULL;
dt_lock (&server->event_lock);
if (server->event_count > 0)
{
entry = server->event;
}
dt_unlock (&server->event_lock);
if (entry != NULL)
dt_info (TAG, "PEEK EVENT:%d From Server:%s \n", entry->type, server->name);
return entry;
}
static int ao_opensl_write(dtaudio_output_t *aout, uint8_t *buf, int size) {
aout_sys_t *sys = (aout_sys_t *) aout->ao_priv;
ao_wrapper_t *wrapper = aout->wrapper;
int ret = 0;
#ifdef ENABLE_DTAP
audio_effect_t *ae = (audio_effect_t *)wrapper->ao_priv;
dt_lock(&ae->lock);
dtap_frame_t frame;
frame.in = buf;
frame.in_size = size;
if(ae->ap.para.item != EQ_EFFECT_NORMAL)
{
dtap_process(&ae->ap, &frame);
}
dt_unlock(&ae->lock);
#endif
dt_lock(&sys->lock);
ret = Play(aout, buf, size);
dt_unlock(&sys->lock);
return ret;
}
void gles2_release()
{
dt_lock(&mutex);
gl_ctx.g_width = 0;
gl_ctx.g_height = 0;
if (gl_ctx.frame.data[0])
{
free(gl_ctx.frame.data[0]);
gl_ctx.frame.data[0] = NULL;
}
gl_ctx.mp = NULL;
gl_ctx.initialized = 0;
dt_unlock(&mutex);
memset(&gl_ctx,0,sizeof(gles2_ctx_t));
}
event_t *dt_get_event (event_server_t * server)
{
event_t *entry = NULL;
dt_lock (&server->event_lock);
if (server->event_count > 0)
{
entry = server->event;
server->event = entry->next;
server->event_count--;
entry->next = NULL;
}
dt_unlock (&server->event_lock);
if (entry != NULL)
dt_info (TAG, "GET EVENT:%d From Server:%s \n", entry->type, server->name);
return entry;
}
static int ao_opensl_level(dtaudio_output_t *aout) {
aout_sys_t *sys = (aout_sys_t *) aout->ao_priv;
dt_lock(&sys->lock);
int level = sys->samples * bytesPerSample(aout);
const int unit_size = sys->samples_per_buf * bytesPerSample(aout);
SLAndroidSimpleBufferQueueState st;
if (!sys->started)
goto END;
SLresult res = GetState(sys->playerBufferQueue, &st);
if (unlikely(res != SL_RESULT_SUCCESS)) {
goto END;
}
level += st.count * unit_size;
//__android_log_print(ANDROID_LOG_DEBUG,TAG, "opensl level:%d st.count:%d sample:%d:%d \n",level, (int)st.count, sys->samples);
END:
dt_unlock(&sys->lock);
return level;
}
int gles2_surface_changed(int w, int h)
{
dt_lock(&mutex);
gl_ctx.g_width = w;
gl_ctx.g_height = h;
gl_ctx.status = GLRENDER_STATUS_RUNNING;
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
checkGlError("glClearColor");
int width = gl_ctx.g_width;
int height = gl_ctx.g_height;
glViewport(0, 0, width, height);
__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "on surface changed\n ");
dt_unlock(&mutex);
}
int dt_register_server (event_server_t * server)
{
dt_server_mgt_t *mgt = &server_mgt;
int ret = 0;
if (!mgt)
{
dt_error (TAG, "SERVICE MGT IS NULL\n");
return -1;
}
dt_lock (&mgt->server_lock);
if (mgt->server_count == 0)
mgt->server = server;
event_server_t *entry = mgt->server;
while (entry->next != NULL)
{
if (entry->id == server->id)
{
dt_error (TAG, "SERVICE HAS BEEN REGISTERD BEFORE\n");
ret = -1;
goto FAIL;
}
entry = entry->next;
}
if (entry->next == NULL)
{
entry->next = server;
server->next = NULL;
mgt->server_count++;
}
dt_unlock (&mgt->server_lock);
dt_info (TAG, "SERVICE:%s REGISTER OK,SERVERCOUNT:%d \n", server->name, mgt->server_count);
return 0;
FAIL:
dt_unlock (&mgt->server_lock);
return ret;
}
int gles2_draw_frame()
{
dt_lock(&mutex);
int width = gl_ctx.g_width;
int height = gl_ctx.g_height;
dt_av_frame_t *frame = &gl_ctx.frame;
uint8_t *data = NULL;
if(gl_ctx.status == GLRENDER_STATUS_IDLE)
goto END;
if(gl_ctx.invalid_frame == 0)
{
//__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "update_frame, No frame to draw \n");
goto END;
}
if(!gl_ctx.frame.data[0])
goto END;
//Fixme: scale to dst width
data = frame->data[0];
//glViewport(0, 0, width, height);
gles2_bindTexture(gl_ctx.g_texYId, data, width, height);
gles2_bindTexture(gl_ctx.g_texUId, data + width * height, width/2, height/2);
gles2_bindTexture(gl_ctx.g_texVId, data + width * height * 5 / 4, width/2, height/2);
gles2_renderFrame();
if(frame->data[0])
free(frame->data[0]);
frame->data[0] = NULL;
gl_ctx.invalid_frame = 0;
END:
dt_unlock(&mutex);
return 0;
}
int dt_add_event (event_t * event, event_server_t * server)
{
event_server_t *server_hub = server;
if (!server_hub)
{
dt_error (TAG, "EVENT SEND FAILED \n");
return -1;
}
dt_lock (&server_hub->event_lock);
if (server_hub->event_count == 0)
server_hub->event = event;
else
{
event_t *entry = server_hub->event;
while (entry->next)
entry = entry->next;
entry->next = event;
}
server_hub->event_count++;
dt_unlock (&server_hub->event_lock);
return 0;
}
/*
* release server
* free memory, stop event trans loop
* */
int dt_event_server_release ()
{
dt_server_mgt_t *mgt = &server_mgt;
dt_lock (&mgt->server_lock);
/*stop loop */
mgt->exit_flag = 1;
pthread_join (mgt->transport_loop_id, NULL);
/*
* for main server, we just remove event
* for normal server, need to remove event and server
* */
event_server_t *entry = mgt->server;
event_server_t *entry_next = NULL;
while (entry)
{
entry_next = entry->next;
dt_remove_server (entry);
entry = entry_next;
}
dt_unlock (&mgt->server_lock);
return 0;
}
// get us delay
//
static int TimeGet(dtaudio_output_t *aout, int64_t *drift) {
aout_sys_t *sys = (aout_sys_t *) aout->ao_priv;
SLAndroidSimpleBufferQueueState st;
SLresult res = GetState(sys->playerBufferQueue, &st);
if (unlikely(res != SL_RESULT_SUCCESS)) {
LOGV("Could not query buffer queue state in TimeGet (%lu)", (unsigned long) res);
return -1;
}
dt_lock(&sys->lock);
bool started = sys->started;
dt_unlock(&sys->lock);
if (!started)
return -1;
*drift = (CLOCK_FREQ * OPENSLES_BUFLEN * st.count / 1000)
+ sys->samples * CLOCK_FREQ / sys->rate;
//__android_log_print(ANDROID_LOG_DEBUG, TAG, "latency %lld ms, %d/%d buffers, samples:%d", *drift / 1000,
// (int)st.count, OPENSLES_BUFFERS, sys->samples);
return 0;
}
void gles2_init()
{
dt_lock (&mutex);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
checkGlError("glClearColor");
memset(&gl_ctx,0,sizeof(gles2_ctx_t));
gl_ctx.simpleProgram = buildProgram(VERTEX_SHADER, FRAG_SHADER);
glUseProgram(gl_ctx.simpleProgram);
glGenTextures(1, &gl_ctx.g_texYId);
glGenTextures(1, &gl_ctx.g_texUId);
glGenTextures(1, &gl_ctx.g_texVId);
checkGlError("glGenTextures");
char *glExtension = (char *)glGetString(GL_EXTENSIONS);
if(strstr(glExtension, "GL_AMD_compressed_ATC_texture") != NULL)
gl_ctx.vertex_index = 1;
else
gl_ctx.vertex_index = 0;
gl_ctx.initialized = 1;
dt_unlock (&mutex);
__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, "opengl esv2 init ok, ext:%s\n ", glExtension);
}
static int cache_write(stream_cache_t *cache, uint8_t *in, int size)
{
dt_lock (&cache->mutex);
int len = MIN(cache->total_size - cache->level - cache->fix_pre_size, size);
if(len == 0)
goto QUIT;
if(cache->wp < cache->rp)
{
if(cache->wp+len >= cache->pre_rp)
{
dt_info(TAG,"[%s:%d]need to move pre from %d to %d \n",__FUNCTION__,__LINE__,cache->pre_rp, cache->wp+len);
cache->pre_rp = cache->wp + len;
cache->pre_size = cache->rp - cache->pre_rp;
}
memcpy(cache->data+cache->wp, in, len);
cache->wp += len;
cache->level += len;
}
else if(len <= (int)(cache->total_size - cache->wp))
{
if(cache->pre_rp > cache->rp)
{
if((cache->wp+len)>cache->pre_rp)
{
dt_info(TAG,"[%s:%d]need to move pre from %d to %d \n",__FUNCTION__,__LINE__,cache->pre_rp, cache->wp+len);
cache->pre_rp = cache->wp + len;
cache->pre_size = cache->rp + cache->total_size - cache->pre_size;
}
}
#if 0
else if(cache->pre_rp > cache->rp)
{
cache->pre_size = cache->total_size - cache->pre_rp + cache->rp;
}
else
cache->pre_size = cache->rp - cache->pre_rp;
#endif
memcpy(cache->data+cache->wp, in, len);
cache->wp += len;
cache->level += len;
}
else
{
int tail_len = (int)(cache->total_size - cache->wp);
memcpy (cache->data+cache->wp, in, tail_len);
if(cache->pre_rp > cache->rp)
{
dt_info(TAG,"[%s:%d]need to move pre from %d to %d \n",__FUNCTION__,__LINE__,cache->pre_rp, cache->wp+len);
cache->pre_rp = len - tail_len;
cache->pre_size = cache->rp - cache->pre_rp;
}
else if(cache->pre_rp < (len-tail_len))
{
dt_info(TAG,"[%s:%d]need to move pre from %d to %d \n",__FUNCTION__,__LINE__,cache->pre_rp, cache->wp+len);
cache->pre_rp = len - tail_len;
cache->pre_size = cache->rp - cache->pre_rp;
}
memcpy (cache->data, in + tail_len, len - tail_len);
cache->wp = len - tail_len;
cache->level += len;
}
QUIT:
dt_unlock (&cache->mutex);
return len;
}
static int cache_seek(stream_cache_t *cache, int step, int orig)
{
if(step <= 0)
return 0;
dt_lock (&cache->mutex);
int ret = 0;
if(!orig) // seek backward
{
if(cache->pre_size < step) // seek out of bound, failed
{
dt_info(TAG,"[%s:%d]rp:%d wp:%d pre_rp:%d level:%d pre_size:%d \n",__FUNCTION__,__LINE__,cache->rp,cache->wp,cache->pre_rp,cache->level,cache->pre_size);
ret = -1;
goto QUIT;
}
if(cache->pre_rp < cache->rp)
{
dt_info(TAG,"[%s:%d]rp:%d wp:%d pre_rp:%d level:%d pre_size:%d \n",__FUNCTION__,__LINE__,cache->rp,cache->wp,cache->pre_rp,cache->level,cache->pre_size);
cache->rp -= step;
cache->pre_size -= step;
cache->level += step;
goto QUIT;
}
if(cache->pre_rp > cache->rp)
{
if(cache->rp > step)
{
dt_info(TAG,"[%s:%d]rp:%d wp:%d pre_rp:%d level:%d pre_size:%d \n",__FUNCTION__,__LINE__,cache->rp,cache->wp,cache->pre_rp,cache->level,cache->pre_size);
cache->rp -= step;
cache->pre_size -= step;
cache->level += step;
goto QUIT;
}
else
{
dt_info(TAG,"[%s:%d]rp:%d wp:%d pre_rp:%d level:%d pre_size:%d \n",__FUNCTION__,__LINE__,cache->rp,cache->wp,cache->pre_rp,cache->level,cache->pre_size);
int left = step - cache->rp;
cache->rp = cache->total_size - left;
cache->pre_size -= step;
cache->level += step;
goto QUIT;
}
}
ret = -1; // failed here
goto QUIT;
}
if(orig)
{
if(cache->level < step) // seek out of bound, failed
{
dt_info(TAG,"[%s:%d]rp:%d wp:%d pre_rp:%d level:%d pre_size:%d \n",__FUNCTION__,__LINE__,cache->rp,cache->wp,cache->pre_rp,cache->level,cache->pre_size);
ret = -1;
goto QUIT;
}
if(cache->rp < cache->wp)
{
dt_info(TAG,"[%s:%d]rp:%d wp:%d pre_rp:%d level:%d pre_size:%d \n",__FUNCTION__,__LINE__,cache->rp,cache->wp,cache->pre_rp,cache->level,cache->pre_size);
cache->rp += step;
cache->pre_size += step;
cache->level -= step;
goto QUIT;
}
if(cache->rp > cache->wp)
{
if((cache->total_size - cache->rp) > step)
{
dt_info(TAG,"[%s:%d]rp:%d wp:%d pre_rp:%d level:%d pre_size:%d \n",__FUNCTION__,__LINE__,cache->rp,cache->wp,cache->pre_rp,cache->level,cache->pre_size);
cache->rp += step;
cache->pre_size += step;
cache->level -= step;
goto QUIT;
}
else
{
dt_info(TAG,"[%s:%d]rp:%d wp:%d pre_rp:%d level:%d pre_size:%d \n",__FUNCTION__,__LINE__,cache->rp,cache->wp,cache->pre_rp,cache->level,cache->pre_size);
int left = step - (cache->total_size - cache->rp);
cache->rp = left;
cache->pre_size += step;
cache->level -= step;
goto QUIT;
}
ret = -1;
goto QUIT;
}
ret = -1;
goto QUIT;
}
QUIT:
dt_info(TAG,"cache seek, step:%d ret:%d orig:%d \n",step,ret,orig);
dt_unlock (&cache->mutex);
return ret;
}
