void
NavAI::Navigator()
{
accumulator.Clear();
magnitude = 0;
brakes = 0;
hold = false;
if (navpt) {
if (navpt->Status() == Instruction::COMPLETE && navpt->HoldTime() > 0) {
ship->SetDirectorInfo(Game::GetText("ai.auto-hold"));
hold = true;
}
else {
ship->SetDirectorInfo(Game::GetText("ai.auto-nav"));
}
}
else {
ship->SetDirectorInfo(Game::GetText("ai.auto-stop"));
}
Accumulate(AvoidTerrain());
Accumulate(AvoidCollision());
if (!hold)
accumulator = SeekTarget();
HelmControl();
ThrottleControl();
}
void
MediaOmxCommonDecoder::ResumeStateMachine()
{
MOZ_ASSERT(NS_IsMainThread());
ReentrantMonitorAutoEnter mon(GetReentrantMonitor());
DECODER_LOG(PR_LOG_DEBUG, ("%s current time %f", __PRETTY_FUNCTION__,
mCurrentTime));
if (!mDecoderStateMachine) {
return;
}
mFallbackToStateMachine = true;
mAudioOffloadPlayer = nullptr;
int64_t timeUsecs = 0;
SecondsToUsecs(mCurrentTime, timeUsecs);
mRequestedSeekTarget = SeekTarget(timeUsecs, SeekTarget::Accurate);
mNextState = mPlayState;
ChangeState(PLAY_STATE_LOADING);
// exit dormant state
RefPtr<nsRunnable> event =
NS_NewRunnableMethodWithArg<bool>(
mDecoderStateMachine,
&MediaDecoderStateMachine::SetDormant,
false);
mDecoderStateMachine->TaskQueue()->Dispatch(event);
}
void
StarshipAI::Navigator()
{
// signifies this ship is a dead hulk:
if (ship && ship->Design()->auto_roll < 0) {
ship->SetDirectorInfo(Game::GetText("ai.dead"));
return;
}
accumulator.Clear();
magnitude = 0;
hold = false;
if ((ship->GetElement() && ship->GetElement()->GetHoldTime() > 0) ||
(navpt && navpt->Status() == Instruction::COMPLETE && navpt->HoldTime() > 0))
hold = true;
ship->SetFLCSMode(Ship::FLCS_HELM);
if (!ship->GetDirectorInfo()) {
if (target)
ship->SetDirectorInfo(Game::GetText("ai.seek-target"));
else if (ship->GetWard())
ship->SetDirectorInfo(Game::GetText("ai.seek-ward"));
else
ship->SetDirectorInfo(Game::GetText("ai.patrol"));
}
if (farcaster && distance < 25e3) {
accumulator = SeekTarget();
}
else {
accumulator = AvoidCollision();
if (!other && !hold)
accumulator = SeekTarget();
}
HelmControl();
ThrottleControl();
FireControl();
AdjustDefenses();
}
void
SeekerAI::Navigator()
{
if (delay > 0) {
delay -= Game::FrameTime();
}
else {
Steer s = SeekTarget();
self->ApplyYaw((float) s.yaw);
self->ApplyPitch((float) s.pitch);
}
}
void
MediaOmxCommonDecoder::FirstFrameLoaded(nsAutoPtr<MediaInfo> aInfo,
MediaDecoderEventVisibility aEventVisibility)
{
MOZ_ASSERT(NS_IsMainThread());
if (mShuttingDown) {
return;
}
MediaDecoder::FirstFrameLoaded(aInfo, aEventVisibility);
if (!CheckDecoderCanOffloadAudio()) {
DECODER_LOG(LogLevel::Debug, ("In %s Offload Audio check failed",
__PRETTY_FUNCTION__));
DisableStateMachineAudioOffloading();
return;
}
#ifdef MOZ_AUDIO_OFFLOAD
mAudioOffloadPlayer = new AudioOffloadPlayer(this);
#endif
if (!mAudioOffloadPlayer) {
DisableStateMachineAudioOffloading();
return;
}
mAudioOffloadPlayer->SetSource(mReader->GetAudioOffloadTrack());
status_t err = mAudioOffloadPlayer->Start(false);
if (err != OK) {
mAudioOffloadPlayer = nullptr;
mFallbackToStateMachine = true;
DECODER_LOG(LogLevel::Debug, ("In %s Unable to start offload audio %d."
"Switching to normal mode", __PRETTY_FUNCTION__, err));
DisableStateMachineAudioOffloading();
return;
}
PauseStateMachine();
if (mLogicallySeeking) {
SeekTarget target = SeekTarget(mLogicalPosition,
SeekTarget::Accurate,
MediaDecoderEventVisibility::Observable);
mSeekRequest.DisconnectIfExists();
mSeekRequest.Begin(mAudioOffloadPlayer->Seek(target)
->Then(AbstractThread::MainThread(), __func__, static_cast<MediaDecoder*>(this),
&MediaDecoder::OnSeekResolved, &MediaDecoder::OnSeekRejected));
}
// Call ChangeState() to run AudioOffloadPlayer since offload state enabled
ChangeState(mPlayState);
}
RefPtr<ReaderProxy::AudioDataPromise>
ReaderProxy::OnAudioDataRequestFailed(const MediaResult& aError)
{
MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
if (mSeamlessLoopingBlocked || !mSeamlessLoopingEnabled ||
aError.Code() != NS_ERROR_DOM_MEDIA_END_OF_STREAM) {
return AudioDataPromise::CreateAndReject(aError, __func__);
}
// The data time in the audio queue is assumed to be increased linearly,
// so we need to add the last ending time as the offset to correct the
// audio data time in the next round when seamless looping is enabled.
mLoopingOffset = mLastAudioEndTime;
// Save the duration of the audio track if it hasn't been set.
if (!mAudioDuration.IsValid()) {
mAudioDuration = mLastAudioEndTime;
}
// For seamless looping, the demuxer is sought to the beginning and then
// keep requesting decoded data in advance, upon receiving EOS.
// The MDSM will not be aware of the EOS and keep receiving decoded data
// as usual while looping is on.
RefPtr<ReaderProxy> self = this;
RefPtr<MediaFormatReader> reader = mReader;
ResetDecode(TrackInfo::kAudioTrack);
return SeekInternal(SeekTarget(media::TimeUnit::Zero(), SeekTarget::Accurate))
->Then(mReader->OwnerThread(),
__func__,
[reader]() { return reader->RequestAudioData(); },
[](const SeekRejectValue& aReject) {
return AudioDataPromise::CreateAndReject(aReject.mError, __func__);
})
->Then(mOwnerThread,
__func__,
[self](RefPtr<AudioData> aAudio) {
return self->OnAudioDataRequestCompleted(aAudio.forget());
},
[](const MediaResult& aError) {
return AudioDataPromise::CreateAndReject(aError, __func__);
});
}
void MediaOmxDecoder::ResumeStateMachine()
{
MOZ_ASSERT(NS_IsMainThread());
ReentrantMonitorAutoEnter mon(GetReentrantMonitor());
DECODER_LOG(PR_LOG_DEBUG, ("%s current time %f", __PRETTY_FUNCTION__,
mCurrentTime));
if (!mDecoderStateMachine) {
return;
}
mFallbackToStateMachine = true;
mAudioOffloadPlayer = nullptr;
mRequestedSeekTarget = SeekTarget(mCurrentTime, SeekTarget::Accurate);
mNextState = mPlayState;
ChangeState(PLAY_STATE_LOADING);
mDecoderStateMachine->SetDormant(false);
}
void
MediaOmxCommonDecoder::ResumeStateMachine()
{
MOZ_ASSERT(NS_IsMainThread());
ReentrantMonitorAutoEnter mon(GetReentrantMonitor());
DECODER_LOG(PR_LOG_DEBUG, ("%s current time %f", __PRETTY_FUNCTION__, mLogicalPosition));
if (mShuttingDown) {
return;
}
if (!GetStateMachine()) {
return;
}
mFallbackToStateMachine = true;
mAudioOffloadPlayer = nullptr;
SeekTarget target = SeekTarget(mLogicalPosition,
SeekTarget::Accurate,
MediaDecoderEventVisibility::Suppressed);
// Call Seek of MediaDecoderStateMachine to suppress seek events.
RefPtr<nsRunnable> event =
NS_NewRunnableMethodWithArg<SeekTarget>(
GetStateMachine(),
&MediaDecoderStateMachine::Seek,
target);
GetStateMachine()->TaskQueue()->Dispatch(event.forget());
mNextState = mPlayState;
ChangeState(PLAY_STATE_LOADING);
// exit dormant state
event =
NS_NewRunnableMethodWithArg<bool>(
GetStateMachine(),
&MediaDecoderStateMachine::SetDormant,
false);
GetStateMachine()->TaskQueue()->Dispatch(event.forget());
UpdateLogicalPosition();
}
status_t AudioOffloadPlayer::Play()
{
MOZ_ASSERT(NS_IsMainThread());
if (mResetTimer) {
mResetTimer->Cancel();
mResetTimer = nullptr;
WakeLockRelease();
}
status_t err = OK;
if (!mStarted) {
// Last pause timed out and offloaded audio sink was reset. Start it again
err = Start(false);
if (err != OK) {
return err;
}
// Seek to last play position only when there was no seek during last pause
android::Mutex::Autolock autoLock(mLock);
if (!mSeekTarget.IsValid()) {
mSeekTarget = SeekTarget(mPositionTimeMediaUs,
SeekTarget::Accurate,
MediaDecoderEventVisibility::Suppressed);
DoSeek();
}
}
if (!mPlaying) {
CHECK(mAudioSink.get());
err = mAudioSink->Start();
if (err == OK) {
mPlaying = true;
}
}
return err;
}
