// 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"); */ }