use crate::av::{Packet, CodecType};
pub struct Stream {
pub codec_type: CodecType,
pub track_id: u32,
pub time_scale: u32,
pub width: u32,
pub height: u32,
pub codec_data: Vec<u8>, pub last_dts: u64,
}
pub struct Mp4Muxer {
pub streams: Vec<Stream>,
pub fragment_index: u32,
pub sample_index: u32,
pub moof_entries: Vec<TrackFragRunEntry>,
pub mdat_buffer: Vec<u8>,
}
pub struct TrackFragRunEntry {
pub duration: u32,
pub size: u32,
pub cts: u32,
pub is_keyframe: bool,
}
impl Mp4Muxer {
pub fn new() -> Self {
Self {
streams: Vec::new(),
fragment_index: 0,
sample_index: 0,
moof_entries: Vec::new(),
mdat_buffer: Vec::new(),
}
}
pub fn add_stream(&mut self, codec_type: CodecType, width: u32, height: u32, codec_data: Vec<u8>) {
let track_id = (self.streams.len() + 1) as u32;
let time_scale = match codec_type {
CodecType::H264 | CodecType::H265 => 90000,
CodecType::AAC => 48000, _ => 1000,
};
self.streams.push(Stream {
codec_type,
track_id,
time_scale,
width,
height,
codec_data,
last_dts: 0,
});
}
pub fn get_init(&self) -> Vec<u8> {
let mut f = Vec::new();
let ftyp_data = [
0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6f, 0x36, 0x00, 0x00, 0x00, 0x01, 0x69, 0x73, 0x6f, 0x36, 0x64, 0x61, 0x73, 0x68, ];
f.extend_from_slice(&ftyp_data);
let mut moov = Vec::new();
moov.extend_from_slice(b"moov");
let mvhd = [
0x00, 0x00, 0x00, 0x6c, 0x6d, 0x76, 0x68, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0,0,0,0, 0,0,0,0,
0x00, 0x01, 0x00, 0x00, 0,0,0,0, 0,0,0,0,
0,0,0,0, 0x00, 0x01, 0x00, 0x00, 0,0,0,0,
0,0,0,0, 0,0,0,0, 0x40, 0x00, 0x00, 0x00, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
0x00, 0x00, 0x00, 0x03, ];
moov.extend_from_slice(&mvhd);
let mut mvex = Vec::new();
mvex.extend_from_slice(b"\x00\x00\x00\x10mehd\x00\x00\x00\x00\x00\x00\x00\x00"); for stream in &self.streams {
let mut trex = vec![0, 0, 0, 32];
trex.extend_from_slice(b"trex");
trex.extend_from_slice(&[0, 0, 0, 0]); trex.extend_from_slice(&stream.track_id.to_be_bytes()); trex.extend_from_slice(&[0, 0, 0, 1]); trex.extend_from_slice(&[0, 0, 0, 0]); trex.extend_from_slice(&[0, 0, 0, 0]); trex.extend_from_slice(&[0, 0, 0, 0]); mvex.extend_from_slice(&trex);
}
let mvex_len = (mvex.len() + 8) as u32;
let mut mvex_box = mvex_len.to_be_bytes().to_vec();
mvex_box.extend_from_slice(b"mvex");
mvex_box.extend_from_slice(&mvex);
moov.extend_from_slice(&mvex_box);
for stream in &self.streams {
let mut trak = Vec::new();
trak.extend_from_slice(b"trak");
let mut tkhd = vec![0, 0, 0, 92];
tkhd.extend_from_slice(b"tkhd");
tkhd.extend_from_slice(&[0, 0, 0, 7]); tkhd.extend_from_slice(&[0; 8]); tkhd.extend_from_slice(&stream.track_id.to_be_bytes()); tkhd.extend_from_slice(&[0; 4]); tkhd.extend_from_slice(&[0; 4]); tkhd.extend_from_slice(&[0; 8]); tkhd.extend_from_slice(&[0; 2]); tkhd.extend_from_slice(&[0; 2]); tkhd.extend_from_slice(&[0x01, 0x00]); tkhd.extend_from_slice(&[0; 2]); tkhd.extend_from_slice(&[
0x00, 0x01, 0x00, 0x00, 0,0,0,0, 0,0,0,0,
0,0,0,0, 0x00, 0x01, 0x00, 0x00, 0,0,0,0,
0,0,0,0, 0,0,0,0, 0x40, 0x00, 0x00, 0x00
]); tkhd.extend_from_slice(&((stream.width as i32) << 16).to_be_bytes()); tkhd.extend_from_slice(&((stream.height as i32) << 16).to_be_bytes()); trak.extend_from_slice(&tkhd);
let mut mdia = Vec::new();
mdia.extend_from_slice(b"mdia");
let mut mdhd = vec![0, 0, 0, 32];
mdhd.extend_from_slice(b"mdhd");
mdhd.extend_from_slice(&[0; 12]); mdhd.extend_from_slice(&stream.time_scale.to_be_bytes()); mdhd.extend_from_slice(&[0; 4]); mdhd.extend_from_slice(&[0x55, 0xc4, 0, 0]); mdia.extend_from_slice(&mdhd);
let sub_type = match stream.codec_type {
CodecType::H264 | CodecType::H265 => b"vide",
CodecType::AAC => b"soun",
_ => b"hint",
};
let mut hdlr = vec![0, 0, 0, 45];
hdlr.extend_from_slice(b"hdlr");
hdlr.extend_from_slice(&[0; 8]); hdlr.extend_from_slice(sub_type);
hdlr.extend_from_slice(&[0; 12]); hdlr.extend_from_slice(b"VideoHandler\x00"); mdia.extend_from_slice(&hdlr);
let mut minf = Vec::new();
minf.extend_from_slice(b"minf");
match stream.codec_type {
CodecType::H264 | CodecType::H265 => {
minf.extend_from_slice(b"\x00\x00\x00\x14vmhd\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"); }
CodecType::AAC => {
minf.extend_from_slice(b"\x00\x00\x00\x10smhd\x00\x00\x00\x00\x00\x00\x00\x00"); }
_ => {}
}
let dref = [
0x00, 0x00, 0x00, 0x1c, 0x64, 0x69, 0x6e, 0x66, 0x00, 0x00, 0x00, 0x14, 0x64, 0x72, 0x65, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c, 0x75, 0x72, 0x6c, 0x20, 0x00, 0x00, 0x00, 0x01, ];
minf.extend_from_slice(&dref);
let mut stbl = Vec::new();
stbl.extend_from_slice(b"stbl");
let mut stsd_payload = Vec::new();
stsd_payload.extend_from_slice(&[0, 0, 0, 0]); stsd_payload.extend_from_slice(&[0, 0, 0, 1]);
match stream.codec_type {
CodecType::H264 => {
let mut avc1 = Vec::new();
avc1.extend_from_slice(&(86 + stream.codec_data.len() as u32).to_be_bytes()); avc1.extend_from_slice(b"avc1");
avc1.extend_from_slice(&[0; 6]); avc1.extend_from_slice(&[0, 1]); avc1.extend_from_slice(&[0; 16]); avc1.extend_from_slice(&(stream.width as u16).to_be_bytes()); avc1.extend_from_slice(&(stream.height as u16).to_be_bytes()); avc1.extend_from_slice(&[0x00, 0x48, 0x00, 0x00]); avc1.extend_from_slice(&[0x00, 0x48, 0x00, 0x00]); avc1.extend_from_slice(&[0; 4]); avc1.extend_from_slice(&[0, 1]); avc1.extend_from_slice(&[0; 32]); avc1.extend_from_slice(&[0, 24]); avc1.extend_from_slice(&[0xff, 0xff]);
let mut avcc = Vec::new();
avcc.extend_from_slice(&((8 + stream.codec_data.len()) as u32).to_be_bytes());
avcc.extend_from_slice(b"avcC");
avcc.extend_from_slice(&stream.codec_data);
avc1.extend_from_slice(&avcc);
stsd_payload.extend_from_slice(&avc1);
}
CodecType::H265 => {
let mut hvc1 = Vec::new();
hvc1.extend_from_slice(&(86 + stream.codec_data.len() as u32).to_be_bytes()); hvc1.extend_from_slice(b"hvc1");
hvc1.extend_from_slice(&[0; 6]); hvc1.extend_from_slice(&[0, 1]); hvc1.extend_from_slice(&[0; 16]); hvc1.extend_from_slice(&(stream.width as u16).to_be_bytes());
hvc1.extend_from_slice(&(stream.height as u16).to_be_bytes());
hvc1.extend_from_slice(&[0x00, 0x48, 0x00, 0x00]);
hvc1.extend_from_slice(&[0x00, 0x48, 0x00, 0x00]);
hvc1.extend_from_slice(&[0; 4]);
hvc1.extend_from_slice(&[0, 1]);
hvc1.extend_from_slice(&[0; 32]);
hvc1.extend_from_slice(&[0, 24]);
hvc1.extend_from_slice(&[0xff, 0xff]);
let mut hvcc = Vec::new();
hvcc.extend_from_slice(&((8 + stream.codec_data.len()) as u32).to_be_bytes());
hvcc.extend_from_slice(b"hvcC");
hvcc.extend_from_slice(&stream.codec_data);
hvc1.extend_from_slice(&hvcc);
stsd_payload.extend_from_slice(&hvc1);
}
CodecType::AAC => {
let mut mp4a = Vec::new();
mp4a.extend_from_slice(&(36 + stream.codec_data.len() as u32).to_be_bytes()); mp4a.extend_from_slice(b"mp4a");
mp4a.extend_from_slice(&[0; 6]); mp4a.extend_from_slice(&[0, 1]); mp4a.extend_from_slice(&[0; 8]); mp4a.extend_from_slice(&[0, 2]); mp4a.extend_from_slice(&[0, 16]); mp4a.extend_from_slice(&[0; 4]); mp4a.extend_from_slice(&[0xbb, 0x80, 0x00, 0x00]);
let mut esds = Vec::new();
esds.extend_from_slice(&((8 + stream.codec_data.len()) as u32).to_be_bytes());
esds.extend_from_slice(b"esds");
esds.extend_from_slice(&stream.codec_data);
mp4a.extend_from_slice(&esds);
stsd_payload.extend_from_slice(&mp4a);
}
_ => {}
}
let stsd_len = (stsd_payload.len() + 8) as u32;
let mut stsd_box = stsd_len.to_be_bytes().to_vec();
stsd_box.extend_from_slice(b"stsd");
stsd_box.extend_from_slice(&stsd_payload);
stbl.extend_from_slice(&stsd_box);
stbl.extend_from_slice(b"\x00\x00\x00\x10stts\x00\x00\x00\x00\x00\x00\x00\x00"); stbl.extend_from_slice(b"\x00\x00\x00\x10stsc\x00\x00\x00\x00\x00\x00\x00\x00"); stbl.extend_from_slice(b"\x00\x00\x00\x10stsz\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); stbl.extend_from_slice(b"\x00\x00\x00\x10stco\x00\x00\x00\x00\x00\x00\x00\x00");
let stbl_len = (stbl.len() + 8) as u32;
let mut stbl_box = stbl_len.to_be_bytes().to_vec();
stbl_box.extend_from_slice(b"stbl");
stbl_box.extend_from_slice(&stbl);
minf.extend_from_slice(&stbl_box);
let minf_len = (minf.len() + 8) as u32;
let mut minf_box = minf_len.to_be_bytes().to_vec();
minf_box.extend_from_slice(b"minf");
minf_box.extend_from_slice(&minf);
mdia.extend_from_slice(&minf_box);
let mdia_len = (mdia.len() + 8) as u32;
let mut mdia_box = mdia_len.to_be_bytes().to_vec();
mdia_box.extend_from_slice(b"mdia");
mdia_box.extend_from_slice(&mdia);
trak.extend_from_slice(&mdia_box);
let trak_len = (trak.len() + 8) as u32;
let mut trak_box = trak_len.to_be_bytes().to_vec();
trak_box.extend_from_slice(b"trak");
trak_box.extend_from_slice(&trak);
moov.extend_from_slice(&trak_box);
}
let moov_len = (moov.len() + 8) as u32;
let mut moov_box = moov_len.to_be_bytes().to_vec();
moov_box.extend_from_slice(b"moov");
moov_box.extend_from_slice(&moov);
f.extend_from_slice(&moov_box);
f
}
pub fn write_packet(&mut self, pkt: &Packet, max_frames: u32) -> (bool, Vec<u8>) {
let stream_idx = pkt.idx as usize;
if stream_idx >= self.streams.len() {
return (false, Vec::new());
}
let is_keyframe = pkt.is_key_frame;
let timescale = self.streams[stream_idx].time_scale as f64;
let raw_duration = pkt.duration.as_secs_f64() * timescale;
let cts = pkt.composition_time.as_secs_f64() * timescale;
if self.sample_index == 0 {
self.mdat_buffer = vec![0, 0, 0, 0, 0x6d, 0x64, 0x61, 0x74];
}
self.moof_entries.push(TrackFragRunEntry {
duration: raw_duration as u32,
size: pkt.data.len() as u32,
cts: cts as u32,
is_keyframe,
});
self.mdat_buffer.extend_from_slice(&pkt.data);
self.sample_index += 1;
if self.sample_index > max_frames && is_keyframe {
let result = self.finalize(pkt.idx);
return (true, result);
}
(false, Vec::new())
}
fn finalize(&mut self, idx: i8) -> Vec<u8> {
let stream = &mut self.streams[idx as usize];
let track_id = stream.track_id;
let seq_num = self.fragment_index + 1;
self.fragment_index += 1;
let mut moof = Vec::new();
moof.extend_from_slice(b"moof");
let mut mfhd = vec![0, 0, 0, 16];
mfhd.extend_from_slice(b"mfhd");
mfhd.extend_from_slice(&[0, 0, 0, 0]); mfhd.extend_from_slice(&seq_num.to_be_bytes()); moof.extend_from_slice(&mfhd);
let mut traf = Vec::new();
traf.extend_from_slice(b"traf");
let mut tfhd = vec![0, 0, 0, 20];
tfhd.extend_from_slice(b"tfhd");
tfhd.extend_from_slice(&[0, 0x02, 0x00, 0x20]); tfhd.extend_from_slice(&track_id.to_be_bytes());
tfhd.extend_from_slice(&[0x01, 0x01, 0x00, 0x00]); traf.extend_from_slice(&tfhd);
let mut tfdt = vec![0, 0, 0, 20];
tfdt.extend_from_slice(b"tfdt");
tfdt.extend_from_slice(&[1, 0, 0, 0]); tfdt.extend_from_slice(&stream.last_dts.to_be_bytes());
traf.extend_from_slice(&tfdt);
let mut trun = Vec::new();
trun.extend_from_slice(b"trun");
trun.extend_from_slice(&[0, 0x00, 0x0b, 0x05]); trun.extend_from_slice(&(self.moof_entries.len() as u32).to_be_bytes());
let data_offset_idx = trun.len();
trun.extend_from_slice(&[0, 0, 0, 0]);
trun.extend_from_slice(&[0x02, 0x00, 0x00, 0x00]);
let mut total_duration = 0;
for entry in &self.moof_entries {
trun.extend_from_slice(&entry.duration.to_be_bytes());
trun.extend_from_slice(&entry.size.to_be_bytes());
let flags = if entry.is_keyframe { 0x02000000u32 } else { 0x01010000u32 };
trun.extend_from_slice(&flags.to_be_bytes());
trun.extend_from_slice(&entry.cts.to_be_bytes());
total_duration += entry.duration as u64;
}
let trun_len = (trun.len() + 8) as u32;
let mut trun_box = trun_len.to_be_bytes().to_vec();
trun_box.extend_from_slice(b"trun");
trun_box.extend_from_slice(&trun);
traf.extend_from_slice(&trun_box);
let traf_len = (traf.len() + 8) as u32;
let mut traf_box = traf_len.to_be_bytes().to_vec();
traf_box.extend_from_slice(b"traf");
traf_box.extend_from_slice(&traf);
moof.extend_from_slice(&traf_box);
let moof_len = (moof.len() + 8) as u32;
let mut moof_box = moof_len.to_be_bytes().to_vec();
moof_box.extend_from_slice(b"moof");
moof_box.extend_from_slice(&moof);
let data_offset = (moof_box.len() + 8) as u32;
let offset_pos = 8 + 16 + 20 + 20 + 8 + 8 + data_offset_idx; if offset_pos + 4 <= moof_box.len() {
moof_box[offset_pos..offset_pos+4].copy_from_slice(&data_offset.to_be_bytes());
}
let mdat_len = self.mdat_buffer.len() as u32;
self.mdat_buffer[0..4].copy_from_slice(&mdat_len.to_be_bytes());
let mut fragment = moof_box;
fragment.extend_from_slice(&self.mdat_buffer);
stream.last_dts += total_duration;
self.sample_index = 0;
self.moof_entries.clear();
self.mdat_buffer.clear();
fragment
}
}