通用格式拆分

该功能利用 FFmpeg 强大的多媒体处理能力，实现对音频、视频等多种格式文件的自动拆分。通过调用本地库中的 NativeMedia.split 方法，可以根据指定的文件大小阈值将一个多媒体文件分割成若干个连续的小文件，而无需重新编码，确保原始编码参数不变，从而实现高效、无损的拆分操作。

功能简介

• 多格式支持：支持 FFmpeg 支持的所有音视频格式，包括 MP3、MP4、MKV、AVI、WAV 等。
• 自动拆分：根据用户指定的大小阈值，自动将输入文件拆分成多个文件，拆分过程保持数据流一致性。
• 流拷贝：采用流拷贝的方式实现拆分，避免了不必要的解码与重编码，保证拆分后的文件与原始文件编码一致。
• 返回拆分结果：方法返回包含所有生成拆分文件路径的 Java 字符串数组，便于后续处理或调用。

使用示例

以下示例展示了如何调用拆分功能，将一个位于 G:\video\input.mp3 的音频文件按每 10MB 进行拆分：

String inputFile = "G:\\video\\input.mp3";
// 将输入文件按 10MB 大小进行拆分
String[] split = NativeMedia.split(inputFile, 10 * 1024 * 1024);

// 输出拆分后生成的各个文件路径
for (String path : split) {
    System.out.println(path);
}

在该示例中，拆分后的文件名会根据原始文件名生成（例如 input_segment_0.mp3、input_segment_1.mp3 等），用户可以直接获取拆分后的各个文件路径，进行后续处理或存档管理。

参数说明

• inputFile
  指定待拆分的输入文件的绝对路径。支持 Windows 下的路径格式，如 "G:\\video\\input.mp3"。

• sizeThreshold
  拆分的大小阈值，单位为字节。例如 10 * 1024 * 1024 表示每个拆分文件的目标大小为 10MB。当当前输出文件数据量达到该阈值时，自动关闭当前段并开始新段。

实现原理

1. 文件打开与信息读取
   通过 FFmpeg 的 avformat_open_input 打开输入文件，并使用 avformat_find_stream_info 获取文件流信息（音频、视频、字幕等）。

2. 生成输出段文件
   根据输入文件的基本名称和扩展名，为每个输出段生成新的文件名。输出文件名称采用类似 input_segment_0.ext 的格式，其中 ext 为文件扩展名（例如 mp3、mp4 等）。

3. 流拷贝方式拆分
   对于输入文件的每个流，创建对应的输出流，并使用 avcodec_parameters_copy 拷贝原始参数。拆分时采用流拷贝的方式（无解码、无重编码），保持数据的原始完整性。

4. 文件大小监控
   在拆分过程中，实时监控当前输出文件的数据量。当输出文件的写入数据量达到用户设定的大小阈值时，调用 av_write_trailer 结束当前输出段，并新建下一个输出段继续写入数据。

5. 返回结果
   拆分结束后，收集所有生成的输出文件路径，并以 Java 字符串数组的形式返回，方便用户后续处理。

注意事项

• 格式兼容性：只要 FFmpeg 支持的格式均可使用该功能进行拆分。拆分过程中保持原始编码参数，因此拆分后各个文件均可在支持相应格式的播放器中正常播放。
• 数据完整性：由于采用流拷贝方式，拆分过程不会对音视频数据进行解码或重编码，确保数据原始质量不变。
• 异常处理：在实际应用中，应注意捕获和处理可能出现的异常情况，例如文件读取失败、输出文件创建失败等问题。

C 代码实现

native_media_av_split.c

#include "com_litongjava_media_NativeMedia.h"
#include <jni.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/opt.h>
#include <libavutil/timestamp.h>
#include <libavutil/error.h>
#ifdef _WIN32
#include <stringapiset.h>
#endif

// 辅助函数：新建一个输出段
// 参数说明：
//   ofmt_ctx      —— 指向当前输出 AVFormatContext 的指针（若不为 NULL，则先关闭上个段）
//   ifmt_ctx      —— 输入文件上下文（用于复制流信息）
//   extension     —— 输出容器格式（例如 "mp3", "mp4", "mkv" 等）
//   base_name     —— 输入文件去除扩展名的基础名称
//   seg_index     —— 本次段的序号
//   seg_filename  —— 用于保存本次段文件名的缓冲区，其大小 seg_filename_size 指定
//   seg_filename_size —— 文件名缓冲区大小
//   seg_names     —— 指向存放段文件名的 char* 数组指针（动态扩容）
//   seg_count     —— 当前已保存的段数
//   seg_capacity  —— 数组的当前容量
// 返回 0 表示成功，否则返回负错误码
static int open_new_segment(AVFormatContext **ofmt_ctx, AVFormatContext *ifmt_ctx,
                            const char *extension, const char *base_name,
                            int seg_index, char *seg_filename, size_t seg_filename_size,
                            char ***seg_names, int *seg_count, int *seg_capacity) {
  int ret;

  // 如果已有一个输出上下文，则先结束上一个段
  if (*ofmt_ctx) {
    ret = av_write_trailer(*ofmt_ctx);
    if (ret < 0)
      return ret;
    if (!((*ofmt_ctx)->oformat->flags & AVFMT_NOFILE) && (*ofmt_ctx)->pb)
      avio_closep(&(*ofmt_ctx)->pb);

    // 保存上个段文件名到数组中
    char *name_copy = strdup(seg_filename);
    if (!name_copy)
      return AVERROR(ENOMEM);
    if (*seg_count >= *seg_capacity) {
      *seg_capacity *= 2;
      char **tmp = realloc(*seg_names, (*seg_capacity) * sizeof(char *));
      if (!tmp)
        return AVERROR(ENOMEM);
      *seg_names = tmp;
    }
    (*seg_names)[*seg_count] = name_copy;
    (*seg_count)++;
    avformat_free_context(*ofmt_ctx);
    *ofmt_ctx = NULL;
  }

  // 构造新段文件名：例如 "input_segment_0.mp3"
  snprintf(seg_filename, seg_filename_size, "%s_segment_%d.%s", base_name, seg_index, extension);

  // 分配输出格式上下文
  ret = avformat_alloc_output_context2(ofmt_ctx, NULL, extension, seg_filename);
  if (ret < 0 || !(*ofmt_ctx))
    return ret;

  // 对输入文件中的每个流都创建一个输出流（流拷贝）
  for (unsigned int i = 0; i < ifmt_ctx->nb_streams; i++) {
    AVStream *in_stream = ifmt_ctx->streams[i];
    AVStream *out_stream = avformat_new_stream(*ofmt_ctx, NULL);
    if (!out_stream)
      return AVERROR_UNKNOWN;
    ret = avcodec_parameters_copy(out_stream->codecpar, in_stream->codecpar);
    if (ret < 0)
      return ret;
    out_stream->codecpar->codec_tag = 0;
    out_stream->time_base = in_stream->time_base;
  }

  // 打开输出文件（若格式需要文件操作）
  if (!((*ofmt_ctx)->oformat->flags & AVFMT_NOFILE)) {
    ret = avio_open(&(*ofmt_ctx)->pb, seg_filename, AVIO_FLAG_WRITE);
    if (ret < 0)
      return ret;
  }

  // 写文件头
  ret = avformat_write_header(*ofmt_ctx, NULL);
  return ret;
}



JNIEXPORT jobjectArray JNICALL
Java_com_litongjava_media_NativeMedia_split(JNIEnv *env, jclass clazz, jstring inputPath, jlong segSize) {
  char input_file[1024] = {0};
#ifdef _WIN32
  // 获取 jstring 的宽字符表示
  const jchar *inputChars = (*env)->GetStringChars(env, inputPath, NULL);
  if (!inputChars) {
    return NULL;
  }
  jsize inputLen = (*env)->GetStringLength(env, inputPath);

  // 构造宽字符缓冲区
  wchar_t wInput[1024] = {0};
  if (inputLen >= 1024) inputLen = 1023;
  for (int i = 0; i < inputLen; i++) {
    wInput[i] = (wchar_t) inputChars[i];
  }
  wInput[inputLen] = L'\0';
  (*env)->ReleaseStringChars(env, inputPath, inputChars);

  // 将宽字符转换为 UTF-8 字符串
  int utf8Len = WideCharToMultiByte(CP_UTF8, 0, wInput, -1, NULL, 0, NULL, NULL);
  if (utf8Len <= 0 || utf8Len > 1024) {
    return NULL;
  }
  WideCharToMultiByte(CP_UTF8, 0, wInput, -1, input_file, sizeof(input_file), NULL, NULL);
#else
  // 非 Windows 平台直接获取 UTF-8 字符串
    const char *tmp = (*env)->GetStringUTFChars(env, inputPath, NULL);
    if (!tmp) return NULL;
    strncpy(input_file, tmp, sizeof(input_file) - 1);
    (*env)->ReleaseStringUTFChars(env, inputPath, tmp);
#endif

  // 以下保持原有逻辑不变
  int ret = 0;
  AVFormatContext *ifmt_ctx = NULL;
  ret = avformat_open_input(&ifmt_ctx, input_file, NULL, NULL);
  if (ret < 0) {
    return NULL;
  }
  ret = avformat_find_stream_info(ifmt_ctx, NULL);
  if (ret < 0) {
    avformat_close_input(&ifmt_ctx);
    return NULL;
  }

  // 根据输入文件名获取基础名和扩展名
  const char *dot = strrchr(input_file, '.');
  char extension[32] = {0};
  if (dot && strlen(dot) > 1) {
    strncpy(extension, dot + 1, sizeof(extension) - 1);
  } else {
    strcpy(extension, "mp4"); // 默认容器
  }
  size_t base_len = dot ? (dot - input_file) : strlen(input_file);
  char base_name[1024] = {0};
  strncpy(base_name, input_file, base_len);
  base_name[base_len] = '\0';

  // 准备存储段文件名的动态数组
  int seg_capacity = 10;
  int seg_count = 0;
  char **seg_names = (char **) malloc(seg_capacity * sizeof(char *));
  if (!seg_names) {
    avformat_close_input(&ifmt_ctx);
    return NULL;
  }

  int seg_index = 0;
  AVFormatContext *ofmt_ctx = NULL;
  char seg_filename[1024] = {0};

  // 初始化第一个段
  ret = open_new_segment(&ofmt_ctx, ifmt_ctx, extension, base_name, seg_index, seg_filename,
                         sizeof(seg_filename), &seg_names, &seg_count, &seg_capacity);
  if (ret < 0) {
    free(seg_names);
    avformat_close_input(&ifmt_ctx);
    return NULL;
  }
  seg_index++;

  AVPacket *pkt = av_packet_alloc();
  if (!pkt) {
    if (ofmt_ctx) {
      av_write_trailer(ofmt_ctx);
      if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE) && ofmt_ctx->pb)
        avio_closep(&ofmt_ctx->pb);
      avformat_free_context(ofmt_ctx);
    }
    free(seg_names);
    avformat_close_input(&ifmt_ctx);
    return NULL;
  }

  // 读取输入数据包，并写入当前段（流拷贝）
  while (av_read_frame(ifmt_ctx, pkt) >= 0) {
    AVStream *in_stream = ifmt_ctx->streams[pkt->stream_index];
    AVStream *out_stream = ofmt_ctx->streams[pkt->stream_index];
    pkt->pts = av_rescale_q_rnd(pkt->pts, in_stream->time_base, out_stream->time_base,
                                AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX);
    pkt->dts = av_rescale_q_rnd(pkt->dts, in_stream->time_base, out_stream->time_base,
                                AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX);
    pkt->duration = av_rescale_q(pkt->duration, in_stream->time_base, out_stream->time_base);
    pkt->pos = -1;

    ret = av_interleaved_write_frame(ofmt_ctx, pkt);
    if (ret < 0)
      break;

    if (ofmt_ctx->pb && ofmt_ctx->pb->pos >= segSize) {
      ret = open_new_segment(&ofmt_ctx, ifmt_ctx, extension, base_name, seg_index, seg_filename,
                             sizeof(seg_filename), &seg_names, &seg_count, &seg_capacity);
      if (ret < 0)
        break;
      seg_index++;
    }
    av_packet_unref(pkt);
  }

  if (ofmt_ctx) {
    av_write_trailer(ofmt_ctx);
    if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE) && ofmt_ctx->pb)
      avio_closep(&ofmt_ctx->pb);
    char *name_copy = strdup(seg_filename);
    if (name_copy) {
      if (seg_count >= seg_capacity) {
        seg_capacity *= 2;
        seg_names = realloc(seg_names, seg_capacity * sizeof(char *));
      }
      seg_names[seg_count++] = name_copy;
    }
    avformat_free_context(ofmt_ctx);
    ofmt_ctx = NULL;
  }

  av_packet_free(&pkt);
  avformat_close_input(&ifmt_ctx);

  // 构造 Java 字符串数组返回结果
  jclass strClass = (*env)->FindClass(env, "java/lang/String");
  jobjectArray jresult = (*env)->NewObjectArray(env, seg_count, strClass, NULL);
  for (int i = 0; i < seg_count; i++) {
    jstring jstr = (*env)->NewStringUTF(env, seg_names[i]);
    (*env)->SetObjectArrayElement(env, jresult, i, jstr);
    free(seg_names[i]);
  }
  free(seg_names);
  return jresult;
}

总结

通用格式拆分功能为多媒体文件管理提供了一种高效、无损的解决方案。用户只需指定输入文件和目标拆分大小，便可自动生成多个拆分文件。该功能不仅支持常见音视频格式，同时兼容 FFmpeg 支持的所有格式，适用于各种场景下的大文件拆分需求。