用Java将一系列BuffereImage转换为视频？

如何将一组缓冲区图像转换为视频？我在做屏幕录音机

之后我将如何压缩视频？

为此，您将需要。Sun在JMF文档中对该主题有详细说明：

---

更新自Oracle接管以来，很多链接都断了，包括JMF链接。幸运的是，

JpegImagesToMovie.java

代码示例已经镜像。为了完整起见，这里有一个复制粘贴：

package org.apollo.jmf.test;

/*
 * @(#)JpegImagesToMovie.java   1.3 01/03/13
 *
 * Copyright (c) 1999-2001 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
 * modify and redistribute this software in source and binary code form,
 * provided that i) this copyright notice and license appear on all copies of
 * the software; and ii) Licensee does not utilize the software in a manner
 * which is disparaging to Sun.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
 * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
 * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
 * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
 * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
 * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
 * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
 * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
 * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
 * This software is not designed or intended for use in on-line control of
 * aircraft, air traffic, aircraft navigation or aircraft communications; or in
 * the design, construction, operation or maintenance of any nuclear
 * facility. Licensee represents and warrants that it will not use or
 * redistribute the Software for such purposes.
 */

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

import javax.media.*;
import javax.media.control.*;
import javax.media.protocol.*;
import javax.media.protocol.DataSource;
import javax.media.datasink.*;
import javax.media.format.VideoFormat;


/**
 * This program takes a list of JPEG image files and convert them into
 * a QuickTime movie.
 */
public class JpegImagesToMovie implements ControllerListener, DataSinkListener {

    public boolean doIt(int width, int height, int frameRate, Vector inFiles, MediaLocator outML) {
    ImageDataSource ids = new ImageDataSource(width, height, frameRate, inFiles);

    Processor p;

    try {
        System.err.println("- create processor for the image datasource ...");
        p = Manager.createProcessor(ids);
    } catch (Exception e) {
        System.err.println("Yikes!  Cannot create a processor from the data source.");
        return false;
    }

    p.addControllerListener(this);

    // Put the Processor into configured state so we can set
    // some processing options on the processor.
    p.configure();
    if (!waitForState(p, p.Configured)) {
        System.err.println("Failed to configure the processor.");
        return false;
    }

    // Set the output content descriptor to QuickTime. 
    p.setContentDescriptor(new ContentDescriptor(FileTypeDescriptor.QUICKTIME));

    // Query for the processor for supported formats.
    // Then set it on the processor.
    TrackControl tcs[] = p.getTrackControls();
    Format f[] = tcs[0].getSupportedFormats();
    if (f == null || f.length <= 0) {
        System.err.println("The mux does not support the input format: " + tcs[0].getFormat());
        return false;
    }

    tcs[0].setFormat(f[0]);

    System.err.println("Setting the track format to: " + f[0]);

    // We are done with programming the processor.  Let's just
    // realize it.
    p.realize();
    if (!waitForState(p, p.Realized)) {
        System.err.println("Failed to realize the processor.");
        return false;
    }

    // Now, we'll need to create a DataSink.
    DataSink dsink;
    if ((dsink = createDataSink(p, outML)) == null) {
        System.err.println("Failed to create a DataSink for the given output MediaLocator: " + outML);
        return false;
    }

    dsink.addDataSinkListener(this);
    fileDone = false;

    System.err.println("start processing...");

    // OK, we can now start the actual transcoding.
    try {
        p.start();
        dsink.start();
    } catch (IOException e) {
        System.err.println("IO error during processing");
        return false;
    }

    // Wait for EndOfStream event.
    waitForFileDone();

    // Cleanup.
    try {
        dsink.close();
    } catch (Exception e) {}
    p.removeControllerListener(this);

    System.err.println("...done processing.");

    return true;
    }


    /**
     * Create the DataSink.
     */
    DataSink createDataSink(Processor p, MediaLocator outML) {

    DataSource ds;

    if ((ds = p.getDataOutput()) == null) {
        System.err.println("Something is really wrong: the processor does not have an output DataSource");
        return null;
    }

    DataSink dsink;

    try {
        System.err.println("- create DataSink for: " + outML);
        dsink = Manager.createDataSink(ds, outML);
        dsink.open();
    } catch (Exception e) {
        System.err.println("Cannot create the DataSink: " + e);
        return null;
    }

    return dsink;
    }


    Object waitSync = new Object();
    boolean stateTransitionOK = true;

    /**
     * Block until the processor has transitioned to the given state.
     * Return false if the transition failed.
     */
    boolean waitForState(Processor p, int state) {
    synchronized (waitSync) {
        try {
        while (p.getState() < state && stateTransitionOK)
            waitSync.wait();
        } catch (Exception e) {}
    }
    return stateTransitionOK;
    }


    /**
     * Controller Listener.
     */
    public void controllerUpdate(ControllerEvent evt) {

    if (evt instanceof ConfigureCompleteEvent ||
        evt instanceof RealizeCompleteEvent ||
        evt instanceof PrefetchCompleteEvent) {
        synchronized (waitSync) {
        stateTransitionOK = true;
        waitSync.notifyAll();
        }
    } else if (evt instanceof ResourceUnavailableEvent) {
        synchronized (waitSync) {
        stateTransitionOK = false;
        waitSync.notifyAll();
        }
    } else if (evt instanceof EndOfMediaEvent) {
        evt.getSourceController().stop();
        evt.getSourceController().close();
    }
    }


    Object waitFileSync = new Object();
    boolean fileDone = false;
    boolean fileSuccess = true;

    /**
     * Block until file writing is done. 
     */
    boolean waitForFileDone() {
    synchronized (waitFileSync) {
        try {
        while (!fileDone)
            waitFileSync.wait();
        } catch (Exception e) {}
    }
    return fileSuccess;
    }


    /**
     * Event handler for the file writer.
     */
    public void dataSinkUpdate(DataSinkEvent evt) {

    if (evt instanceof EndOfStreamEvent) {
        synchronized (waitFileSync) {
        fileDone = true;
        waitFileSync.notifyAll();
        }
    } else if (evt instanceof DataSinkErrorEvent) {
        synchronized (waitFileSync) {
        fileDone = true;
        fileSuccess = false;
        waitFileSync.notifyAll();
        }
    }
    }


    public static void main(String args[]) {

    if (args.length == 0)
        prUsage();

    // Parse the arguments.
    int i = 0;
    int width = -1, height = -1, frameRate = 1;
    Vector inputFiles = new Vector();
    String outputURL = null;

    while (i < args.length) {

        if (args[i].equals("-w")) {
        i++;
        if (i >= args.length)
            prUsage();
        width = new Integer(args[i]).intValue();
        } else if (args[i].equals("-h")) {
        i++;
        if (i >= args.length)
            prUsage();
        height = new Integer(args[i]).intValue();
        } else if (args[i].equals("-f")) {
        i++;
        if (i >= args.length)
            prUsage();
        frameRate = new Integer(args[i]).intValue();
        } else if (args[i].equals("-o")) {
        i++;
        if (i >= args.length)
            prUsage();
        outputURL = args[i];
        } else {
            for (int j = 0; j < 120; j++) {
                inputFiles.addElement(args[i]);
            }
        }
        i++;
    }

    if (outputURL == null || inputFiles.size() == 0)
        prUsage();

    // Check for output file extension.
    if (!outputURL.endsWith(".mov") && !outputURL.endsWith(".MOV")) {
        System.err.println("The output file extension should end with a .mov extension");
        prUsage();
    }

    if (width < 0 || height < 0) {
        System.err.println("Please specify the correct image size.");
        prUsage();
    }

    // Check the frame rate.
    if (frameRate < 1)
        frameRate = 1;

    // Generate the output media locators.
    MediaLocator oml;

    if ((oml = createMediaLocator(outputURL)) == null) {
        System.err.println("Cannot build media locator from: " + outputURL);
        System.exit(0);
    }

    JpegImagesToMovie imageToMovie = new JpegImagesToMovie();
    imageToMovie.doIt(width, height, frameRate, inputFiles, oml);

    System.exit(0);
    }

    static void prUsage() {
    System.err.println("Usage: java JpegImagesToMovie -w <width> -h <height> -f <frame rate> -o <output URL> <input JPEG file 1> <input JPEG file 2> ...");
    System.exit(-1);
    }

    /**
     * Create a media locator from the given string.
     */
    static MediaLocator createMediaLocator(String url) {

    MediaLocator ml;

    if (url.indexOf(":") > 0 && (ml = new MediaLocator(url)) != null)
        return ml;

    if (url.startsWith(File.separator)) {
        if ((ml = new MediaLocator("file:" + url)) != null)
        return ml;
    } else {
        String file = "file:" + System.getProperty("user.dir") + File.separator + url;
        if ((ml = new MediaLocator(file)) != null)
        return ml;
    }

    return null;
    }


    ///////////////////////////////////////////////
    //
    // Inner classes.
    ///////////////////////////////////////////////


    /**
     * A DataSource to read from a list of JPEG image files and
     * turn that into a stream of JMF buffers.
     * The DataSource is not seekable or positionable.
     */
    class ImageDataSource extends PullBufferDataSource {

    ImageSourceStream streams[];

    ImageDataSource(int width, int height, int frameRate, Vector images) {
        streams = new ImageSourceStream[1];
        streams[0] = new ImageSourceStream(width, height, frameRate, images);
    }

    public void setLocator(MediaLocator source) {
    }

    public MediaLocator getLocator() {
        return null;
    }

    /**
     * Content type is of RAW since we are sending buffers of video
     * frames without a container format.
     */
    public String getContentType() {
        return ContentDescriptor.RAW;
    }

    public void connect() {
    }

    public void disconnect() {
    }

    public void start() {
    }

    public void stop() {
    }

    /**
     * Return the ImageSourceStreams.
     */
    public PullBufferStream[] getStreams() {
        return streams;
    }

    /**
     * We could have derived the duration from the number of
     * frames and frame rate.  But for the purpose of this program,
     * it's not necessary.
     */
    public Time getDuration() {
        return DURATION_UNKNOWN;
    }

    public Object[] getControls() {
        return new Object[0];
    }

    public Object getControl(String type) {
        return null;
    }
    }


    /**
     * The source stream to go along with ImageDataSource.
     */
    class ImageSourceStream implements PullBufferStream {

    Vector images;
    int width, height;
    VideoFormat format;

    int nextImage = 0;  // index of the next image to be read.
    boolean ended = false;

    public ImageSourceStream(int width, int height, int frameRate, Vector images) {
        this.width = width;
        this.height = height;
        this.images = images;

        format = new VideoFormat(VideoFormat.JPEG,
                new Dimension(width, height),
                Format.NOT_SPECIFIED,
                Format.byteArray,
                (float)frameRate);
    }

    /**
     * We should never need to block assuming data are read from files.
     */
    public boolean willReadBlock() {
        return false;
    }

    /**
     * This is called from the Processor to read a frame worth
     * of video data.
     */
    public void read(Buffer buf) throws IOException {

        // Check if we've finished all the frames.
        if (nextImage >= images.size()) {
        // We are done.  Set EndOfMedia.
        System.err.println("Done reading all images.");
        buf.setEOM(true);
        buf.setOffset(0);
        buf.setLength(0);
        ended = true;
        return;
        }

        String imageFile = (String)images.elementAt(nextImage);
        nextImage++;

        System.err.println("  - reading image file: " + imageFile);

        // Open a random access file for the next image. 
        RandomAccessFile raFile;
        raFile = new RandomAccessFile(imageFile, "r");

        byte data[] = null;

        // Check the input buffer type & size.

        if (buf.getData() instanceof byte[])
        data = (byte[])buf.getData();

        // Check to see the given buffer is big enough for the frame.
        if (data == null || data.length < raFile.length()) {
        data = new byte[(int)raFile.length()];
        buf.setData(data);
        }

        // Read the entire JPEG image from the file.
        raFile.readFully(data, 0, (int)raFile.length());

        System.err.println("    read " + raFile.length() + " bytes.");

        buf.setOffset(0);
        buf.setLength((int)raFile.length());
        buf.setFormat(format);
        buf.setFlags(buf.getFlags() | buf.FLAG_KEY_FRAME);

        // Close the random access file.
        raFile.close();
    }

    /**
     * Return the format of each video frame.  That will be JPEG.
     */
    public Format getFormat() {
        return format;
    }

    public ContentDescriptor getContentDescriptor() {
        return new ContentDescriptor(ContentDescriptor.RAW);
    }

    public long getContentLength() {
        return 0;
    }

    public boolean endOfStream() {
        return ended;
    }

    public Object[] getControls() {
        return new Object[0];
    }

    public Object getControl(String type) {
        return null;
    }
    }
}

package org.apollo.jmf.test；
/*
*@（#）JpegImagesToMovie.java 1.3 01/03/13
*
*版权所有（c）1999-2001 Sun Microsystems，Inc.保留所有权利。
*
*Sun授予您（“被许可人”）非独家、免版税的使用许可，
*以源代码和二进制代码的形式修改并重新发布此软件，
*前提是i）本版权声明和许可证出现在
*软件；以及ii）被许可方未以以下方式使用软件：
*这是对太阳的蔑视。
*
*本软件按“原样”提供，不提供任何形式的担保。全部的
*明示或暗示的条件、陈述和保证，包括
*对适销性、特定用途的适用性或
*不侵权，特此排除。SUN及其许可方不得
*对被许可方因使用、修改或更换而遭受的任何损害负责
*或分发软件或其衍生产品。在任何情况下，太阳或它的
*许可方应对任何收入、利润或数据损失或直接，
*但是，间接、特殊、后果性、附带或惩罚性损害赔偿
*而不论责任理论如何，因使用而产生的
*或者无法使用软件，即使SUN已被告知
*这种损害的可能性。
*
*本软件的设计或使用目的不是在线控制
*飞机、空中交通、飞机导航或飞机通信；或者
*任何核设施的设计、建造、运行或维护
*设施。被许可人声明并保证其不会使用或
*为此目的重新分发软件。
*/
导入java.io.*；
导入java.util.*；
导入java.awt.Dimension；
导入javax.media.*；
导入javax.media.control.*；
导入javax.media.protocol.*；
导入javax.media.protocol.DataSource；
导入javax.media.datasink.*；
导入javax.media.format.VideoFormat；
/**
*该程序获取JPEG图像文件列表并将其转换为
*快节奏电影。
*/
公共类JpegImagesToMovie实现ControllerListener、DataSinkListener{
公共布尔doIt（int-width、int-height、int-frameRate、向量填充、MediaLocator-outML）{
ImageDataSource ID=新的ImageDataSource（宽度、高度、帧率、填充）；
处理器p；
试一试{
System.err.println（“-create processor for the image datasource…”）；
p=Manager.createProcessor（ids）；
}捕获（例外e）{
System.err.println（“Yikes！无法从数据源创建处理器。”）；
返回false；
}
p、 addControllerListener（本）；
//将处理器置于已配置状态，以便我们可以设置
//处理器上的一些处理选项。
p、 configure（）；
如果（！waitForState（p，p.Configured））{
System.err.println（“未能配置处理器”）；
返回false；
}
//将输出内容描述符设置为QuickTime。
p、 setContentDescriptor（新的ContentDescriptor（FileTypeDescriptor.QUICKTIME））；
//查询处理器支持的格式。
//然后在处理器上设置它。
轨迹控制tcs[]=p.getTrackControls（）；
格式f[]=tcs[0]。getSupportedFormats（）；
if（f==null | | f.length=args.length）
prUsage（）；
宽度=新整数（args[i]）.intValue（）；
}else if（args[i].等于（“-h”））{
i++；
如果（i>=参数长度）
prUsage（）；
高度=新整数（args[i]）.intValue（）；
}else if（args[i].等于（“-f”））{
i++；
如果（i>=参数长度）
prUsage（）；
帧率=新整数（args[i]）.intValue（）；
}else if（args[i].equals（“-o”））{
i++；
如果（i>=参数长度）
prUsage（）；
outputURL=args[i]；
}否则{
对于（int j=0；j<120；j++）{
addElement（args[i]）；
}
}
i++；
}
if（outputURL==null | | inputFiles.size（）==0）
prUsage（）；
//检查输出文件扩展名。
如果（！outputURL.endsWith（“.mov”）和（&！outputURL.endsWith（.mov”））{
System.err.println（“输出文件扩展名应以.mov扩展名结尾”）；
prUsage（）；
}
如果（宽度<0 | |高度<0）{
System.err.println（“请指定正确的图像大小”）；
prUsage（）；
}
//检查帧速率。
如果（帧率<1）
帧率=1；
//生成输出媒体定位器。
媒体定位器oml；
if（（oml=createMediaLocator（outputURL））==null）{
System.err.println（“无法从“+outputURL”生成媒体定位器）；
系统出口（0）；
}
JpegImagesToMovie imageToMovie=新的JpegImagesToMovie（）；
doIt（宽度、高度、帧率、输入文件、oml）；
系统出口（0）；
}
静态孔隙prUsage（）{
System.err.println（“用法：javajpegimagestomovie-w-h-f-o…”）；
系统退出（-1）；
}
/**
*从给定字符串创建媒体定位器。
*/
静态MediaLocator createMediaLocator（字符串url）{
媒体定位仪；
如果（url.indexOf（“：”）>0&&（ml=newMediaLocator（url））！=null）
返回ml；
if（url.startsWith（File.separator））{
if（（ml=新的MediaLocator（“文件：“+url”）！=null）
返回ml；
}否则{
String file=“file:”+System.getProperty（“user.dir”）+file.separator+url；
if（（ml=新的MediaLocator（文件））！=null）
返回ml；