/*
 * @(#)ProcessEngine.java	1.16 02/08/21
 *
 * Copyright (c) 1996-2002 Sun Microsystems, Inc.  All rights reserved.
 */

package com.sun.media;

import java.io.*;
import java.util.*;
import java.awt.*;

import javax.media.*;
import javax.media.protocol.*;
import javax.media.control.*;
import javax.media.format.*;
import javax.media.renderer.*;
import com.sun.media.util.*;
import com.sun.media.controls.*;
import com.sun.media.renderer.audio.AudioRenderer;
import com.sun.media.codec.video.colorspace.RGBScaler;


/**
 * ProcessEngine implements the media engine for processors.
 */
public class ProcessEngine extends PlaybackEngine {

    protected BasicMuxModule muxModule;
    protected ContentDescriptor outputContentDes = null;


    public ProcessEngine(BasicProcessor p) {
	super(p);
    }


    /**
     * Configuring the engine.
     */
    protected boolean doConfigure() {

	if (!doConfigure1())
	    return false;

	// The indices to the connector names, tracks, and track controls
	// should all correspond to each other.
	String names[] = source.getOutputConnectorNames();
	trackControls = new BasicTrackControl[tracks.length];
	for (int i = 0; i < tracks.length; i++) {
	    trackControls[i] = new ProcTControl(this, tracks[i], 
				source.getOutputConnector(names[i]));
	}

	if (!doConfigure2())
	    return false;

	// By default a Processor generates RAW output.
	outputContentDes = new ContentDescriptor(ContentDescriptor.RAW);

	// The parser disables the hint tracks by default.  We'll 
	// re-enable them.
	reenableHintTracks();

	return true;
    }


    /**
     * @return true if successful.
     */ 
    protected synchronized boolean doRealize() {

	// Reset the target multiplexers
	targetMuxes = null;

	if (!super.doRealize1())
	    return false;

	// Connect the tracks to a multiplexer, if there's one.
	if (targetMux != null && !connectMux()) {
	    Log.error(realizeError);
	    Log.error("  Cannot connect the multiplexer\n");
	    player.processError = genericProcessorError;
	    return false;
	}

	if (!super.doRealize2())
	    return false;

	return true;
    }


    /**
     * Return true if the given format is RTP related.
     */
    boolean isRTPFormat(Format fmt) {
	return fmt != null && fmt.getEncoding() != null && 
		fmt.getEncoding().endsWith("rtp") || 
		fmt.getEncoding().endsWith("RTP");
    }


    void reenableHintTracks() {
	for (int i = 0; i < trackControls.length; i++) {
	    if (isRTPFormat(trackControls[i].getOriginalFormat())) {
		trackControls[i].setEnabled(true);
		break;
	    }
	}
    }


    BasicMuxModule getMuxModule() {
	return muxModule;
    }


    /**
     * Connect the multiplexer.
     */
    boolean connectMux() {

	/**
	 * The target Mux has already been determined.  We'll just
	 * hook it up.
	 */
	BasicTrackControl tcs[] = new BasicTrackControl[trackControls.length];
	int total = 0;
	Multiplexer mux = (Multiplexer)targetMux.plugin;

	for (int i = 0; i < trackControls.length; i++) {
	    if (trackControls[i].isEnabled()) {
		tcs[total++] = trackControls[i];
	    }
	}

	try {
	    mux.setContentDescriptor(outputContentDes);
	} catch (Exception e) {
	    Log.comment("Failed to set the output content descriptor on the multiplexer.");
	    return false;
	}

	boolean failed = false;
	
	if (mux.setNumTracks(targetMuxFormats.length) != targetMuxFormats.length) {
	    Log.comment("Failed  to set number of tracks on the multiplexer.");
	    return false;
	}

	for (int mf = 0; mf < targetMuxFormats.length; mf++) {
	    if (targetMuxFormats[mf] == null || 
		mux.setInputFormat(targetMuxFormats[mf], mf) == null) {
		Log.comment("Failed to set input format on the multiplexer.");
		failed = true;
		break;
	    }
	}
		
	if (failed)
	    return false;

	if (SimpleGraphBuilder.inspector != null && !SimpleGraphBuilder.inspector.verify(mux, targetMuxFormats))
	    return false;

	//Log.comment("Found multiplexer: " + mux);

	InputConnector ic;
	BasicMuxModule bmm = new BasicMuxModule(mux, targetMuxFormats);
	if (DEBUG) bmm.setJMD(jmd);
	String name;

	// Make the connections.
	for (int j = 0; j < targetMuxFormats.length; j++) {
	    ic = bmm.getInputConnector(BasicMuxModule.ConnectorNamePrefix + j);
	    if (ic == null) {
		// Something is terribly wrong.
		Log.comment("BasicMuxModule: connector mismatched.");
		return false;
	    }
	    ic.setFormat(targetMuxFormats[j]);
	    tcs[j].lastOC.setProtocol(ic.getProtocol());
	    tcs[j].lastOC.connectTo(ic, targetMuxFormats[j]);
	}

	if (!bmm.doRealize()) {
	    //Log.comment("Failed to open the multiplexer.");
	    return false;
	}

        bmm.setModuleListener(this);
        bmm.setController(this);
        modules.addElement(bmm);
	sinks.addElement(bmm);

	muxModule = bmm;

	return true;
    }


    /**
     * Search and update the master time base.
     */
    protected BasicSinkModule findMasterSink() {

	// Obtain a master time base from one of its SinkModules.

	if (muxModule != null && muxModule.getClock() != null) {
	    return muxModule;
	}

	return super.findMasterSink();
    }


    String prefetchError = "Failed to prefetch: " + this;

    /**
     * The stub function to perform the steps to prefetch the controller.
     * @return true if successful.
     */ 
    protected synchronized boolean doPrefetch() {

	if (prefetched)
	    return true;

	if (!doPrefetch1())
	    return false;

	// Fail if the mux module cannot be prefetched.
	if (muxModule != null && !muxModule.doPrefetch()) {
	    Log.error(prefetchError);
	    Log.error("  Cannot prefetch the multiplexer: " + 
			muxModule.getMultiplexer() + "\n");
	    return false;
	}

	return doPrefetch2();
    }


    /**
     * Start immediately.
     * Invoked from start(tbt) when the scheduled start time is reached.
     * Use the public start(tbt) method for the public interface.
     * Override this to implement subclass behavior.
     */
    protected synchronized void doStart() {

	if (started) return;

	doStart1();

	if (muxModule != null)
	    muxModule.doStart();

	doStart2();
    }


    /**
     * Invoked from stop().
     * Override this to implement subclass behavior.
     */
    protected synchronized void doStop() {
	if (!started) return;

	doStop1();

	if (muxModule != null)
	    muxModule.doStop();

	doStop2();
    }


    /**
     * Get the track controls.
     */
    public TrackControl [] getTrackControls() throws NotConfiguredError {
	if (getState() < Configured)
	    throwError(new NotConfiguredError("getTrackControls " + NOT_CONFIGURED_ERROR));
	return trackControls;
    }


    /** 
     * Return all the content-types which this Processor's output supports. 
     */
    public ContentDescriptor[] getSupportedContentDescriptors() 
	throws NotConfiguredError {
	if (getState() < Configured)
	    throwError(new NotConfiguredError("getSupportedContentDescriptors " + 
					NOT_CONFIGURED_ERROR));
	Vector names = PlugInManager.getPlugInList(null,
					null, PlugInManager.MULTIPLEXER);
	Vector fmts = new Vector();
	Format fs[];
	int i, j, k;
	boolean duplicate;

	for (i = 0; i < names.size(); i++) {
	    fs = PlugInManager.getSupportedOutputFormats(
					(String)names.elementAt(i),
					PlugInManager.MULTIPLEXER);
	    if (fs == null)
		continue;
	    for (j = 0; j < fs.length; j++) {
		if (!(fs[j] instanceof ContentDescriptor))
		   continue;
		duplicate = false;
		for (k = 0; k < fmts.size(); k++) {
		    if (fmts.elementAt(k).equals(fs[j])) {
			duplicate = true;
			break;
		    }
		}
		if (!duplicate)
		    fmts.addElement(fs[j]);
	    }
	}

	ContentDescriptor cds[] = new ContentDescriptor[fmts.size()];

	for (i = 0; i < fmts.size(); i++)
	    cds[i] = (ContentDescriptor)fmts.elementAt(i);

	return cds;
    }

    
    /**
     * Set the output content-type. 
     */
    public ContentDescriptor setContentDescriptor(ContentDescriptor ocd) 
	throws NotConfiguredError {

	if (getState() < Configured)
	    throwError(new NotConfiguredError("setContentDescriptor " + 
					NOT_CONFIGURED_ERROR));

	if (getState() > Configured)
	    return null;

	if (ocd != null) {
	    Vector cnames = PlugInManager.getPlugInList(null,
				ocd, PlugInManager.MULTIPLEXER);

	    if (cnames == null || cnames.size() == 0)
		return null;
	}

	outputContentDes = ocd;

	return outputContentDes;
    }

    
    /**
     * Return the output content-type.
     */
    public ContentDescriptor getContentDescriptor() 
	throws NotConfiguredError {
	if (getState() < Configured)
	    throwError(new NotConfiguredError("getContentDescriptor " + 
					NOT_CONFIGURED_ERROR));
	return outputContentDes;
    }

    
    /** 
     * Return the output DataSource of the Processor. 
     */
    public DataSource getDataOutput() throws NotRealizedError {
	if (getState() < Controller.Realized)
	    throwError(new NotRealizedError("getDataOutput " + 
					NOT_REALIZED_ERROR));
	if (muxModule != null)
	    return muxModule.getDataOutput();
	else
	    return null;
    }
    

    /**
     * Report the output bit rate if a mux is used.
     */
    protected long getBitRate() {
	if (muxModule != null)
	    return muxModule.getBitsWritten();
	else
	    return source.getBitsRead();
    }


    protected void resetBitRate() {
	if (muxModule != null)
	    muxModule.resetBitsWritten();
	else
	    source.resetBitsRead();
    }


    //////////////////////////////////
    //
    // Flow graph building routines.
    //////////////////////////////////

    /**
     * Get the plugin from a module.  For debugging.
     */
    protected PlugIn getPlugIn(BasicModule m) {

	if (m instanceof BasicMuxModule)
	    return ((BasicMuxModule)m).getMultiplexer();

	return super.getPlugIn(m);
    }


    //////////////////////////////////
    //
    // Inner classes
    //////////////////////////////////

    class ProcTControl extends BasicTrackControl implements Owned {

	// Customized options.
	protected Format formatWanted = null;
	protected Codec codecChainWanted[] = null;
	protected Renderer rendererWanted = null;
	protected ProcGraphBuilder gb;

	protected Format supportedFormats[] = null;

	public ProcTControl(ProcessEngine engine, Track track, OutputConnector oc) {
	    super(engine, track, oc);
	}

	public Object getOwner() {
	    return player;
	}

	public Format getFormat() {
	    return (formatWanted == null ? track.getFormat() : formatWanted);
	}

	public Format [] getSupportedFormats() {

	    // First check to see if we have already computed the supported
	    // formats for the track format in the past.  If not, then we'll
	    // compute the supported formats using the graph builder.

	    if (supportedFormats == null &&
		(supportedFormats = Resource.getDB(track.getFormat())) == null) {

		if (gb == null)
		    gb = new ProcGraphBuilder((ProcessEngine)engine);
		else
		    gb.reset();
	        supportedFormats = gb.getSupportedOutputFormats(track.getFormat());
		supportedFormats = Resource.putDB(track.getFormat(), 
							supportedFormats);
		needSavingDB = true;
	    }

	    // If an output content descriptor is given, we'll need to
	    // verify if the mux support individual inputs.
	    if (outputContentDes != null) {
		return verifyMuxInputs(outputContentDes, supportedFormats);
	    } else
		return supportedFormats;
	}

	/**
         * If a multiplexer (ContentDescriptor) is specified, we'll verify
	 * if the multiplexer supports the given input.
	 */
	Format [] verifyMuxInputs(ContentDescriptor cd, Format inputs[]) {

	    if (cd == null || cd.getEncoding() == ContentDescriptor.RAW)
		return inputs;

	    // Instantiate all the multiplexers that support the 
	    // given output content descriptor.

	    Vector cnames = PlugInManager.getPlugInList(null,
				cd, PlugInManager.MULTIPLEXER);
	    if (cnames == null || cnames.size() == 0)
		return new Format[0];

	    Multiplexer mux[] = new Multiplexer[cnames.size()];
	    int total = 0;

	    Multiplexer m;
	    for (int i = 0; i < cnames.size(); i++) {
		if ((m = (Multiplexer)SimpleGraphBuilder.createPlugIn((String)cnames.elementAt(i), 
				PlugInManager.MULTIPLEXER)) != null) {

		    try {
			    m.setContentDescriptor(outputContentDes);
		    } catch (Exception e) {
			    continue;
		    }

		    if (m.setNumTracks(1) < 1)
			continue;

		    mux[total++] = m;
		}
	    }

	    // Query the multiplexers to see if they support the input
	    // format.

	    Format tmp[] = new Format[inputs.length];
	    Format fmt;
	    int vtotal = 0;

	    for (int i = 0; i < inputs.length; i++) {
		if (total == 1) {
		    // Let's do some loop unrolling.
		    if ((fmt = mux[0].setInputFormat(inputs[i], 0)) != null)
			tmp[vtotal++] = fmt;
		} else {
		    for (int j = 0; j < total; j++) {
			if ((fmt = mux[j].setInputFormat(inputs[i], 0)) != null) {
			    tmp[vtotal++] = fmt;
			    break;
			}
		    }
		}
	    }

	    Format verified[] = new Format[vtotal];
	    System.arraycopy(tmp, 0, verified, 0, vtotal);

	    return verified;
	}

	public Format setFormat(Format format) {
	    if (engine.getState() > Configured)
		return getFormat();

	      /*
		Force a new size for testing.
		if (format instanceof VideoFormat) {
		    VideoFormat newf = new VideoFormat(null, 
					new Dimension(100, 100),
					Format.NOT_SPECIFIED,
					null,
					Format.NOT_SPECIFIED);
		    format = newf.intersects(format);
		}
	      */

	    if (format != null && !format.matches(track.getFormat())) {
		formatWanted = checkSize(format);
	    } else
		return format;

	    /*
	    Format fmts[] = getSupportedFormats();
	    boolean good = false;
	    for (int i = 0; i < fmts.length; i++) {
		if (formatWanted.matches(fmts[i])) {
		    System.err.println("It's a good format");
		    good = true;
		}
	    }
	    if (!good) {
	        System.err.println("Format set: " + formatWanted);
		System.err.println("It's a bad format");
	    }
	    */

	    return formatWanted;
	}


	/**
	 * Check if the video size of the given format is valid.
	 * If not, return a format with the correct size.
	 */
	private Format checkSize(Format fmt) {
	    if (!(fmt instanceof VideoFormat))
		return fmt;

	    VideoFormat vfmt = (VideoFormat)fmt;
	    Dimension size = ((VideoFormat)fmt).getSize();

	    if (size == null) {
		Format ofmt = getOriginalFormat();
		if (ofmt == null || (size = ((VideoFormat)ofmt).getSize()) == null)
		    return fmt;
	    }

	    int w = size.width, h = size.height;

	    if (fmt.matches(new VideoFormat(VideoFormat.JPEG_RTP)) ||
		fmt.matches(new VideoFormat(VideoFormat.JPEG))) {
		// JPEG sizes should be a multiple of 8.
		if (size.width % 8 != 0)
		    w = size.width / 8 * 8;
		if (size.height % 8 != 0)
		    h = size.height / 8 * 8;
		if (w == 0 || h == 0) {
		    w = size.width;
		    h = size.height;
		}

	    } else if (fmt.matches(new VideoFormat(VideoFormat.H263_RTP)) ||
		fmt.matches(new VideoFormat(VideoFormat.H263_1998_RTP)) ||
		fmt.matches(new VideoFormat(VideoFormat.H263))) {
		// H.263 sizes are pretty rigid.
		if (size.width >= 352) {
		    w = 352;
		    h = 288;
		} else if (size.width >= 160) {
		    w = 176;
		    h = 144;
		} else {
		    w = 128;
		    h = 96;
		}
	    }

	    if (w != size.width || h != size.height) {
		Log.comment("setFormat: " + fmt.getEncoding() +
				": video aspect ratio mismatched.");
		Log.comment("  Scaled from " + size.width + "x" + 
				size.height + " to " + w + "x" + h + ".\n");
		fmt = (new VideoFormat(null, 
				new Dimension(w, h),
				Format.NOT_SPECIFIED,
				null,
				Format.NOT_SPECIFIED)).intersects(fmt);
	    }

	    return fmt;
	}


	/**
	 * Top level routine to build a single track.
	 */
	public boolean buildTrack(int trackID, int numTracks) {
	    if (gb == null)
		gb = new ProcGraphBuilder((ProcessEngine)engine);
	    else
		gb.reset();
	    boolean rtn = gb.buildGraph(this, trackID, numTracks);

	    // dispose the old GraphBuilder after building a track.
	    // The cache is not valid anymore.
	    gb = null;

	    return rtn;
	}


	/**
	 * Returns true if this track holds the master time base.
	 */
	public boolean isTimeBase() {
	    for (int j = 0; j < modules.size(); j++) {
		if (modules.elementAt(j) == masterSink)
		    return true;
	    }
	    return false;
	}


	public void setCodecChain(Codec codec[]) 
		throws NotConfiguredError, UnsupportedPlugInException {
	    if (engine.getState() > Configured)
		throwError(new NotConfiguredError(connectErr));
	    if (codec.length < 1)
		throw new UnsupportedPlugInException("No codec specified in the array.");
	    codecChainWanted = new Codec[codec.length];
	    for (int i = 0; i < codec.length; i++)
		codecChainWanted[i] = codec[i];
	}

	public void setRenderer(Renderer renderer) 
		throws NotConfiguredError {
	    if (engine.getState() > Configured)
		throwError(new NotConfiguredError(connectErr));
	    this.rendererWanted = renderer;
	    if (renderer instanceof SlowPlugIn)
		((SlowPlugIn)renderer).forceToUse();	
	}

	public boolean isCustomized() {
	    return formatWanted != null ||
		   codecChainWanted != null || rendererWanted != null;
	}

	public void prError() {

	    if (!isCustomized()) {
		super.prError();
		return;
	    }

	    Log.error("  Cannot build a flow graph with the customized options:");
	    if (formatWanted != null) {
		Log.error("    Unable to transcode format: " + 
				getOriginalFormat());
		Log.error("      to: " + getFormat());
		if (outputContentDes != null)
		    Log.error("      outputting to: " + outputContentDes);
	    }
	    if (codecChainWanted != null) {
		Log.error("    Unable to add customed codecs: ");
		for (int i = 0; i < codecChainWanted.length; i++)
		    Log.error("      " + codecChainWanted[i]);
	    }
	    if (rendererWanted != null) {
		Log.error("    Unable to add customed renderer: " + 
				rendererWanted);
	    }
	    Log.write("\n");
	}

	protected ProgressControl progressControl() {
	    return progressControl;
	}
	
	protected FrameRateControl frameRateControl() {
	    this.muxModule = getMuxModule();
	    return frameRateControl;
	}
    }



    /**
     * This is the Graph builder to generate the data flow graph for
     * the media engine.  It extends from the SimpleGraphBuilder to
     * handle multiplexers, customized output formats, codecs and renderers.
     *
     * It contains 3 parts:
     * 1) Routines to search for all the supported output formats;
     * 2) Routines to build a default flow graph -- buildGraph;
     * 3) Routines to build a custom flow graph -- buildCustomGraph.
     * 
     * A default graph is such that no customised option is specified on
     * the TrackControl.  
     *
     */

    // The list of target multiplexers.
    protected Vector targetMuxNames = null;
    protected GraphNode targetMuxes[] = null;
    protected GraphNode targetMux = null;
    protected Format targetMuxFormats[] = null;

    class ProcGraphBuilder extends SimpleGraphBuilder {

	protected ProcessEngine engine;

	protected Format targetFormat;
 	protected int trackID = 0;
 	protected int numTracks = 1;
	protected int nodesVisited = 0;


	ProcGraphBuilder(ProcessEngine engine) {
	    this.engine = engine;
	}


	/**
	 * Given an input format, find out all the supported output formats
	 * by searching through the node graph.
	 */
	public Format [] getSupportedOutputFormats(Format input) {

	    long formatsTime = System.currentTimeMillis();
	    Vector collected = new Vector();
	    Vector candidates = new Vector();

	    GraphNode node = new GraphNode(null, (PlugIn)null, input, null, 0);
	    candidates.addElement(node);
	    collected.addElement(input);
	    nodesVisited++;

	    while (!candidates.isEmpty())
		doGetSupportedOutputFormats(candidates, collected);

	    // Convert the resulting vector into an array.
	    Format all[] = new Format[collected.size()];

	    // The following bit of code is a hack to put MPEG/RTP the
	    // the end of the supported list since it's the least robust
	    // RTP codecs.
	    int front = 0, back = all.length - 1;
	    Format mpegAudio = new AudioFormat(AudioFormat.MPEG_RTP);
	    boolean mpegInput = 
		    (new AudioFormat(AudioFormat.MPEG)).matches(input) ||
		    (new AudioFormat(AudioFormat.MPEGLAYER3)).matches(input) ||
		    (new VideoFormat(VideoFormat.MPEG)).matches(input);

	    for (int i = 0; i < all.length; i++) {
		Object obj = collected.elementAt(i);
		if (!mpegInput && mpegAudio.matches((Format)obj))
		    all[back--] = (Format)obj;
		else
		    all[front++] = (Format)obj;
	    }

	    Log.comment("Getting the supported output formats for:");
	    Log.comment("  " + input);
	    Log.comment("  # of nodes visited: " + nodesVisited);
	    Log.comment("  # of formats supported: " + all.length + "\n");
	    engine.profile("getSupportedOutputFormats", formatsTime);

	    return all;
	}


	/**
 	 * Collect the supported output formats from the list of node 
	 * candidates.
	 */
	void doGetSupportedOutputFormats(Vector candidates, Vector collected) {
	    GraphNode node = (GraphNode)candidates.firstElement();
	    candidates.removeElementAt(0);

	    if (node.input == null && 
		(node.plugin == null || !(node.plugin instanceof Codec))) {
		// shouldn't happen!
		Log.error("Internal error: doGetSupportedOutputFormats");
		return;
	    }

	    if (node.plugin != null) {

		// It may not seem necessary to do this since the
		// previous round has already verified the input.
		// But since the same plugin could have a different
		// input called on it on previous rounds, it needs to
		// be resetted to the designated input.  This has
		// caused a bug in failing setOutputFormat for some
		// codecs. 
		if (verifyInput(node.plugin, node.input) == null)
		    return;
	    }

	    Format input, outs[];
	    if (node.plugin != null) {
		outs = node.getSupportedOutputs(node.input);
		if (outs == null || outs.length == 0)
		    return;

		// Add the output formats to the collected list and
		// check for duplication.
		boolean found;
		int j, k, size;
		Format other;
		for (j = 0; j < outs.length; j++) {

		    size = collected.size();
		    found = false;

		    for (k = 0; k < size; k++) {
			other = (Format)collected.elementAt(k);
			if (other == outs[j] || other.equals(outs[j])) {
			    found = true;
			    break;
			} 
		    }

		    if (!found)
			collected.addElement(outs[j]);
		}
		input = node.input;
	    } else {
		outs = new Format[1];
		outs[0] = node.input;
		input = null;
	    }

	    // Don't go deeper than allowed.
	    if (node.level >= STAGES)
		return;

	    GraphNode gn, n;
	    Format fmt, ins[];
	    for (int i = 0; i < outs.length; i++) {

		// Ignore outputs that are the same as the input.
		if (input != null && input.equals(outs[i]))
		    continue;

		// Verify the output format.
		if (node.plugin != null &&
		    verifyOutput(node.plugin, outs[i]) == null) {
		    continue;
		}

		Vector cnames = PlugInManager.getPlugInList(outs[i], 
					null, PlugInManager.CODEC);
		if (cnames == null || cnames.size() == 0)
		    continue;

		for (int j = 0; j < cnames.size(); j++) {

		    // Instantiate and verify the codec.
		    if ((gn = getPlugInNode((String)cnames.elementAt(j), 
					PlugInManager.CODEC, plugIns)) == null)
			continue;

		    // Check to see if the particular input/plugin combination
		    // has already been attempted.  If so, we don't need to
		    // do it again.
		    if (gn.checkAttempted(outs[i]))
			continue;

		    ins = gn.getSupportedInputs();
		    if ((fmt = matches(outs[i], ins, null, gn.plugin)) == null)
			continue;
		    n = new GraphNode(gn, fmt, node, node.level+1);
		    candidates.addElement(n);
	    	    nodesVisited++;
		}
	    }
	}


	boolean buildGraph(BasicTrackControl tc, int trackID, int numTracks) {

	    this.trackID = trackID;
	    this.numTracks = numTracks;

	    // If the custom options are specified, we'll use the
	    // different routine that's specialized for this.
	    if (tc.isCustomized()) {
		Log.comment("Input: " + tc.getOriginalFormat());
		return buildCustomGraph((ProcTControl)tc);
	    }

	    return super.buildGraph(tc);
	}


	protected GraphNode buildTrackFromGraph(BasicTrackControl tc, GraphNode node) {
	    return engine.buildTrackFromGraph((ProcTControl)tc, node);
	}


	/**
	 * This defines when the search ends.  The "targets" array defines
	 * the nodes that are to be the "end points" (leaf nodes) of the
	 * graph.
	 * With the default graph builder, the targets array contains the
	 * list of sinks that can potentially support the input format.
	 */
	GraphNode findTarget(GraphNode node) {

	    Format outs[];

	    // Expand the outputs of the next node.
	    if (node.plugin == null) {
		outs = new Format[1];
		outs[0] = node.input;
	    } else {
		if (node.output != null) {
		    outs = new Format[1];
		    outs[0] = node.output;
		} else {
		    outs = node.getSupportedOutputs(node.input);
		    if (outs == null || outs.length == 0) {
			//Log.write("Weird!  The given plugin does not support any output."); 
			return null;
		    }
		}
	    }

	    // If there's a constraint format, check for that first.
	    if (targetFormat != null) {

		Format matched = null;

		if ((matched = matches(outs, targetFormat, node.plugin, null)) == null)
		    return null;

		if (inspector != null && 
		    !inspector.verify((Codec)node.plugin, node.input, matched))
		    return null;

		// If there's no more targets to match, we are done.
		if (targetPlugins == null && targetMuxes == null) {
		    node.output = matched;
		    return node;
		}

		// The matching target format is chosen.
		outs = new Format[1];
		outs[0] = matched;
	    }

	    GraphNode n;

	    // Check for the list of predefined targets.
	    if (targetPlugins != null) {
		if ((n = verifyTargetPlugins(node, outs)) != null)
		    return n;
		else
		    return null;
	    }

	    // Check for the list of predefined muxes.
	    if (targetMuxes != null && (n = verifyTargetMuxes(node, outs)) != null)
		return n;

	    return null;
	}
	    

	/**
	 * If a multiplexer is specified, check for that.
	 */
	GraphNode verifyTargetMuxes(GraphNode node, Format outs[]) {

	    Multiplexer mux;
	    GraphNode gn;
	    Format fmt;

	    for (int i = 0; i < targetMuxes.length; i++) {
		if ((gn = targetMuxes[i]) == null) {
		    String name = (String)targetMuxNames.elementAt(i);

		    if (name == null)
			continue;

		    // We'll want to instantiate it to get more info from it.
		    if ((gn = getPlugInNode(name, PlugInManager.MULTIPLEXER, 
				plugIns)) == null) {
			targetMuxNames.setElementAt(null, i);
			continue;
		    }

		    mux = (Multiplexer)gn.plugin;

		    if (mux.setContentDescriptor(outputContentDes) == null) {
			targetMuxNames.setElementAt(null, i);
			continue;
		    }

		    if (mux.setNumTracks(numTracks) != numTracks) {
			targetMuxNames.setElementAt(null, i);
			continue;
		    }

		    targetMuxes[i] = gn;
		}

		if (targetMux != null && gn != targetMux)
		    continue;

		for (int j = 0; j < outs.length; j++) {

		    if ((fmt = ((Multiplexer)gn.plugin).setInputFormat(outs[j], 
						trackID)) == null)
			continue;

		    // found the target.

		    if (inspector != null) {

			if (node.plugin != null &&
			    !inspector.verify((Codec)node.plugin, node.input, fmt))
			    continue;
		    }

		    targetMux = gn; 
		    targetMuxFormats[trackID] = fmt;
		    node.output = fmt;

		    return node;
		}
	    }

	    return null;
	}


	/**
	 * Set the default targets, which are the renderers.
	 */
	boolean setDefaultTargets(Format in) {

	    // If there's an output content descriptor specified,
	    // The targets will be a list of multiplexers.
	    if (outputContentDes != null)
		return setDefaultTargetMux();
	    else
		return setDefaultTargetRenderer(in);
	}


	boolean setDefaultTargetRenderer(Format in) {

	    if (!super.setDefaultTargetRenderer(in))
		return false;
	    targetMuxes = null;

	    return true;
	}


	boolean setDefaultTargetMux() {
	    // If the target muxes are already defined, we don't need
	    // to do that again.
	    if (targetMuxes != null)
		return true;

	    Log.comment("An output content type is specified: " + outputContentDes);

	    targetMuxNames = PlugInManager.getPlugInList(null,
			outputContentDes, PlugInManager.MULTIPLEXER);

	    if (targetMuxNames == null || targetMuxNames.size() == 0) {
		Log.error("No multiplexer is found for that content type: " +
				outputContentDes);
		return false;
	    }

	    targetMuxes = new GraphNode[targetMuxNames.size()];
	    targetMux = null;
	    targetMuxFormats = new Format[numTracks];

	    // The regular targets will not be used.
	    targetPluginNames = null;
	    targetPlugins = null;
	    return true;
	}


	/**
	 * Set the target to a custom plugin specified.
	 */
	void setTargetPlugin(PlugIn p, int type) {
	    targetPlugins = new GraphNode[1];
	    targetPlugins[0] = new GraphNode(p, null, null, 0);
	    targetPlugins[0].custom = true;
	    targetPlugins[0].type = type;
	}


	/******************************************
	 *
	 * Routines for building custom graphs
	 *
	 ******************************************/

	Codec codecs[] = null;
	Renderer rend = null;
	Format format = null;

	boolean buildCustomGraph(ProcTControl tc) {

	    this.codecs = tc.codecChainWanted;
	    this.rend = tc.rendererWanted;
	    this.format = tc.formatWanted;

	    if (format instanceof VideoFormat &&
		tc.getOriginalFormat() instanceof VideoFormat) {
		Dimension s1 = ((VideoFormat)tc.getOriginalFormat()).getSize();
		Dimension s2 = ((VideoFormat)format).getSize();
		if (s1 != null && s2 != null && !s1.equals(s2)) {

		    // The video needs to be resized.
		    // We'll instantiate the video scaler then
		    // insert it into the flow graph.
		    RGBScaler scaler = new RGBScaler(s2);

		    if (codecs == null || codecs.length == 0) {
			codecs = new Codec[1];
			codecs[0] = scaler;
		    } else {
			// There are some custom codecs specified.
			// We'll use some simple heuristics to determine
			// where to insert the scaler.
			codecs = new Codec[tc.codecChainWanted.length + 1];
			int i;
			if (!isRawVideo(format)) {
			     // The destination format is not a raw format.
			     // we'll insert the scaler at the front.
			     codecs[0] = scaler; 
			     i = 1;
			} else {
			     codecs[tc.codecChainWanted.length] = scaler;
			     i = 0;
			}

			for (int j = 0; j < tc.codecChainWanted.length; j++)
			     codecs[i++] = tc.codecChainWanted[j];
		    }
		}
	    }

	    GraphNode node, failed;

	    return ((node = buildCustomGraph(tc.getOriginalFormat())) != null) &&
		((failed = buildTrackFromGraph(tc, node)) == null);
	}


	/**
	 * Overrides GraphBuider's buildGraph method.
	 * The major difference is, it pay attentions to the effects,
	 * codecs, renderers specified.
	 */
	GraphNode buildCustomGraph(Format in) {
	    Vector candidates = new Vector();
	    GraphNode node, n = null;
	    Format fmt, fmts[];

	    // root.
	    node = new GraphNode(null, (PlugIn)null, in, null, 0);
	    candidates.addElement(node);

	    Log.comment("Custom options specified.");
	    indent = 1; 
	    Log.setIndent(indent);

	    // Handle custom codec chain.
	    if (codecs != null) {

	      resetTargets();

	      for (int i = 0; i < codecs.length; i++) {

		if (codecs[i] == null)
		    continue;

		Log.comment("A custom codec is specified: " + codecs[i]);

		// Set the custom target to be the next codec specified.
		setTargetPlugin(codecs[i], PlugInManager.CODEC);

		if ((node = buildGraph(candidates)) == null) {
		    Log.error("The input format is not compatible with the given codec plugin: " + codecs[i]);
		    indent = 0;
	    	    Log.setIndent(indent);
		    return null;
		}
		node.level = 0;
		candidates = new Vector();
		candidates.addElement(node);
	      }
	    }

	    if (outputContentDes != null) {

		resetTargets();

	        // Set the target format.
	        if (format != null) {
		    targetFormat = format;
		    Log.comment("An output format is specified: " + format);
		}

		// A mux is specified.
		if (!setDefaultTargetMux())
		    return null;

		if ((node = buildGraph(candidates)) == null) {
		    Log.error("Failed to build a graph for the given custom options.");
		    indent = 0;
	    	    Log.setIndent(indent);
		    return null;
		}

	   } else {

	        if (format != null) {

		    // A target format is set.  First find a route to
		    // to transcode to the target format.

		    resetTargets();

		    targetFormat = format;
		    Log.comment("An output format is specified: " + format);

		    if ((node = buildGraph(candidates)) == null) {
			Log.error("The input format cannot be transcoded to the specified target format.");
			indent = 0;
			Log.setIndent(indent);
			return null;
		    }
		    node.level = 0;
		    candidates = new Vector();
		    candidates.addElement(node);
		    targetFormat = null;
		}

		// Connect the rest of the graph to a renderer.

		if (rend != null) {
		    // Handle custom renderer.
		    Log.comment("A custom renderer is specified: " + rend);

		    // Set the custom target to be the renderer specified.
		    setTargetPlugin(rend, PlugInManager.RENDERER);

		    if ((node = buildGraph(candidates)) == null) {
			if (format != null)
			    Log.error("The customed transocoded format is not compatible with the given renderer plugin: " + rend);
			else
			    Log.error("The input format is not compatible with the given renderer plugin: " + rend);
			indent = 0;
			Log.setIndent(indent);
			return null;
		    }

		} else {

		    // Handle the default renderers.
		    if (!setDefaultTargetRenderer(format == null ? in : format))
			return null;

		    if ((node = buildGraph(candidates)) == null) {
			if (format != null)
			    Log.error("Failed to find a renderer that supports the customed transcoded format.");
			else
			    Log.error("Failed to build a graph to render the input format with the given custom options.");
			indent = 0;
			Log.setIndent(indent);
			return null;
		    }
		}
	    }

	    indent = 0;
	    Log.setIndent(indent);
	    return node;
	}


	public void reset() {
	    super.reset();
	    resetTargets();
	}


	/**
	 * Reset all the targets.
	 */
	void resetTargets() {
	    targetFormat = null;
	    targetPlugins = null;
	}

    }
}

