ts2mp4 0.3.2

A library and CLI tool for converting MPEG-TS files to MP4 format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use clap::{Parser, Subcommand};
use std::fs;
use std::io::{self, ErrorKind};
use std::path::PathBuf;

#[derive(Parser)]
#[command(name = "ts2mp4")]
#[command(about = "Convert TS/MP4 files and extract thumbnails", long_about = None)]
#[command(version)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Convert TS or MP4 file (with optional timestamp reset)
    Convert {
        /// Input file path (TS or MP4)
        #[arg(short, long)]
        input: PathBuf,

        /// Output MP4 file path
        #[arg(short, long)]
        output: PathBuf,

        /// Reset timestamps to start from 0 (like ffmpeg -avoid_negative_ts make_zero)
        #[arg(short, long, default_value_t = false)]
        reset_timestamps: bool,
    },
    /// Extract thumbnail from TS file
    ThumbnailTs {
        /// Input TS file path
        #[arg(short, long)]
        input: PathBuf,

        /// Output JPEG file path
        #[arg(short, long)]
        output: PathBuf,
    },
    /// Extract thumbnail from MP4 file
    ThumbnailMp4 {
        /// Input MP4 file path
        #[arg(short, long)]
        input: PathBuf,

        /// Output JPEG file path
        #[arg(short, long)]
        output: PathBuf,
    },
}

fn main() -> io::Result<()> {
    let cli = Cli::parse();

    match cli.command {
        Commands::Convert {
            input,
            output,
            reset_timestamps,
        } => convert_command(&input, &output, reset_timestamps),
        Commands::ThumbnailTs { input, output } => extract_thumbnail_ts(&input, &output),
        Commands::ThumbnailMp4 { input, output } => extract_thumbnail_mp4(&input, &output),
    }
}

fn detect_file_type(data: &[u8]) -> FileType {
    // Check for MP4 signature (ftyp box)
    if data.len() >= 8 && &data[4..8] == b"ftyp" {
        return FileType::Mp4;
    }

    // Check for TS sync byte (0x47)
    if data.len() >= 188 && data[0] == 0x47 {
        return FileType::Ts;
    }

    FileType::Unknown
}

enum FileType {
    Ts,
    Mp4,
    Unknown,
}

fn convert_command(input: &PathBuf, output: &PathBuf, reset_timestamps: bool) -> io::Result<()> {
    eprintln!("Input: {}", input.display());
    eprintln!("Output: {}", output.display());
    if reset_timestamps {
        eprintln!("Timestamp reset: enabled");
    }

    let input_data = fs::read(input)?;
    let file_type = detect_file_type(&input_data);

    let mp4_data = match file_type {
        FileType::Ts => {
            eprintln!("Detected: MPEG-TS format");
            ts2mp4::convert_ts_to_mp4_with_options(&input_data, reset_timestamps)?
        }
        FileType::Mp4 => {
            eprintln!("Detected: MP4 format");
            if reset_timestamps {
                eprintln!("Converting Fragmented MP4 to regular MP4...");
                // Fragmented MP4를 일반 MP4로 변환 시도
                match ts2mp4::defragment_mp4(&input_data) {
                    Ok(data) => {
                        eprintln!("Defragmentation successful");
                        data
                    }
                    Err(_) => {
                        // Fragmented MP4가 아니면 timestamp reset만
                        eprintln!("Not fragmented, resetting timestamps...");
                        ts2mp4::reset_mp4_timestamps(&input_data)?
                    }
                }
            } else {
                eprintln!("No conversion needed, copying MP4 file...");
                input_data.clone()
            }
        }
        FileType::Unknown => {
            return Err(io::Error::new(
                ErrorKind::InvalidData,
                "Unknown file format. Expected TS or MP4 file.",
            ));
        }
    };

    fs::write(output, mp4_data)?;
    eprintln!("Conversion complete!");
    Ok(())
}

fn extract_thumbnail_ts(input: &PathBuf, output: &PathBuf) -> io::Result<()> {
    eprintln!("Extracting thumbnail from TS: {}", input.display());

    let ts_data = fs::read(input)?;
    let jpeg_data = ts2mp4::extract_thumbnail_from_ts(&ts_data)?;
    fs::write(output, jpeg_data)?;

    eprintln!("Thumbnail saved to {}", output.display());
    Ok(())
}

fn extract_thumbnail_mp4(input: &PathBuf, output: &PathBuf) -> io::Result<()> {
    eprintln!("Extracting thumbnail from MP4: {}", input.display());

    let mp4_data = fs::read(input)?;
    let jpeg_data = ts2mp4::extract_thumbnail_from_mp4(&mp4_data)?;
    fs::write(output, jpeg_data)?;

    eprintln!("Thumbnail saved to {}", output.display());
    Ok(())
}