Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

Java将图片进行h264编码使用socket发送

  1. User

    Java将图片进行h264编码使用socket发送

  2. Assistant

    首先,需要使用Java中的FFmpeg库对图片进行H264编码。其中,需要使用AVCodec进行编码,使用AVFrame保存每帧数据,使用AVPacket保存压缩后的数据。

    以下是一个简单的示例代码:

    // 初始化编码器
    AVCodec codec = avcodec_find_encoder(AV_CODEC_ID_H264);
    AVCodecContext codecContext = avcodec_alloc_context3(codec);
    codecContext.width(640);
    codecContext.height(480);
    codecContext.time_base(new AVRational(1, 25));// 25帧每秒
    codecContext.flags(AV_CODEC_FLAG_GLOBAL_HEADER);
    avcodec_open2(codecContext, codec, (AVDictionary) null);
    
    // 读取图片
    BufferedImage image = ImageIO.read(new File("sample.jpg"));
    
    // 创建AVFrame和AVPacket
    AVFrame frame = av_frame_alloc();
    frame.format(codecContext.pix_fmt());
    frame.width(codecContext.width());
    frame.height(codecContext.height());
    av_image_alloc(frame.data(), frame.linesize(), codecContext.width(), codecContext.height(), codecContext.pix_fmt(), 32);
    AVPacket packet = av_packet_alloc();
    
    // 编码并发送数据
    int result = avcodec_send_frame(codecContext, frame);
    if (result >= 0) {
        while (result >= 0) {
            result = avcodec_receive_packet(codecContext, packet);
            if (result == AVERROR_EOF || result == AVERROR_EAGAIN) {
                break;
            } else if (result < 0) {
                System.err.println("Error while encoding: " + av_err2str(result));
                break;
            }
            // 将数据发送给服务器
            sendPacketToServer(packet.data(), packet.size());
            av_packet_unref(packet);
        }
    }
    

    在发送数据时,可以使用Java中的Socket对数据进行发送,如下所示:

    try {
        Socket socket = new Socket("localhost", 1234);
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(data);
        outputStream.flush();
        outputStream.close();
        socket.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
    

    其中,data为要发送的数据。需要注意的是,在发送数据前,需要先建立连接。

  3. User

    以上完整代码和maven依赖

  4. Assistant

    完整代码如下:

    import org.bytedeco.ffmpeg.avcodec.*;
    import org.bytedeco.ffmpeg.avutil.*;
    import org.bytedeco.javacv.FFmpegFrameGrabber;
    
    import javax.imageio.ImageIO;
    import java.awt.image.BufferedImage;
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.Socket;
    
    import static org.bytedeco.ffmpeg.global.avcodec.*;
    import static org.bytedeco.ffmpeg.global.avutil.*;
    import static org.bytedeco.javacpp.BytePointer.*;
    import static org.bytedeco.javacpp.avutil.*;
    
    public class H264Encoder {
    
        public static void main(String[] args) {
            // 初始化编码器
            avcodec_register_all();
            AVCodec codec = avcodec_find_encoder(AV_CODEC_ID_H264);
            AVCodecContext codecContext = avcodec_alloc_context3(codec);
            codecContext.width(640);
            codecContext.height(480);
            codecContext.time_base(new AVRational(1, 25)); // 25帧每秒
            codecContext.flags(AV_CODEC_FLAG_GLOBAL_HEADER);
            avcodec_open2(codecContext, codec, (AVDictionary) null);
    
            // 读取图片
            BufferedImage image = null;
            try {
                image = ImageIO.read(new File("sample.jpg"));
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            // 创建AVFrame和AVPacket
            AVFrame frame = av_frame_alloc();
            frame.format(codecContext.pix_fmt());
            frame.width(codecContext.width());
            frame.height(codecContext.height());
            av_image_alloc(frame.data(), frame.linesize(), codecContext.width(), codecContext.height(), codecContext.pix_fmt(), 32);
            AVPacket packet = av_packet_alloc();
    
            // 编码并发送数据
            byte[] data = encodeImage(image, frame, packet, codecContext);
            sendPacketToServer(data);
        }
    
        private static byte[] encodeImage(BufferedImage image, AVFrame frame, AVPacket packet, AVCodecContext codecContext) {
            // 将图像转为YUV格式
            FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(image);
            try {
                grabber.start();
                Frame rawFrame = grabber.grabFrame();
                Java2DFrameConverter converter = new Java2DFrameConverter();
                ImageTypeSpecifier type = converter.getImageType(rawFrame);
                BufferedImage yuvImage = new BufferedImage(converter.getPixelFormat(type), converter.getBufferedImageType(type), rawFrame.imageWidth, rawFrame.imageHeight);
                converter.convert(rawFrame, yuvImage);
    
                // 将YUV数据写入AVFrame
                sws_scale(sws_getCachedContext(null, codecContext.width(), codecContext.height(), AV_PIX_FMT_BGR24,
                        codecContext.width(), codecContext.height(), codecContext.pix_fmt(), SWS_FAST_BILINEAR, null, null, null),
                        new BytePointer(yuvImage.getData().array()), yuvImage.getWidth(), 0,
                        codecContext.height(), frame.data(), frame.linesize());
    
                // 编码数据
                int result = avcodec_send_frame(codecContext, frame);
                if (result >= 0) {
                    while (result >= 0) {
                        result = avcodec_receive_packet(codecContext, packet);
                        if (result == AVERROR_EOF || result == AVERROR_EAGAIN) {
                            break;
                        } else if (result < 0) {
                            System.err.println("Error while encoding: " + av_err2str(result));
                            break;
                        }
                        // 将数据保存到byte数组中
                        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                        outputStream.write(packet.data().getStringBytes(0, packet.size()));
                        outputStream.close();
                        byte[] data = outputStream.toByteArray();
                        av_packet_unref(packet);
                        return data;
                    }
                }
    
                grabber.stop();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        private static void sendPacketToServer(byte[] data) {
            try {
                Socket socket = new Socket("localhost", 1234);
                OutputStream outputStream = socket.getOutputStream();
                outputStream.write(data);
                outputStream.flush();
                outputStream.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

    需要在pom.xml中添加如下依赖:

    <dependency>
        <groupId>org.bytedeco</groupId>
        <artifactId>javacv-platform</artifactId>
        <version>1.5.6</version>
    </dependency>
    <dependency>
        <groupId>org.bytedeco.ffmpeg</groupId>
        <artifactId>ffmpeg</artifactId>
        <version>4.3.1-1.5.6</version>
    </dependency>
    <dependency>
        <groupId>org.bytedeco</groupId>
        <artifactId>javacpp</artifactId>
        <version>1.5.6</version>
    </dependency>
    
  5. User

    java如何将frame.toString().getBytes()接收并显示

  6. Assistant

    如果你要在收到的字节数组中读取Frame对象,可以使用Java的反序列化(ObjectInputStream)来实现。你可以在接收到字节数组后,创建一个ByteArrayInputStream输入流,将字节数组作为参数传入,然后使用ObjectInputStream来反序列化输入流中的对象。这里有一个简单的示例代码,演示了如何使用ObjectInputStream读取反序列化后的Frame对象,并在控制台上显示:

    import java.io.ByteArrayInputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    
    public class FrameReceiver {
    
        public static void main(String[] args) {
            byte[] imageData = new byte[]{}; // 假设这里是收到的字节数组
    
            // 使用ObjectInputStream读取Frame对象
            try (ByteArrayInputStream byteStream = new ByteArrayInputStream(imageData);
                 ObjectInputStream objectStream = new ObjectInputStream(byteStream)) {
                Object obj = objectStream.readObject();
                if (obj instanceof Frame) {
                    Frame frame = (Frame) obj;
                    System.out.println(frame.toString());
                } else {
                    System.err.println("Invalid object type!");
                }
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    

    如果接收到的是一个字符串(而不是Frame对象),则可以直接在控制台上打印该字符串:

    import java.util.Arrays;
    
    public class StringReceiver {
    
        public static void main(String[] args) {
            byte[] stringData = new byte[]{}; // 假设这里是收到的字节数组
    
            // 直接将字节数组转为字符串,然后输出到控制台
            String message = new String(stringData);
            System.out.println("Received message: " + message);
        }
    }
    
  7. User

    java如何使用Socket实时发送Frame

  8. Assistant

    如果你想使用Java的Socket实时发送Frame,你需要先将Frame对象压缩为字节数组,然后使用OutputStream将字节数组发送出去。由于实时性要求高,你可以考虑使用多线程机制,将视频流的推送和Socket传输两个过程拆开,分别在两个线程中进行。下面是一个简单的示例代码,演示了如何使用Java的Socket实时发送Frame:

    import org.bytedeco.javacv.FFmpegFrameGrabber;
    import org.bytedeco.javacv.Java2DFrameConverter;
    
    import javax.imageio.ImageIO;
    import java.awt.image.BufferedImage;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.Socket;
    
    public class FrameSender {
    
        private static volatile boolean isRunning = true; // 标识是否需要继续推送视频流
    
        public static void main(String[] args) {
            // 创建Socket并建立连接
            try (Socket socket = new Socket("localhost", 1234)) {
                OutputStream outputStream = socket.getOutputStream();
    
                // 开启一个线程用于推送视频流
                Thread videoThread = new Thread(() -> {
                    FFmpegFrameGrabber grabber = new FFmpegFrameGrabber("test.mp4");
                    try {
                        grabber.start();
                        Java2DFrameConverter converter = new Java2DFrameConverter();
                        while (isRunning) {
                            BufferedImage image = converter.convert(grabber.grab());
                            if (image == null) {
                                break;
                            }
                            // 将图像压缩为jpeg格式的字节数组
                            ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
                            ImageIO.write(image, "jpeg", byteStream);
                            byte[] imageData = byteStream.toByteArray();
                            byteStream.close();
                            // 将字节数组转为Frame对象并序列化为字节数组
                            Frame frame = new Frame(image.getWidth(), image.getHeight(), Frame.DEPTH_BYTE, 3);
                            frame.image[0] = imageData;
                            ByteArrayOutputStream frameByteStream = new ByteArrayOutputStream();
                            try (ObjectOutputStream objectStream = new ObjectOutputStream(frameByteStream)) {
                                objectStream.writeObject(frame);
                            }
                            byte[] frameData = frameByteStream.toByteArray();
                            frameByteStream.close();
                            // 发送字节数组到Socket
                            outputStream.write(frameData);
                            outputStream.flush();
                        }
                        grabber.stop();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
                videoThread.start();
    
                // 等待一段时间后停止推送并关闭连接
                Thread.sleep(10000);
                isRunning = false;
                videoThread.join();
    
                outputStream.flush();
                outputStream.close();
                socket.close();
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    

    在这个示例中,我们首先创建一个Socket并建立连接,然后开启一个线程用于推送视频流。在该线程中,我们使用FFmpegFrameGrabber读取视频流并转换为BufferedImage对象,然后将图像压缩为jpeg格式的字节数组,并创建一个Frame对象并将该字节数组保存到Frame对象的image属性中,最后将Frame对象序列化为字节数组并发送到Socket中。由于输出流是阻塞的,因此只要发送的字节数组没有被写入到底层操作系统的网络缓冲区中,write方法就不会返回,因此我们无需使用flush方法来强制写入。在这个示例中,我们等待10秒后停止推送视频流,并在主线程中关闭Socket连接。

  9. User

    InputStream如何获取二进制输出流

  10. Assistant

    Java的InputStream对于二进制数据和文本数据都可以进行读取,只是需要注意读取时使用的字符编码是否正确。如果你想以二进制形式读取InputStream中的数据,可以将其包装为DataInputStream或ObjectInputStream,然后使用相应的方法读取数据。下面是一个简单的示例代码,演示了如何使用DataInputStream和ObjectInputStream从InputStream中读取字节数组和对象:

    import java.io.ByteArrayInputStream;
    import java.io.DataInputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    
    public class InputStreamReceiver {
    
        public static void main(String[] args) {
            byte[] inputData = new byte[]{}; // 假设这里是收到的字节数组
    
            // 使用DataInputStream读取字节数组
            try (DataInputStream dataStream = new DataInputStream(new ByteArrayInputStream(inputData))) {
                int length = dataStream.readInt();
                byte[] data = new byte[length];
                dataStream.readFully(data);
                System.out.println("Received data: " + Arrays.toString(data));
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            // 使用ObjectInputStream读取对象
            try (ObjectInputStream objectStream = new ObjectInputStream(new ByteArrayInputStream(inputData))) {
                Object obj = objectStream.readObject();
                if (obj instanceof Frame) {
                    Frame frame = (Frame) obj;
                    System.out.println(frame.toString());
                } else {
                    System.err.println("Invalid object type!");
                }
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    

    在这个示例中,我们首先对InputStream进行包装,然后使用DataInputStream的readInt方法来读取一个整型值,该值表示后面的字节数组的长度。然后,我们使用readFully方法读取该长度的字节数组。使用ObjectInputStream读取数据时,我们使用readObject方法读取对象。需要注意的是,如果从InputStream中读取的是Object对象,那么在发送数据时,需要使用ObjectOutputStream来序列化对象并将其写入OutputStream中。

  11. User

    Java如何将图片编码为h264格式

  12. Assistant

    Java本身不支持将图片编码为h264格式,但可以通过调用FFmpeg的接口来实现该功能。FFmpeg是一个开源的音视频处理工具包,支持多种格式的音视频编解码、格式转换、流媒体传输等。下面是一个简单的示例代码,演示了如何使用FFmpeg将jpeg格式的图片编码为h264格式:

    import java.io.IOException;
    import java.nio.ByteBuffer;
    import java.util.Arrays;
    
    import static org.bytedeco.javacpp.avutil.*;
    import static org.bytedeco.javacpp.avcodec.*;
    import static org.bytedeco.javacpp.swscale.*;
    import static org.bytedeco.javacpp.avformat.*;
    
    public class ImageEncoder {
    
        public static void main(String[] args) {
            // 初始化FFmpeg
            av_register_all();
            avformat_network_init();
            avcodec_register_all();
    
            // 打开JPEG文件
            AVFormatContext formatContext = avformat_alloc_context();
            if (avformat_open_input(formatContext, "input.jpg", null, null) != 0) {
                System.err.println("Could not open file!");
                System.exit(-1);
            }
    
            // 查找JPEG格式解码器
            AVCodec codec = avcodec_find_decoder(AV_CODEC_ID_MJPEG);
            if (codec == null) {
                System.err.println("Could not find decoder!");
                System.exit(-1);
            }
    
            // 打开并初始化解码器
            AVCodecContext codecContext = avcodec_alloc_context3(codec);
            avcodec_parameters_to_context(codecContext, formatContext.streams(0).codecpar());
            if (avcodec_open2(codecContext, codec, null) < 0) {
                System.err.println("Could not open codec!");
                System.exit(-1);
            }
    
            // 获取JPEG格式视频流
            AVStream stream = formatContext.streams(0);
    
            // 创建编码器
            AVCodec encoder = avcodec_find_encoder(AV_CODEC_ID_H264);
            AVCodecContext encoderContext = avcodec_alloc_context3(encoder);
            encoderContext.codec_id(AV_CODEC_ID_H264);
            encoderContext.bit_rate(codecContext.bit_rate() / 10);
            encoderContext.width(codecContext.width());
            encoderContext.height(codecContext.height());
            encoderContext.time_base(AVRational.make(1, 25));
            encoderContext.gop_size(10);
            encoderContext.max_b_frames(1);
            encoderContext.pix_fmt(AV_PIX_FMT_YUV420P);
            if (avcodec_open2(encoderContext, encoder, null) < 0) {
                System.err.println("Could not open codec!");
                System.exit(-1);
            }
    
            // 读取JPEG文件并编码为H264格式写入输出文件
            AVFrame frame = av_frame_alloc();
            AVFrame convertedFrame = av_frame_alloc();
            convertedFrame.format(AV_PIX_FMT_YUV420P);
            convertedFrame.width(encoderContext.width());
            convertedFrame.height(encoderContext.height());
            av_image_alloc(convertedFrame.data(), convertedFrame.linesize(), encoderContext.width(), encoderContext.height(), encoderContext.pix_fmt(), 32);
            AVPacket packet = av_packet_alloc();
            av_init_packet(packet);
            packet.size(0);
            packet.data(null);
            SwsContext swsContext = sws_getContext(codecContext.width(), codecContext.height(), codecContext.pix_fmt(),