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

使用ffmpeg 库,完成从h264到h265的转换

  1. User

    使用ffmpeg 库,完成从h264到h265的转换

  2. Assistant

    使用ffmpeg进行h264到h265转换的方法如下:

    1.下载和安装ffmpeg库。在官网(https://ffmpeg.org/)下载对应操作系统版本的ffmpeg,并安装到系统中。

    2.使用命令行进入到h264文件所在目录。

    3.使用以下命令对h264文件进行转换:

    ffmpeg -i input.h264 -c:v libx265 output.hevc

    其中,input.h264是要转换的h264文件名,output.hevc是要输出的h265文件名。

    4.转换过程完成后,在同一目录下会生成output.hevc文件。可以使用支持h265格式的视频播放器进行播放。

    也可以使用自己的编程语言对ffmpeg进行二次封装,以实现更复杂的转换操作。

  3. User

    通过调用ffmpeg接口完成上述转换

  4. Assistant

    以下是使用ffmpeg C API完成h264到h265转换的示例代码:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <libavutil/frame.h>
    #include <libavutil/imgutils.h>
    #include <libavutil/opt.h>
    #include <libavutil/samplefmt.h>
    #include <libavutil/pixdesc.h>
    #include <libavcodec/avcodec.h>
    
    int main(int argc, char* argv[])
    {
        if (argc < 3)
        {
            printf("Usage: %s input.h264 output.hevc\n", argv[0]);
            return -1;
        }
    
        const char* input_file = argv[1];
        const char* output_file = argv[2];
    
        av_register_all();
    
        AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_H264);
        if (!codec)
        {
            printf("Failed to find H.264 decoder\n");
            return -1;
        }
    
        AVCodecContext* ctx = avcodec_alloc_context3(codec);
        if (!ctx)
        {
            printf("Failed to allocate H.264 decoder context\n");
            return -1;
        }
    
        int ret = avcodec_open2(ctx, codec, NULL);
        if (ret < 0)
        {
            printf("Failed to open H.264 decoder\n");
            return -1;
        }
    
        FILE* fp_in = fopen(input_file, "rb");
        if (!fp_in)
        {
            printf("Failed to open input file %s\n", input_file);
            return -1;
        }
    
        AVFrame* frame = av_frame_alloc();
        if (!frame)
        {
            printf("Failed to allocate frame\n");
            return -1;
        }
    
        AVPacket pkt;
        av_init_packet(&pkt);
    
        ret = avcodec_receive_frame(ctx, frame);
        if (ret < 0)
        {
            printf("Error decoding H.264 frame\n");
            return -1;
        }
    
        avcodec_free_context(&ctx);
    
        AVCodec* h265_codec = avcodec_find_encoder(AV_CODEC_ID_HEVC);
        if (!h265_codec)
        {
            printf("Failed to find H.265 encoder\n");
            return -1;
        }
    
        AVCodecContext* h265_ctx = avcodec_alloc_context3(h265_codec);
        if (!h265_ctx)
        {
            printf("Failed to allocate H.265 encoder context\n");
            return -1;
        }
    
        h265_ctx->height = frame->height;
        h265_ctx->width = frame->width;
        h265_ctx->time_base = av_make_q(1, 25);
        h265_ctx->framerate = av_make_q(25, 1);
        h265_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
        h265_ctx->gop_size = 10;
        h265_ctx->max_b_frames = 2;
        ret = avcodec_open2(h265_ctx, h265_codec, NULL);
        if (ret < 0)
        {
            printf("Failed to open H.265 encoder\n");
            return -1;
        }
    
        FILE* fp_out = fopen(output_file, "wb");
        if (!fp_out)
        {
            printf("Failed to open output file %s\n", output_file);
            return -1;
        }
    
        AVFrame* h265_frame = av_frame_alloc();
        if (!h265_frame)
        {
            printf("Failed to allocate frame\n");
            return -1;
        }
    
        int got_packet = 0;
        int frame_count = 0;
    
        while (1)
        {
            ret = av_read_frame(format_ctx, &pkt);
            if (ret < 0)
            {
                break;
            }
    
            if (pkt.stream_index == video_stream_idx)
            {
                ret = avcodec_send_packet(ctx, &pkt);
                if (ret < 0)
                {
                    printf("Failed to send packet for decoding\n");
                    return -1;
                }
    
                while (ret >= 0)
                {
                    ret = avcodec_receive_frame(ctx, frame);
                    if (ret < 0)
                    {
                        break;
                    }
    
                    av_image_copy(h265_frame->data, h265_frame->linesize, 
                                  (const uint8_t**)frame->data, frame->linesize, 
                                  h265_ctx->pix_fmt, h265_ctx->width, h265_ctx->height);
    
                    h265_frame->pts = frame->pts;
    
                    ret = avcodec_send_frame(h265_ctx, h265_frame);
                    if (ret < 0)
                    {
                        printf("Failed to send frame for encoding\n");
                        return -1;
                    }
    
                    while (ret >= 0)
                    {
                        AVPacket h265_pkt;
                        av_init_packet(&h265_pkt);
    
                        ret = avcodec_receive_packet(h265_ctx, &h265_pkt);
                        if (ret < 0)
                        {
                            break;
                        }
    
                        av_packet_rescale_ts(&h265_pkt, h265_ctx->time_base, h265_ctx->time_base);
                        h265_pkt.stream_index = 0;
    
                        ret = av_interleaved_write_frame(fmt_ctx, &h265_pkt);
    
                        av_packet_unref(&h265_pkt);
    
                        if (ret < 0)
                        {
                            printf("Failed to write packet to output file\n");
                            return -1;
                        }
    
                        got_packet = 1;
                    }
    
                    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                    {
                        ret = 0;
                    }
                }
            }
        }
    
        ret = avcodec_send_frame(h265_ctx, NULL);
        if (ret < 0)
        {
            printf("Failed to send frame for flushing\n");
            return -1;
        }
    
        while (1)
        {
            AVPacket h265_pkt;
            av_init_packet(&h265_pkt);
    
            ret = avcodec_receive_packet(h265_ctx, &h265_pkt);
            if (ret < 0)
            {
                break;
            }
    
            av_packet_rescale_ts(&h265_pkt, h265_ctx->time_base, h265_ctx->time_base);
            h265_pkt.stream_index = 0;
    
            ret = av_interleaved_write_frame(fmt_ctx, &h265_pkt);
    
            av_packet_unref(&h265_pkt);
    
            if (ret < 0)
            {
                printf("Failed to write packet to output file\n");
                return -1;
            }
    
            got_packet = 1;
        }
    
        if (!got_packet)
        {
            printf("Failed to get any packet for decoding\n");
            return -1;
        }
    
        fclose(fp_in);
        fclose(fp_out);
    
        av_frame_free(&frame);
        av_frame_free(&h265_frame);
        avcodec_free_context(&ctx);
        avcodec_free_context(&h265_ctx);
    
        avformat_close_input(&fmt_ctx);
        avformat_free_context(fmt_ctx);
    
        return 0;
    }
    

    这是一个简单的例子,仅供参考。更多使用细节和高级应用方法可以参考ffmpeg官方文档和示例代码。