Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· OpenAIAi2 WildChat-4.8M (AI2)

Java如何取出FFmpegFrameRecorder设置的timestamp

  1. User

    Java如何取出FFmpegFrameRecorder设置的timestamp

  2. Assistant

    可以通过FFmpegFrameRecorder类中的getTimestamp()方法来获取设置的timestamp,如下所示:

    FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(filePath, imageWidth, imageHeight, audioChannels);
    recorder.setTimestamp(System.currentTimeMillis());
    long timestamp = recorder.getTimestamp();
    System.out.println("Timestamp = " + timestamp);
    

    在上面的示例代码中,我们首先创建一个FFmpegFrameRecorder对象,并使用setTimestamp()方法设置timestamp。然后,我们使用getTimestamp()方法获取设置的timestamp并将其输出到控制台上。

  3. User

    接收端如何取出FFmpegFrameRecorder设置的timestamp

  4. Assistant

    接收端无法直接获取FFmpegFrameRecorder设置的timestamp,因为这个timestamp是应用于发送端的。

    在接收端,你可以根据你自己的需求设置一些标记或者时间戳记录接收到的视频帧、音频帧和其他相关信息,以便后续处理或者分析。建议使用自己的时间戳,而不是从发送端获取的timestamp,因为两个时间点之间存在网络延迟等不确定性因素,导致收到的视频帧不一定与发送端发送的时间点完全对应。

    下面是一个接收端采用自己的时间戳记录的示例代码:

    FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(url);
    grabber.start();
    long startTime = System.currentTimeMillis(); // 记录开始时间
    long timestamp = 0; // 自己设置的时间戳
    while (true) {
        Frame frame = grabber.grab();
        if (frame == null) {
            break;
        }
        // 计算自己的时间戳
        timestamp = System.currentTimeMillis() - startTime;
        // 对接收到的视频帧进行处理,比如保存到本地、进行解码等等
        // ...
    }
    grabber.stop();
    

    在上面的示例代码中,我们首先创建一个FFmpegFrameGrabber对象并打开了视频流。在循环中,我们获取每个视频帧并计算自己的时间戳,然后对视频帧进行处理。其中,startTime表示开始时间,timestamp表示接收到的视频帧对应的时间戳。

  5. User

    Java使用rstp推流如何将图片信息发送给接收端

  6. Assistant

    在Java中,可以使用开源库OpenCV来处理图像信息并通过RSTP协议推流。

    首先,你需要导入OpenCV的依赖库。这里以Maven为例,在pom.xml中添加如下依赖:

    <dependency>
        <groupId>org.openpnp</groupId>
        <artifactId>opencv</artifactId>
        <version>4.5.1-1</version>
    </dependency>
    

    然后,你需要创建一个OpenCV的VideoCapture对象来读取摄像头数据,并使用FFmpegFrameRecorder对象进行推流。在读取每一帧图像时,需要将图像转换为FFmpegFrameRecorder支持的Image类型。以下是示例代码:

    import org.bytedeco.javacv.FFmpegFrameRecorder;
    import org.bytedeco.javacv.Java2DFrameUtils;
    import org.bytedeco.opencv.opencv_core.Mat;
    import org.bytedeco.opencv.opencv_videoio.VideoCapture;
    import org.opencv.core.CvType;
    import org.opencv.core.MatOfByte;
    import org.opencv.core.MatOfInt;
    import org.opencv.core.Rect;
    import org.opencv.core.Size;
    import org.opencv.imgcodecs.Imgcodecs;
    
    import java.awt.image.BufferedImage;
    import java.io.ByteArrayInputStream;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    public class RstpPushTest {
        // 定义推流地址
        private static final String STREAM_URL = "rtsp://xxxxxx:554/live/stream";
    
        public static void main(String[] args) throws Exception {
            // 初始化OpenCV
            System.loadLibrary(org.opencv.core.Core.NATIVE_LIBRARY_NAME);
    
            // 打开本地摄像头
            VideoCapture camera = new VideoCapture(0);
    
            // 创建FFmpegFrameRecorder对象,进行推流
            int imageWidth = 640;
            int imageHeight = 480;
            int audioChannels = 0;
            FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(STREAM_URL, imageWidth, imageHeight, audioChannels);
            recorder.setFormat("rtsp");
            recorder.setPixelFormat(org.bytedeco.javacpp.avutil.AV_PIX_FMT_YUV420P);
            recorder.setVideoCodec(org.bytedeco.javacpp.avcodec.AV_CODEC_ID_H264);
            recorder.start();
    
            while(true) {
                // 读取每一帧图像
                Mat frame = new Mat();
                camera.read(frame);
    
                // 裁剪图像
                Rect rect = new Rect(0, 0, 320, 240);
                frame = new Mat(frame, rect);
    
                // 转换为FFmpegFrameRecorder支持的Image类型
                BufferedImage bufferedImage = matToBufferedImage(frame);
                org.bytedeco.javacv.Frame recorderFrame = Java2DFrameUtils.toFrame(bufferedImage);
    
                // 将图像写入到FFmpegFrameRecorder对象中进行推流
                recorder.record(recorderFrame);
            }
    
            // 关闭相机和推流对象
            camera.release();
            recorder.stop();
        }
    
        /**
         * 将OpenCV的Mat对象转换为BufferedImage对象
         */
        public static BufferedImage matToBufferedImage(Mat mat) throws IOException {
            MatOfByte matOfByte = new MatOfByte();
            Imgcodecs.imencode(".bmp", mat, matOfByte);
            return ImageIO.read(new ByteArrayInputStream(matOfByte.toArray()));
        }
    }
    

    在上面的代码中,我们首先初始化了OpenCV,并打开了本地摄像头。然后,我们创建了一个FFmpegFrameRecorder对象进行推流,并初始化一些推流参数。在循环中,我们读取每一帧图像并对图像进行裁剪和转换,最后将图像写入FFmpegFrameRecorder对象中进行推流。

  7. User

    Java使用rstp推流如何将图片名发送给接收端

  8. Assistant

    RSTP协议本身不支持在数据包中传输图片名。不过,你可以在发送端和接收端之间通过其他方式传递图片名信息,例如在RTSP的SDP消息中加入相关描述信息,以便接收端解析获取。

    具体实现时,你可以在发送端通过SDP描述将相关信息包含在描述中,然后在推流时将SDP描述信息放在SETUP消息中发送给服务器。在接收端,当接收到SETUP消息时,会解析SDP描述并获取相关信息。以下是示例代码:

    发送端:

    import org.bytedeco.javacv.FFmpegFrameRecorder;
    import org.bytedeco.javacv.Java2DFrameUtils;
    import org.bytedeco.opencv.opencv_core.Mat;
    import org.bytedeco.opencv.opencv_videoio.VideoCapture;
    import org.bytedeco.opencv.opencv_videoio.Videoio;
    
    import javax.imageio.ImageIO;
    import java.awt.image.BufferedImage;
    import java.io.ByteArrayInputStream;
    import java.net.InetSocketAddress;
    import java.nio.charset.StandardCharsets;
    import java.util.Base64;
    
    public class RstpPushTest {
        // 定义推流地址
        private static final String STREAM_URL = "rtsp://localhost:8554/stream";
        // 定义图像名称
        private static final String IMAGE_NAME = "image.png";
    
        public static void main(String[] args) throws Exception {
            // 初始化OpenCV
            System.loadLibrary(org.opencv.core.Core.NATIVE_LIBRARY_NAME);
    
            // 打开本地摄像头
            VideoCapture camera = new VideoCapture(0);
            camera.set(Videoio.CAP_PROP_FRAME_WIDTH, 640);
            camera.set(Videoio.CAP_PROP_FRAME_HEIGHT, 480);
    
            // 创建FFmpegFrameRecorder对象,进行推流
            int imageWidth = (int)camera.get(Videoio.CAP_PROP_FRAME_WIDTH);
            int imageHeight = (int)camera.get(Videoio.CAP_PROP_FRAME_HEIGHT);
            int audioChannels = 0;
            FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(STREAM_URL, imageWidth, imageHeight, audioChannels);
            recorder.setFormat("rtsp");
            recorder.setPixelFormat(org.bytedeco.javacpp.avutil.AV_PIX_FMT_YUV420P);
            recorder.setVideoCodec(org.bytedeco.javacpp.avcodec.AV_CODEC_ID_H264);
    
            // 设置SDP描述信息
            String sdp = String.format("v=0\r\ns=%s\r\nm=video 0 RTP/AVP 96\r\na=rtpmap:96 H264/90000\r\na=fmtp:96 packetization-mode=1; sprop-parameter-sets=H264 [126c00][28d00d00]\r\na=control:stream\r\n", IMAGE_NAME);
            recorder.setInterleaved(false);
            recorder.setAdditionalData(sdp.getBytes(StandardCharsets.UTF_8));
    
            recorder.start();
    
            while(true) {
                // 读取每一帧图像
                Mat frame = new Mat();
                camera.read(frame);
    
                // 将图像转换为FFmpegFrameRecorder支持的Image类型
                BufferedImage bufferedImage = matToBufferedImage(frame);
                org.bytedeco.javacv.Frame recorderFrame = Java2DFrameUtils.toFrame(bufferedImage);
    
                // 将图像写入到FFmpegFrameRecorder对象中进行推流
                recorder.record(recorderFrame);
            }
    
            // 关闭相机和推流对象
            camera.release();
            recorder.stop();
        }
    
        /**
         * 将OpenCV的Mat对象转换为BufferedImage对象
         */
        public static BufferedImage matToBufferedImage(Mat mat) throws IOException {
            MatOfByte matOfByte = new MatOfByte();
            Imgcodecs.imencode(".bmp", mat, matOfByte);
            return ImageIO.read(new ByteArrayInputStream(matOfByte.toArray()));
        }
    }
    

    在上面的代码中,我们在设置FFmpegFrameRecorder对象的AdditionalData属性中设置了SDP描述信息,并通过RTSP协议发送给接收端。

    接收端:

    import org.bytedeco.javacpp.avutil;
    import org.bytedeco.javacv.FFmpegFrameGrabber;
    import org.bytedeco.javacv.Frame;
    import org.bytedeco.javacv.Java2DFrameConverter;
    import org.bytedeco.opencv.opencv_core.Mat;
    
    import javax.imageio.ImageIO;
    import java.awt.image.BufferedImage;
    import java.io.ByteArrayInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class RstpPullTest {
        // 定义推流地址
        private static final String STREAM_URL = "rtsp://localhost:8554/stream";
    
        public static void main(String[] args) throws Exception {
            // 创建FFmpegFrameGrabber对象,连接RTSP流
            FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(STREAM_URL);
            grabber.setOption("rtsp_transport", "tcp");
            grabber.start();
    
            // 获取SDP描述信息
            byte[] additionalData = grabber.getAdditionalData();
            String sdp = new String(additionalData);
    
            // 从SDP描述信息中解析出图片名称
            String imageName = "";
            String[] lines = sdp.split("\r\n");
            for (String line : lines) {
                if (line.startsWith("s=")) {
                    imageName = line.substring(2);
                    break;
                }
            }
    
            while(true) {
                // 读取每一帧图像
                Frame frame = grabber.grab();
    
                // 将Frame转换为BufferedImage
                Java2DFrameConverter converter = new Java2DFrameConverter();
                BufferedImage bufferedImage = converter.convert(frame);
    
                // 将BufferedImage转换为Mat
                Mat mat = bufferedImageToMat(bufferedImage);
    
                // 处理接收到的图像,比如保存到本地
                String imagePath = String.format("%s%s%s", "F:/", imageName, ".jpg");
                saveImage(mat, imagePath);
            }
    
            // 关闭推流对象
            grabber.stop();
        }
    
        /**
         * 将BufferedImage对象转换为OpenCV的Mat对象
         */
        public static Mat bufferedImageToMat(BufferedImage bufferedImage) {
            Java2DFrameConverter converter = new Java2DFrameConverter();
            Frame frame = converter.convert(bufferedImage);
            return converter.getMat(frame, 0);
        }
    
        /**
         * 将OpenCV的Mat对象保存为图片文件
         */
        public static void saveImage(Mat mat, String imagePath) throws IOException {
            BufferedImage bufferedImage = matToBufferedImage(mat);
            ImageIO.write(bufferedImage, "jpg", new FileOutputStream(imagePath));
        }
    
        /**
         * 将OpenCV的Mat对象转换为BufferedImage对象
         */
        public static BufferedImage matToBufferedImage(Mat mat) throws IOException {
            avutil.av_image_fill_arrays(
                    mat.data(), mat.linesize(),
                    new byte[][]{mat.getByteBuffer().array()},
                    new int[]{mat.arrayOffset()},
                    mat.depth(), mat.cols(), mat.rows(), mat.channels()
            );
            avutil.AVPixelFormat pixelFormat = avutil.AVPixelFormat.AV_PIX_FMT_BGR24;
            int width = mat.cols();
            int height = mat.rows();
            int stride = mat.cols() * mat.channels();
            BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
            avutil.AVFrame frame = avutil.av_frame_alloc();
            avutil.av_image_fill_arrays(frame.data(), frame.linesize(), Java2DFrameConverter.toImageData(image, pixelFormat), pixelFormat, width, height, 1);
            avutil.av_image_copy(frame.data(), frame.linesize(), mat.data(), mat.linesize(), pixelFormat, width, height);
            return image;
        }
    }
    

    在上面的代码中,我们首先创建了一个FFmpegFrameGrabber对象连接到RTSP流,并获取SDP描述信息。然后,我们从SDP描述信息中解析了图片名称。在循环中,我们读取每一帧图像并将其转换为OpenCV的Mat对象进行处理,比如保存到本地。