import com.xuggle.xuggler.Global; //导入依赖的package包/类
/**
 * Returns the time to sleep in milliseconds.
 * @param timestamp the timestamp
 * @param isVideoStream true if the media we are sync-ing is a video stream
 * @return long
 */
public long getSynchronizationTime(long timestamp, boolean isVideoStream) {
    if (this.firstTimestamp == Global.NO_PTS) {
    	// initialize the clock
    	this.firstTimestamp = timestamp;
    	this.startTime = System.currentTimeMillis();
    } else {
    	// compute the estimated sleep time for the current thread
        long systemClockCurrentTime = System.currentTimeMillis();
        long millisecondsClockTimeSinceStartofVideo = systemClockCurrentTime - startTime;
        long millisecondsStreamTimeSinceStartOfVideo = (long)Math.ceil((double)(timestamp - firstTimestamp) / 1000.0);
        // allow 50 milliseconds of tolerance
        final long millisecondsTolerance = isVideoStream ? 50 : 0;
        final long millisecondsToSleep = (millisecondsStreamTimeSinceStartOfVideo - (millisecondsClockTimeSinceStartofVideo + millisecondsTolerance));
        if (millisecondsToSleep > 0) {
        	return millisecondsToSleep;
        }
    }
    return 0;
}
 

import com.xuggle.xuggler.Global; //导入依赖的package包/类
private void setupReader(IContainer container) {
	// Set up a new reader using the container that reads the images.
	this.reader = ToolFactory.makeReader(container);
	this.reader.setBufferedImageTypeToGenerate(BufferedImage.TYPE_3BYTE_BGR);
	this.reader.addListener(new FrameGetter());

	// Find the video stream.
	IStream s = null;
	int i = 0;
	while (i < container.getNumStreams()) {
		s = container.getStream(i);
		if (s != null && s.getStreamCoder().getCodecType() == ICodec.Type.CODEC_TYPE_VIDEO) {
			// Save the stream index so that we only get frames from
			// this stream in the FrameGetter
			this.streamIndex = i;
			break;
		}
		i++;
	}

	if (container.getDuration() == Global.NO_PTS)
		this.totalFrames = -1;
	else
		this.totalFrames = (long) (s.getDuration() *
				s.getTimeBase().getDouble() * s.getFrameRate().getDouble());

	// If we found the video stream, set the FPS
	if (s != null)
		this.fps = s.getFrameRate().getDouble();

	// If we found a video stream, setup the MBFImage buffer.
	if (s != null) {
		final int w = s.getStreamCoder().getWidth();
		final int h = s.getStreamCoder().getHeight();
		this.width = w;
		this.height = h;
	}
}
 

import com.xuggle.xuggler.Global; //导入依赖的package包/类
private void printStreamInfo(IStream stream) {
    IStreamCoder coder = stream.getStreamCoder();
    IContainer container = stream.getContainer();
    String info = "";

    info += (String.format("type: %s; ", coder.getCodecType()));
    info += (String.format("codec: %s; ", coder.getCodecID()));
    info += String.format(
            "duration: %s; ",
            stream.getDuration() == Global.NO_PTS ? "unknown" : ""
                    + stream.getDuration());
    info += String.format("start time: %s; ",
            container.getStartTime() == Global.NO_PTS ? "unknown" : ""
                    + stream.getStartTime());
    info += String
            .format("language: %s; ",
                    stream.getLanguage() == null ? "unknown" : stream
                            .getLanguage());
    info += String.format("timebase: %d/%d; ", stream.getTimeBase()
            .getNumerator(), stream.getTimeBase().getDenominator());
    info += String.format("coder tb: %d/%d; ", coder.getTimeBase()
            .getNumerator(), coder.getTimeBase().getDenominator());

    if (coder.getCodecType() == ICodec.Type.CODEC_TYPE_AUDIO) {
        info += String.format("sample rate: %d; ", coder.getSampleRate());
        info += String.format("channels: %d; ", coder.getChannels());
        info += String.format("format: %s", coder.getSampleFormat());
    } else if (coder.getCodecType() == ICodec.Type.CODEC_TYPE_VIDEO) {
        info += String.format("width: %d; ", coder.getWidth());
        info += String.format("height: %d; ", coder.getHeight());
        info += String.format("format: %s; ", coder.getPixelType());
        info += String.format("frame-rate: %5.2f; ", coder.getFrameRate()
                .getDouble());
    }
    LOG.debug(info);
}
 

import com.xuggle.xuggler.Global; //导入依赖的package包/类
/**
 * Perform muxing of tracks and feed them to the facade.
 * 
 * @param feedAmount
 * @param clock
 * @return
 */
private double feedAudio(double feedAmount, double clock) {
	int requestedSamplesAmount = (int) ((feedAmount / 1000000d) * samplingRate);
	short[] samples = popMuxedData(requestedSamplesAmount);
	if (samples == null) {
		return 0;
	}
	facade.queueAudio(samples, (int) clock, Global.DEFAULT_TIME_UNIT);
	double result = samples.length / 2;
	result = (double)result / (double) samplingRate;
	result *= 1000000d;
	return result;
}
 

import com.xuggle.xuggler.Global; //导入依赖的package包/类
public void afterPropertiesSet() throws Exception {
	// put xuggle into turbo mode
	ToolFactory.setTurboCharged(true);
	if (log.isDebugEnabled()) {
		Global.setFFmpegLoggingLevel(99);
	}
	log.debug("Executor - prefers short tasks: {} daemon: {}", segmentExecutor.prefersShortLivedTasks(), segmentExecutor.isDaemon());
}
 

import com.xuggle.xuggler.Global; //导入依赖的package包/类
public void encodeVideo(IVideoPicture picture, long timeStamp, TimeUnit timeUnit) {
	log.debug("encodeVideo {}", outputUrl);
	// establish the stream, return silently if no stream returned
	if (null != picture) {
		IPacket videoPacket = IPacket.make();
		// encode video picture
		int result = videoCoder.encodeVideo(videoPacket, picture, 0);
		//System.out.printf("Flags v: %08x\n", videoCoder.getFlags());
		if (result < 0) {
			log.error("{} Failed to encode video: {} picture: {}", new Object[] { result, getErrorMessage(result), picture });
			videoPacket.delete();
			return;
		}
		videoComplete = videoPacket.isComplete();
		if (videoComplete) {
			final long timeStampMicro;
			if (timeUnit == null) {
				timeStampMicro = Global.NO_PTS;
			} else {
				timeStampMicro = MICROSECONDS.convert(timeStamp, timeUnit);
			}
			log.trace("Video timestamp {} us", timeStampMicro);
			// write packet
			writePacket(videoPacket);
			// add the duration of our video
			double dur = (timeStampMicro + videoPacket.getDuration() - prevVideoTime) / 1000000d;
			videoDuration += dur;
			log.trace("Duration - video: {}", dur);
			//double videoPts = (double) videoPacket.getDuration() * videoCoder.getTimeBase().getNumerator() / videoCoder.getTimeBase().getDenominator();
			//log.trace("Video pts - calculated: {} reported: {}", videoPts, videoPacket.getPts());
			prevVideoTime = timeStampMicro;
			videoPacket.delete();
		} else {
			log.warn("Video packet was not complete");
		}
	} else {
		throw new IllegalArgumentException("No picture");
	}
}
 

import com.xuggle.xuggler.Global; //导入依赖的package包/类
@Override
public double getDuration() {
	IRational timeBase = videoStream.getTimeBase();
	long      duration = videoStream.getDuration();
	return duration == Global.NO_PTS ? AbstractFrameSource.LENGTH_UNKNOWN : (duration * timeBase.getNumerator()) / (double)timeBase.getDenominator();
}
 

import com.xuggle.xuggler.Global; //导入依赖的package包/类
/**
 * Default constructor.
 */
public XugglerMediaClock() {
	this.firstTimestamp = Global.NO_PTS;
}
 

import com.xuggle.xuggler.Global; //导入依赖的package包/类
/**
 * Resets the clock.
 */
public void reset() {
    this.firstTimestamp = Global.NO_PTS;
}
 

import com.xuggle.xuggler.Global; //导入依赖的package包/类
private SampleData(short[] buffer) {
	this.id = index.getAndIncrement();
	this.buffer = ShortBuffer.wrap(buffer);
	this.pts = Global.NO_PTS;
}