Void SystemCfg_notifyCB__P(UInt16 procId, UInt16 lineId, UInt32 eventNum,
UArg arg, UInt32 payload)
{
Error_Block eb;
struct SystemCfg *stateObj = (struct SystemCfg *)arg;
Log_print4(Diags_ENTRY,
"--> %s: (prodId: %d, eventNum: %d, payload: 0x%x)",
(IArg)FXNN, (IArg)procId, (IArg)eventNum, (IArg)payload);
Error_init(&eb);
switch (Global_EvtMask & payload) {
case Global_EvtCreateDone:
case Global_EvtReady:
case Global_EvtCloseDone:
case Global_EvtDone:
SemThread_post(stateObj->semH, &eb);
if (Error_check(&eb)) {
/* Log_error() */
Log_print3(
Diags_USER8,
"Error: %s, line %d: %s: SemThread_post() returned error",
(IArg)__FILE__, (IArg)__LINE__, (IArg)FXNN);
}
break;
}
Log_print1(Diags_EXIT, "<-- %s:", (IArg)FXNN);
}
/*
* ======== Hello_notifyCB ========
*/
static Void Hello_notifyCB(
UInt16 procId,
UInt16 lineId,
UInt32 eventId,
UArg arg,
UInt32 payload)
{
UInt next;
Error_Block eb;
Error_init(&eb);
/* ignore no-op events */
if (payload == App_CMD_NOP) {
return;
}
/* compute next slot in queue */
next = (Module.head + 1) % QUEUESIZE;
if (next == Module.tail) {
/* queue is full, drop event and set error flag */
Module.error = App_E_OVERFLOW;
return;
}
else {
Module.eventQue[Module.head] = payload;
Module.head = next;
}
/* signal semaphore (counting) that new event is in queue */
SemThread_post(Module.semH, &eb);
}
/*
* ======== doCmd ========
*/
static Int doCmd(Int cmdId, Processor_Handle proc)
{
Int result;
IArg key;
Log_print2(Diags_ENTRY, "[+E] doCmd> Enter (cmdId=%d, proc=0x%x)",
(IArg)cmdId, (IArg)proc);
//pthread_mutex_lock(&dcmd.gate);
key = GateThread_enter(dcmd.gate);
dcmd.proc = proc;
dcmd.cmdId = cmdId;
//pthread_cond_signal(&dcmd.cmdPresent);
SemThread_post(dcmd.cmdPresent, NULL);
//while (dcmd.reply == NONE) {
// pthread_cond_wait(&dcmd.replyPresent, &dcmd.gate);
//}
SemThread_pend(dcmd.replyPresent, SemThread_FOREVER, NULL);
result = dcmd.reply;
dcmd.reply = NONE;
//pthread_mutex_unlock(&dcmd.gate);
GateThread_leave(dcmd.gate, key);
Log_print1(Diags_EXIT, "[+X] doCmd> Exit (result=%d)", (IArg)result);
return (result);
}
void
dvtb_audPlay(DvevmStThreadInfo *T)
{
int aud_outBuffer_index = 0;
int status = DVEVM_ST_SUCCESS;
int nBytes;
while (1)
{
SemThread_pend(sem_in, SemThread_FOREVER);
if ((tskPlayState == EXITING) && (0 == availableInBuff))
break;
SemThread_pend(sem_block, SemThread_FOREVER);
availableInBuff -= 1;
SemThread_post(sem_block);
if (T->useAlgorithm)
nBytes = audioDesc[aud_outBuffer_index].aud_bufSize;
else
nBytes = AUD_FRAME_BUFF_SIZE;
#ifdef TEST_SEM
status = dvtb_fileWrite(T->targetFp, audioDesc[aud_outBuffer_index].aud_outBuffer, nBytes);
#else
// status = dvtb_audioOut(&T->g.aud, audioDesc[aud_outBuffer_index].aud_outBuffer, nBytes);
#endif
if (DVEVM_ST_FAIL == status)
{
SYS_ERROR("Audio play-back failed\n");
}
aud_outBuffer_index++;
if (AUD_OUTBUF_COUNT <= aud_outBuffer_index)
aud_outBuffer_index = 0;
SemThread_post(sem_out);
}
tskPlayState = DELETED;
dvtb_waitThread();
}
/*
* ======== putReply ========
*/
static Void putReply(Int status)
{
//pthread_mutex_lock(&dcmd.gate);
dcmd.reply = status;
//pthread_cond_signal(&dcmd.replyPresent);
SemThread_post(dcmd.replyPresent, NULL);
//Log_print2(Diags_USER1, "putReply(0x%x): proc = 0x%lx",
// (IArg)status, (IArg)(dcmd.proc));
//pthread_mutex_unlock(&dcmd.gate);
}
/*
* ======== rmanTask ========
*/
Void rmanTask(UArg arg0, UArg arg1)
{
Int taskId = (Int)arg0;
Int index = (Int)arg1; /* index into attrsTable */
IALG_Fxns * algFxns = (IALG_Fxns *)&DUMALG_TI_IDUMALG;
IRES_Fxns * resFxns = &DUMALG_TI_IRES;
IDUMALG_Handle dumHandle = NULL;
IDUMALG_Params params;
Int scratchId = attrsTable[index].scratchId;
Int yieldFlag = attrsTable[index].yieldFlag;
Int priority = attrsTable[index].priority;
Arg resourceId = (Arg)(&(attrsTable[index].id));
Int i;
IRES_Status status;
Log_print0(Diags_ENTRY, "[+E] rmanTask> Enter ");
params.size = sizeof(IDUMALG_Params);
Log_print4(Diags_USER4, "[+4] rmanTask> "
"Task #%d: ScratchId %d, Priority %d Yield %d",
(IArg)taskId, (IArg)scratchId, (IArg)priority, (IArg)yieldFlag);
params.yieldFlag = yieldFlag;
params.taskId = taskId;
for (i = 0; i < NUM_RESOURCES; i++) {
params.hdvicp[i] = *((IRES_HDVICP_RequestType *)resourceId + i);
Log_print1(Diags_USER4, "[+4] rmanTask> "
"Requesting resource %d (2 => ANY)",
(IArg)((Int)params.hdvicp[i]));
}
/*
* Create an instance of the algorithm using "algFxns"
*/
SemThread_pend(mutex, SemThread_FOREVER, NULL);
dumHandle = (IDUMALG_Handle)DSKT2_createAlg((Int)scratchId,
(IALG_Fxns *)algFxns, NULL,(IALG_Params *)¶ms);
if (dumHandle == NULL) {
Log_print0(Diags_USER7, "[+7] rmanTask> Alg creation failed");
System_abort("DSKT2_createAlg() failed, aborting...\n");
}
SemThread_post(mutex, NULL);
/* Assign resources to the algorithm */
status = RMAN_assignResources((IALG_Handle)dumHandle, resFxns, scratchId);
if (status != IRES_OK) {
Log_print1(Diags_USER7, "[+7] rmanTask> Assign resource failed [%d]",
(IArg)status);
System_abort("RMAN_assignResources() failed, aborting...\n");
}
/* Activate the Algorithm */
DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle);
/* Activate All Resources */
RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/* Use IALG interfaces to do something */
dumHandle->fxns->useHDVICP(dumHandle, taskId);
/* Deactivate All Resources */
RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/* Deactivate algorithm */
DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle);
/* Free resources assigned to this algorihtm */
status = RMAN_freeResources((IALG_Handle)(dumHandle), resFxns, scratchId);
if (status != IRES_OK) {
Log_print1(Diags_USER7, "[+7] rmanTask> Free resource failed [%d]",
(IArg)status);
System_abort("RMAN_freeResources() failed, aborting...\n");
}
/*
* Free instance of the algorithm created
*/
SemThread_pend(mutex, SemThread_FOREVER, NULL);
DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle);
SemThread_post(mutex, NULL);
SemThread_post(done, NULL);
Log_print0(Diags_EXIT, "[+X] rmanTask> Exit ");
}
/*
* ======== SyncSemThread_signal ========
*/
Void SyncSemThread_signal(SyncSemThread_Object *obj)
{
SemThread_post(obj->semThread, NULL);
}
void
dvtb_AudDec1Play(DvevmStThreadInfo *T)
{
int nBytes = DVEVM_ST_FAIL, nFrames = 0, frameSize = 0, totalBytesConsumed = 0, bytesRemaining = 0,
buffsize = 1000000, thresh_hold = 900000, hugeChunk = 0, decDuration = 0, aud_outBuffer_index = 0,
noOfOutChannels = 0, inFrameSize =0;
char *buff = NULL, *inBuffer = NULL;
unsigned int inputFileSize = 0;
Thread_Handle thrHandle = NULL;
Thread_Params thrParams;
DvevmStRetCode status = DVEVM_ST_FAIL;
DvevmStBool usecaseFailed = DVEVM_ST_FALSE, audioDeviceOpened = DVEVM_ST_FALSE, fileBased = DVEVM_ST_TRUE;
if (!T->sourceFp)
{
SYS_ERROR("Source file cannot be opened. It is a mandatory parameter\n");
dvtb_fileClose(&T->sourceFp, &T->targetFp);
dvtb_freeThread(T);
dvtb_waitThread();
}
if (!T->targetFp)
{
SYS_ERROR("Target file cannot be opened. It is a mandatory parameter\n");
dvtb_fileClose(&T->sourceFp, &T->targetFp);
dvtb_freeThread(T);
dvtb_waitThread();
}
if (DVEVM_ST_FAIL == dvtb_audDec1SemOpen(&sem_in, 0, &sem_out, AUD_OUTBUF_COUNT-2, &sem_block, 1))
{
SYS_ERROR("sem_open() FAILED\n");
dvtb_fileClose(&T->sourceFp, &T->targetFp);
dvtb_freeThread(T);
dvtb_waitThread();
}
// dvtb_audDec1SemInit(sem_in, 0, sem_out, AUD_OUTBUF_COUNT-2, sem_block, 1);
if (!T->targetFp)
fileBased = DVEVM_ST_FALSE;
dvtb_startMessage(DVEVM_ST_DECODE, "Audio", T->useAlgorithm, fileBased);
dvtb_audDec1InitPtrs(&T->g.adec1);
dvtb_audDec1InitPlayThreadBuffs(audioDesc, AUD_OUTBUF_COUNT);
// [Decode][Play] scenario
do
{
T->g.adec1.hTime = dvtb_timeCreate();
if(NULL == T->g.adec1.hTime)
{
SYS_ERROR("Unable to Create Time handle. \n");
usecaseFailed = DVEVM_ST_TRUE;
break;
}
if (T->useAlgorithm)
{
if (DVEVM_ST_FAIL == dvtb_audDec1HanInit(&T->g.adec1, T->g.eng.name))
{
SYS_ERROR("Unable to initialize Audio decode handle \n");
usecaseFailed = DVEVM_ST_TRUE;
break;
}
SYS_OUT("Audio Decoder <%s> initialized\n", T->g.adec1.adecName);
}
if (DVEVM_ST_FALSE == fileBased)
{
if (!T->useAlgorithm)
{
#if 0
T->g.aud.mode = SND_PCM_STREAM_PLAYBACK;
status = dvtb_audioSetup(&T->g.aud);
if (DVEVM_ST_FAIL == status)
{
SYS_ERROR("Unable to setup Audio device <%s> for playback\n", T->g.aud.device);
usecaseFailed = DVEVM_ST_TRUE;
break;
}
audioDeviceOpened = DVEVM_ST_TRUE;
SYS_OUT("Audio device <%s> initialized for playback\n", T->g.aud.device);
#endif
}
dvtb_audDec1InitThread(&thrParams);
}
hugeChunk = buffsize;
//Get file Size
if (DVEVM_ST_FAIL == dvtb_getFileSize(T->sourceFp, &inputFileSize))
{
SYS_ERROR("Unable to Get file size\n");
usecaseFailed = DVEVM_ST_TRUE;
break;
}
//If input file size is less than huge chunk than set hugeChunk to input file Size
if ((int)inputFileSize < hugeChunk)
hugeChunk = inputFileSize;
if (DVEVM_ST_FAIL == dvtb_allocSingleBufCmem(&inBuffer, buffsize))
{
SYS_ERROR("Unable to allocate memory for In Buffer\n");
usecaseFailed = DVEVM_ST_TRUE;
break;
}
bytesRemaining = 0;
if (DVEVM_ST_FAIL == dvtb_audDec1ReadInput(inBuffer, &totalBytesConsumed, &bytesRemaining, buffsize, T->sourceFp, &nBytes))
{
SYS_ERROR("Error in Read Input\n");
usecaseFailed = DVEVM_ST_TRUE;
break;
}
if (DVEVM_ST_FAIL == dvtb_audDec1AllocPlayThreadBuffs(audioDesc, T->g.adec1.outBuf.bufSizes[0], AUD_OUTBUF_COUNT))
{
SYS_ERROR("Unable to allocate Buffers for play thread \n");
usecaseFailed = DVEVM_ST_TRUE;
break;
}
aud_outBuffer_index = 0;
T->g.adec1.outBuf.bufs[0] = audioDesc[aud_outBuffer_index].aud_outBuffer;
if (T->useAlgorithm)
{
inFrameSize = T->g.adec1.inBuf.bufSizes[0];
}
else
inFrameSize = AUD_FRAME_BUFF_SIZE;
while (!feof(T->sourceFp) || bytesRemaining)
{
if (totalBytesConsumed > thresh_hold)
{
if (DVEVM_ST_FAIL == dvtb_audDec1ReadInput(inBuffer, &totalBytesConsumed, &bytesRemaining, buffsize, T->sourceFp, &nBytes))
{
SYS_ERROR("Error in Read Input\n");
usecaseFailed = DVEVM_ST_TRUE;
break;
}
hugeChunk = nBytes;
if (nBytes == 0)
{
SYS_OUT("End of file reached. Exiting...\n");
break;
}
}
nFrames++;
if (bytesRemaining < inFrameSize)
nBytes = bytesRemaining;
else
nBytes = inFrameSize;
buff = &inBuffer[totalBytesConsumed];
T->g.adec1.inBuf.bufs[0] = buff;
if (T->useAlgorithm)
{
T->g.adec1.inFrameSize = nBytes;
if(DVEVM_ST_FAIL == dvtb_audDec1DecProcess(&T->g.adec1, &decDuration))
{
SYS_ERROR("Unable to decode frame # %d\n", nFrames);
if (DVEVM_ST_FALSE == fileBased)
{
tskPlayState = EXITING;
SemThread_post(sem_in);
}
usecaseFailed = DVEVM_ST_TRUE;
break;
}
frameSize = T->g.adec1.decFrameSize;
totalBytesConsumed += frameSize;
bytesRemaining = hugeChunk - totalBytesConsumed;
buff = T->g.adec1.outBuf.bufs[0];
nBytes = dvtb_audDec1getOutPutBytes(&T->g.adec1.adecStatus);
audioDesc[aud_outBuffer_index].aud_bufSize = nBytes;
#if 0
if (T->g.aud.sampleRate != T->g.adec1.adecStatus.sampleRate)
T->g.aud.sampleRate = T->g.adec1.adecStatus.sampleRate;
#endif
noOfOutChannels = (T->g.adec1.adecStatus.channelMode == 0) ? 1 : 2;
#ifdef PERF
if(!T->g.adec1.pEnable)
{
SYS_PERF("Thread, %x, Frame#, %d, Decoded Frame Size(bytes), %d, DecTime(us), %d\n", (unsigned int) T, nFrames, nBytes, decDuration);
SYS_DEBUG("Frame#, %d, Frame Size(bytes), %d, DecTime(us), %d\n", nFrames, frameSize, decDuration);
}
#endif
}
else
{
memcpy(audioDesc[aud_outBuffer_index].aud_outBuffer, buff, nBytes);
totalBytesConsumed += nBytes;
bytesRemaining = hugeChunk - totalBytesConsumed;
}
#ifndef TEST_SEM
if (DVEVM_ST_TRUE == fileBased)
{
if(DVEVM_ST_FAIL == dvtb_fileWrite(T->targetFp, buff, nBytes))
{
SYS_ERROR("Error in writing to file.\n");
usecaseFailed = DVEVM_ST_TRUE;
break;
}
}
else
#endif
{
#if 0
if (T->useAlgorithm && (noOfOutChannels != T->g.aud.numChannels))
{
SYS_ERROR("No of channels of audio driver is not set correctly \n");
SYS_ERROR("Decoder: number of channels %d \n", noOfOutChannels);
SYS_ERROR("Driver: number of channels %d \n", T->g.aud.numChannels);
usecaseFailed = DVEVM_ST_TRUE;
tskPlayState = EXITING;
SemThread_post(sem_in);
break;
}
#endif
SemThread_post(sem_in);
SemThread_pend(sem_block, SemThread_FOREVER);
availableInBuff += 1;
SemThread_post(sem_block);
status = DVEVM_ST_SUCCESS;
//status = dvtb_audioOut(&T->g.aud, buff, nBytes);
SemThread_pend(sem_out, SemThread_FOREVER);
}
aud_outBuffer_index++;
if (AUD_OUTBUF_COUNT == aud_outBuffer_index)
aud_outBuffer_index = 0;
T->g.adec1.outBuf.bufs[0] = audioDesc[aud_outBuffer_index].aud_outBuffer;
if (nFrames == (AUD_OUTBUF_COUNT-2))
{
#ifndef TEST_SEM
if ((DVEVM_ST_FALSE == fileBased))
#endif
{
if(T->useAlgorithm)
{
#if 0
T->g.aud.mode = SND_PCM_STREAM_PLAYBACK;
T->g.aud.framesize = T->g.adec1.outBuf.bufSizes[0];
status = dvtb_audioSetup(&T->g.aud);
if (DVEVM_ST_FAIL == status)
{
SYS_ERROR("Unable to setup Audio device <%s> for playback\n", T->g.aud.device);
usecaseFailed = DVEVM_ST_TRUE;
break;
}
audioDeviceOpened = DVEVM_ST_TRUE;
SYS_OUT("Audio device <%s> initialized for playback\n", T->g.aud.device);
#endif
}
tskPlayState = RUNNING;
thrParams.arg = (IArg)T;
thrParams.name = "dvtb_audPlay";
thrParams.priority = Thread_Priority_HIGHEST;
if (DVEVM_ST_FAIL == dvtb_createThread((Thread_RunFxn) dvtb_audPlay, &thrParams, &thrHandle))
{
SYS_ERROR("Unable to create a thread\n");
usecaseFailed = DVEVM_ST_TRUE;
break;
}
}
}
}
#ifdef TEST_SEM
if (DVEVM_ST_FALSE == fileBased)
#endif
{
if (EXITING > tskPlayState)
{
tskPlayState = EXITING;
SemThread_post(sem_in);
}
if(NULL != thrHandle)
{
while (DELETED != tskPlayState)
{
dvtb_sleepThread(1);
}
dvtb_deleteThread(&thrHandle);
}
}
} while (DVEVM_ST_FALSE); // Dummy loop
dvtb_audDec1ProcessEndMessage(T->useAlgorithm, fileBased, nFrames);
#if 0
if (DVEVM_ST_TRUE == audioDeviceOpened)
{
dvtb_audioClose(&T->g.aud);
SYS_OUT("Audio Device <%s> closed\n", T->g.aud.device);
}
#endif
if (NULL != inBuffer)
{
dvtb_freeSingleBufCmem(inBuffer, buffsize);
inBuffer = NULL;
}
if (T->useAlgorithm)
dvtb_audDec1HanClose(&T->g.adec1, T->g.eng.name);
dvtb_audDec1FreePlayThreadBuffs(audioDesc, T->g.adec1.inBuf.bufSizes[0], AUD_OUTBUF_COUNT);
dvtb_fileClose(&T->sourceFp, &T->targetFp);
dvtb_audDec1SemClose(&sem_in, &sem_out, &sem_block);
dvtb_timeDelete(T->g.adec1.hTime);
dvtb_exitMessage(DVEVM_ST_DECODE, "Audio", T->useAlgorithm, fileBased, usecaseFailed);
dvtb_freeThread(T);
dvtb_waitThread();
}
Int RcmClient_getReturnMsg_P(RcmClient_Object *obj, const UInt16 msgId,
RcmClient_Message **returnMsg)
{
List_Elem *elem;
Recipient *recipient;
RcmClient_Packet *packet;
Bool messageDelivered;
MessageQ_Msg msgqMsg = NULL;
Bool messageFound = FALSE;
Int queueLockAcquired = 0;
Error_Block eb;
Int rval;
Int status = RcmClient_S_SUCCESS;
Log_print3(Diags_ENTRY,
"--> "FXNN": (obj=0x%x, msgId=%d, returnMsgPtr=0x%x",
(IArg)obj, (IArg)msgId, (IArg)returnMsg);
Error_init(&eb);
*returnMsg = NULL;
/* keep trying until message found */
while (!messageFound) {
/* acquire the mailbox lock */
Semaphore_pend(obj->mbxLock, Semaphore_FOREVER, &eb);
if (Error_check(&eb)) {
/* TODO */
goto leave;
}
/* search new mail list for message */
elem = NULL;
while ((elem = List_next(obj->newMail, elem)) != NULL) {
packet = getPacketAddrElem(elem);
if (msgId == packet->msgId) {
List_remove(obj->newMail, elem);
*returnMsg = &packet->message;
messageFound = TRUE;
break;
}
}
if (messageFound) {
/* release the mailbox lock */
Semaphore_post(obj->mbxLock, &eb);
if (Error_check(&eb)) {
/* TODO */
}
}
else {
/* attempt the message queue lock */
queueLockAcquired = Semaphore_pend(obj->queueLock, 0, &eb);
if (Error_check(&eb)) {
/* TODO */
goto leave;
}
if (1 == queueLockAcquired) {
/*
* mailman role
*/
/* deliver new mail until message found */
while (!messageFound) {
/* get message from queue if available (non-blocking) */
if (NULL == msgqMsg) {
rval = MessageQ_get(obj->msgQue, &msgqMsg, 0);
if ((MessageQ_E_TIMEOUT != rval) && (rval < 0)) {
Log_error0(FXNN": lost return message");
status = RcmClient_E_LOSTMSG;
goto leave;
}
Log_print0(Diags_INFO, FXNN": return message received");
}
while (NULL != msgqMsg) {
/* check if message found */
packet = getPacketAddrMsgqMsg(msgqMsg);
messageFound = (msgId == packet->msgId);
if (messageFound) {
*returnMsg = &packet->message;
/* search wait list for new mailman */
elem = NULL;
while ((elem =
List_next(obj->recipients, elem)) != NULL) {
recipient = (Recipient *)elem;
if (NULL == recipient->msg) {
/* signal recipient's event */
SemThread_post(SemThread_handle(
&recipient->event), &eb);
break;
}
}
/* release the message queue lock */
Semaphore_post(obj->queueLock, &eb);
if (Error_check(&eb)) {
/* TODO */
}
/* release the mailbox lock */
Semaphore_post(obj->mbxLock, &eb);
if (Error_check(&eb)) {
/* TODO */
}
break;
}
else {
/*
* deliver message to mailbox
*/
/* search recipient list for message owner */
elem = NULL;
messageDelivered = FALSE;
while ((elem =
List_next(obj->recipients, elem)) != NULL) {
recipient = (Recipient *)elem;
if (recipient->msgId == packet->msgId) {
recipient->msg = &packet->message;
/* signal the recipient's event */
SemThread_post(SemThread_handle(
&recipient->event), &eb);
messageDelivered = TRUE;
break;
}
}
/* add undelivered message to new mail list */
if (!messageDelivered) {
/* use the elem in the MessageQ header */
elem = (List_Elem *)&packet->msgqHeader;
List_put(obj->newMail, elem);
}
}
/* get next message from queue if available */
rval = MessageQ_get(obj->msgQue, &msgqMsg, 0);
if ((MessageQ_E_TIMEOUT != rval) && (rval < 0)) {
Log_error0(FXNN": lost return message");
status = RcmClient_E_LOSTMSG;
goto leave;
}
Log_print0(Diags_INFO, FXNN": return message received");
}
if (!messageFound) {
/*
* message queue empty
*/
/* release the mailbox lock */
Semaphore_post(obj->mbxLock, &eb);
if (Error_check(&eb)) {
/* TODO */
}
/* get next message, this blocks the thread */
rval = MessageQ_get(obj->msgQue, &msgqMsg,
MessageQ_FOREVER);
if (rval < 0) {
Log_error0(FXNN": lost return message");
status = RcmClient_E_LOSTMSG;
goto leave;
}
Log_print0(Diags_INFO, FXNN": return message received");
if (msgqMsg == NULL) {
Log_error0(FXNN": reply message has been lost");
status = RcmClient_E_LOSTMSG;
goto leave;
}
/* acquire the mailbox lock */
Semaphore_pend(obj->mbxLock, Semaphore_FOREVER, &eb);
if (Error_check(&eb)) {
goto leave; /* TODO */
}
}
}
}
else {
/* construct recipient on local stack */
Recipient self;
self.msgId = msgId;
self.msg = NULL;
SemThread_construct(&self.event, 0, NULL, &eb);
if (Error_check(&eb)) {
/* TODO */
}
/* add recipient to wait list */
elem = &self.elem;
List_put(obj->recipients, elem);
/* release the mailbox lock */
Semaphore_post(obj->mbxLock, &eb);
if (Error_check(&eb)) {
/* TODO */
}
/* wait on event */
SemThread_pend(SemThread_handle(&self.event),
Semaphore_FOREVER, &eb);
if (Error_check(&eb)) {
/* TODO */
}
/* acquire the mailbox lock */
Semaphore_pend(obj->mbxLock, Semaphore_FOREVER, &eb);
if (Error_check(&eb)) {
goto leave; /* TODO */
}
if (NULL != self.msg) {
/* pickup message */
*returnMsg = self.msg;
messageFound = TRUE;
}
/* remove recipient from wait list */
List_remove(obj->recipients, elem);
SemThread_destruct(&self.event);
/* release the mailbox lock */
Semaphore_post(obj->mbxLock, &eb);
if (Error_check(&eb)) {
/* TODO */
}
}
}
} /* while (!messageFound) */
leave:
Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
return(status);
}
