Java 如何使用xuggler从flash视频中仅创建一个缩略图？

我正在尝试从*flv视频的随机位置创建一个缩略图。 我在网上找到的代码示例并没有真正的帮助

---

或者有一个代码或方法可以，请分享/解释。谢谢。

我已经浏览了这里提供的示例代码(http://www.javacodegeeks.com/2011/02/xuggler-tutorial-frames-capture-video.html)这将从给定的输入视频文件中创建缩略图。为了只创建一个缩略图，可以引入类级成员变量（在示例代码中，变量名为Image抓取）。该变量只跟踪缩略图的生成，一旦创建了第一个缩略图，就在调用函数中生成（在示例代码中，调用函数是main（））while循环退出

希望这有帮助

问候,， 伊斯梅尔

/**
*VideoThumbnailsExample.java 2012年10月29日
*/
包com.test；
导入java.awt.image.buffereImage；
导入java.io.File；
导入java.io.IOException；
导入javax.imageio.imageio；
导入com.xuggle.mediatool.IMediaReader；
导入com.xuggle.mediatool.MediaListenerAdapter；
导入com.xuggle.mediatool.ToolFactory；
导入com.xuggle.mediatool.event.ivideoctureevent；
导入com.xuggle.xuggler.Global；
/**
* 
*Java文件。
*标题：VideoThumbnailsExample.java
*说明：
* 
*/
公共类VideoThumbnailsExample
{
公共静态两帧之间的最后双秒=1；
私有静态最终字符串inputFilename=“/Users/ismail/practice/vlc/sample.3gp”；
私有静态最终字符串outputFilePrefix=“/Users/ismail/practice/vlc/”；
//视频流索引，用于确保显示来自一个或多个视频流的帧
//仅来自媒体容器的一个视频流。
私有静态int mVideoStreamIndex=-1；
//最后一帧写入时间
私有静态长mLastPtsWrite=Global.NO_PTS；
公共静态最终长微秒（帧间）=（长）（Global.DEFAULT\u PTS\u PER\u SECONDS*帧间秒）；
公共静态void main（字符串[]args）
{
long startTime=System.currentTimeMillis（）；
长停车时间=0L；
IMediaReader-mediaReader=ToolFactory.makeReader（inputFilename）；
//规定我们需要以BGR 24位颜色创建缓冲区图像
//空间
尝试
{
媒体阅读器
.setBufferedImageTypeToGenerate（BufferedImage.TYPE_3BYTE_BGR）；
ImageSnapListener isListener=新的ImageSnapListener（）；
mediaReader.addListener（isListener）；
//读取媒体文件的内容，然后
//将事件分派到附加的侦听器
而（！isListener.isImage（））
{
mediaReader.readPacket（）；
}
/*
while（mediaReader.readPacket（）==null）
;
*/
//mediaReader.readPacket（）；
stopTime=System.currentTimeMillis（）；
}
捕获（例外情况除外）
{
例如printStackTrace（）；
}
System.out.println（“总时间：+（停止时间开始时间））；
}
私有静态类ImageSnapListener扩展MediaListenerAdapter
{
公共布尔值=false；
视频图片公开作废（IVideoPictureEvent事件）
{
if（event.getStreamIndex（）！=mVideoStreamIndex）
{
//如果选定的视频流id尚未设置，请继续
//选择此幸运视频流
如果（mVideoStreamIndex==-1）
mVideoStreamIndex=event.getStreamIndex（）；
//无需显示此视频流中的帧
其他的
返回；
}
//如果未初始化，则返回日期mLastPtsWrite以获取第一个
//框架
如果（mLastPtsWrite==Global.NO_PTS）
mLastPtsWrite=event.getTimeStamp（）
-帧之间的微秒；
//如果是时候写下一帧了
if（event.getTimeStamp（）-mLastPtsWrite>=MICRO\u帧之间的秒数）
{
字符串outputFilename=dumpImageToFile（event.getImage（））；
this.imagehapped=true；//从电影中抓取图像后，将此变量设置为true。
//指示已写入的文件
双秒=（（双）事件。getTimeStamp（））
/Global.DEFAULT_PTS_PER_SECOND；
System.out.printf（“在经过%6.3f秒时写入：%s\n”，秒，outputFilename）；
//System.out.printf（“在经过%6.3f秒时写入：SOMEFILE\n”，秒）；
//更新上次写入时间
mLastPtsWrite+=帧之间的微秒；
}
}
私有字符串dumpImageToFile（BuffereImage映像）
{
尝试
{
字符串outputFilename=outputFilePrefix
+System.currentTimeMillis（）+“.jpg”；
System.out.println（“缩略图名称将为：===>”+outputFilename）；
write（图像，“jpg”，新文件（outputFilename））；
返回outputFilename；
}
捕获（IOE异常）
{
e、 printStackTrace（）；
返回null；
}
}
公共布尔值（）{
返回图像；
}
}
}

是否可以在以后的帧中创建缩略图？此代码在0:00创建图像修改此：

如果（event.getTimeStamp（）-mLastPtsWrite>=帧间微秒）

到此

如果（event.getTimeStamp（）-mLastPtsWrite>=（帧间微秒*3））

。您可以看到，我已将帧间的

微秒数乘以3。您可以使用任何其他方法
/**
 * VideoThumbnailsExample.java Oct 29, 2012
 */
package com.test;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

import com.xuggle.mediatool.IMediaReader;
import com.xuggle.mediatool.MediaListenerAdapter;
import com.xuggle.mediatool.ToolFactory;
import com.xuggle.mediatool.event.IVideoPictureEvent;
import com.xuggle.xuggler.Global;

/**
 * <pre>
 * Java File.
 * Title        : VideoThumbnailsExample.java
 * Description  : <Description>
 * </pre>
 */
public class VideoThumbnailsExample
{
    public static final double SECONDS_BETWEEN_FRAMES = 1;

    private static final String inputFilename = "/Users/ismail/practice/vlc/sample.3gp";
    private static final String outputFilePrefix = "/Users/ismail/practice/vlc/";

    // The video stream index, used to ensure we display frames from one and
    // only one video stream from the media container.
    private static int mVideoStreamIndex = -1;

    // Time of last frame write
    private static long mLastPtsWrite = Global.NO_PTS;

    public static final long MICRO_SECONDS_BETWEEN_FRAMES = (long) (Global.DEFAULT_PTS_PER_SECOND * SECONDS_BETWEEN_FRAMES);

    public static void main(String[] args)
    {
        long startTime = System.currentTimeMillis();
        long stopTime = 0L;

        IMediaReader mediaReader = ToolFactory.makeReader(inputFilename);

        // stipulate that we want BufferedImages created in BGR 24bit color
        // space

        try
        {
            mediaReader
            .setBufferedImageTypeToGenerate(BufferedImage.TYPE_3BYTE_BGR);

            ImageSnapListener isListener = new ImageSnapListener();

            mediaReader.addListener(isListener);

            // read out the contents of the media file and
            // dispatch events to the attached listener

            while (!isListener.isImageGrabbed())
            {
                mediaReader.readPacket();
            }
            /*
            while (mediaReader.readPacket() == null)
                ;
            */
            //mediaReader.readPacket();
            stopTime = System.currentTimeMillis();

        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }



        System.out.println("Total Time: " + (stopTime-startTime));


    }

    private static class ImageSnapListener extends MediaListenerAdapter
    {
        public boolean imageGrabbed = false;


        public void onVideoPicture(IVideoPictureEvent event)
        {

            if (event.getStreamIndex() != mVideoStreamIndex)
            {

                // if the selected video stream id is not yet set, go ahead an
                // select this lucky video stream

                if (mVideoStreamIndex == -1)
                    mVideoStreamIndex = event.getStreamIndex();

                // no need to show frames from this video stream
                else
                    return;

            }

            // if uninitialized, back date mLastPtsWrite to get the very first
            // frame

            if (mLastPtsWrite == Global.NO_PTS)

                mLastPtsWrite = event.getTimeStamp()
                        - MICRO_SECONDS_BETWEEN_FRAMES;

            // if it's time to write the next frame

            if (event.getTimeStamp() - mLastPtsWrite >= MICRO_SECONDS_BETWEEN_FRAMES)
            {

                String outputFilename = dumpImageToFile(event.getImage());

                this.imageGrabbed = true; //set this var to true once an image is grabbed out of the movie.

                // indicate file written
                double seconds = ((double) event.getTimeStamp())
                        / Global.DEFAULT_PTS_PER_SECOND;

                System.out.printf("at elapsed time of %6.3f seconds wrote: %s\n",seconds, outputFilename);
                //System.out.printf("at elapsed time of %6.3f seconds wrote: SOMEFILE\n",seconds);

                // update last write time
                mLastPtsWrite += MICRO_SECONDS_BETWEEN_FRAMES;

            }

        }

        private String dumpImageToFile(BufferedImage image)
        {

            try
            {

                String outputFilename = outputFilePrefix
                        + System.currentTimeMillis() + ".jpg";

                System.out.println("Thumbnail image name is going to be : =====>" + outputFilename);

                ImageIO.write(image, "jpg", new File(outputFilename));

                return outputFilename;

            }

            catch (IOException e)
            {
                e.printStackTrace();
                return null;

            }

        }

        public boolean isImageGrabbed() {
            return imageGrabbed;
        }

    }

}