Time frameDelay = Seconds (0);

      pkt->AddHeader (ch);

      Time eventTime = startDelay + frameDelay;

      Simulator::Schedule (eventTime, &UanMacRc::SendPacket, this, pkt, m_currentRate);

      frameDelay = frameDelay + m_sifs + Seconds (pkt->GetSize () / currentBps);

        mFakeCurrPts = mFakeNextPts;

        double frameDelay = av_rescale(timeBase->getNumerator(),

            AV_TIME_BASE, timeBase->getDenominator());

        frameDelay += avFrame->repeat_pict * (frameDelay * 0.5);

        // adjust our next Pts pointer

        mFakeNextPts += (int64_t) frameDelay;

        protected Dictionary<String, String[]> _StateFrameImageKeys = new Dictionary<string, string[]>();

        //protected int FrameDelay = 35; //delay between frame changes.

        protected Dictionary<String, int[]> FrameDelayTimes = new Dictionary<string, int[]>();

                StateFrameIndex.Clear();

                FrameDelayTimes.Clear();

                    FrameDelayTimes.Add(kvp.Key, CreateArray<int>(50, kvp.Value.Length));

        protected Dictionary<String, int> StateFrameIndex = new Dictionary<string, int>();

        public GameEnemy(PointF Position, Dictionary<String, String[]> StateFrameData, int FrameDelay)

            : this(Position, StateFrameData, FrameDelay, null)

        private int GetFrameDelayTime()

        {

            /*if (FrameDelayTimes == null || FrameDelayTimes.Count < StateFrameIndex[_EnemyState])

    float frameDelay = narrowPrecisionToFloat(estimationFrame.extractAverageGroupDelay());

    return frameDelay;

HRTFKernel::HRTFKernel(AudioChannel* channel, size_t fftSize, float sampleRate, bool bassBoost)

    : m_frameDelay(0)

    // Determine the leading delay (average group delay) for the response.

    m_frameDelay = extractAverageGroupDelay(channel, fftSize / 2);

    // Add leading delay back in.

    fftFrame.addConstantGroupDelay(m_frameDelay);

    float frameDelay = (1 - x) * kernel1->frameDelay() + x * kernel2->frameDelay();

    OwnPtr<FFTFrame> interpolatedFrame = FFTFrame::createInterpolatedFrame(*kernel1->fftFrame(), *kernel2->fftFrame(), x);

    return HRTFKernel::create(interpolatedFrame.release(), frameDelay, sampleRate1);

    float frameDelay = narrowPrecisionToFloat(estimationFrame.extractAverageGroupDelay());

    return frameDelay;

HRTFKernel::HRTFKernel(AudioChannel* channel, size_t fftSize, float sampleRate, bool bassBoost)

    : m_frameDelay(0)

    // Determine the leading delay (average group delay) for the response.

    m_frameDelay = extractAverageGroupDelay(channel, fftSize / 2);

    // Add leading delay back in.

    fftFrame.addConstantGroupDelay(m_frameDelay);

    float frameDelay = (1 - x) * kernel1->frameDelay() + x * kernel2->frameDelay();

    OwnPtr<FFTFrame> interpolatedFrame = FFTFrame::createInterpolatedFrame(*kernel1->fftFrame(), *kernel2->fftFrame(), x);

    return HRTFKernel::create(interpolatedFrame.release(), frameDelay, sampleRate1);

    double frameDelay = estimationFrame.extractAverageGroupDelay();

    return frameDelay;

HRTFKernel::HRTFKernel(AudioChannel* channel, size_t fftSize, double sampleRate, bool bassBoost)

    : m_frameDelay(0.0)

    // Determine the leading delay (average group delay) for the response.

    m_frameDelay = extractAverageGroupDelay(channel, fftSize / 2);

    // Add leading delay back in.

    fftFrame.addConstantGroupDelay(m_frameDelay);

    double frameDelay = (1.0 - x) * kernel1->frameDelay() + x * kernel2->frameDelay();

    OwnPtr<FFTFrame> interpolatedFrame = FFTFrame::createInterpolatedFrame(*kernel1->fftFrame(), *kernel2->fftFrame(), x);

    return HRTFKernel::create(interpolatedFrame.release(), frameDelay, sampleRate1);

    // Screen refresh information

    private static long timeElapsed, frameDelay;

                        g.setColor(Color.white);

                        s = "Frame Delay: " + frameDelay + " (FPS: " + framesPerSecond + ")";

                 */

                frameDelay = ((lastLoopTime + (debug ? DEBUGDELAY : DELAY) * 1000000 - System.nanoTime()) / 1000000);

                // Sleep for specified time

                Thread.sleep(frameDelay); 

    private long 	timeElapsed;

    private long 	frameDelay;

                    g.setColor(Color.white);

                    s = "Frame Delay: " + frameDelay + " (FPS: " + framesPerSecond + ")";

                 */

                frameDelay = ((lastLoopTime + (gameDebug ? DEBUGDELAY : DELAY) * 1000000 - System.nanoTime()) / 1000000);

                // Sleep for specified time

                Thread.sleep(frameDelay); 

        public string Uri { get; private set; }

        public uint FrameDelay { get; private set; }

            string uri, 

            uint frameDelay,

            Uri = uri;

            FrameDelay = frameDelay;

      int frameDelay = delay/length;

      int sampleDelay = delay-frameDelay*length;

      ObjectRef secondValue=nilObject;

      if (count-frameDelay-1 >=0 )

	 firstValue = getInput(inputID, count-frameDelay-1);

      if (count-frameDelay >=0 )

	 secondValue = getInput(inputID, count-frameDelay);

      int frameDelay = delay/length;

      int sampleDelay = delay-frameDelay*length;

      ObjectRef secondValue=Object::nilObject;

      if (count-frameDelay-1 >=0 )

	 firstValue = getInput(inputID, count-frameDelay-1);

      if (count-frameDelay >=0 )

	 secondValue = getInput(inputID, count-frameDelay);

      int frameDelay = delay/length;

      int sampleDelay = delay-frameDelay*length;

      ObjectRef secondValue=Object::nilObject;

      if (count-frameDelay-1 >=0 )

	 firstValue = getInput(inputID, count-frameDelay-1);

      if (count-frameDelay >=0 )

	 secondValue = getInput(inputID, count-frameDelay);

            spinningLetter.Repeat = cycles;

            spinningLetter.FrameDelay = pause;

            spinningBar.Repeat = cycles;

            spinningBar.FrameDelay = pause;

            spinningAnimation.Repeat = cycles;

            spinningAnimation.FrameDelay = pause;

            spinningAnimation.Repeat = cycles;

            spinningAnimation.FrameDelay = pause;

            spinningDiagonals.Repeat = cycles;

            spinningDiagonals.FrameDelay = pause;

            pulsingCube.Repeat = cycles;

            pulsingCube.FrameDelay = pause;

		switch(Type){

		case TYPE11_ICE:return 2*AScreen.FrameDelay;

		case TYPE12_ICE:return 4*AScreen.FrameDelay;

		case TYPE13_ICE:return 8*AScreen.FrameDelay;

		case TYPE41_ICE:return 2*AScreen.FrameDelay;

		case TYPE42_ICE:return 4*AScreen.FrameDelay;

		switch(Type){

		case TYPE21_FIRE:return 5*AScreen.FrameDelay;

		case TYPE22_FIRE:return 10*AScreen.FrameDelay;

		case TYPE23_FIRE:return 15*AScreen.FrameDelay;

		case TYPE51_FIRE:return 5*AScreen.FrameDelay;

		case TYPE52_FIRE:return 10*AScreen.FrameDelay;

		case TYPE53_FIRE:return 15*AScreen.FrameDelay;

		}

		long tickDelay = 1000 / this.TPS;

		long frameDelay = 1000 / this.FPS;

		long nextTick = lastTick + tickDelay;

		long nextFrame = lastFrame + frameDelay;

					}

					nextFrame += frameDelay;

				this.renderer.render();

				nextFrame += frameDelay;

    private int frameCount;                 // Counts ticks for change

    private int frameDelay;                 // frame delay 1-12 (You will have to play around with this)

    	// Get frame delay

    	frameDelay = Integer.parseInt(lines[1]);

            if (frameCount > frameDelay) 

         */

        public void DelayedStateChange(Indexer changeTo, int frameDelay)

#if DEBUG

            if (frameDelay <= 0)

            switchTo = changeTo;

            switchCounter = frameDelay;

		    frameCount = 0;

		    frameDelay = throwDistance;

		    if(frameCount >= frameDelay) {

    		    }

    		    frameDelay = 2;

		    frameCount = 0;

		    frameDelay = throwDistance;

		    if(frameCount >= frameDelay) {

    		    }

    		    frameDelay = 2;

                           PRUint32* frameBlend,

                           PRUint32* frameDelay,

    // delay=# (in ms)

    } else if (nsCRT::strcmp(token, "delay") == 0 && frameDelay) {

      if (PR_sscanf(value, "%u", frameDelay) != 1) { return NS_ERROR_INVALID_ARG; }