/*
* @(#)BasicPlayer.java 1.81 02/08/21
*
* Copyright (c) 1996-2002 Sun Microsystems, Inc. All rights reserved.
*/
package com.sun.media;
import java.security.*;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
import java.io.*;
import java.net.URL;
import java.awt.*;
import java.awt.image.*;
import java.util.*;
import javax.media.*;
import javax.media.format.*;
import javax.media.protocol.*;
import javax.media.control.BufferControl;
import com.sun.media.util.*;
import com.sun.media.controls.*;
import com.sun.media.ui.*;
import com.ms.security.PermissionID;
import com.ms.security.PolicyEngine;
/**
* BasicPlayer implements the bases of a javax.media.Player. It handles
* all the Player state transitions, event handling and management of
* any Controller under its control.
*/
public abstract class BasicPlayer extends BasicController
implements Player, ControllerListener, DownloadProgressListener {
static public String VERSION = JMFI18N.getResource("mediaplayer.version");
// private MediaSource source = null;
protected javax.media.protocol.DataSource source = null;
protected Vector controllerList = new Vector();
private Vector optionalControllerList = new Vector();
private Vector removedControllerList = new Vector();
private Vector currentControllerList = new Vector();
private Vector potentialEventsList = null;
private Vector receivedEventList = new Vector();
private boolean receivedAllEvents = false;
private Vector configureEventList = new Vector();
private Vector realizeEventList = new Vector();
private Vector prefetchEventList = new Vector();
private Vector stopEventList = new Vector();
private ControllerEvent CachingControlEvent = null;
private Controller restartFrom = null;
private Vector eomEventsReceivedFrom = new Vector();
private Vector stopAtTimeReceivedFrom = new Vector();
private PlayThread playThread = null;
private StatsThread statsThread = null;
private Time duration = DURATION_UNKNOWN;
private Time startTime, mediaTimeAtStart;
private boolean aboutToRestart = false;
private boolean closing = false;
private boolean prefetchFailed = false;
protected boolean framePositioning = true;
protected Control [] controls = null;
protected Component controlComp = null;
// Information controls
public SliderRegionControl regionControl = null;
protected CachingControl cachingControl = null;
protected ExtendedCachingControl extendedCachingControl = null;
protected BufferControl bufferControl = null;
private Object startSync = new Object();
private Object mediaTimeSync = new Object();
private static JMFSecurity jmfSecurity = null;
private static boolean securityPrivelege=false;
private Method m[] = new Method[1];
private Class cl[] = new Class[1];
private Object args[][] = new Object[1][0];
static {
try {
jmfSecurity = JMFSecurityManager.getJMFSecurity();
securityPrivelege = true;
} catch (SecurityException e) {
}
}
public BasicPlayer() {
configureEventList.addElement("javax.media.ConfigureCompleteEvent");
configureEventList.addElement("javax.media.ResourceUnavailableEvent");
realizeEventList.addElement("javax.media.RealizeCompleteEvent");
realizeEventList.addElement("javax.media.ResourceUnavailableEvent");
prefetchEventList.addElement("javax.media.PrefetchCompleteEvent");
prefetchEventList.addElement("javax.media.ResourceUnavailableEvent");
stopEventList.addElement("javax.media.StopEvent");
stopEventList.addElement("javax.media.StopByRequestEvent");
stopEventList.addElement("javax.media.StopAtTimeEvent");
stopThreadEnabled = false;
}
/**
* Will return true if the player can do frame
* positioning. Hack for now, should be removed when players
* actually implement the framePositioning control.
*/
public boolean isFramePositionable(){
return framePositioning;
}
/**
* A player is not configurable.
*/
protected boolean isConfigurable() {
return false;
}
/**
* Set the DataSource that provides the media for this player.
* BasicPlayer only supports PullDataSource by default. Subclasses
* can override this method to support other DataSources.
*
* @param source of media for this player.
* @exception IOException thrown when an i/o error occurs
* in reading information from the data source.
* @exception IncompatibleSourceException thrown if the Player
* can't use this source.
*/
public void setSource(javax.media.protocol.DataSource source)
throws IOException, IncompatibleSourceException {
this.source = source;
try {
cachingControl = (CachingControl) source.getControl("javax.media.CachingControl");
if ( (cachingControl != null) &&
(cachingControl instanceof ExtendedCachingControl) ) {
extendedCachingControl = (ExtendedCachingControl) cachingControl;
if (extendedCachingControl != null) {
// update progress every 100 kilobytes
regionControl = new SliderRegionControlAdapter();
extendedCachingControl.addDownloadProgressListener(this, 100);
}
}
} catch (ClassCastException e) {
}
}
public void downloadUpdate() {
if (extendedCachingControl == null)
return;
// It will be nice if we can avoid the cast to BasicController
sendEvent(new CachingControlEvent(this, cachingControl,
cachingControl.getContentProgress()));
if ( regionControl == null )
return;
long contentLength = cachingControl.getContentLength();
int maxValuePercent;
if ( (contentLength == javax.media.protocol.SourceStream.LENGTH_UNKNOWN) ||
(contentLength <= 0) ) {
maxValuePercent = 0;
} else {
long endOffset = extendedCachingControl.getEndOffset();
maxValuePercent = (int) ((100.0 * endOffset) / contentLength);
if (maxValuePercent < 0)
maxValuePercent = 0;
else if (maxValuePercent > 100)
maxValuePercent = 100;
}
regionControl.setMinValue(0);
regionControl.setMaxValue(maxValuePercent);
}
public MediaLocator getMediaLocator() {
if (source != null)
return source.getLocator();
return null;
}
public String getContentType() {
if (source != null)
return source.getContentType();
return null;
}
/**
* Get the DataSource used by this player.
* @return the DataSource used by this player.
*/
protected javax.media.protocol.DataSource getSource() {
return source;
}
/**
* This is called when close() is invoked on the Player. close() takes
* care of the general behavior before invoking doClose(). Subclasses
* should implement this only if it needs to do something specific to
* close the player.
*/
protected void doClose() {
synchronized (this) {
closing = true;
notifyAll();
}
if (getState() == Controller.Started) {
// Stop everything first.
stop(LOCAL_STOP);
}
// Ask all its controllers to close themselves.
if (controllerList != null) {
Controller c;
while (!controllerList.isEmpty()) {
c = (Controller)controllerList.firstElement();
c.close();
controllerList.removeElement(c);
}
}
// Close the ui components.
if (controlComp != null)
((DefaultControlPanel)controlComp).dispose();
controlComp = null;
if (statsThread != null)
statsThread.kill();
sendEvent(new ControllerClosedEvent(this));
}
/**
* Assigns a timebase for the player.
* If the BasicPlayer plays back audio, the timebase can be none
* other than the master timebase as returned by getMasterTimeBase().
* This is to ensure that we won't set to a timebase the audio
* cannot handle at this point.
* If the playback is video only, the timebase can be set to any
* timebase desired.
* @param tb time base to be used by the Player.
* @exception IncompatibleTimeBaseException thrown when a time base other
* than the master time base is set when audio is enabled.
*/
public void setTimeBase(TimeBase tb) throws IncompatibleTimeBaseException{
TimeBase oldTimeBase = getMasterTimeBase();
if (tb == null)
tb = oldTimeBase;
Controller c = null;
int i;
if (controllerList != null) {
try {
i = controllerList.size();
while (--i >= 0) {
c = (Controller)controllerList.elementAt(i);
c.setTimeBase(tb);
}
} catch (IncompatibleTimeBaseException e) {
// SetTimeBase had failed on one Controller. Some
// controllers may have already assigned the new timeBase
// We'll need to reverse that now.
Controller cx;
i = controllerList.size();
while (--i >= 0) {
cx = (Controller)controllerList.elementAt(i);
if (cx == c)
break;
cx.setTimeBase(oldTimeBase);
}
Log.dumpStack(e);
throw e;
}
}
super.setTimeBase(tb);
}
/**
* Set the upper bound of the media time.
* @param duration the duration in nanoseconds.
*/
protected void setMediaLength(long t) {
duration = new Time(t);
super.setMediaLength(t);
}
long lastTime = 0;
/**
* Get the duration of the movie.
* @return the duration of the movie.
*/
public Time getDuration() {
long t;
if ((t = getMediaNanoseconds()) > lastTime) {
lastTime = t;
updateDuration();
}
return duration;
}
protected synchronized void updateDuration() {
Time oldDuration = duration;
duration = DURATION_UNKNOWN;
for (int i = 0; i < controllerList.size(); i++) {
Controller c = (Controller) controllerList.elementAt(i);
Time dur = c.getDuration();
if ( dur.equals(DURATION_UNKNOWN) ) {
if (! (c instanceof BasicController)) {
duration = DURATION_UNKNOWN;
break;
}
} else if (dur.equals(DURATION_UNBOUNDED)) {
duration = DURATION_UNBOUNDED;
break;
} else {
if (duration.equals(DURATION_UNKNOWN))
duration = dur;
else if (duration.getNanoseconds() < dur.getNanoseconds())
duration = dur;
}
}
if (duration.getNanoseconds() != oldDuration.getNanoseconds()) {
setMediaLength(duration.getNanoseconds());
sendEvent( new DurationUpdateEvent(this, duration) );
}
}
public Time getStartLatency() {
super.getStartLatency();
Time latency;
long t = 0;
// Find the longest start latency from all the slave Controllers.
for (int i = 0; i < controllerList.size(); i++) {
Controller c = (Controller) controllerList.elementAt(i);
latency = c.getStartLatency();
if (latency == LATENCY_UNKNOWN)
continue;
if (latency.getNanoseconds() > t)
t = latency.getNanoseconds();
}
if (t == 0)
return LATENCY_UNKNOWN;
return new Time(t);
}
/**
* Stop because stop time has been reached.
* Subclasses should override this method.
*/
protected void stopAtTime() {
// We'll overwrite the parent method which stops the controller.
// For the player, we don't have to do anything in particular
// since the controllers are supposed to stop themselves.
}
/**
* This is for subclass to access Controller's implementation of stopAtTime.
*/
protected void controllerStopAtTime() {
super.stopAtTime();
}
public void setStopTime(Time t) {
if (state < Realized) {
throwError(new NotRealizedError("Cannot set stop time on an unrealized controller."));
}
if (getClock().getStopTime() == null ||
getClock().getStopTime().getNanoseconds() != t.getNanoseconds()) {
sendEvent(new StopTimeChangeEvent(this, t));
}
doSetStopTime(t);
}
private void doSetStopTime(Time t) {
getClock().setStopTime(t);
Vector list = controllerList;
int i = list.size();
while (--i >= 0) {
Controller c = (Controller)controllerList.elementAt(i);
c.setStopTime(t);
}
}
/**
* This is for subclass to access Controller's implementation of setStopTime.
*/
protected void controllerSetStopTime(Time t) {
super.setStopTime(t);
}
/**
* Loops through the list of controllers maintained by this
* player and invoke setMediaTime on each of them.
* This is a "final" method and cannot be overridden by subclasses.
* @param now the target media time.
**/
public final void setMediaTime(Time now) {
if (state < Realized)
throwError(new NotRealizedError(MediaTimeError));
// Set Media time from EOM and user click on the slider is
// trampling on one another. Causing the player to hang
// this mediaTimeSync will guard against that.
synchronized (mediaTimeSync) {
if (syncStartInProgress())
return;
if (getState() == Controller.Started) {
aboutToRestart = true;
stop(RESTARTING);
}
// If source is Positionable, we'll take care of this
// at the top level.
if (source instanceof Positionable)
now = ((Positionable)source).setPosition(now, Positionable.RoundDown);
super.setMediaTime(now);
int i = controllerList.size();
while (--i >= 0) {
((Controller)controllerList.elementAt(i)).setMediaTime(now);
}
// For subclasses to add in their own behavior.
doSetMediaTime(now);
if (aboutToRestart) {
syncStart(getTimeBase().getTime());
aboutToRestart = false;
}
}
}
/**
* Return true if the player is about to restart again.
*/
public boolean isAboutToRestart() {
return aboutToRestart;
}
/**
* Called from setMediaTime.
* This is used for subclasses to add in their own behavior.
* @param now the target media time.
*/
protected void doSetMediaTime(Time now) {
}
/**
* Get the Component this player will output its visual media to. If
* this player has no visual component (e.g. audio only)
* getVisualComponent() will return null.
* Subclasses should override this method and return the visual
* component but call this method first to ensure that the restrictions
* on player methods are enforced.
* @return the media display component.
*/
public Component getVisualComponent() {
int state = getState();
if (state < Realized) {
throwError(new NotRealizedError("Cannot get visual component on an unrealized player"));
}
return null;
}
/**
* Get the Component with the default user interface for controlling
* this player.
* If this player has no default control panel null is
* returned.
* Subclasses should override this method and return the control panel
* component but call this method first to ensure that the restrictions
* on player methods are enforced.
* @return the default control panel GUI.
*/
public Component getControlPanelComponent() {
int state = getState();
if (state < Realized) {
throwError(new NotRealizedError("Cannot get control panel component on an unrealized player"));
}
if (controlComp == null) {
controlComp = new DefaultControlPanel( this );
}
return controlComp;
}
/**
* Get the object for controlling audio gain. Return null
* if this player does not have a GainControl (e.g. no audio).
*
* @return the GainControl object for this player.
*/
public GainControl getGainControl() {
int state = getState();
if (state < Realized) {
throwError(new NotRealizedError("Cannot get gain control on an unrealized player"));
} else {
return (GainControl)getControl("javax.media.GainControl");
}
return null;
}
/**
* Return the list of controls from its slave controllers plus the
* ones that this player supports.
* @return the list of controls supported by this player.
*/
public Control [] getControls() {
if (controls != null)
return controls;
// build the list of controls. It is the total of all the
// controls from each controllers plus the ones that are maintained
// by the player itself (e.g. playbackControl).
Vector cv = new Vector();
if (cachingControl != null)
cv.addElement(cachingControl);
if (bufferControl != null)
cv.addElement(bufferControl);
Control c;
Object cs[];
Controller ctrller;
int i, size = controllerList.size();
for (i = 0; i < size; i++) {
ctrller = (Controller)controllerList.elementAt(i);
cs = ctrller.getControls();
if (cs == null) continue;
for (int j = 0; j < cs.length; j++) {
cv.addElement(cs[j]);
}
}
Control ctrls[];
size = cv.size();
ctrls = new Control[size];
for (i = 0; i < size; i++) {
ctrls[i] = (Control)cv.elementAt(i);
}
// If the player has already been realized, we'll save what
// we've collected this time. Then next time, we won't need
// to go through this expensive search again.
if (getState() >= Realized)
controls = ctrls;
return ctrls;
}
/**
* This get called when some Controller notifies this player of
* any event.
*/
final public void controllerUpdate(ControllerEvent evt) {
processEvent(evt);
}
/**
* Return the list of BasicControllers supported by this Player.
* @return a vector of the BasicControllers supported by this Player.
*/
public final Vector getControllerList() {
return controllerList;
}
private Vector getPotentialEventsList() {
return potentialEventsList;
}
/**
* Resets the list of received events
*/
private void resetReceivedEventList() {
if (receivedEventList != null)
receivedEventList.removeAllElements();
}
/**
* Return the list of received events
*/
private Vector getReceivedEventsList() {
return receivedEventList;
}
/**
* Updates the list of received events. Sources are stored.
*/
private void updateReceivedEventsList(ControllerEvent event) {
if (receivedEventList != null) {
Controller source = event.getSourceController();
if (receivedEventList.contains(source)) {
// System.out.println("DUPLICATE " + event +
// " received from: " + source);
return;
}
receivedEventList.addElement(source);
}
}
/**
* Start the Player as soon as possible.
* Start attempts to transition the player into the
* started state.
* If the player has not been realized, or prefetched,
* then the equivalent of those actions will occur,
* and the appropriate events will be generated.
* If the implied realize or prefetch fail, a failure
* event will be generated and the Player will remain in
* one of the non-started states.<p>
* This is a "final" method. Subclasses should override doStart() to
* implement its own specific behavior.
*/
public final void start() {
synchronized (startSync) {
if (restartFrom != null) {
return;
}
if (getState() == Started) {
sendEvent(new StartEvent(this, Started, Started,
Started, mediaTimeAtStart, startTime));
return; // ignored according to jmf spec.
}
if ( (playThread == null) || (! playThread.isAlive()) ) {
setTargetState(Started);
if ( /*securityPrivelege && */ (jmfSecurity != null) ) {
String permission = null;
try {
if (jmfSecurity.getName().startsWith("jmf-security")) {
permission = "thread";
jmfSecurity.requestPermission(m, cl, args, JMFSecurity.THREAD);
m[0].invoke(cl[0], args[0]);
permission = "thread group";
jmfSecurity.requestPermission(m, cl, args, JMFSecurity.THREAD_GROUP);
m[0].invoke(cl[0], args[0]);
} else if (jmfSecurity.getName().startsWith("internet")) {
PolicyEngine.checkPermission(PermissionID.THREAD);
PolicyEngine.assertPermission(PermissionID.THREAD);
}
} catch (Throwable e) {
if (JMFSecurityManager.DEBUG) {
System.err.println("Unable to get " + permission +
" privilege " + e);
}
securityPrivelege = false;
// TODO: Do the right thing if permissions cannot be obtained.
// User should be notified via an event
}
}
if ( (jmfSecurity != null) && (jmfSecurity.getName().startsWith("jdk12"))) {
try {
Constructor cons = CreateWorkThreadAction.cons;
playThread = (PlayThread) jdk12.doPrivM.invoke(
jdk12.ac,
new Object[] {
cons.newInstance(
new Object[] {
PlayThread.class,
BasicPlayer.class,
this
})});
playThread.start();
} catch (Exception e) {
}
} else {
playThread = new PlayThread(this);
playThread.start();
}
} else {
// $$$$
// System.out.print("WARNING: playThread is alive. start ignored"); // $$$
// System.out.println(": MP State: " + getState());
}
} // startSync
}
/**
* Start at the given time base time.
* This overrides Clock.syncStart() and obeys all its semantics.<p>
* This is a "final" method. Subclasses should override doStart() to
* implement its own specific behavior.
* @param tbt the time base time to start the player.
*/
public final void syncStart(Time tbt) {
/**
* To guard against conflict with setMediaTime.
*/
synchronized (mediaTimeSync) {
if (syncStartInProgress())
return;
int state = getState();
if (state == Started) {
throwError(new ClockStartedError("syncStart() cannot be used on an already started player"));
}
if (state != Prefetched) {
throwError(new NotPrefetchedError("Cannot start player before it has been prefetched"));
}
// Clear the EOM and StopAtTime lists.
eomEventsReceivedFrom.removeAllElements();
stopAtTimeReceivedFrom.removeAllElements();
setTargetState(Started);
int i = controllerList.size();
// The start(tbt) will throw a NotPrefetchedError if
// a controller is not in Prefetched state
while (--i >= 0) {
if (getTargetState() == Started) { // ADDED
((Controller)controllerList.elementAt(i)).syncStart(tbt);
}
}
if (getTargetState() == Started) { // ADDED
// If control comes here, the controllers
// are in Started state.
startTime = tbt;
mediaTimeAtStart = getMediaTime();
super.syncStart(tbt); // To start the clock and set the state to Started
}
}
}
/**
* Invoked by start() or syncstart().
* Called from a separate thread called TimedStart thread.
* subclasses can override this method to implement its specific behavior.
*/
protected void doStart() {
}
/**
* This method gets run in a separate thread called PlayThread
*/
final synchronized void play() {
boolean status;
// If a deallocate() happens before this thread gets to run.
// or if a stop() happens before this thread gets to run.
if (getTargetState() != Started) {
return;
}
prefetchFailed = false;
// The following completed checks should be looked at seriously.
// It should be something like (state < Prefetched) etc.
// It's too late for 2.1.1 release. We'll leave it this way. --ivg
int state = getState();
if ( (state == Unrealized) || (state == Configured) || (state == Realized) ) {
prefetch();
}
while (!closing && !prefetchFailed &&
(getState() == Configuring || getState() == Realizing ||
getState() == Realized || getState() == Prefetching)) {
try {
wait();
} catch (InterruptedException e) {
}
}
if ( getState() != Started &&
getTargetState() == Started && getState() == Prefetched ) {
syncStart(getTimeBase().getTime());
}
}
/**
* The stop() method calls doStop() so that subclasses can
* add additional behavior.
*/
protected void doStop() {
}
/**
* Stop the player.
* If current state is Started, sends stop() to all the
* managed controllers, and waits for a StopEvent from
* all of them. It then sends a StopEvent to any listener(s).
*/
public final /*synchronized*/ void stop() {
stop(STOP_BY_REQUEST);
}
static final int LOCAL_STOP = 0;
static final int STOP_BY_REQUEST = 1;
static final int RESTARTING = 2;
private /*synchronized*/ void stop(int stopType) {
int state;
switch (state = getState()) {
case Unrealized:
case Realized:
case Prefetched:
setTargetState(state);
break;
case Realizing:
setTargetState(Realized);
break;
case Prefetching:
case Started:
setTargetState(Prefetched);
break;
}
if (getState() != Started) {
switch (stopType) {
case STOP_BY_REQUEST:
sendEvent( new StopByRequestEvent(this, getState(),
getState(),
getTargetState(),
getMediaTime()));
break;
case RESTARTING:
sendEvent( new RestartingEvent(this, getState(),
getState(),
Started,
getMediaTime()));
break;
default:
sendEvent( new StopEvent(this, getState(),
getState(),
getTargetState(),
getMediaTime()));
break;
}
} else if (getState() == Started) {
synchronized(this) {
// List of potential events for stop()
potentialEventsList = stopEventList;
// Reset list of received events
resetReceivedEventList();
receivedAllEvents = false;
currentControllerList.removeAllElements();
int i = controllerList.size();
while (--i >= 0) {
Controller c = (Controller) controllerList.elementAt(i);
currentControllerList.addElement(c);
c.stop();
}
if (currentControllerList == null)
return;
if (!currentControllerList.isEmpty()) {
try {
while (!closing && !receivedAllEvents)
wait();
} catch (InterruptedException e) {
}
currentControllerList.removeAllElements();
}
super.stop();
//doStop(); // Allow subclasses to extend the behavior
switch (stopType) {
case STOP_BY_REQUEST:
sendEvent( new StopByRequestEvent(this, Started,
getState(),
getTargetState(),
getMediaTime()));
break;
case RESTARTING:
sendEvent( new RestartingEvent(this, Started,
getState(),
Started,
getMediaTime()));
break;
default:
sendEvent( new StopEvent(this, Started,
getState(),
getTargetState(),
getMediaTime()));
break;
}
}
}
}
protected final void processEndOfMedia() {
super.stop();
sendEvent(new EndOfMediaEvent(this, Started, Prefetched,
getTargetState(), getMediaTime()));
}
/**
* Add a Controller to the list of Controllers under this Player's
* management. This is a protected method use only by subclasses.
* Use addController() for public access.
*/
protected final void manageController(Controller controller) {
manageController(controller, false);
}
/**
* Add a Controller to the list of Controllers under this Player's
* management.
*/
protected final void manageController(Controller controller, boolean optional) {
if (controller != null) {
if (!controllerList.contains(controller)) {
controllerList.addElement(controller);
if (optional)
optionalControllerList.addElement(controller);
controller.addControllerListener(this);
}
}
updateDuration();
}
/**
* Remove a Controller from the list of Controllers under this Player's
* management. This is a protected method use only by subclasses.
* Use removeController() for public access.
*/
public final void unmanageController(Controller controller) {
if (controller != null)
if (controllerList.contains(controller)) {
controllerList.removeElement(controller);
controller.removeControllerListener(this);
}
}
/**
* Assume control of another Controller.
* A Player can accept responsibility for controlling
* another Controller.
* Once a Controller has been added
* this Player will:
* <ul>
* <li> Slave the Controller to the Player's time-base.
* <li> Use the Controller in the Player's computation
* of start latency.
* The value the Player returns in its <b>getStartLatency</b>
* method is the larger
* of: <b>getStartLatency</b> before the Controller was added, or
* <b>getStartLatency</b> of the Controller.
* <li> Pass along, as is appropriate, events that the Controller
* generates.
* <li> Invoke all Controller methods on the Controller.
* <li> For all asynchronous methods (realize, prefetch) a completion
* event will not be generated until all added Controllers have
* generated completion events.
* </ul><p>
*
* <b>Note:</b> It is undefined what will happen if a Controller is
* under the control of a Player and any of the
* Controller's methods are called outside of the controlling
* Player.
*
* @param newController the Controller this
* Player will control.
* @exception IncompatibleTimeBaseException thrown if the new controller
* will not accept the player's timebase.
*/
public synchronized void addController(Controller newController)
throws IncompatibleTimeBaseException
{
int playerState = getState();
if (playerState == Started) {
throwError(new ClockStartedError("Cannot add controller to a started player"));
}
if ( (playerState == Unrealized) || (playerState == Realizing) ) {
throwError(new NotRealizedError("A Controller cannot be added to an Unrealized Player"));
}
if (newController == null || newController == this)
return;
int controllerState = newController.getState();
if ( (controllerState == Unrealized) || (controllerState == Realizing) ) {
throwError(new NotRealizedError("An Unrealized Controller cannot be added to a Player"));
}
if (controllerList.contains(newController)) {
return;
}
if (playerState == Prefetched) {
if ( (controllerState == Realized) ||
(controllerState == Prefetching) ) {
// System.out.println("Calling deallocate");
deallocate(); // Transition back to realized state
}
}
manageController(newController);
// Synchronize the players.
newController.setTimeBase(getTimeBase());
newController.setMediaTime(getMediaTime());
newController.setStopTime(getStopTime());
if (newController.setRate(getRate()) != getRate()) {
// The slave does not support the master's rate.
// We'll reset everything back to rate 1.0.
setRate(1.0f);
}
}
/**
* Stop controlling a Controller.
*
* @param oldController the Controller to stop controlling.
*/
public final synchronized void removeController(Controller oldController) {
int state = getState();
if (state < Realized) {
throwError(new NotRealizedError("Cannot remove controller from a unrealized player"));
}
if (state == Started) {
throwError(new ClockStartedError("Cannot remove controller from a started player"));
}
if (oldController == null)
return;
if (controllerList.contains(oldController)) {
controllerList.removeElement(oldController);
oldController.removeControllerListener(this);
updateDuration();
// Reset the controller to its default time base.
try {
oldController.setTimeBase(null);
} catch (IncompatibleTimeBaseException e) {}
}
}
/**
* Return true if the player is currently playing media
* with an audio track.
* @return true if the player is playing audio.
*/
protected abstract boolean audioEnabled();
/**
* Return true if the player is currently playing media
* with a video track.
* @return true if the player is playing video.
*/
protected abstract boolean videoEnabled();
/**
* This should be implemented by the subclass.
* The subclass method should return the master TimeBase -- the
* TimeBase that all other controllers slave to.
* Use SystemTimeBase if unsure.
* @return the master time base.
*/
protected abstract TimeBase getMasterTimeBase();
/**
* The stub function (invoked from configure()) to perform the steps to
* configure the player. It performs the following:
* <ul>
* <li> call configure() on each controller managed by this player.
* <li> wait for ConfigureCompleteEvent from each controller;
* </ul>
* Subclasses are allowed to override doConfigure(). But this should be
* done in caution. Subclass should also invoke super.doConfigure().
* This is called from a separately running thread.
* @return true if successful.
*/
protected synchronized boolean doConfigure() {
potentialEventsList = configureEventList; // List of potential events for the
// configure() method
resetReceivedEventList(); // Reset list of received events
receivedAllEvents = false;
currentControllerList.removeAllElements();
int i = controllerList.size();
while (--i >= 0) {
Controller c = (Controller) controllerList.elementAt(i);
if (c.getState() == Unrealized &&
(c instanceof Processor || c instanceof BasicController)) {
currentControllerList.addElement(c);
}
}
i = currentControllerList.size();
while (--i >= 0) {
Controller c = (Controller) currentControllerList.elementAt(i);
if (c instanceof Processor)
((Processor)c).configure();
else if (c instanceof BasicController)
((BasicController)c).configure();
}
if (!currentControllerList.isEmpty()) {
try {
while (!closing && !receivedAllEvents)
wait();
} catch (InterruptedException e) {
}
currentControllerList.removeAllElements();
}
// Make sure all the controllers are in in Configured State.
// If not, it means that configure failed on one or more controllers.
// Currenly, if configure fails then you get a ResourceUnavailableEvent
// instead of RealizeCompleteEvent
i = controllerList.size();
while (--i >= 0) {
Controller c = (Controller) controllerList.elementAt(i);
if ((c instanceof Processor || c instanceof BasicController) &&
c.getState() < Configured) {
Log.error("Error: Unable to configure " + c);
source.disconnect();
return false;
}
}
// subclass will implement this to configure up the signal graph.
return true;
}
/**
* Called as a last step to complete the configure call.
*/
protected void completeConfigure() {
super.completeConfigure();
synchronized (this) {
notify();
}
}
/**
* Called when configure fails.
*/
protected void doFailedConfigure() {
super.doFailedConfigure();
synchronized (this) {
notify();
}
close();
}
/**
* The stub function (invoked from configure()) to perform the steps to
* configure the player. It performs the following:
* <ul>
* <li> call realize() on each controller managed by this player.
* <li> wait for RealizeCompleteEvent from each controller;
* </ul>
* Subclasses are allowed to override doRealize(). But this should be
* done in caution. Subclass should also invoke super.doRealize().
* This is called from a separately running thread.
* @return true if successful.
*/
protected synchronized boolean doRealize() {
potentialEventsList = realizeEventList; // List of potential events for the
// realize() method
resetReceivedEventList(); // Reset list of received events
receivedAllEvents = false;
currentControllerList.removeAllElements();
int i = controllerList.size();
while (--i >= 0) {
Controller c = (Controller) controllerList.elementAt(i);
if (c.getState() == Unrealized || c.getState() == Configured) {
currentControllerList.addElement(c);
}
}
i = currentControllerList.size();
while (--i >= 0) {
Controller c = (Controller) currentControllerList.elementAt(i);
c.realize();
}
if (!currentControllerList.isEmpty()) {
try {
while (!closing && !receivedAllEvents)
wait();
} catch (InterruptedException e) {
}
currentControllerList.removeAllElements();
}
// Make sure all the controllers are in in Realized State.
// If not, it means that realize failed on one or more controllers.
// Currenly, if realize fails then you get a ResourceUnavailableEvent
// instead of RealizeCompleteEvent
i = controllerList.size();
while (--i >= 0) {
Controller c = (Controller) controllerList.elementAt(i);
if (c.getState() < Realized) {
Log.error("Error: Unable to realize " + c);
source.disconnect();
return false;
}
}
updateDuration();
if ( /*securityPrivelege &&*/ (jmfSecurity != null) ) {
String permission = null;
try {
if (jmfSecurity.getName().startsWith("jmf-security")) {
permission = "thread";
jmfSecurity.requestPermission(m, cl, args, JMFSecurity.THREAD);
m[0].invoke(cl[0], args[0]);
permission = "thread group";
jmfSecurity.requestPermission(m, cl, args, JMFSecurity.THREAD_GROUP);
m[0].invoke(cl[0], args[0]);
} else if (jmfSecurity.getName().startsWith("internet")) {
PolicyEngine.checkPermission(PermissionID.THREAD);
PolicyEngine.assertPermission(PermissionID.THREAD);
}
} catch (Exception e) {
if (JMFSecurityManager.DEBUG) {
System.err.println("Unable to get " + permission +
" privilege " + e);
}
securityPrivelege = false;
// TODO: Do the right thing if permissions cannot be obtained.
// User should be notified via an event
}
}
if ( (jmfSecurity != null) && (jmfSecurity.getName().startsWith("jdk12"))) {
try {
Constructor cons = CreateWorkThreadAction.cons;
statsThread = (StatsThread) jdk12.doPrivM.invoke(
jdk12.ac,
new Object[] {
cons.newInstance(
new Object[] {
StatsThread.class,
BasicPlayer.class,
this
})});
statsThread.start();
} catch (Exception e) {
}
} else {
statsThread = new StatsThread(this);
statsThread.start();
}
// subclass will implement this to connect up the signal graph.
return true;
}
/**
* Called as a last step to complete the realize call.
*/
protected void completeRealize() {
state = Realized;
try {
slaveToMasterTimeBase(getMasterTimeBase());
} catch (IncompatibleTimeBaseException e) {
Log.error(e);
}
super.completeRealize();
synchronized (this) {
notify();
}
}
/**
* Called when realize fails.
*/
protected void doFailedRealize() {
super.doFailedRealize();
synchronized (this) {
notify();
}
close();
}
/**
* Called as a last step to complete the prefetch call.
*/
protected void completePrefetch() {
super.completePrefetch();
synchronized(this) {
notify();
}
}
/**
* Called when prefetch fails.
*/
protected void doFailedPrefetch() {
super.doFailedPrefetch();
synchronized (this) {
notify();
}
}
/**
* Called when the realize() is aborted, i.e. deallocate() was called
* while realizing. Release all resources claimed previously by the
* realize() call.
*/
protected final void abortRealize() {
if (controllerList != null) {
int i = controllerList.size();
while (--i >= 0) {
Controller c = (Controller) controllerList.elementAt(i);
c.deallocate();
}
}
synchronized(this) {
notify();
}
}
/**
* The stub function to perform the steps to prefetch the controller.
* This will call prefetch() on every controller in the controller list and wait
* for their completion events.
* This is called from a separately running thread.
* @return true if successful.
*/
protected /*synchronized*/ boolean doPrefetch() {
potentialEventsList = prefetchEventList; // List of potential events for the
// prefetch() method
resetReceivedEventList(); // Reset list of received events
receivedAllEvents = false;
currentControllerList.removeAllElements();
Vector list = controllerList;
if (list == null) {
return false;
}
int i = list.size();
while (--i >= 0) {
Controller c = (Controller) list.elementAt(i);
if (c.getState() == Realized) {
currentControllerList.addElement(c);
c.prefetch();
}
}
if (!currentControllerList.isEmpty()) {
synchronized(this) {
try {
while (!closing && !receivedAllEvents)
wait();
} catch (InterruptedException e) {
}
currentControllerList.removeAllElements();
}
}
// Make sure all the controllers are in in Prefetched State.
// If not, it means that prefetch failed on one or more controllers.
// Currenly, if prefetch fails then you get a ResourceUnavailableEvent
// instead of PrefetchCompleteEvent
i = list.size();
while (--i >= 0) {
Controller c = (Controller) list.elementAt(i);
if (c.getState() < Prefetched) {
Log.error("Error: Unable to prefetch " + c + "\n");
if (optionalControllerList.contains(c)) {
//System.out.println(c + " Controller is optional... continuing");
removedControllerList.addElement(c);
} else {
// Notify the play thread which could still be waiting.
synchronized (this) {
prefetchFailed = true;
notifyAll();
}
return false;
}
}
}
if (removedControllerList != null) {
i = removedControllerList.size();
while (--i >= 0) {
Object o = removedControllerList.elementAt(i);
controllerList.removeElement(o);
( (BasicController) o).close();
if (! deviceBusy((BasicController) o)) {
// Notify the play thread which could still be waiting.
synchronized (this) {
prefetchFailed = true;
notifyAll();
}
return false; // prefetch failed
}
}
removedControllerList.removeAllElements();
//$ System.err.println("final list of controllers: " + list);
}
return true;
}
/**
* Called when the prefetch() is aborted, i.e. deallocate() was called
* while prefetching. Release all resources claimed previously by the
* prefetch call.
*/
protected final void abortPrefetch() {
if (controllerList != null) {
int i = controllerList.size();
while (--i >= 0) {
Controller c = (Controller) controllerList.elementAt(i);
c.deallocate();
}
}
synchronized(this) {
notify();
}
}
/**
* Check the given controller to see if it's busy or not.
* Needs to be overridden by subclass.
* The subclass method should change the master timebase
* if necessary. It should handle audio only or video
* only tracks properly when the device is busy.
* @return true if the given controller is usable; false if the controller
* cannot be used.
*/
protected boolean deviceBusy(BasicController mc) {
return true;
}
/**
* Slave all the controllers to the master time base.
* The controllers should be in realized or greater state
* This differs from the setTimeBase() as it loops through each
* controllers and call setTimeBase on each of them.
* @param tb the time base to be used by all controllers.
* @exception IncompatibleTimeBaseException thrown if any controller
* will not accept the player's timebase.
*/
protected void slaveToMasterTimeBase(TimeBase tb)
throws javax.media.IncompatibleTimeBaseException {
//$$ System.out.println("slaveToMasterTimeBase: master timebase is " + tb);
//$ System.out.println("Setting master " + tb + " on " + this);
this.setTimeBase(tb); // For the player
}
private /*synchronized*/ void notifyIfAllEventsArrived(Vector controllerList,
Vector receivedEventList) {
if ( (receivedEventList != null) &&
(receivedEventList.size() == currentControllerList.size()) ) {
receivedAllEvents = true;
resetReceivedEventList(); // Reset list of received events
synchronized(this) {
notifyAll();
}
}
}
protected /*synchronized*/ void processEvent(ControllerEvent evt) {
Controller source = evt.getSourceController();
if (evt instanceof AudioDeviceUnavailableEvent) {
sendEvent(new AudioDeviceUnavailableEvent(this));
return;
}
// If this is a closed event triggered by one of the
// managed controllers, not triggered by the player,
// then we'll need to programmtically close all the
// controllers and the player itself.
if ( evt instanceof ControllerClosedEvent && !closing &&
controllerList.contains(source) &&
! (evt instanceof ResourceUnavailableEvent) ) {
// The source of the error event should have been closed
// already. So we'll just remove it from the list of
// managed controllers.
controllerList.removeElement(source);
if (evt instanceof ControllerErrorEvent)
sendEvent(new ControllerErrorEvent(this,
((ControllerErrorEvent) evt).getMessage()));
close();
}
//
// Send SizeChangeEvent down to Player
//
if ( (evt instanceof SizeChangeEvent) && controllerList.contains(source) ) {
// System.err.println("width = " + ((SizeChangeEvent)evt).getWidth());
// System.err.println("height = " + ((SizeChangeEvent)evt).getHeight());
sendEvent(new SizeChangeEvent(this,
((SizeChangeEvent)evt).getWidth(),
((SizeChangeEvent)evt).getHeight(),
((SizeChangeEvent)evt).getScale()));
return;
}
//
// Send UnsupportedFormatEvent down to Player
//
/*
if ( (evt instanceof UnsupportedFormatEvent) &&
controllerList.contains(source) ) {
// System.err.println("Reason = " + ((UnsupportedFormatEvent)evt).toString());
sendEvent(new UnsupportedFormatEvent(this,
((UnsupportedFormatEvent)evt).getFormat()));
return;
}
*/
// If we get a DurationUpdateEvent from one of the controllers,
// update the duration of the player
if ((evt instanceof DurationUpdateEvent) && controllerList.contains(source)) {
updateDuration();
return;
}
// HANGS.
// if ((evt instanceof RestartingEvent) && controllerList.contains(source)) {
// System.out.println("MP: Got RestartingEvent from " + source);
// stop(LOCAL_STOP); // Stop without sending any stop event
// sendEvent(new RestartingEvent(this, Started, Prefetching, Started,
// getMediaTime()));
// }
// So I am handling RestartingEvent this way
if ((evt instanceof RestartingEvent) && controllerList.contains(source)) {
restartFrom = source;
int i = controllerList.size();
super.stop(); // Added
setTargetState(Prefetched); // necessary even if super.stop is called.
for (int ii = 0; ii < i; ii++) {
Controller c = (Controller) controllerList.elementAt(ii);
if (c != source) {
c.stop();
}
}
super.stop();
// doStop(); // Allow subclasses to extend the behavior
sendEvent(new RestartingEvent(this, Started, Prefetching, Started,
getMediaTime()));
}
if ((evt instanceof StartEvent) && (source == restartFrom) ) {
restartFrom = null;
// $$ TODO: Should probably send PrefetchCompleteEvent
start();
}
if ( (evt instanceof SeekFailedEvent) && controllerList.contains(source) ) {
int i = controllerList.size();
super.stop(); // Added
setTargetState(Prefetched); // necessary even if super.stop is called.
for (int ii = 0; ii < i; ii++) {
Controller c = (Controller) controllerList.elementAt(ii);
if (c != source) {
c.stop();
}
}
/*
super.stop();
setMediaTime(new Time(0));
start();
*/
sendEvent(new SeekFailedEvent(this, Started, Prefetched, Prefetched,
getMediaTime()));
}
if ( (evt instanceof EndOfMediaEvent) && controllerList.contains(source) ) {
if (eomEventsReceivedFrom.contains(source)) {
return;
}
eomEventsReceivedFrom.addElement(source);
if (eomEventsReceivedFrom.size() == controllerList.size()) {
super.stop();
sendEvent(new EndOfMediaEvent(this, Started, Prefetched,
getTargetState(), getMediaTime()));
}
return;
}
if ((evt instanceof StopAtTimeEvent) && controllerList.contains(source) &&
(getState() == Started)) {
synchronized (stopAtTimeReceivedFrom) {
if (stopAtTimeReceivedFrom.contains(source))
return;
stopAtTimeReceivedFrom.addElement(source);
boolean allStopped = (stopAtTimeReceivedFrom.size() == controllerList.size());
if (!allStopped) {
// Now check if the other controllers have already EOM'ed.
allStopped = true;
for (int i = 0; i < controllerList.size(); i++) {
Controller c = (Controller)controllerList.elementAt(i);
if (!stopAtTimeReceivedFrom.contains(c) &&
!eomEventsReceivedFrom.contains(c)) {
allStopped = false;
break;
}
}
}
if (allStopped) {
super.stop();
doSetStopTime(Clock.RESET);
sendEvent(new StopAtTimeEvent(this, Started, Prefetched,
getTargetState(), getMediaTime()));
}
return;
} // synchronized stopAtTimeReceivedFrom
}
if ((evt instanceof CachingControlEvent) && controllerList.contains(source) ) {
CachingControl mcc = (CachingControl)
((CachingControlEvent) evt).getCachingControl();
sendEvent(new CachingControlEvent(this,
mcc,
mcc.getContentProgress()));
return;
}
Vector eventList = potentialEventsList;
if (controllerList != null && controllerList.contains(source) &&
eventList != null && eventList.contains(evt.getClass().getName())) {
updateReceivedEventsList(evt);
notifyIfAllEventsArrived(controllerList, getReceivedEventsList());
}
}
private boolean trySetRate(float rate) {
int i = controllerList.size();
while(--i >=0) {
Controller c = (Controller)controllerList.elementAt(i);
if ( c.setRate(rate) != rate ) {
return false;
}
}
return true;
}
protected float doSetRate(float factor) {
return factor;
}
/**
* Set the playback rate on the player.
* It loops through its list of controllers and invoke setRate on each
* of them.
*/
public float setRate(float rate) {
if (state < Realized) {
throwError(new NotRealizedError("Cannot set rate on an unrealized Player."));
}
// Verify to see if the DataSource supports that rate.
if (source instanceof RateConfigureable)
rate = checkRateConfig((RateConfigureable)source, rate);
float oldRate = getRate();
if (oldRate == rate)
return rate;
if (getState() == Controller.Started) {
aboutToRestart = true;
stop(RESTARTING);
}
float rateSet; // Actual rate set
if (!trySetRate(rate)) {
if (!trySetRate(oldRate)) { // try to go back to the oldRate
trySetRate(1.0F); // try setRate(1.0) which shouldn't fail
rateSet = 1.0F;
} else {
rateSet = oldRate;
}
} else {
rateSet = rate;
}
super.setRate(rateSet);
if (aboutToRestart) {
syncStart(getTimeBase().getTime());
aboutToRestart = false;
}
return rateSet;
}
/**
* Check if the given rate configureable supports the given rate.
* if not, returns the closest match.
*/
float checkRateConfig(RateConfigureable rc, float rate) {
RateConfiguration config[] = rc.getRateConfigurations();
if (config == null)
return 1.0f;
RateConfiguration c;
RateRange rr;
float corrected = 1.0f;
for (int i = 0; i < config.length; i++) {
rr = config[i].getRate();
if (rr != null && rr.inRange(rate)) {
rr.setCurrentRate(rate);
corrected = rate;
c = rc.setRateConfiguration(config[i]);
if (c != null && (rr = c.getRate()) != null)
corrected = rr.getCurrentRate();
break;
}
}
return corrected;
}
/**
* This is being called from a looping thread to update the stats.
*/
abstract public void updateStats();
/*************************************************************************
* INNER CLASSES
*************************************************************************/
}
// PlayThread and StatsThread are no longer inner classes
class PlayThread extends MediaThread {
BasicPlayer player;
public PlayThread(BasicPlayer player) {
this.player = player;
setName(getName() + " (PlayThread)");
useControlPriority();
}
public void run() {
player.play();
}
}
class StatsThread extends LoopThread {
BasicPlayer player;
int pausecount = -1;
public StatsThread(BasicPlayer p) {
this.player = p;
}
protected boolean process() {
try {
Thread.currentThread().sleep(1000);
} catch (Exception e) {}
// Check to see if the thread was killed.
// If so exits.
if (!waitHereIfPaused())
return false;
if ( player.getState() == Controller.Started ) {
pausecount = -1;
player.updateStats();
} else if ( pausecount < 5 ) {
pausecount++;
player.updateStats();
}
return true;
}
}