// Sets the internal state for this resource
void MpStreamPlayer::setState(PlayerState iState)
{
UtlBoolean bShouldFire = FALSE ;
mSemStateGuard.acquire() ;
if (isValidStateChange(mState, iState))
{
bShouldFire = TRUE ;
#ifdef MP_STREAM_DEBUG /* [ */
osPrintf("MpStreamPlayer::setState changed from %s to %s.\n\n",
getEventString(mState), getEventString(iState)) ;
#endif /* ] */
mState = iState ;
}
#ifdef MP_STREAM_DEBUG /* [ */
else if (mState != iState)
{
osPrintf("** WARNING MpStreamPlayer(%08X): invalid state change (%s to %s)\n",
this, getEventString(mState), getEventString(iState)) ;
}
#endif /* MP_STREAM_DEBUG ] */
mSemStateGuard.release() ;
if (bShouldFire)
fireEvent(iState) ;
mSemStateChange.release() ;
}
// Handles processing for the prefetched state
void MpStreamPlaylistPlayer::handlePrefetchedState(PlayerState oldState, PlayerState newState)
{
//
// Updated the mAggregateState if all play list items are prefetched
//
if ((mAggregateState == PlayerUnrealized) || (mAggregateState == PlayerRealized))
{
UtlBoolean bAllPrefetched = TRUE;
UtlSListIterator playListDbIterator(*mPlayListDb) ;
while(PlayListEntry* e = (PlayListEntry*)playListDbIterator())
{
if ( (e->state != PlayerPrefetched) &&
(e->state != PlayerFailed))
{
bAllPrefetched = FALSE;
break;
}
}
// If everything is prefetched, then updated the aggregate state and
// fire off the event to listeners
if (bAllPrefetched)
{
#ifdef MP_STREAM_DEBUG /* [ */
osPrintf("MpStreamPlaylistPlayer::handlePrefetchedState(%p): Changed from %s to PlayerPrefetched.\n",
this, getEventString(mAggregateState));
#endif /* ] */
mAggregateState = PlayerPrefetched;
fireEvent(PlayerPrefetched);
}
}
}
// Handles processing for the failed state
void MpStreamPlaylistPlayer::handleFailedState(PlayerState oldState, PlayerState newState)
{
#ifdef MP_STREAM_DEBUG /* [ */
osPrintf("MpStreamPlaylistPlayer::handleFailedState(%p): Changed from %s to PlayerFailed.\n",
this, getEventString(mAggregateState));
#endif /* ] */
mAggregateState = PlayerFailed;
// Wake up anyone waiting on play completion.
mWaitEvent.signal(0);
}
// Handles processing for the stopped state
void MpStreamPlaylistPlayer::handleStoppedState(PlayerState oldState, PlayerState newState)
{
if ( (mbAutoAdvance) &&
(mCurrentElement < (int)mPlayListDb->entries()) &&
(newState != PlayerAborted))
{
playNext(FALSE);
}
else if (newState == PlayerAborted)
{
if (mAggregateState != PlayerAborted)
{
#ifdef MP_STREAM_DEBUG /* [ */
osPrintf("MpStreamPlaylistPlayer::handleStoppedState(%p): Changed from %s to PlayerAborted.\n",
this, getEventString(mAggregateState));
#endif /* ] */
mAggregateState = PlayerAborted;
fireEvent(PlayerAborted);
// Wake up anyone waiting on play completion.
mWaitEvent.signal(0);
}
}
else
{
if (mCurrentElement >= (int)mPlayListDb->entries())
{
mbAutoAdvance = FALSE;
if (mAggregateState != PlayerStopped)
{
#ifdef MP_STREAM_DEBUG /* [ */
osPrintf("MpStreamPlaylistPlayer::handleStoppedState(%p): Changed from %s to PlayerStopped.\n",
this, getEventString(mAggregateState));
#endif /* ] */
mAggregateState = PlayerStopped;
fireEvent(PlayerStopped);
// Wake up anyone waiting on play completion.
mWaitEvent.signal(0);
}
}
}
}
// Sets the state for a specific entry.
void MpStreamPlaylistPlayer::setEntryState(PlayListEntry* e, PlayerState newState)
{
// OsSysLog::add(FAC_MP, PRI_DEBUG, "MpStreamPlaylistPlayer::setEntryState %p[%d] newState=%d", e, e?e->index:-1, newState);
if (e == NULL)
{
// Update any blocking calls
mSemStateChange.release();
return ;
}
PlayerState oldState = e->state;
if (oldState != newState)
{
#ifdef MP_STREAM_DEBUG /* [ */
osPrintf("MpStreamPlaylistPlayer::setEntryState(%p): Setting mPlayListDb[%d].state = %s\n",
this, e->index, getEventString(newState));
#endif /* MP_STREAM_DEBUG ] */
// Store the new state
e->state = newState;
// Updated aggregate state given the new entry state
switch (newState)
{
case PlayerUnrealized:
break;
case PlayerRealized:
handleRealizedState(oldState, newState);
break;
case PlayerPrefetched:
handlePrefetchedState(oldState, newState);
break;
case PlayerPlaying:
handlePlayingState(oldState, newState);
break;
case PlayerPaused:
handlePausedState(oldState, newState);
break;
case PlayerStopped:
case PlayerAborted:
handleStoppedState(oldState, newState);
break;
case PlayerDestroyed:
break;
case PlayerFailed:
handleFailedState(oldState, newState);
break;
}
// Update any blocking calls
mSemStateChange.release();
}
}
// Handles processing for the paused state
void MpStreamPlaylistPlayer::handlePausedState(PlayerState oldState, PlayerState newState)
{
if (mAggregateState != PlayerPaused)
{
#ifdef MP_STREAM_DEBUG /* [ */
osPrintf("MpStreamPlaylistPlayer::handlePausedState(%p): Changed from %s to PlayerPaused.\n",
this, getEventString(mAggregateState));
#endif /* ] */
mAggregateState = PlayerPaused;
fireEvent(PlayerPaused);
}
}
// Fires events to interested parties
void MpStreamFeeder::fireEvent(FeederEvent eventType)
{
OsLock lock(m_eventGuard) ;
#ifdef MP_STREAM_DEBUG /* [ */
osPrintf("MpStreamFeeder(%d): %s\n", m_iInstanceId, getEventString(eventType)) ;
#endif /* MP_STREAM_DEBUG ] */
if (m_pEventHandler != NULL)
{
m_pEventHandler->signal(eventType) ;
// Safe guard: once the destroyed event is signalled, the
// m_pEventHandler can be deleted.
if (eventType == FeederStreamDestroyedEvent)
{
m_pEventHandler = NULL ;
}
#ifdef MP_STREAM_DEBUG /* [ */
pthread_t taskId = -1 ;
OsTask *pTask = OsTask::getCurrentTask() ;
if (pTask != NULL)
{
pTask->id(taskId) ;
}
osPrintf("MpStreamFeeder(%d-%08X): signaled event: %s\n",
m_iInstanceId, taskId, getEventString(eventType)) ;
#endif /* MP_STREAM_DEBUG ] */
}
#ifdef MP_STREAM_DEBUG /* [ */
else
{
osPrintf("** WARNING: Null handler for event: %s\n", getEventString(eventType)) ;
}
#endif /* MP_STREAM_DEBUG ] */
}
static INT_PTR DbEventGetText(WPARAM wParam, LPARAM lParam)
{
DBEVENTGETTEXT* egt = (DBEVENTGETTEXT*)lParam;
if (egt == NULL)
return 0;
DBEVENTINFO *dbei = egt->dbei;
DBEVENTTYPEDESCR *et = (DBEVENTTYPEDESCR*)DbEventTypeGet((WPARAM)dbei->szModule, (LPARAM)dbei->eventType);
if (et && ServiceExists(et->textService))
return CallService(et->textService, wParam, lParam);
if (!dbei->pBlob)
return 0;
if (dbei->eventType == EVENTTYPE_AUTHREQUEST || dbei->eventType == EVENTTYPE_ADDED) {
// EVENTTYPE_AUTHREQUEST: uin(DWORD), hContact(DWORD), nick(ASCIIZ), first(ASCIIZ), last(ASCIIZ), email(ASCIIZ)
// EVENTTYPE_ADDED: uin(DWORD), hContact(HANDLE), nick(ASCIIZ), first(ASCIIZ), last(ASCIIZ), email(ASCIIZ)
DWORD uin = *(DWORD*)dbei->pBlob;
HANDLE hContact = (HANDLE)*(DWORD*)(dbei->pBlob + sizeof(DWORD));
char *buf = LPSTR(dbei->pBlob) + sizeof(DWORD)*2;
ptrT tszNick(getEventString(dbei, buf));
ptrT tszFirst(getEventString(dbei, buf));
ptrT tszLast(getEventString(dbei, buf));
ptrT tszEmail(getEventString(dbei, buf));
CMString nick, text;
if (tszFirst || tszLast) {
nick.AppendFormat(_T("%s %s"), tszFirst, tszLast);
nick.Trim();
}
if (tszEmail) {
if (!nick.IsEmpty())
nick.Append(_T(", "));
nick.Append(tszEmail);
}
if (uin != 0) {
if (!nick.IsEmpty())
nick.Append(_T(", "));
nick.AppendFormat(_T("%d"), uin);
}
if (!nick.IsEmpty())
nick = _T("(") + nick + _T(")");
if (dbei->eventType == EVENTTYPE_AUTHREQUEST) {
ptrT tszReason(getEventString(dbei, buf));
text.Format(TranslateT("Authorization request from %s%s: %s"),
(*tszNick == 0) ? cli.pfnGetContactDisplayName(hContact, 0) : tszNick, nick, tszReason);
}
else text.Format(TranslateT("You were added by %s%s"),
(*tszNick == 0) ? cli.pfnGetContactDisplayName(hContact, 0) : tszNick, nick);
return (egt->datatype == DBVT_WCHAR) ? (INT_PTR)mir_tstrdup(text) : (INT_PTR)mir_t2a(text);
}
if (dbei->eventType == EVENTTYPE_CONTACTS) {
CMString text(TranslateT("Contacts: "));
// blob is: [uin(ASCIIZ), nick(ASCIIZ)]*
char *buf = LPSTR(dbei->pBlob), *limit = LPSTR(dbei->pBlob) + dbei->cbBlob;
while (buf < limit) {
ptrT tszUin(getEventString(dbei, buf));
ptrT tszNick(getEventString(dbei, buf));
if (tszNick && *tszNick)
text.AppendFormat(_T("\"%s\" "), tszNick);
if (tszUin && *tszUin)
text.AppendFormat(_T("<%s>; "), tszUin);
}
return (egt->datatype == DBVT_WCHAR) ? (INT_PTR)mir_tstrdup(text) : (INT_PTR)mir_t2a(text);
}
if (dbei->eventType == EVENTTYPE_FILE) {
char *buf = LPSTR(dbei->pBlob) + sizeof(DWORD);
ptrT tszFileName(getEventString(dbei, buf));
ptrT tszDescription(getEventString(dbei, buf));
ptrT &ptszText = (lstrlen(tszDescription) == 0) ? tszFileName : tszDescription;
switch (egt->datatype) {
case DBVT_WCHAR:
return (INT_PTR)ptszText.detouch();
case DBVT_ASCIIZ:
return (INT_PTR)mir_t2a(ptszText);
}
return 0;
}
// by default treat an event's blob as a string
if (egt->datatype == DBVT_WCHAR) {
char *str = (char*)alloca(dbei->cbBlob + 1);
memcpy(str, dbei->pBlob, dbei->cbBlob);
str[dbei->cbBlob] = 0;
if (dbei->flags & DBEF_UTF) {
WCHAR *msg = NULL;
Utf8DecodeCP(str, egt->codepage, &msg);
if (msg)
return (INT_PTR)msg;
}
return (INT_PTR)mir_a2t_cp(str, egt->codepage);
}
if (egt->datatype == DBVT_ASCIIZ) {
char *msg = mir_strdup((char*)dbei->pBlob);
if (dbei->flags & DBEF_UTF)
Utf8DecodeCP(msg, egt->codepage, NULL);
return (INT_PTR)msg;
}
return 0;
}
void io_internal_event(ioreq_event *curr)
{
ASSERT(curr != NULL);
#ifdef DEBUG_IOSIM
fprintf(outputfile, "%f: io_internal_event, time %f, type %s (%d), ", simtime, curr->time, getEventString(curr->type), curr->type );
fprintf(outputfile, "busno %d, slotno %d, devno %d, blkno %lld, bcount %d, %s(%x)\n", curr->busno, curr->slotno, curr->devno, curr->blkno, curr->bcount, (curr->flags & 1) ? "read" : "write", curr->flags );
fflush(outputfile);
/*
fprintf (outputfile, "%f: io_internal_event entered with event type %d, %f\n", curr->time, curr->type, simtime);
*/
#endif
switch (curr->type) {
case IO_REQUEST_ARRIVE:
iodriver_request(0, curr);
break;
case IO_ACCESS_ARRIVE:
iodriver_schedule(0, curr);
break;
case IO_INTERRUPT_ARRIVE:
iodriver_interrupt_arrive(0, (intr_event *) curr);
break;
case IO_RESPOND_TO_DEVICE:
iodriver_respond_to_device(0, (intr_event *) curr->tempptr1);
addtoextraq((event *) curr);
break;
case IO_ACCESS_COMPLETE:
iodriver_access_complete(0, (intr_event *) curr->tempptr1);
addtoextraq((event *) curr);
break;
case IO_INTERRUPT_COMPLETE:
iodriver_interrupt_complete(0, (intr_event *) curr);
break;
case DEVICE_OVERHEAD_COMPLETE:
case DEVICE_ACCESS_COMPLETE:
case DEVICE_DATA_TRANSFER_COMPLETE:
case DEVICE_PREPARE_FOR_DATA_TRANSFER:
case DEVICE_BUFFER_SEEKDONE:
case DEVICE_BUFFER_TRACKACC_DONE:
case DEVICE_BUFFER_SECTOR_DONE:
case DEVICE_GOT_REMAPPED_SECTOR:
case DEVICE_GOTO_REMAPPED_SECTOR:
case MEMS_SLED_SCHEDULE:
case MEMS_SLED_SEEK:
case MEMS_SLED_SERVO:
case MEMS_SLED_DATA:
case MEMS_SLED_UPDATE:
case MEMS_BUS_INITIATE:
case MEMS_BUS_TRANSFER:
case MEMS_BUS_UPDATE:
case SSD_CLEAN_ELEMENT:
case SSD_CLEAN_GANG:
device_event_arrive(curr);
break;
case BUS_OWNERSHIP_GRANTED:
case BUS_DELAY_COMPLETE:
bus_event_arrive(curr);
break;
case CONTROLLER_DATA_TRANSFER_COMPLETE:
controller_event_arrive(curr->tempint2, curr);
break;
case TIMESTAMP_LOGORG:
logorg_timestamp(curr);
break;
case IO_TRACE_REQUEST_START:
iodriver_trace_request_start(0, curr);
break;
default:
fprintf(stderr, "Unknown event type passed to io_internal_events\n");
exit(1);
}
/*
fprintf (outputfile, "Leaving io_internal_event\n");
*/
}
