#include <libavformat/avformat.h>

int open_video_file(const char *file_path) {
    // 分配格式上下文
    AVFormatContext *fmt_ctx = avformat_alloc_context();
    if (!fmt_ctx) {
        fprintf(stderr, "分配AVFormatContext失败\n");
        return -1;
    }

    // 打开输入文件
    int ret = avformat_open_input(&fmt_ctx, file_path, NULL, NULL);
    if (ret < 0) {
        char errbuf[128];
        av_strerror(ret, errbuf, sizeof(errbuf));
        fprintf(stderr, "打开文件失败: %s\n", errbuf);
        avformat_free_context(fmt_ctx);
        return ret;
    }

    // 获取流信息
    ret = avformat_find_stream_info(fmt_ctx, NULL);
    if (ret < 0) {
        fprintf(stderr, "获取流信息失败\n");
        avformat_close_input(&fmt_ctx);
        return ret;
    }

    // 打印流信息（调试用）
    av_dump_format(fmt_ctx, 0, file_path, 0);

    // 查找最佳视频流
    int video_stream_idx = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    printf("视频流索引: %d\n", video_stream_idx);

    // 清理资源
    avformat_close_input(&fmt_ctx);
    return 0;
}

#include <libswscale/swscale.h>

UIImage *convert_frame_to_image(AVFrame *frame) {
    // 创建转换上下文
    struct SwsContext *sws_ctx = sws_getContext(
        frame->width, frame->height, frame->format,
        frame->width, frame->height, AV_PIX_FMT_RGB24,
        SWS_BILINEAR, NULL, NULL, NULL
    );

    // 分配RGB帧空间
    AVFrame *rgb_frame = av_frame_alloc();
    int buffer_size = av_image_get_buffer_size(AV_PIX_FMT_RGB24, frame->width, frame->height, 1);
    uint8_t *rgb_buffer = av_malloc(buffer_size);
    av_image_fill_pointers(rgb_frame->data, AV_PIX_FMT_RGB24, frame->height, rgb_buffer, rgb_frame->linesize);

    // 执行格式转换
    sws_scale(sws_ctx, frame->data, frame->linesize, 0, frame->height, rgb_frame->data, rgb_frame->linesize);

    // 创建UIImage
    CGDataProviderRef provider = CGDataProviderCreateWithData(NULL, rgb_frame->data[0], buffer_size, NULL);
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
    CGImageRef cgImage = CGImageCreate(frame->width, frame->height, 8, 24, rgb_frame->linesize[0],
                                       colorSpace, kCGBitmapByteOrderDefault, provider, NULL, NO, kCGRenderingIntentDefault);
    UIImage *image = [UIImage imageWithCGImage:cgImage];

    // 释放资源
    CGImageRelease(cgImage);
    CGColorSpaceRelease(colorSpace);
    CGDataProviderRelease(provider);
    av_free(rgb_buffer);
    av_frame_free(&rgb_frame);
    sws_freeContext(sws_ctx);

    return image;
}

#include <libswresample/swresample.h>

int process_audio_frame(AVFrame *frame, AudioBuffer *output) {
    // 创建重采样上下文
    SwrContext *swr_ctx = swr_alloc_set_opts(NULL,
        AV_CH_LAYOUT_STEREO, AV_SAMPLE_FMT_S16, 44100,  // 输出格式
        frame->channel_layout, frame->format, frame->sample_rate,  // 输入格式
        0, NULL);
    swr_init(swr_ctx);

    // 分配输出缓冲区
    int dst_samples = av_rescale_rnd(frame->nb_samples, 44100, frame->sample_rate, AV_ROUND_UP);
    uint8_t *buffer;
    av_samples_alloc(&buffer, NULL, 2, dst_samples, AV_SAMPLE_FMT_S16, 0);

    // 执行重采样
    int samples_out = swr_convert(swr_ctx, &buffer, dst_samples,
                                 (const uint8_t **)frame->data, frame->nb_samples);

    // 填充输出缓冲区
    output->data = buffer;
    output->size = samples_out * 2 * 2; // 双通道，16位采样

    // 释放资源（注意：buffer需要在使用后释放）
    swr_free(&swr_ctx);
    return samples_out;
}

int decode_video(AVCodecContext *dec_ctx, AVFrame *frame, AVPacket *pkt) {
    int ret = avcodec_send_packet(dec_ctx, pkt);
    if (ret < 0) return ret;

    while (ret >= 0) {
        ret = avcodec_receive_frame(dec_ctx, frame);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) return 0;
        if (ret < 0) return ret;

        // 处理解码后的frame
        process_video_frame(frame);

        av_frame_unref(frame);
    }
    return 0;
}

int write_output_file(AVFormatContext *fmt_ctx, const char *filename) {
    // 创建输出上下文
    AVFormatContext *out_ctx = NULL;
    avformat_alloc_output_context2(&out_ctx, NULL, NULL, filename);

    // 复制流信息
    for (int i = 0; i < fmt_ctx->nb_streams; i++) {
        AVStream *in_stream = fmt_ctx->streams[i];
        AVStream *out_stream = avformat_new_stream(out_ctx, NULL);
        avcodec_parameters_copy(out_stream->codecpar, in_stream->codecpar);
    }

    // 打开输出文件
    avio_open(&out_ctx->pb, filename, AVIO_FLAG_WRITE);
    avformat_write_header(out_ctx, NULL);

    // 写入数据包
    // ...

    // 写入文件尾
    av_write_trailer(out_ctx);
    avio_closep(&out_ctx->pb);
    avformat_free_context(out_ctx);
    return 0;
}

int process_with_error_handling(const char *command) {
    int ret = system(command);
    if (ret < 0) {
        char errbuf[128];
        av_strerror(ret, errbuf, sizeof(errbuf));

        // 转换为用户友好的错误信息
        const char *user_message;
        switch (ret) {
            case AVERROR_INVALIDDATA:
                user_message = "视频文件已损坏，请重新上传";
                break;
            case AVERROR(ENOMEM):
                user_message = "内存不足，请关闭其他应用后重试";
                break;
            default:
                user_message = "处理视频时出错，请重试";
        }

        display_error(user_message);
        return ret;
    }
    return 0;
}

int setup_filter_graph(AVFilterGraph **graph_ptr, AVFilterContext **src_ctx, AVFilterContext **sink_ctx,
                      AVCodecContext *dec_ctx, AVCodecContext *enc_ctx) {
    char args[512];
    int ret = 0;
    AVFilterGraph *graph = avfilter_graph_alloc();

    // 创建源滤镜
    snprintf(args, sizeof(args), "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
             dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
             dec_ctx->time_base.num, dec_ctx->time_base.den,
             dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);

    avfilter_graph_create_filter(src_ctx, avfilter_get_by_name("buffer"), "in", args, NULL, graph);

    // 创建模糊滤镜
    AVFilterContext *blur_ctx;
    avfilter_graph_create_filter(&blur_ctx, avfilter_get_by_name("boxblur"), "blur", "5:1", NULL, graph);

    // 创建输出滤镜
    avfilter_graph_create_filter(sink_ctx, avfilter_get_by_name("buffersink"), "out", NULL, NULL, graph);

    // 连接滤镜
    ret = avfilter_link(*src_ctx, 0, blur_ctx, 0);
    ret = avfilter_link(blur_ctx, 0, *sink_ctx, 0);

    // 配置滤镜图
    ret = avfilter_graph_config(graph, NULL);
    *graph_ptr = graph;

    return ret;
}

void cleanup_resources(AVFormatContext *fmt_ctx, AVCodecContext *dec_ctx,
                       AVFrame *frame, AVPacket *pkt) {
    // 释放帧和数据包
    av_frame_free(&frame);
    av_packet_free(&pkt);

    // 释放解码器上下文
    avcodec_free_context(&dec_ctx);

    // 关闭输入
    avformat_close_input(&fmt_ctx);
}

double video_pts = frame->pts * av_q2d(video_stream->time_base);
double audio_pts = /* 从AVAudioPlayer获取 */;
double diff = video_pts - audio_pts;

if (diff > 0.1) {
    // 视频太快，等待音频
    usleep(diff * 1000000);
} else if (diff < -0.1) {
    // 音频太快，丢弃视频帧
    return;
}
// 渲染视频帧

typedef struct FrameNode {
    AVFrame *frame;
    struct FrameNode *next, *prev;
} FrameNode;

// 添加帧
FrameNode *enqueue(FrameNode *head, AVFrame *frame) {
    FrameNode *node = malloc(sizeof(FrameNode));
    node->frame = av_frame_clone(frame);
    node->next = head;
    node->prev = NULL;
    if (head) head->prev = node;
    return node;
}

// 插入帧（用于特效）
void insert_frame(FrameNode *position, AVFrame *frame) {
    FrameNode *node = malloc(sizeof(FrameNode));
    node->frame = av_frame_clone(frame);

    node->next = position->next;
    node->prev = position;

    if (position->next) position->next->prev = node;
    position->next = node;
}