mediaplayer/media_node_framework/PlaybackManager.cpp

// PlaybackManager.cpp

#include <algorithm>
#include <stdio.h>

#include <Message.h>
#include <OS.h>
#include <Window.h>

#include "EventQueue.h"
#include "MessageEvent.h"
#include "PlaybackListener.h"

#include "PlaybackManager.h"

using namespace std;

//#define TRACE_NODE_MANAGER
#ifdef TRACE_NODE_MANAGER
# define TRACE(x...)	printf(x)
# define ERROR(x...)	fprintf(stderr, x)
#else
# define TRACE(x...)
# define ERROR(x...)	fprintf(stderr, x)
#endif

void
tdebug(const char* str)
{
	TRACE("[%lx, %lld] ", find_thread(NULL), system_time());
	TRACE(str);
}


struct PlaybackManager::PlayingState {
	int64		start_frame;
	int64		end_frame;
	int64		frame_count;
	int64		first_visible_frame;
	int64		last_visible_frame;
	int64		max_frame_count;
	int32		play_mode;
	int32		loop_mode;
	bool		looping_enabled;
	int64		current_frame;			// Playlist frame
	int64		range_index;			// playing range index of current_frame
	int64		activation_frame;		// absolute video frame
};


struct PlaybackManager::SpeedInfo {
	int64		activation_frame;		// absolute video frame
	bigtime_t	activation_time;		// performance time
	float		speed;					// speed to be used for calculations,
										// is 1.0 if not playing
	float		set_speed;				// speed set by the user
};


// #pragma mark - PlaybackManager


PlaybackManager::PlaybackManager()
	: BLooper("playback manager"),
	  fStates(10),
	  fSpeeds(10),
	  fCurrentAudioTime(0),
	  fCurrentVideoTime(0),
	  fPerformanceTime(0),
	  fFrameRate(1.0),
	  fStopPlayingFrame(-1),
	  fListeners(),
	  fNoAudio(false)
{
	Run();
}


PlaybackManager::~PlaybackManager()
{
	Cleanup();
}


void
PlaybackManager::Init(float frameRate, int32 loopingMode, bool loopingEnabled,
	float playbackSpeed, int32 playMode, int32 currentFrame)
{
	// cleanup first
	Cleanup();

	// set the new frame rate
	fFrameRate = frameRate;
	fCurrentAudioTime = 0;
	fCurrentVideoTime = 0;
	fPerformanceTime = 0;
	fStopPlayingFrame = -1;

	// set up the initial speed
	SpeedInfo* speed = new SpeedInfo;
	speed->activation_frame = 0;
	speed->activation_time = 0;
	speed->speed = playbackSpeed;
	speed->set_speed = playbackSpeed;
	_PushSpeedInfo(speed);

	// set up the initial state
	PlayingState* state = new PlayingState;
	state->frame_count = Duration();
	state->start_frame = 0;
	state->end_frame = 0;
	state->first_visible_frame = 0;
	state->last_visible_frame = 0;
	state->max_frame_count = state->frame_count;

	state->play_mode = MODE_PLAYING_PAUSED_FORWARD;
	state->loop_mode = loopingMode;
	state->looping_enabled = loopingEnabled;
	state->current_frame = currentFrame;
	state->activation_frame = 0;
	fStates.AddItem(state);

	TRACE("initial state pushed: state count: %ld\n", fStates.CountItems());

	// notify the listeners
	NotifyPlayModeChanged(PlayMode());
	NotifyLoopModeChanged(LoopMode());
	NotifyLoopingEnabledChanged(IsLoopingEnabled());
	NotifyVideoBoundsChanged(VideoBounds());
	NotifyFPSChanged(FramesPerSecond());
	NotifySpeedChanged(Speed());
	NotifyCurrentFrameChanged(CurrentFrame());
	SetPlayMode(playMode);
}


void
PlaybackManager::Cleanup()
{
	// delete states
	for (int32 i = 0; PlayingState* state = _StateAt(i); i++)
		delete state;
	fStates.MakeEmpty();

	// delete speed infos
	for (int32 i = 0; SpeedInfo* speed = _SpeedInfoAt(i); i++)
		delete speed;
	fSpeeds.MakeEmpty();
}


void
PlaybackManager::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case MSG_EVENT:
			SetPerformanceTime(TimeForRealTime(system_time()));
//TRACE("MSG_EVENT: rt: %lld, pt: %lld\n", system_time(), fPerformanceTime);
			break;

		case MSG_PLAYBACK_FORCE_UPDATE:
		{
			int64 frame;
			if (message->FindInt64("frame", &frame) < B_OK)
				frame = CurrentFrame();
			SetCurrentFrame(frame);
			break;
		}

		case MSG_PLAYBACK_SET_RANGE:
		{
			int64 startFrame = _LastState()->start_frame;
			int64 endFrame = _LastState()->end_frame;
			message->FindInt64("start frame", &startFrame);
			message->FindInt64("end frame", &endFrame);
			if (startFrame != _LastState()->start_frame
				|| endFrame != _LastState()->end_frame) {
				PlayingState* state = new PlayingState(*_LastState());
				state->start_frame = startFrame;
				state->end_frame = endFrame;
				_PushState(state, true);
			}
			break;
		}

		case MSG_PLAYBACK_SET_VISIBLE:
		{
			int64 startFrame = _LastState()->first_visible_frame;
			int64 endFrame = _LastState()->last_visible_frame;
			message->FindInt64("start frame", &startFrame);
			message->FindInt64("end frame", &endFrame);
			if (startFrame != _LastState()->first_visible_frame
				|| endFrame != _LastState()->last_visible_frame) {
				PlayingState* state = new PlayingState(*_LastState());
				state->first_visible_frame = startFrame;
				state->last_visible_frame = endFrame;
				_PushState(state, true);
			}
			break;
		}

		case MSG_PLAYBACK_SET_LOOP_MODE:
		{
			int32 loopMode = _LastState()->loop_mode;
			message->FindInt32("mode", &loopMode);
			if (loopMode != _LastState()->loop_mode) {
				PlayingState* state = new PlayingState(*_LastState());
				state->loop_mode = loopMode;
				_PushState(state, true);
			}
			break;
		}

		// other messages
		default:
			BLooper::MessageReceived(message);
			break;
	}
}

// #pragma mark - playback control


void
PlaybackManager::StartPlaying(bool atBeginning)
{
	TRACE("PlaybackManager::StartPlaying()\n");
	int32 playMode = PlayMode();
	if (playMode == MODE_PLAYING_PAUSED_FORWARD)
		SetPlayMode(MODE_PLAYING_FORWARD, !atBeginning);
	if (playMode == MODE_PLAYING_PAUSED_BACKWARD)
		SetPlayMode(MODE_PLAYING_BACKWARD, !atBeginning);
}


void
PlaybackManager::StopPlaying()
{
	TRACE("PlaybackManager::StopPlaying()\n");
	int32 playMode = PlayMode();
	if (playMode == MODE_PLAYING_FORWARD)
		SetPlayMode(MODE_PLAYING_PAUSED_FORWARD, true);
	if (playMode == MODE_PLAYING_BACKWARD)
		SetPlayMode(MODE_PLAYING_PAUSED_BACKWARD, true);
}


void
PlaybackManager::TogglePlaying(bool atBeginning)
{
	// playmodes (paused <-> playing) are the negative of each other
	SetPlayMode(-PlayMode(), !atBeginning);
}


void
PlaybackManager::PausePlaying()
{
	if (PlayMode() > 0)
		TogglePlaying();
}


bool
PlaybackManager::IsPlaying() const
{
	return (PlayMode() > 0);
}


int32
PlaybackManager::PlayMode() const
{
	if (!_LastState())
		return MODE_PLAYING_PAUSED_FORWARD;
	return _LastState()->play_mode;
}


int32
PlaybackManager::LoopMode() const
{
	if (!_LastState())
		return LOOPING_ALL;
	return _LastState()->loop_mode;
}


bool
PlaybackManager::IsLoopingEnabled() const
{
	if (!_LastState())
		return true;
	return _LastState()->looping_enabled;
}


int32
PlaybackManager::CurrentFrame() const
{
	return PlaylistFrameAtFrame(FrameForTime(fPerformanceTime));
}


float
PlaybackManager::Speed() const
{
	if (!_LastState())
		return 1.0;
	return _LastSpeedInfo()->set_speed;
}


void
PlaybackManager::SetFramesPerSecond(float framesPerSecond)
{
	if (framesPerSecond != fFrameRate) {
		fFrameRate = framesPerSecond;
		NotifyFPSChanged(fFrameRate);
	}
}


float
PlaybackManager::FramesPerSecond() const
{
	return fFrameRate;
}


void
PlaybackManager::FrameDropped() const
{
	NotifyFrameDropped();
}


void
PlaybackManager::DurationChanged()
{
	if (!_LastState())
		return;
	int32 frameCount = Duration();
	if (frameCount != _LastState()->frame_count) {
		PlayingState* state = new PlayingState(*_LastState());
		state->frame_count = frameCount;
		state->max_frame_count = frameCount;

		_PushState(state, true);
	}
}

/*! Creates a new playing state that equals the previous one aside from
	its current frame which is set to /frame/.
	The new state will be activated as soon as possible. */
void
PlaybackManager::SetCurrentFrame(int64 frame)
{
	if (_LastState()->current_frame == frame)
		return;
	PlayingState* newState = new PlayingState(*_LastState());
	newState->current_frame = frame;
	_PushState(newState, false);
}


/*!	Creates a new playing state that equals the previous one aside from
	its playing mode which is set to /mode/.
	The new state will be activated as soon as possible.
	If /continuePlaying/ is true and the new state is a `not stopped'
	state, playing continues at the frame the last state reaches when the
	new state becomes active (or the next frame in the playing range).
	If /continuePlaying/ is false, playing starts at the beginning of the
	playing range (taking the playing direction into consideration). */
void
PlaybackManager::SetPlayMode(int32 mode, bool continuePlaying)
{
//printf("PlaybackManager::SetPlayMode(%ld, %d)\n", mode, continuePlaying);
	PlayingState* newState = new PlayingState(*_LastState());
	newState->play_mode = mode;
	// Jump to the playing start frame if we should not continue, where we
	// stop.
	if (!continuePlaying && !(_PlayingDirectionFor(newState) == 0))
		newState->current_frame = _PlayingStartFrameFor(newState);
	_PushState(newState, continuePlaying);
	NotifyPlayModeChanged(mode);
}


/*!	Creates a new playing state that equals the previous one aside from
	its loop mode which is set to /mode/.
	The new state will be activated as soon as possible.
	If /continuePlaying/ is true and the new state is a `not stopped'
	state, playing continues at the frame the last state reaches when the
	new state becomes active (or the next frame in the playing range).
	If /continuePlaying/ is false, playing starts at the beginning of the
	playing range (taking the playing direction into consideration). */
void
PlaybackManager::SetLoopMode(int32 mode, bool continuePlaying)
{
	PlayingState* newState = new PlayingState(*_LastState());
	newState->loop_mode = mode;
	// Jump to the playing start frame if we should not continue, where we
	// stop.
	if (!continuePlaying && !(_PlayingDirectionFor(newState) == 0))
		newState->current_frame = _PlayingStartFrameFor(newState);
	_PushState(newState, continuePlaying);
	NotifyLoopModeChanged(mode);
}


/*	Creates a new playing state that equals the previous one aside from
	its looping enabled flag which is set to /enabled/.
	The new state will be activated as soon as possible.
	If /continuePlaying/ is true and the new state is a `not stopped'
	state, playing continues at the frame the last state reaches when the
	new state becomes active (or the next frame in the playing range).
	If /continuePlaying/ is false, playing starts at the beginning of the
	playing range (taking the playing direction into consideration). */
void
PlaybackManager::SetLoopingEnabled(bool enabled, bool continuePlaying)
{
	PlayingState* newState = new PlayingState(*_LastState());
	newState->looping_enabled = enabled;
	// Jump to the playing start frame if we should not continue, where we
	// stop.
	if (!continuePlaying && !(_PlayingDirectionFor(newState) == 0))
		newState->current_frame = _PlayingStartFrameFor(newState);
	_PushState(newState, continuePlaying);
	NotifyLoopingEnabledChanged(enabled);
}


void
PlaybackManager::SetSpeed(float speed)
{
	SpeedInfo* lastSpeed = _LastSpeedInfo();
	if (speed != lastSpeed->set_speed) {
		SpeedInfo* info = new SpeedInfo(*lastSpeed);
		info->activation_frame = NextFrame();
		info->set_speed = speed;
		if (_PlayingDirectionFor(_StateAtFrame(info->activation_frame)) != 0)
			info->speed = info->set_speed;
		else
			info->speed = 1.0;
		_PushSpeedInfo(info);
	}
}


// #pragma mark -


/*!	Returns the first frame at which a new playing state could become active,
	that is the first frame for that neither the audio nor the video producer
	have fetched data.*/
int64
PlaybackManager::NextFrame() const
{
	if (fNoAudio)
		return FrameForTime(fCurrentVideoTime - 1) + 1;

	return FrameForTime(max((bigtime_t)fCurrentAudioTime,
		(bigtime_t)fCurrentVideoTime) - 1) + 1;
}


//! Returns the Playlist frame for NextFrame().
int64
PlaybackManager::NextPlaylistFrame() const
{
	return PlaylistFrameAtFrame(NextFrame());
}


int64
PlaybackManager::FirstPlaybackRangeFrame()
{
	PlayingState* state = _StateAtFrame(CurrentFrame());
	switch (state->loop_mode) {
		case LOOPING_RANGE:
			return state->start_frame;
		case LOOPING_SELECTION:
			// TODO: ...
			return 0;
		case LOOPING_VISIBLE:
			return state->first_visible_frame;

		case LOOPING_ALL:
		default:
			return 0;
	}
}


int64
PlaybackManager::LastPlaybackRangeFrame()
{
	PlayingState* state = _StateAtFrame(CurrentFrame());
	switch (state->loop_mode) {
		case LOOPING_RANGE:
			return state->end_frame;
		case LOOPING_SELECTION:
			// TODO: ...
			return state->frame_count - 1;
		case LOOPING_VISIBLE:
			return state->last_visible_frame;

		case LOOPING_ALL:
		default:
			return state->frame_count - 1;
	}
}


// #pragma mark -


int64
PlaybackManager::StartFrameAtFrame(int64 frame)
{
	return _StateAtFrame(frame)->start_frame;
}


int64
PlaybackManager::StartFrameAtTime(bigtime_t time)
{
	return _StateAtTime(time)->start_frame;
}


int64
PlaybackManager::EndFrameAtFrame(int64 frame)
{
	return _StateAtTime(frame)->end_frame;
}


int64
PlaybackManager::EndFrameAtTime(bigtime_t time)
{
	return _StateAtTime(time)->end_frame;
}


int64
PlaybackManager::FrameCountAtFrame(int64 frame)
{
	return _StateAtTime(frame)->frame_count;
}


int64
PlaybackManager::FrameCountAtTime(bigtime_t time)
{
	return _StateAtTime(time)->frame_count;
}


int32
PlaybackManager::PlayModeAtFrame(int64 frame)
{
	return _StateAtTime(frame)->play_mode;
}


int32
PlaybackManager::PlayModeAtTime(bigtime_t time)
{
	return _StateAtTime(time)->play_mode;
}


int32
PlaybackManager::LoopModeAtFrame(int64 frame)
{
	return _StateAtTime(frame)->loop_mode;
}


int32
PlaybackManager::LoopModeAtTime(bigtime_t time)
{
	return _StateAtTime(time)->loop_mode;
}


/*!	Returns which Playlist frame should be displayed at (performance) video
	frame /frame/. Additionally the playing direction (0, 1, -1) is returned,
	as well as if a new playing state becomes active with this frame.
	A new playing state is installed, if either some data directly concerning
	the playing (play mode, loop mode, playing ranges, selection...) or the
	Playlist has changed. */
int64
PlaybackManager::PlaylistFrameAtFrame(int64 frame, int32& playingDirection,
	bool& newState) const
{
//TRACE("PlaybackManager::PlaylistFrameAtFrame(%lld)\n", frame);
	PlayingState* state = _StateAtFrame(frame);
	newState = (state->activation_frame == frame);
	playingDirection = _PlayingDirectionFor(state);
//TRACE("playing state: activation frame: %lld, current frame: %lld, dir: %ld\n",
//state->activation_frame, state->current_frame, state->play_mode);
	// The first part of the index calculation is invariable for a state. We
	// could add it to the state data.
	int64 result = state->current_frame;
	if (playingDirection != 0) {
//		int64 index = _RangeFrameForFrame(state, state->current_frame)
		int64 index = state->range_index
			+ (frame - state->activation_frame) * playingDirection;
		result = _FrameForRangeFrame(state, index);
	}
//TRACE("PlaybackManager::PlaylistFrameAtFrame() done: %lld\n", result);
//printf("PlaybackManager::PlaylistFrameAtFrame(%lld): %lld, direction: %ld\n",
//	frame, result, playingDirection);
	return result;
}


int64
PlaybackManager::PlaylistFrameAtFrame(int64 frame, int32& playingDirection) const
{
	bool newState;
	return PlaylistFrameAtFrame(frame, playingDirection, newState);
}


int64
PlaybackManager::PlaylistFrameAtFrame(int64 frame) const
{
	bool newState;
	int32 playingDirection;
	return PlaylistFrameAtFrame(frame, playingDirection, newState);
}


/*!	Returns the index of the next frame after /startFrame/ at which a
	playing state or speed change occurs or /endFrame/, if this happens to be
	earlier. */
int64
PlaybackManager::NextChangeFrame(int64 startFrame, int64 endFrame) const
{
	int32 startIndex = _IndexForFrame(startFrame);
	int32 endIndex = _IndexForFrame(endFrame);
	if (startIndex < endIndex)
		endFrame = _StateAt(startIndex + 1)->activation_frame;
	startIndex = _SpeedInfoIndexForFrame(startFrame);
	endIndex = _SpeedInfoIndexForFrame(endFrame);
	if (startIndex < endIndex)
		endFrame = _SpeedInfoAt(startIndex + 1)->activation_frame;
	return endFrame;
}


/*!	Returns the next time after /startTime/ at which a playing state or
	speed change occurs or /endTime/, if this happens to be earlier. */
bigtime_t
PlaybackManager::NextChangeTime(bigtime_t startTime, bigtime_t endTime) const
{
	int32 startIndex = _IndexForTime(startTime);
	int32 endIndex = _IndexForTime(endTime);
	if (startIndex < endIndex)
		endTime = TimeForFrame(_StateAt(startIndex + 1)->activation_frame);
	startIndex = _SpeedInfoIndexForTime(startTime);
	endIndex = _SpeedInfoIndexForTime(endTime);
	if (startIndex < endIndex)
		endTime = TimeForFrame(_SpeedInfoAt(startIndex + 1)->activation_frame);
	return endTime;
}


/*!	Returns a contiguous Playlist frame interval for a given frame interval.
	The returned interval may be smaller than the supplied one. Therefore
	the supplied /endFrame/ is adjusted.
	The value written to /xEndFrame/ is the first frame that doesn't belong
	to the interval. /playingDirection/ may either be -1 for backward,
	1 for forward or 0 for not playing. */
void
PlaybackManager::GetPlaylistFrameInterval(int64 startFrame, int64& endFrame,
	int64& xStartFrame, int64& xEndFrame, int32& playingDirection) const
{
	// limit the interval to one state and speed info
	endFrame = NextChangeFrame(startFrame, endFrame);
	// init return values
	xStartFrame = PlaylistFrameAtFrame(startFrame);
	xEndFrame = xStartFrame;
	playingDirection = _PlayingDirectionFor(_StateAtFrame(startFrame));
	// Step through the interval and check whether the respective Playlist
	// frames belong to the Playlist interval.
	bool endOfInterval = false;
	int64 intervalLength = 0;
	while (startFrame < endFrame && !endOfInterval) {
		intervalLength++;
		startFrame++;
		xEndFrame += playingDirection;
		endOfInterval = (PlaylistFrameAtFrame(startFrame) != xEndFrame);
	}
	// order the interval bounds, if playing backwards
	if (xStartFrame > xEndFrame) {
		swap(xStartFrame, xEndFrame);
		xStartFrame++;
		xEndFrame++;
	}
}


/*!	The same as GetPlaylistFrameInterval() just for time instead of frame
	intervals. Note, that /startTime/ and /endTime/ measure
	performance times whereas /xStartTime/ and /xEndTime/ specifies an
	Playlist time interval. In general it does not hold
	xEndTime - xStartTime == endTime - startTime, even if playing (think
	of a playing speed != 1.0). */
void
PlaybackManager::GetPlaylistTimeInterval(bigtime_t startTime,
	bigtime_t& endTime, bigtime_t& xStartTime, bigtime_t& xEndTime,
	float& playingSpeed) const
{
	// Get the frames that bound the given time interval. The end frame might
	// be greater than necessary, but that doesn't harm.
	int64 startFrame = FrameForTime(startTime);
	int64 endFrame = FrameForTime(endTime) + 1;
	SpeedInfo* info = _SpeedInfoForFrame(startFrame);
	// Get the Playlist frame interval that belongs to the frame interval.
	int64 xStartFrame;
	int64 xEndFrame;
	int32 playingDirection;
	GetPlaylistFrameInterval(startFrame, endFrame, xStartFrame, xEndFrame,
		playingDirection);
	// Calculate the performance time interval end/length.
	bigtime_t endTimeForFrame = TimeForFrame(endFrame);
	endTime = min(endTime, endTimeForFrame);
	bigtime_t intervalLength = endTime - startTime;

	// Finally determine the time bounds for the Playlist interval (depending
	// on the playing direction).
	switch (playingDirection) {
		// forward
		case 1:
		{
//			xStartTime = PlaylistTimeForFrame(xStartFrame)
//						 + startTime - TimeForFrame(startFrame);
//			xEndTime = xStartTime + intervalLength;

// TODO: The current method does not handle the times the same way.
//       It may happen, that for the same performance time different
//       Playlist times (within a frame) are returned when passing it
//       one time as a start time and another time as an end time.
			xStartTime = PlaylistTimeForFrame(xStartFrame)
				+ bigtime_t(double(startTime - TimeForFrame(startFrame))
							* info->speed);
			xEndTime = xStartTime
					   + bigtime_t((double)intervalLength * info->speed);
			break;
		}
		// backward
		case -1:
		{
//			xEndTime = PlaylistTimeForFrame(xEndFrame)
//					   - startTime + TimeForFrame(startFrame);
//			xStartTime = xEndTime - intervalLength;

			xEndTime = PlaylistTimeForFrame(xEndFrame)
				- bigtime_t(double(startTime - TimeForFrame(startFrame))
							* info->speed);
			xStartTime = xEndTime
					   - bigtime_t((double)intervalLength * info->speed);
			break;
		}
		// not playing
		case 0:
		default:
			xStartTime = PlaylistTimeForFrame(xStartFrame);
			xEndTime = xStartTime;
			break;
	}
	playingSpeed = (float)playingDirection * info->speed;
}


/*!	Returns the frame that is being performed at the supplied time.
	It holds TimeForFrame(frame) <= time < TimeForFrame(frame + 1). */
int64
PlaybackManager::FrameForTime(bigtime_t time) const
{
//TRACE("PlaybackManager::FrameForTime(%lld)\n", time);
//	return (int64)((double)time * (double)fFrameRate / 1000000.0);
	// In order to avoid problems caused by rounding errors, we check
	// if for the resulting frame holds
	// TimeForFrame(frame) <= time < TimeForFrame(frame + 1).
//	int64 frame = (int64)((double)time * (double)fFrameRate / 1000000.0);
	SpeedInfo* info = _SpeedInfoForTime(time);
if (!info) {
	fprintf(stderr, "PlaybackManager::FrameForTime() - no SpeedInfo!\n");
	return 0;
}
	int64 frame = (int64)(((double)time - info->activation_time)
		* (double)fFrameRate * info->speed / 1000000.0)
		+ info->activation_frame;
	if (TimeForFrame(frame) > time)
		frame--;
	else if (TimeForFrame(frame + 1) <= time)
		frame++;
//TRACE("PlaybackManager::FrameForTime() done: %lld\n", frame);
//printf("PlaybackManager::FrameForTime(%lld): %lld\n", time, frame);
	return frame;
}


/*!	Returns the time at which the supplied frame should be performed (started
	to be performed). */
bigtime_t
PlaybackManager::TimeForFrame(int64 frame) const
{
//	return (bigtime_t)((double)frame * 1000000.0 / (double)fFrameRate);
	SpeedInfo* info = _SpeedInfoForFrame(frame);
if (!info) {
	fprintf(stderr, "PlaybackManager::TimeForFrame() - no SpeedInfo!\n");
	return 0;
}
//	return (bigtime_t)((double)(frame - info->activation_frame) * 1000000.0
//					   / ((double)fFrameRate * info->speed))
// 		   + info->activation_time;
bigtime_t result = (bigtime_t)((double)(frame - info->activation_frame) * 1000000.0
/ ((double)fFrameRate * info->speed)) + info->activation_time;
//fprintf(stderr, "PlaybackManager::TimeForFrame(%lld): %lld\n", frame, result);
return result;
}


/*!	Returns the Playlist frame for an Playlist time.
	It holds PlaylistTimeForFrame(frame) <= time <
	PlaylistTimeForFrame(frame + 1). */
int64
PlaybackManager::PlaylistFrameForTime(bigtime_t time) const
{
	// In order to avoid problems caused by rounding errors, we check
	// if for the resulting frame holds
	// PlaylistTimeForFrame(frame) <= time < PlaylistTimeForFrame(frame + 1).
	int64 frame = (int64)((double)time * (double)fFrameRate / 1000000.0);
	if (TimeForFrame(frame) > time)
		frame--;
	else if (TimeForFrame(frame + 1) <= time)
		frame++;
	return frame;
}


//! Returns the Playlist start time for an Playlist frame.
bigtime_t
PlaybackManager::PlaylistTimeForFrame(int64 frame) const
{
	return (bigtime_t)((double)frame * 1000000.0 / (double)fFrameRate);
}


//! To be called when done with all activities concerning audio before /time/.
void
PlaybackManager::SetCurrentAudioTime(bigtime_t time)
{
TRACE("PlaybackManager::SetCurrentAudioTime(%lld)\n", time);
	bigtime_t lastFrameTime = _TimeForLastFrame();
	fCurrentAudioTime = time;
//	_UpdateStates();
	bigtime_t newLastFrameTime = _TimeForLastFrame();
	if (lastFrameTime != newLastFrameTime) {
		bigtime_t eventTime = RealTimeForTime(newLastFrameTime);
		EventQueue::Default().AddEvent(new MessageEvent(eventTime, this));
		_CheckStopPlaying();
	}
}


//! To be called when done with all activities concerning video before /frame/.
void
PlaybackManager::SetCurrentVideoFrame(int64 frame)
{
	SetCurrentVideoTime(TimeForFrame(frame));
}


//! To be called when done with all activities concerning video before /time/.
void
PlaybackManager::SetCurrentVideoTime(bigtime_t time)
{
TRACE("PlaybackManager::SetCurrentVideoTime(%lld)\n", time);
	bigtime_t lastFrameTime = _TimeForLastFrame();
	fCurrentVideoTime = time;
//	_UpdateStates();
	bigtime_t newLastFrameTime = _TimeForLastFrame();
	if (lastFrameTime != newLastFrameTime) {
		bigtime_t eventTime = RealTimeForTime(newLastFrameTime);
		EventQueue::Default().AddEvent(new MessageEvent(eventTime, this));
		_CheckStopPlaying();
	}
}


//! To be called as soon as video frame /frame/ is being performed.
void
PlaybackManager::SetPerformanceFrame(int64 frame)
{
	SetPerformanceFrame(TimeForFrame(frame));
}


/*!	Similar to SetPerformanceTime() just with a time instead of a frame
	argument. */
void
PlaybackManager::SetPerformanceTime(bigtime_t time)
{
	int32 oldCurrentFrame = CurrentFrame();
	fPerformanceTime = time;
	_UpdateStates();
	_UpdateSpeedInfos();
	int32 currentFrame = CurrentFrame();

//printf("PlaybackManager::SetPerformanceTime(%lld): %ld -> %ld\n",
//	time, oldCurrentFrame, currentFrame);

	if (currentFrame != oldCurrentFrame)
		NotifyCurrentFrameChanged(currentFrame);
}


// #pragma mark - Listeners


void
PlaybackManager::AddListener(PlaybackListener* listener)
{
	if (!listener)
		return;

	if (!Lock())
		return;

	if (!fListeners.HasItem(listener) && fListeners.AddItem(listener)) {
		// bring listener up2date, if we have been initialized
		if (_LastState()) {
			listener->PlayModeChanged(PlayMode());
			listener->LoopModeChanged(LoopMode());
			listener->LoopingEnabledChanged(IsLoopingEnabled());
			listener->VideoBoundsChanged(VideoBounds());
			listener->FramesPerSecondChanged(FramesPerSecond());
			listener->SpeedChanged(Speed());
			listener->CurrentFrameChanged(CurrentFrame());
		}
	}

	Unlock();
}


void
PlaybackManager::RemoveListener(PlaybackListener* listener)
{
	if (listener && Lock()) {
		fListeners.RemoveItem(listener);
		Unlock();
	}
}


void
PlaybackManager::NotifyPlayModeChanged(int32 mode) const
{
	for (int32 i = 0;
		 PlaybackListener* listener = (PlaybackListener*)fListeners.ItemAt(i);
		 i++) {
		listener->PlayModeChanged(mode);
	}
}


void
PlaybackManager::NotifyLoopModeChanged(int32 mode) const
{
	for (int32 i = 0;
		 PlaybackListener* listener = (PlaybackListener*)fListeners.ItemAt(i);
		 i++) {
		listener->LoopModeChanged(mode);
	}
}


void
PlaybackManager::NotifyLoopingEnabledChanged(bool enabled) const
{
	for (int32 i = 0;
		 PlaybackListener* listener = (PlaybackListener*)fListeners.ItemAt(i);
		 i++) {
		listener->LoopingEnabledChanged(enabled);
	}
}


void
PlaybackManager::NotifyVideoBoundsChanged(BRect bounds) const
{
	for (int32 i = 0;
		 PlaybackListener* listener = (PlaybackListener*)fListeners.ItemAt(i);
		 i++) {
		listener->VideoBoundsChanged(bounds);
	}
}


void
PlaybackManager::NotifyFPSChanged(float fps) const
{
	for (int32 i = 0;
		 PlaybackListener* listener = (PlaybackListener*)fListeners.ItemAt(i);
		 i++) {
		listener->FramesPerSecondChanged(fps);
	}
}


void
PlaybackManager::NotifyCurrentFrameChanged(int32 frame) const
{
	for (int32 i = 0;
		 PlaybackListener* listener = (PlaybackListener*)fListeners.ItemAt(i);
		 i++) {
		listener->CurrentFrameChanged(frame);
	}
}


void
PlaybackManager::NotifySpeedChanged(float speed) const
{
	for (int32 i = 0;
		 PlaybackListener* listener = (PlaybackListener*)fListeners.ItemAt(i);
		 i++) {
		listener->SpeedChanged(speed);
	}
}


void
PlaybackManager::NotifyFrameDropped() const
{
	for (int32 i = 0;
		 PlaybackListener* listener = (PlaybackListener*)fListeners.ItemAt(i);
		 i++) {
		listener->FrameDropped();
	}
}


void
PlaybackManager::NotifyStopFrameReached() const
{
	// not currently implemented in PlaybackListener interface
}


void
PlaybackManager::PrintState(PlayingState* state)
{
	TRACE("state: activation frame: %lld, current frame: %lld, "
		   "start frame: %lld, end frame: %lld, frame count: %lld, "
		   "first visible: %lld, last visible: %lld, selection (...), "
		   "play mode: %ld, loop mode: %ld\n",
			state->activation_frame,
			state->current_frame,
			state->start_frame,
			state->end_frame,
			state->frame_count,
			state->first_visible_frame,
			state->last_visible_frame,
//			state->selection,
			state->play_mode,
			state->loop_mode);
}


void
PlaybackManager::PrintStateAtFrame(int64 frame)
{
	TRACE("frame %lld: ", frame);
	PrintState(_StateAtFrame(frame));
}


/*!	Appends the supplied state to the list of states. If the state would
	become active at the same time as _LastState() the latter is removed
	and deleted. However, the activation time for the new state is adjusted,
	so that it is >= that of the last state and >= the current audio and
	video time. If the additional parameter /adjustCurrentFrame/ is true,
	the new state's current frame is tried to be set to the frame that is
	reached at the time the state will become active. In every case
	it is ensured that the current frame lies within the playing range
	(if playing). */
void
PlaybackManager::_PushState(PlayingState* state, bool adjustCurrentFrame)
{
//	if (!_LastState())
//		debugger("PlaybackManager::_PushState() used before Init()\n");

TRACE("PlaybackManager::_PushState()\n");
	if (state) {
		// unset fStopPlayingFrame
		int64 oldStopPlayingFrame = fStopPlayingFrame;
		fStopPlayingFrame = -1;
		// get last state
		PlayingState* lastState = _LastState();
		int64 activationFrame = max(max(state->activation_frame,
										lastState->activation_frame),
									NextFrame());
TRACE("  state activation frame: %lld, last state activation frame: %lld, "
"NextFrame(): %lld\n", state->activation_frame, lastState->activation_frame,
NextFrame());

		int64 currentFrame = 0;
		// remember the current frame, if necessary
		if (adjustCurrentFrame)
			currentFrame = PlaylistFrameAtFrame(activationFrame);
		// check whether it is active
		// (NOTE: We may want to keep the last state, if it is not active,
		//  but then the new state should become active after the last one.
		//  Thus we had to replace `NextFrame()' with `activationFrame'.)
		if (lastState->activation_frame >= NextFrame()) {
			// it isn't -- remove it
			fStates.RemoveItem(fStates.CountItems() - 1);
TRACE("deleting last \n");
PrintState(lastState);
			delete lastState;
		} else {
			// it is -- keep it
		}
		// adjust the new state's current frame and activation frame
		if (adjustCurrentFrame)
			state->current_frame = currentFrame;
		int32 playingDirection = _PlayingDirectionFor(state);
		if (playingDirection != 0) {
			state->current_frame
				= _NextFrameInRange(state, state->current_frame);
		} else {
			// If not playing, we check at least, if the current frame lies
			// within the interval [0, max_frame_count).
			if (state->current_frame >= state->max_frame_count)
				state->current_frame = state->max_frame_count - 1;
			if (state->current_frame < 0)
				state->current_frame = 0;
		}
		state->range_index = _RangeFrameForFrame(state, state->current_frame);
		state->activation_frame = activationFrame;
		fStates.AddItem(state);
PrintState(state);
TRACE("_PushState: state count: %ld\n", fStates.CountItems());
		// push a new speed info
		SpeedInfo* speedInfo = new SpeedInfo(*_LastSpeedInfo());
		if (playingDirection == 0)
			speedInfo->speed = 1.0;
		else
			speedInfo->speed = speedInfo->set_speed;
		speedInfo->activation_frame = state->activation_frame;
		_PushSpeedInfo(speedInfo);
		// If the new state is a playing state and looping is turned off,
		// determine when playing shall stop.
		if (playingDirection != 0 && !state->looping_enabled) {
			int64 startFrame, endFrame, frameCount;
			_GetPlayingBoundsFor(state, startFrame, endFrame, frameCount);
			if (playingDirection == -1)
				swap(startFrame, endFrame);
			// If we shall stop at the frame we start, set the current frame
			// to the beginning of the range.
			// We have to take care, since this state may equal the one
			// before (or probably differs in just one (unimportant)
			// parameter). This happens for instance, if the user changes the
			// data or start/end frame... while playing. In this case setting
			// the current frame to the start frame is unwanted. Therefore
			// we check whether the previous state was intended to stop
			// at the activation frame of this state.
			if (oldStopPlayingFrame != state->activation_frame
				&& state->current_frame == endFrame && frameCount > 1) {
				state->current_frame = startFrame;
				state->range_index
					= _RangeFrameForFrame(state, state->current_frame);
			}
			if (playingDirection == 1) {	// forward
				fStopPlayingFrame = state->activation_frame
									+ frameCount - state->range_index - 1;
			} else {						// backwards
				fStopPlayingFrame = state->activation_frame
									+ state->range_index;
			}
			_CheckStopPlaying();
		}
	}
TRACE("PlaybackManager::_PushState() done\n");
}


/*!	Removes and deletes all states that are obsolete, that is which stopped
	being active at or before the current audio and video time. */
void
PlaybackManager::_UpdateStates()
{
//	int32 firstActive = min(_IndexForTime(fCurrentAudioTime),
//							_IndexForTime(fCurrentVideoTime));
	// Performance time should always be the least one.
	int32 firstActive = _IndexForTime(fPerformanceTime);
//TRACE("firstActive: %ld, numStates: %ld\n", firstActive, fStates.CountItems());
	for (int32 i = 0; i < firstActive; i++)
		delete _StateAt(i);
	if (firstActive > 0)
{
		fStates.RemoveItems(0, firstActive);
TRACE("_UpdateStates: states removed: %ld, state count: %ld\n",
firstActive, fStates.CountItems());
}
}


/*!	Returns the index of the state, that is active at frame /frame/.
	The index of the first frame (0) is returned, if /frame/ is even less
	than the frame at which this state becomes active. */
int32
PlaybackManager::_IndexForFrame(int64 frame) const
{
	int32 index = 0;
	PlayingState* state;
	while (((state = _StateAt(index + 1))) && state->activation_frame <= frame)
		index++;
	return index;
}

/*!	Returns the index of the state, that is active at time /time/.
	The index of the first frame (0) is returned, if /time/ is even less
	than the time at which this state becomes active. */
int32
PlaybackManager::_IndexForTime(bigtime_t time) const
{
	return _IndexForFrame(FrameForTime(time));
}


//! Returns the state that reflects the most recent changes.
PlaybackManager::PlayingState*
PlaybackManager::_LastState() const
{
	return _StateAt(fStates.CountItems() - 1);
}


PlaybackManager::PlayingState*
PlaybackManager::_StateAt(int32 index) const
{
	return (PlayingState*)fStates.ItemAt(index);
}


PlaybackManager::PlayingState*
PlaybackManager::_StateAtFrame(int64 frame) const
{
	return _StateAt(_IndexForFrame(frame));
}


PlaybackManager::PlayingState*
PlaybackManager::_StateAtTime(bigtime_t time) const
{
	return _StateAt(_IndexForTime(time));
}


int32
PlaybackManager::_PlayingDirectionFor(int32 playingMode)
{
	int32 direction = 0;
	switch (playingMode) {
		case MODE_PLAYING_FORWARD:
			direction = 1;
			break;
		case MODE_PLAYING_BACKWARD:
			direction = -1;
			break;
		case MODE_PLAYING_PAUSED_FORWARD:
		case MODE_PLAYING_PAUSED_BACKWARD:
			break;
	}
	return direction;
}


int32
PlaybackManager::_PlayingDirectionFor(PlayingState* state)
{
	return _PlayingDirectionFor(state->play_mode);
}


/*!	Returns the Playlist frame range that bounds the playing range of a given
	state.
	\a startFrame is the lower and \a endFrame the upper bound of the range,
	and \a frameCount the number of frames in the range; it is guaranteed to
	be >= 1, even for an empty selection. */
void
PlaybackManager::_GetPlayingBoundsFor(PlayingState* state, int64& startFrame,
	int64& endFrame, int64& frameCount)
{
	switch (state->loop_mode) {
		case LOOPING_ALL:
			startFrame = 0;
			endFrame = max(startFrame, state->frame_count - 1);
			frameCount = endFrame - startFrame + 1;
			break;
		case LOOPING_RANGE:
			startFrame = state->start_frame;
			endFrame = state->end_frame;
			frameCount = endFrame - startFrame + 1;
			break;
//		case LOOPING_SELECTION:
//			if (!state->selection.IsEmpty()) {
//				startFrame = state->selection.FirstIndex();
//				endFrame = state->selection.LastIndex();
//				frameCount = state->selection.CountIndices();
//TRACE("  LOOPING_SELECTION: %lld - %lld (%lld)\n", startFrame, endFrame,
//frameCount);
//			} else {
//				startFrame = state->current_frame;
//				endFrame = state->current_frame;
//				frameCount = 1;
//			}
//			break;
		case LOOPING_VISIBLE:
			startFrame = state->first_visible_frame;
			endFrame = state->last_visible_frame;
			frameCount = endFrame - startFrame + 1;
			break;
	}
}


/*!	Returns the frame at which playing would start for a given playing
	state. If the playing mode for the supplied state specifies a stopped
	or undefined mode, the result is the state's current frame. */
int64
PlaybackManager::_PlayingStartFrameFor(PlayingState* state)
{
	int64 startFrame, endFrame, frameCount, frame = 0;
	_GetPlayingBoundsFor(state, startFrame, endFrame, frameCount);
	switch (_PlayingDirectionFor(state)) {
		case -1:
			frame = endFrame;
			break;
		case 1:
			frame = startFrame;
			break;
		default:
			frame = state->current_frame;
			break;
	}
	return frame;
}


/*!	Returns the frame at which playing would end for a given playing
	state. If the playing mode for the supplied state specifies a stopped
	or undefined mode, the result is the state's current frame. */
int64
PlaybackManager::_PlayingEndFrameFor(PlayingState* state)
{
	int64 startFrame, endFrame, frameCount, frame = 0;
	_GetPlayingBoundsFor(state, startFrame, endFrame, frameCount);
	switch (_PlayingDirectionFor(state)) {
		case -1:
			frame = startFrame;
			break;
		case 1:
			frame = endFrame;
			break;
		default:
			frame = state->current_frame;
			break;
	}
	return frame;
}


/*!	Returns the index that the supplied frame has within a playing range.
	If the state specifies a not-playing mode, 0 is returned. The supplied
	frame has to lie within the bounds of the playing range, but it doesn't
	need to be contained, e.g. if the range is not contiguous. In this case
	the index of the next frame within the range (in playing direction) is
	returned. */
int64
PlaybackManager::_RangeFrameForFrame(PlayingState* state, int64 frame)
{
TRACE("PlaybackManager::_RangeFrameForFrame(%lld)\n", frame);
	int64 startFrame, endFrame, frameCount;
	int64 index = 0;
	_GetPlayingBoundsFor(state, startFrame, endFrame, frameCount);
TRACE("  start frame: %lld, end frame: %lld, frame count: %lld\n",
startFrame, endFrame, frameCount);
	switch (state->loop_mode) {
		case LOOPING_ALL:
		case LOOPING_RANGE:
		case LOOPING_VISIBLE:
			index = frame - startFrame;
			break;
	}
TRACE("PlaybackManager::_RangeFrameForFrame() done: %lld\n", index);
	return index;
}


/*!	Returns the Playlist frame for a playing range index. /index/ doesn't need
	to be in the playing range -- it is mapped into. */
int64
PlaybackManager::_FrameForRangeFrame(PlayingState* state, int64 index)
{
TRACE("PlaybackManager::_FrameForRangeFrame(%lld)\n", index);
	int64 startFrame, endFrame, frameCount;
	_GetPlayingBoundsFor(state, startFrame, endFrame, frameCount);
TRACE("  frame range: %lld - %lld, count: %lld\n", startFrame, endFrame,
frameCount);
	// map the index into the index interval of the playing range
	if (frameCount > 1)
		index = (index % frameCount + frameCount) % frameCount;

	// get the frame for the index
	int32 frame = startFrame;
	switch (state->loop_mode) {
		case LOOPING_ALL:
		case LOOPING_RANGE:
		case LOOPING_VISIBLE:
			frame = startFrame + index;
			break;
	}
TRACE("PlaybackManager::_FrameForRangeFrame() done: %ld\n", frame);
	return frame;
}


/*!	Given an arbitrary Playlist frame this function returns the next frame within
	the playing range for the supplied playing state. */
int64
PlaybackManager::_NextFrameInRange(PlayingState* state, int64 frame)
{
	int64 newFrame = frame;
	int64 startFrame, endFrame, frameCount;
	_GetPlayingBoundsFor(state, startFrame, endFrame, frameCount);
	if (frame < startFrame || frame > endFrame)
		newFrame = _PlayingStartFrameFor(state);
	else {
		int64 index = _RangeFrameForFrame(state, frame);
		newFrame = _FrameForRangeFrame(state, index);
		if (newFrame > frame && _PlayingDirectionFor(state) == -1)
			newFrame = _FrameForRangeFrame(state, index - 1);
	}
	return newFrame;
}


void
PlaybackManager::_PushSpeedInfo(SpeedInfo* info)
{
	if (info) {
		// check the last state
		if (SpeedInfo* lastSpeed = _LastSpeedInfo()) {
			// set the activation time
			info->activation_time = TimeForFrame(info->activation_frame);
			// Remove the last state, if it won't be activated.
			if (lastSpeed->activation_frame == info->activation_frame) {
//fprintf(stderr, "  replacing last speed info\n");
				fSpeeds.RemoveItem(lastSpeed);
				delete lastSpeed;
			}
		}
		fSpeeds.AddItem(info);
//fprintf(stderr, "  speed info pushed: activation frame: %lld, "
//"activation time: %lld, speed: %f\n", info->activation_frame,
//info->activation_time, info->speed);
		// ...
	}
}


PlaybackManager::SpeedInfo*
PlaybackManager::_LastSpeedInfo() const
{
	return (SpeedInfo*)fSpeeds.ItemAt(fSpeeds.CountItems() - 1);
}


PlaybackManager::SpeedInfo*
PlaybackManager::_SpeedInfoAt(int32 index) const
{
	return (SpeedInfo*)fSpeeds.ItemAt(index);
}


int32
PlaybackManager::_SpeedInfoIndexForFrame(int64 frame) const
{
	int32 index = 0;
	SpeedInfo* info;
	while (((info = _SpeedInfoAt(index + 1)))
		   && info->activation_frame <= frame) {
		index++;
	}
//fprintf(stderr, "PlaybackManager::_SpeedInfoIndexForFrame(%lld): %ld\n",
//frame, index);
	return index;
}


int32
PlaybackManager::_SpeedInfoIndexForTime(bigtime_t time) const
{
	int32 index = 0;
	SpeedInfo* info;
	while (((info = _SpeedInfoAt(index + 1)))
		   && info->activation_time <= time) {
		index++;
	}
//fprintf(stderr, "PlaybackManager::_SpeedInfoIndexForTime(%lld): %ld\n",
//time, index);
	return index;
}


PlaybackManager::SpeedInfo*
PlaybackManager::_SpeedInfoForFrame(int64 frame) const
{
	return _SpeedInfoAt(_SpeedInfoIndexForFrame(frame));
}


PlaybackManager::SpeedInfo*
PlaybackManager::_SpeedInfoForTime(bigtime_t time) const
{
	return _SpeedInfoAt(_SpeedInfoIndexForTime(time));
}


void
PlaybackManager::_UpdateSpeedInfos()
{
	int32 firstActive = _SpeedInfoIndexForTime(fPerformanceTime);
	for (int32 i = 0; i < firstActive; i++)
		delete _SpeedInfoAt(i);
	if (firstActive > 0)
		fSpeeds.RemoveItems(0, firstActive);
//fprintf(stderr, "  speed infos 0 - %ld removed\n", firstActive);
}


/*!	Returns the end time for the last video frame that the video and the
	audio producer both have completely processed. */
bigtime_t
PlaybackManager::_TimeForLastFrame() const
{
	if (fNoAudio)
		return TimeForFrame(FrameForTime(fCurrentVideoTime));

	return TimeForFrame(FrameForTime(min((bigtime_t)fCurrentAudioTime,
										 (bigtime_t)fCurrentVideoTime)));
}


/*!	Returns the start time for the first video frame for which
	neither the video nor the audio producer have fetched data. */
bigtime_t
PlaybackManager::_TimeForNextFrame() const
{
	return TimeForFrame(NextFrame());
}


void
PlaybackManager::_CheckStopPlaying()
{
//printf("_CheckStopPlaying() - %lld, next: %lld\n", fStopPlayingFrame, NextFrame());
	if (fStopPlayingFrame > 0 && fStopPlayingFrame <= NextFrame()) {
		StopPlaying();
		NotifyStopFrameReached();
	}
}