int tdav_consumer_dsound_start(tmedia_consumer_t* self)
{
tdav_consumer_dsound_t* dsound = (tdav_consumer_dsound_t*)self;
tsk_size_t i;
HRESULT hr;
LPDIRECTSOUNDNOTIFY lpDSBNotify;
DSBPOSITIONNOTIFY pPosNotify[TDAV_DSOUNS_CONSUMER_NOTIF_POS_COUNT] = {0};
if(!dsound){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
if(!dsound->device || !dsound->primaryBuffer || !dsound->secondaryBuffer){
TSK_DEBUG_ERROR("Consumer not prepared");
return -2;
}
if(dsound->started){
TSK_DEBUG_WARN("Consumer already started");
return 0;
}
if((hr = IDirectSoundBuffer_QueryInterface(dsound->secondaryBuffer, &IID_IDirectSoundNotify, (LPVOID*)&lpDSBNotify)) != DS_OK){
tdav_win32_print_error("IDirectSoundBuffer_QueryInterface", hr);
return -3;
}
/* Events associated to notification points */
for(i = 0; i<sizeof(dsound->notifEvents)/sizeof(HANDLE); i++){
dsound->notifEvents[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
pPosNotify[i].dwOffset = ((dsound->bytes_per_notif * i) + dsound->bytes_per_notif) - 1;
pPosNotify[i].hEventNotify = dsound->notifEvents[i];
}
if((hr = IDirectSoundNotify_SetNotificationPositions(lpDSBNotify, TDAV_DSOUNS_CONSUMER_NOTIF_POS_COUNT, pPosNotify)) != DS_OK){
IDirectSoundNotify_Release(lpDSBNotify);
tdav_win32_print_error("IDirectSoundBuffer_QueryInterface", hr);
return -4;
}
if((hr = IDirectSoundNotify_Release(lpDSBNotify))){
tdav_win32_print_error("IDirectSoundNotify_Release", hr);
}
/* start the reader thread */
tsk_thread_create(&dsound->tid[0], __playback_thread, dsound);
/* Start the buffer */
if((hr = IDirectSoundBuffer_Play(dsound->secondaryBuffer,0, 0, DSBPLAY_LOOPING)) != DS_OK){
tdav_win32_print_error("IDirectSoundNotify_Release", hr);
return -5;
}
dsound->started = tsk_true;
return 0;
}
int tdav_producer_waveapi_start(tmedia_producer_t* self)
{
tdav_producer_waveapi_t* producer = (tdav_producer_waveapi_t*)self;
MMRESULT result;
tsk_size_t i;
if(!producer){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
if(producer->started || producer->hWaveIn){
TSK_DEBUG_WARN("Producer already started");
return 0;
}
/* create events */
if(!producer->events[0]){
producer->events[0] = CreateEvent(NULL, FALSE, FALSE, NULL);
}
if(!producer->events[1]){
producer->events[1] = CreateEvent(NULL, FALSE, FALSE, NULL);
}
/* open */
result = waveInOpen((HWAVEIN *)&producer->hWaveIn, /*WAVE_MAPPER*/0, &producer->wfx, (DWORD)producer->events[0], (DWORD_PTR)producer, CALLBACK_EVENT);
if(result != MMSYSERR_NOERROR){
print_last_error(result, "waveInOpen");
return -2;
}
/* start */
result = waveInStart(producer->hWaveIn);
if(result != MMSYSERR_NOERROR){
print_last_error(result, "waveInStart");
return -2;
}
/* start thread */
tsk_thread_create(&producer->tid[0], __record_thread, producer);
/* write */
for(i = 0; i< sizeof(producer->hWaveHeaders)/sizeof(LPWAVEHDR); i++){
add_wavehdr(producer, i);
}
producer->started = tsk_true;
return 0;
}
static int tdav_producer_audiounit_start(tmedia_producer_t* self)
{
tdav_producer_audiounit_t* producer = (tdav_producer_audiounit_t*)self;
if(!producer){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
if(producer->paused){
producer->paused = tsk_false;
return tsk_false;
}
int ret;
if(producer->started){
TSK_DEBUG_WARN("Already started");
return 0;
}
else {
ret = tdav_audiounit_handle_start(producer->audioUnitHandle);
if(ret){
TSK_DEBUG_ERROR("tdav_audiounit_handle_start failed with error code=%d", ret);
return ret;
}
}
producer->started = tsk_true;
// create conditional variable
if (!producer->senderCondWait) {
if (!(producer->senderCondWait = tsk_condwait_create())){
TSK_DEBUG_ERROR("Failed to create conditional variable");
return -2;
}
}
// start the reader thread
ret = tsk_thread_create(&producer->senderThreadId[0], __sender_thread, producer);
if(ret){
TSK_DEBUG_ERROR("Failed to start the sender thread. error code=%d", ret);
return ret;
}
TSK_DEBUG_INFO("AudioUnit producer started");
return 0;
}
/*
* Runnable interface implementation.
*/
static void* TSK_STDCALL run(void* self)
{
int ret = 0;
tsk_list_item_t *curr;
tnet_transport_t *transport = self;
TSK_DEBUG_INFO("Transport::run() - enter");
/* create main thread */
if((ret = tsk_thread_create(transport->mainThreadId, tnet_transport_mainthread, transport))){ /* More important than "tsk_runnable_start" ==> start it first. */
TSK_FREE(transport->context); /* Otherwise (tsk_thread_create is ok) will be freed when mainthread exit. */
TSK_DEBUG_FATAL("Failed to create main thread [%d]", ret);
return tsk_null;
}
/* set thread priority
iOS and OSX: no incoming pkts (STUN, rtp, dtls...) when thread priority is changed -> to be checked
*/
#if !TNET_UNDER_APPLE
ret = tsk_thread_set_priority(transport->mainThreadId[0], TSK_THREAD_PRIORITY_TIME_CRITICAL);
#endif
TSK_RUNNABLE_RUN_BEGIN(transport);
if((curr = TSK_RUNNABLE_POP_FIRST_SAFE(TSK_RUNNABLE(transport)))){
const tnet_transport_event_t *e = (const tnet_transport_event_t*)curr->data;
if (transport->callback) {
transport->callback(e);
}
tsk_object_unref(curr);
}
TSK_RUNNABLE_RUN_END(transport);
TSK_DEBUG_INFO("Transport::run(%s) - exit", transport->description);
return tsk_null;
}
int tdav_video_jb_start(tdav_video_jb_t* self)
{
int ret = 0;
if(!self){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
if(self->started){
return 0;
}
self->started = tsk_true;
if(!self->decode_thread[0]){
ret = tsk_thread_create(&self->decode_thread[0], _tdav_video_jb_decode_thread_func, self);
if(ret != 0 || !self->decode_thread[0]){
TSK_DEBUG_ERROR("Failed to create new thread");
}
ret = tsk_thread_set_priority(self->decode_thread[0], TSK_THREAD_PRIORITY_TIME_CRITICAL);
}
return ret;
}