进一步有进一步惊喜

#include <float.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/imgutils.h>
#include <libavutil/log.h>
#include <libavutil/opt.h>
#include <libswscale/swscale.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define LOGE(format, ...)                                             \
  fprintf(stderr, "ERR [%s:%d]:" format "\n", __FUNCTION__, __LINE__, \
          ##__VA_ARGS__)

// 初始化FFmpeg
void init_ffmpeg() {
  av_log_set_level(AV_LOG_QUIET);
  avformat_network_init();
}

// 打开视频文件
AVFormatContext* open_video(const char* filename) {
  AVFormatContext* format_ctx = NULL;

  if (avformat_open_input(&format_ctx, filename, NULL, NULL) != 0) {
    LOGE("无法打开视频文件: %s\n", filename);
    return NULL;
  }

  if (avformat_find_stream_info(format_ctx, NULL) < 0) {
    LOGE("无法获取流信息\n");
    avformat_close_input(&format_ctx);
    return NULL;
  }

  return format_ctx;
}

// 查找视频流
int find_video_stream(AVFormatContext* format_ctx) {
  for (unsigned int i = 0; i < format_ctx->nb_streams; i++) {
    if (format_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
      return i;
    }
  }
  return -1;
}

// 打开解码器
AVCodecContext* open_decoder(AVFormatContext* format_ctx, int video_stream) {
  AVCodecParameters* codecpar = format_ctx->streams[video_stream]->codecpar;
  AVCodec* codec = avcodec_find_decoder(codecpar->codec_id);

  if (!codec) {
    LOGE("找不到解码器\n");
    return NULL;
  }

  AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
  if (avcodec_parameters_to_context(codec_ctx, codecpar) < 0) {
    LOGE("无法复制编解码器参数到上下文\n");
    avcodec_free_context(&codec_ctx);
    return NULL;
  }

  if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
    LOGE("无法打开解码器\n");
    avcodec_free_context(&codec_ctx);
    return NULL;
  }

  return codec_ctx;
}

// 跳转到指定时间点
int seek_to_time(AVFormatContext* format_ctx, AVCodecContext* codec_ctx,
                 double seconds) {
  // 使用更精确的跳转方式
  int64_t seek_target = (int64_t)(seconds * AV_TIME_BASE);
  int ret =
      avformat_seek_file(format_ctx, -1, INT64_MIN, seek_target, INT64_MAX, 0);

  if (ret < 0) {
    LOGE("跳转失败: %.2f秒, 错误码: %d\n", seconds, ret);
    return -1;
  }

  avcodec_flush_buffers(codec_ctx);
  return 0;
}

// 读取并解码一帧
AVFrame* decode_frame(AVFormatContext* format_ctx, AVCodecContext* codec_ctx,
                      int video_stream) {
  AVPacket packet;
  AVFrame* frame = av_frame_alloc();
  int ret;

  while (av_read_frame(format_ctx, &packet) >= 0) {
    if (packet.stream_index == video_stream) {
      ret = avcodec_send_packet(codec_ctx, &packet);
      if (ret < 0 && ret != AVERROR(EAGAIN)) {
        av_packet_unref(&packet);
        continue;
      }

      ret = avcodec_receive_frame(codec_ctx, frame);
      if (ret == 0) {
        av_packet_unref(&packet);
        return frame;
      } else if (ret != AVERROR(EAGAIN)) {
        break;
      }
    }
    av_packet_unref(&packet);
  }

  av_frame_free(&frame);
  return NULL;
}

// 提取指定时间点的帧
AVFrame* extract_frame_at_time(AVFormatContext* format_ctx,
                               AVCodecContext* codec_ctx, int video_stream,
                               double target_time) {
  if (seek_to_time(format_ctx, codec_ctx, target_time - 0.5) < 0) {
    return NULL;
  }

  AVFrame* best_frame = NULL;
  double best_diff = DBL_MAX;
  int frames_tried = 0;

  // 解码多帧以找到最接近的帧
  while (frames_tried < 30) {  // 最多尝试30帧
    AVFrame* frame = decode_frame(format_ctx, codec_ctx, video_stream);
    if (!frame) break;

    double frame_time = frame->best_effort_timestamp *
                        av_q2d(format_ctx->streams[video_stream]->time_base);
    double diff = fabs(frame_time - target_time);

    if (diff < best_diff) {
      if (best_frame) av_frame_free(&best_frame);
      best_frame = frame;
      best_diff = diff;
    } else {
      av_frame_free(&frame);
      // 如果时间已经超过目标时间，提前退出
      if (frame_time > target_time + 0.1) break;
    }

    frames_tried++;
    if (best_diff < 0.05) break;  // 如果足够接近，提前退出
  }

  return best_frame;
}

// 将帧转换为RGB24格式（修复颜色问题）
AVFrame* convert_to_rgb(AVFrame* frame, AVCodecContext* codec_ctx) {
  if (!frame || !codec_ctx) return NULL;

  struct SwsContext* sws_ctx = sws_getContext(
      frame->width, frame->height, codec_ctx->pix_fmt, frame->width,
      frame->height, AV_PIX_FMT_RGB24, SWS_BILINEAR, NULL, NULL, NULL);

  if (!sws_ctx) {
    LOGE("无法创建转换上下文\n");
    return NULL;
  }

  AVFrame* rgb_frame = av_frame_alloc();
  rgb_frame->format = AV_PIX_FMT_RGB24;
  rgb_frame->width = frame->width;
  rgb_frame->height = frame->height;

  if (av_frame_get_buffer(rgb_frame, 32) < 0) {
    LOGE("无法分配RGB帧缓冲区\n");
    av_frame_free(&rgb_frame);
    sws_freeContext(sws_ctx);
    return NULL;
  }

  // 执行颜色空间转换
  sws_scale(sws_ctx, (const uint8_t* const*)frame->data, frame->linesize, 0,
            frame->height, rgb_frame->data, rgb_frame->linesize);

  sws_freeContext(sws_ctx);
  return rgb_frame;
}

// 修复BGR到RGB的转换（如果需要）
void fix_bgr_to_rgb(AVFrame* frame) {
  if (!frame || frame->format != AV_PIX_FMT_RGB24) return;

  int width = frame->width;
  int height = frame->height;
  uint8_t* data = frame->data[0];
  int line_size = frame->linesize[0];

  for (int y = 0; y < height; y++) {
    uint8_t* line = data + y * line_size;
    for (int x = 0; x < width; x++) {
      // 交换R和B通道
      uint8_t temp = line[x * 3];
      line[x * 3] = line[x * 3 + 2];
      line[x * 3 + 2] = temp;
    }
  }
}

// 创建合并后的图片（修复布局和颜色问题）
AVFrame* create_grid_image(AVFrame** frames, int frame_count, int cols,
                           int rows) {
  if (frame_count == 0 || frames[0] == NULL) return NULL;

  int frame_width = frames[0]->width;
  int frame_height = frames[0]->height;
  int border = 5;  // 边框大小

  // 创建目标帧
  AVFrame* grid_frame = av_frame_alloc();
  grid_frame->format = AV_PIX_FMT_RGB24;
  grid_frame->width = frame_width * cols + border * (cols + 1);
  grid_frame->height = frame_height * rows + border * (rows + 1);

  if (av_frame_get_buffer(grid_frame, 32) < 0) {
    LOGE("无法分配网格帧缓冲区\n");
    av_frame_free(&grid_frame);
    return NULL;
  }

  // 填充白色背景
  for (int y = 0; y < grid_frame->height; y++) {
    uint8_t* line = grid_frame->data[0] + y * grid_frame->linesize[0];
    for (int x = 0; x < grid_frame->width; x++) {
      line[x * 3] = 255;      // R
      line[x * 3 + 1] = 255;  // G
      line[x * 3 + 2] = 255;  // B
    }
  }

  // 将各个帧复制到网格中
  for (int i = 0; i < frame_count && i < cols * rows; i++) {
    if (!frames[i]) continue;

    int row = i / cols;
    int col = i % cols;
    int dest_x = border + col * (frame_width + border);
    int dest_y = border + row * (frame_height + border);

    // 复制图像数据
    for (int y = 0; y < frame_height; y++) {
      if (dest_y + y >= grid_frame->height) continue;

      uint8_t* src_line = frames[i]->data[0] + y * frames[i]->linesize[0];
      uint8_t* dest_line = grid_frame->data[0] +
                           (dest_y + y) * grid_frame->linesize[0] + dest_x * 3;

      for (int x = 0; x < frame_width; x++) {
        if (dest_x + x >= grid_frame->width) continue;

        dest_line[x * 3] = src_line[x * 3];          // R
        dest_line[x * 3 + 1] = src_line[x * 3 + 1];  // G
        dest_line[x * 3 + 2] = src_line[x * 3 + 2];  // B
      }
    }
  }

  return grid_frame;
}

// 保存帧为PNG文件（使用FFmpeg编码器）
int save_frame_as_png(AVFrame* frame, FILE* output) {
  AVCodec* codec = avcodec_find_encoder(AV_CODEC_ID_PNG);
  if (!codec) {
    LOGE("找不到PNG编码器\n");
    return -1;
  }

  AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
  if (!codec_ctx) {
    LOGE("无法分配编码器上下文\n");
    return -1;
  }

  codec_ctx->width = frame->width;
  codec_ctx->height = frame->height;
  codec_ctx->pix_fmt = AV_PIX_FMT_RGB24;
  codec_ctx->time_base = (AVRational){1, 25};

  if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
    LOGE("无法打开PNG编码器\n");
    avcodec_free_context(&codec_ctx);
    return -1;
  }

  AVPacket* pkt = av_packet_alloc();
  if (!pkt) {
    LOGE("无法分配AVPacket\n");
    avcodec_free_context(&codec_ctx);
    return -1;
  }

  int ret = avcodec_send_frame(codec_ctx, frame);
  if (ret < 0) {
    LOGE("发送帧到编码器失败\n");
    av_packet_free(&pkt);
    avcodec_free_context(&codec_ctx);
    return -1;
  }

  ret = avcodec_receive_packet(codec_ctx, pkt);
  if (ret < 0) {
    LOGE("从编码器接收包失败\n");
    av_packet_free(&pkt);
    avcodec_free_context(&codec_ctx);
    return -1;
  }

  // 写入到标准输出
  fwrite(pkt->data, 1, pkt->size, output);
  fflush(output);

  av_packet_free(&pkt);
  avcodec_free_context(&codec_ctx);
  return 0;
}

// 主函数
int main(int argc, char* argv[]) {
  if (argc < 4) {
    return 1;
  }

  const char* input_file = argv[1];
  const int row = atoi(argv[2]);
  const int col = atoi(argv[3]);
  if (row <= 0 || col <= 0) {
    LOGE("not correct params grid %dx%d", row, col);
    return 1;
  }
  int frame_count = row * col;

  init_ffmpeg();

  // 打开视频文件
  AVFormatContext* format_ctx = open_video(input_file);
  if (!format_ctx) return 1;

  // 查找视频流
  int video_stream = find_video_stream(format_ctx);
  if (video_stream < 0) {
    LOGE("找不到视频流\n");
    avformat_close_input(&format_ctx);
    return 1;
  }

  // 获取视频时长
  double duration = format_ctx->duration / (double)AV_TIME_BASE;
  // printf("视频时长: %.2f秒\n", duration);

  // 打开解码器
  AVCodecContext* codec_ctx = open_decoder(format_ctx, video_stream);
  if (!codec_ctx) {
    avformat_close_input(&format_ctx);
    return 1;
  }

  // 计算提取时间点（避免开头和结尾）
  double start_time = duration * 0.05;  // 从5%开始
  double end_time = duration * 0.95;    // 到95%结束
  double effective_duration = end_time - start_time;
  double time_interval = effective_duration / frame_count;

  AVFrame** extracted_frames = calloc(frame_count, sizeof(AVFrame*));

  // printf("开始提取帧...\n");

  // 提取10个帧
  for (int i = 0; i < frame_count; i++) {
    double target_time = start_time + time_interval * i;
    // printf("提取 %.2f秒的帧...\n", target_time);

    AVFrame* frame =
        extract_frame_at_time(format_ctx, codec_ctx, video_stream, target_time);
    if (frame) {
      extracted_frames[i] = convert_to_rgb(frame, codec_ctx);
      if (extracted_frames[i]) {
        // 修复颜色顺序（如果需要）
        // fix_bgr_to_rgb(extracted_frames[i]);
      }
      av_frame_free(&frame);
    }

    if (!extracted_frames[i]) {
      LOGE("无法提取第%d帧\n", i + 1);
    }
  }

  // 创建网格图片
  // printf("创建网格图片...\n");
  AVFrame* grid_image =
      create_grid_image(extracted_frames, row * col, col, row);

  if (grid_image) {
    // 保存结果
    if (save_frame_as_png(grid_image, stdout) == 0) {
    } else {
      LOGE("保存文件失败\n");
      return 1;
    }
    av_frame_free(&grid_image);
  } else {
    LOGE("无法创建网格图片\n");
    return 0;
  }

  // 清理资源
  for (int i = 0; i < frame_count; i++) {
    if (extracted_frames[i]) av_frame_free(&extracted_frames[i]);
  }

  avcodec_free_context(&codec_ctx);
  avformat_close_input(&format_ctx);
  free(extracted_frames);
  return 0;
}