如何使用 Java 高效合并多个 MP4 文件（避免逐次合并导致的编码损坏）

本文介绍一种稳定、可扩展的 java 方案，通过 mp4parser 库一次性合并任意数量的 mp4 文件，规避逐次两两合并引发的轨道不兼容、编解码器错乱（如 mp4a/avc1 损坏）等问题，并提供完整可运行代码与关键注意事项。

在使用 mp4parser（即 isoparser）进行 MP4 合并时，核心问题在于：逐次两两合并（output0 → output1 → output2…）会不断重写容器结构，导致音视频轨道的编码参数（如 AVC/H.264 SPS/PPS、AAC ADTS 头、时间基 timebase、sample rate 等）在中间文件中丢失或错配。最终生成的 output1.mp4 虽能写入磁盘，但因元数据不一致，被播放器识别为“MP4A with AVC1”等异常组合，实际无法解码。

✅ 正确做法是：一次性读取所有源文件，统一提取并拼接音视频轨道，再构建单个输出 Movie 对象。以下是优化后的完整实现：

import com.coremedia.iso.IsoFile;
import com.coremedia.iso.boxes.MovieBox;
import com.googlecode.mp4parser.authoring.*;
import com.googlecode.mp4parser.authoring.builder.DefaultMp4Builder;
import com.googlecode.mp4parser.authoring.container.mp4.MovieCreator;
import com.googlecode.mp4parser.authoring.tracks.AppendTrack;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.WritableByteChannel;
import java.util.*;
import java.util.stream.Collectors;

public class MP4Merger {

    public static void mergeMP4s(List inputFiles, File outputFile) throws IOException {
        if (inputFiles.isEmpty()) throw new IllegalArgumentException("At least one input file required");

        // Step 1: Load all movies
        List movies = inputFiles.stream()
                .map(file -> {
                    try {
                        return MovieCreator.build(file.getAbsolutePath());
                    } catch (IOException e) {
                        throw new RuntimeException("Failed to load " + file.getName(), e);
                    }
                })
                .collect(Collectors.toList());

        // Step 2: Extract & group tracks by handler (ensure consistent codec & parameters)
        List videoTracks = new ArrayList<>();
        List audioTracks = new ArrayList<>();

        for (Movie movie : movies) {
            for (Track track : movie.getTracks()) {
                String handler = track.getHandler();
                if ("vide".equals(handler)) {
                    videoTracks.add(track);
                } else if ("soun".equals(handler)) {
                    audioTracks.add(track);
                }
                // Ignore subtitles, metadata, etc. (optional: log warnings)
            }
        }

        // Step 3: Validate track compatibility (critical for stability)
        if (!videoTracks.isEmpty() && !areTracksCompatible(videoTracks)) {
            throw new IllegalStateException("Video tracks have incompatible encoding parameters");
        }
        if (!audioTracks.isEmpty() && !areTracksCompatible(audioTracks)) {
            throw new IllegalStateException("Audio tracks have incompatible encoding parameters");
        }

        // Step 4: Build merged movie
        Movie outputMovie = new Movie();
        List allTracks = new ArrayList<>();

        if (!videoTracks.isEmpty()) {
            allTracks.add(new AppendTrack(videoTracks.toArray(new Track[0])));
        }
        if (!audioTracks.isEmpty()) {
            allTracks.add(new AppendTrack(audioTracks.toArray(new Track[0])));
        }

        outputMovie.setTracks(allTracks);

        // Step 5: Build and write container
        Container container = new DefaultMp4Builder().build(outputMovie);
        try (FileOutputStream fos = new FileOutputStream(outputFile);
             WritableByteChannel channel = fos.getChannel()) {
            container.writeContainer(channel);
        }
    }

    // Simple compatibility check: same handler, same timescale, same cod
ec string
    private static boolean areTracksCompatible(List tracks) {
        if (tracks.size() < 2) return true;
        Track ref = tracks.get(0);
        long refTimescale = ref.getTrackMetaData().getTimescale();
        String refCodec = ref.getHandler(); // or use track.getSampleDescriptionBox() for deeper checks

        return tracks.stream().allMatch(t -> {
            long ts = t.getTrackMetaData().getTimescale();
            return ts == refTimescale && t.getHandler().equals(refCodec);
        });
    }

    // Usage example
    public static void main(String[] args) throws IOException {
        List inputs = Arrays.asList(
            new File("test1.mp4"),
            new File("test2.mp4"),
            new File("test3.mp4")
        );
        mergeMP4s(inputs, new File("merged_output.mp4"));
        System.out.println("✅ Merge completed: merged_output.mp4");
    }
}

? 关键注意事项：

• 依赖配置：需在 pom.xml 中添加最新版 isoparser（推荐 1.9.41+）：

  
      com.googlecode.mp4parser
      isoparser
      1.9.41
  

• 编码一致性要求：所有输入 MP4 必须使用相同编码格式（H.264 + AAC）、相同采样率、帧率及时间基（timescale）。若源文件来自不同设备或转码器，建议先用 FFmpeg 统一预处理：

  ffmpeg -i input.mp4 -c:v libx264 -crf 23 -c:a aac -b:a 128k -movflags +faststart normalized.mp4

• 替代方案（推荐生产环境）：对可靠性要求极高时，建议调用系统级 ffmpeg（零拷贝、全编码支持）：

  // 使用 bramp/ffmpeg-cli-wrapper
  FFmpeg ffmpeg = new FFmpeg("/usr/bin/ffmpeg");
  FFmpegBuilder builder = new FFmpegBuilder()
      .addInput(UrlInput.fromPath("file1.mp4"))
      .addInput(UrlInput.fromPath("file2.mp4"))
      .addOutput(UrlOutput.toPath("merged.mp4"))
      .setConcat(true);
  ffmpeg.run(builder);

该方案彻底规避了中间文件污染问题，确保输出 MP4 元数据完整、结构标准，可被 VLC、QuickTime、Android/iOS 原生播放器无缝支持。