/
remux.rs
234 lines (219 loc) · 7.57 KB
/
remux.rs
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
#![allow(unused)]
//! Losslessly convert file formats without decoding. I.e. MP4 into something
//! else, without altering the contained video, audio, etc. streams.
//!
//! Tested with this file:
//! * [sintel_trailer-1080p.mp4](https://download.blender.org/durian/trailer/sintel_trailer-1080p.mp4)
//! * sha1: `6679861234298c4d406ed66e8bd7d2e0583bbe91`
//!
//! Example code based on the
//! [original C example](https://github.com/FFmpeg/FFmpeg/blob/master/doc/examples/remuxing.c).
use std::convert::AsRef;
use std::path::{PathBuf, Path};
use std::ffi::{CStr, CString};
use std::os::raw::{c_char, c_int};
use libc::{size_t, c_float, c_void};
use ffmpeg_dev::sys::{
self,
AVMediaType_AVMEDIA_TYPE_UNKNOWN as AVMEDIA_TYPE_UNKNOWN,
AVMediaType_AVMEDIA_TYPE_VIDEO as AVMEDIA_TYPE_VIDEO,
AVMediaType_AVMEDIA_TYPE_AUDIO as AVMEDIA_TYPE_AUDIO,
AVMediaType_AVMEDIA_TYPE_DATA as AVMEDIA_TYPE_DATA,
AVMediaType_AVMEDIA_TYPE_SUBTITLE as AVMEDIA_TYPE_SUBTITLE,
AVMediaType_AVMEDIA_TYPE_ATTACHMENT as AVMEDIA_TYPE_ATTACHMENT,
AVMediaType_AVMEDIA_TYPE_NB as AVMEDIA_TYPE_NB,
AVFMT_NOFILE,
AVIO_FLAG_WRITE,
AVRounding_AV_ROUND_NEAR_INF as AV_ROUND_NEAR_INF,
AVRounding_AV_ROUND_PASS_MINMAX as AV_ROUND_PASS_MINMAX,
AVCodecID_AV_CODEC_ID_H264 as AV_CODEC_ID_H264,
};
fn c_str(s: &str) -> CString {
CString::new(s).expect("str to c str")
}
unsafe fn remux(
input_path: &str,
output_path: &str,
) {
// I/O
assert!(PathBuf::from(input_path).exists());
let input_path_cstr = CString::new(input_path).expect("to c str");
let output_path_cstr = CString::new(output_path).expect("to c str");
// SETUP AV CONTEXT
let mut ifmt_ctx: *mut sys::AVFormatContext = std::ptr::null_mut();
let mut ofmt_ctx: *mut sys::AVFormatContext = std::ptr::null_mut();
let mut pkt: sys::AVPacket = std::mem::zeroed();
// OPEN SOURCE
assert_eq!(
sys::avformat_open_input(
&mut ifmt_ctx,
input_path_cstr.as_ptr(),
std::ptr::null_mut(),
std::ptr::null_mut(),
),
0
);
assert!(sys::avformat_find_stream_info(ifmt_ctx, std::ptr::null_mut()) >= 0);
sys::av_dump_format(
ifmt_ctx,
0,
input_path_cstr.as_ptr(),
0,
);
// OUTPUT CONTEXT
assert!(sys::avformat_alloc_output_context2(
&mut ofmt_ctx,
std::ptr::null_mut(),
std::ptr::null_mut(),
output_path_cstr.as_ptr(),
) >= 0);
// OUTPUT META
let mut ofmt: *mut sys::AVOutputFormat = (*ofmt_ctx).oformat;
// STREAM TRACKER
let stream_mapping_size: u32 = (*ifmt_ctx).nb_streams;
let mut stream_mapping: Vec<i32> = vec![0; stream_mapping_size as usize];
// SOURCE TO DEST STREAMS
let input_streams = {
let len = stream_mapping_size as usize;
std::slice::from_raw_parts((*ifmt_ctx).streams, len)
.iter()
.map(|x| (*x).as_ref().expect("not null"))
.collect::<Vec<&sys::AVStream>>()
};
for (index, in_stream) in input_streams.iter().enumerate() {
assert!(!in_stream.codecpar.is_null());
let mut out_stream: *mut sys::AVStream = std::ptr::null_mut();
let skip = {
(*in_stream.codecpar).codec_type != AVMEDIA_TYPE_VIDEO
};
if skip {
stream_mapping[index] = -1;
} else {
out_stream = sys::avformat_new_stream(ofmt_ctx, std::ptr::null());
assert!(!out_stream.is_null());
let status = sys::avcodec_parameters_copy(
(*out_stream).codecpar,
in_stream.codecpar,
);
assert!(status >= 0);
(*(*out_stream).codecpar).codec_tag = 0;
}
}
sys::av_dump_format(ofmt_ctx, 0, output_path_cstr.as_ptr(), 1);
// OPEN OUTPUT STREAM
if ((*ofmt).flags & (AVFMT_NOFILE as i32)) == 0 {
let status = sys::avio_open(
&mut (*ofmt_ctx).pb,
output_path_cstr.as_ptr(),
AVIO_FLAG_WRITE as i32,
);
assert!(status >= 0);
}
// WRITE OUTPUT
let mut opts: *mut ffmpeg_dev::sys::AVDictionary = std::ptr::null_mut();
ffmpeg_dev::sys::av_dict_set(
&mut opts,
c_str("movflags").as_ptr(),
c_str("frag_keyframe+empty_moov+default_base_moof").as_ptr(),
0,
);
assert!(sys::avformat_write_header(ofmt_ctx, &mut opts) >= 0);
let mut status = 0;
loop {
if sys::av_read_frame(ifmt_ctx, &mut pkt) != 0 {
break;
}
// SOURCE
let in_stream: *mut sys::AVStream = (*(*ifmt_ctx).streams).offset(pkt.stream_index as isize);
assert!(!in_stream.is_null());
// DEST
let mut out_stream: *mut sys::AVStream = std::ptr::null_mut();
// ???
let skip = {
pkt.stream_index >= stream_mapping.len() as i32 ||
stream_mapping[pkt.stream_index as usize] < 0
};
if skip {
sys::av_packet_unref(&mut pkt);
continue;
}
pkt.stream_index = stream_mapping[pkt.stream_index as usize];
out_stream = (*(*ofmt_ctx).streams).offset(pkt.stream_index as isize);
// COPY PACKET
pkt.pts = sys::av_rescale_q_rnd(
pkt.pts,
(*in_stream).time_base,
(*out_stream).time_base,
AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX,
);
pkt.dts = sys::av_rescale_q_rnd(
pkt.dts,
(*in_stream).time_base,
(*out_stream).time_base,
AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX
);
pkt.duration = sys::av_rescale_q(
pkt.duration,
(*in_stream).time_base,
(*out_stream).time_base,
);
pkt.pos = -1;
// WRITE
// RESCALE OUTPUT PACKET TIMESTAMP VALUES FROM CODEC TO STREAM TIMEBASE
// av_packet_rescale_ts(pkt, *time_base, st->time_base);
// pkt->stream_index = st->index;
// WRITE THE COMPRESSED FRAME TO THE MEDIA FILE
assert!(sys::av_interleaved_write_frame(ofmt_ctx, &mut pkt) >= 0);
// assert!(av_write_frame(ofmt_ctx, &mut pkt) >= 0);
sys::av_packet_unref(&mut pkt);
}
sys::av_write_trailer(ofmt_ctx);
(*ifmt_ctx);
// CLOSE OUTPUT
if !ofmt_ctx.is_null() && ((*ofmt).flags & (AVFMT_NOFILE as i32) <= 0) {
sys::avio_closep(&mut (*ofmt_ctx).pb);
}
sys::avformat_free_context(ofmt_ctx);
assert!(status != sys::EOF);
}
///////////////////////////////////////////////////////////////////////////////
// MAIN
///////////////////////////////////////////////////////////////////////////////
pub fn main() {
// HELPER FUNCTION
pub fn path_exists(path: &str) -> bool {
std::fs::metadata(path).is_ok()
}
// CLI Example:
// ```
// cargo run --example remux -- \
// assets/samples/sintel_trailer.1080p.mp4 assets/output/test.mp4
// ```
fn run() -> Result<(), String> {
let args = std::env::args().collect::<Vec<_>>();
let input_path = args
.get(1)
.ok_or(String::from("missing input argument"))?
.as_ref();
let output_path = args
.get(2)
.ok_or(String::from("missing output argument"))?
.as_ref();
if !path_exists(input_path) {
return Err(String::from("missing input file"))
}
unsafe {
remux(
input_path,
output_path
);
};
Ok(())
}
match run() {
Ok(()) => (),
Err(msg) => {
eprintln!("[failed] {:?}", msg);
}
}
}