|
|
|
use crate::av::avio::{AVIOWriter, AVIO};
|
|
|
|
use crate::av::decoder::Decoder;
|
|
|
|
use crate::av::dictionary::Dictionary;
|
|
|
|
use crate::av::encoder::Encoder;
|
|
|
|
use crate::av::format::Format;
|
|
|
|
use crate::av::mov_avc::{annex_b_to_avc, AvcDecoderConfigurationRecord, NalBuffer, NalUnitType};
|
|
|
|
use crate::av::packet::Packet;
|
|
|
|
use crate::av::resampler::Resampler;
|
|
|
|
use crate::av::scaler::Scaler;
|
|
|
|
use crate::av::stream::Stream;
|
|
|
|
use crate::av::xcoder::XCoder;
|
|
|
|
use crate::av::Rational;
|
|
|
|
use crate::utils::SortedFrameBuffer;
|
|
|
|
use ffmpeg_sys_next::AVMediaType::{AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_VIDEO};
|
|
|
|
use ffmpeg_sys_next::AVPictureType::AV_PICTURE_TYPE_I;
|
|
|
|
use ffmpeg_sys_next::AVPixelFormat::AV_PIX_FMT_YUV420P;
|
|
|
|
use ffmpeg_sys_next::{avio_wb32, AVIOContext, AVPixelFormat, AV_TIME_BASE, SWS_BILINEAR};
|
|
|
|
use num_rational::Ratio;
|
|
|
|
use std::cmp::{max, min};
|
|
|
|
use std::fs::{DirBuilder, File};
|
|
|
|
use std::io::Write;
|
|
|
|
use std::ops::Mul;
|
|
|
|
use std::option::Option::Some;
|
|
|
|
|
|
|
|
pub struct AudioTranscoder {
|
|
|
|
encoder: Encoder,
|
|
|
|
decoder: Decoder,
|
|
|
|
frame_buffer: SortedFrameBuffer,
|
|
|
|
output_stream: Stream,
|
|
|
|
input_stream: Stream,
|
|
|
|
format: Format<Buffer>,
|
|
|
|
output_path: String,
|
|
|
|
resampler: Resampler,
|
|
|
|
segment: Option<u32>,
|
|
|
|
last_pts: i64,
|
|
|
|
current_pts: i64,
|
|
|
|
seconds_per_segment: u32,
|
|
|
|
segment_target: Option<u32>,
|
|
|
|
header_written: bool,
|
|
|
|
last_written_segment: Option<u32>,
|
|
|
|
latest_written_segment: Option<u32>,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub const SECONDS_PER_SEGMENT: u32 = 5;
|
|
|
|
|
|
|
|
impl AudioTranscoder {
|
|
|
|
fn process_packet(&mut self, packet: Packet) -> Result<(), String> {
|
|
|
|
self.decoder
|
|
|
|
.send_packet(&packet)
|
|
|
|
.map_err(|err| format!("Failed sending audio packet: {}", err))?;
|
|
|
|
while let Some(frame) = self.decoder.read_frame()? {
|
|
|
|
if let Some(target) = self.segment_target {
|
|
|
|
let segment = (self
|
|
|
|
.input_stream
|
|
|
|
.time_base()
|
|
|
|
.mul(frame.pts() as i32)
|
|
|
|
.to_integer()
|
|
|
|
/ self.seconds_per_segment as i32) as u32;
|
|
|
|
if (target as i64 - 1) > (segment as i64) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let resampled = self.resampler.convert(&frame)?;
|
|
|
|
let resampled_pts = resampled.pts();
|
|
|
|
self.frame_buffer.insert_frame(resampled);
|
|
|
|
let mut offset: f64 = 0.0;
|
|
|
|
while let Some(drain_resampled) = self.resampler.drain()? {
|
|
|
|
offset += (drain_resampled.nb_samples() as f64 / self.encoder.sample_rate() as f64)
|
|
|
|
* self.input_stream.time_base().den() as f64;
|
|
|
|
drain_resampled.set_pts(resampled_pts + offset as i64);
|
|
|
|
self.frame_buffer.insert_frame(drain_resampled);
|
|
|
|
}
|
|
|
|
|
|
|
|
self.encode()?;
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn input_stream(&self) -> &Stream {
|
|
|
|
&self.input_stream
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn output_stream(&self) -> &Stream {
|
|
|
|
&self.output_stream
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn encoder(&self) -> &Encoder {
|
|
|
|
&self.encoder
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn decoder(&self) -> &Decoder {
|
|
|
|
&self.decoder
|
|
|
|
}
|
|
|
|
|
|
|
|
fn start_segment(&self, force: bool) {
|
|
|
|
if self.segment == Some(0) && !force {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsafe {
|
|
|
|
let pb = (*self.format.as_mut_ptr()).pb;
|
|
|
|
avio_wb32(pb, 24);
|
|
|
|
|
|
|
|
ffio_wfourcc(pb, b"styp");
|
|
|
|
ffio_wfourcc(pb, b"msdh");
|
|
|
|
avio_wb32(pb, 0); /* minor */
|
|
|
|
ffio_wfourcc(pb, b"msdh");
|
|
|
|
ffio_wfourcc(pb, b"msix");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn write_header(&mut self) -> Result<(), String> {
|
|
|
|
File::create(format!("{}/audio-init.mp4", &self.output_path))
|
|
|
|
.unwrap()
|
|
|
|
.write_all(&mut self.format.avio_inner_mut().unwrap().buffer())
|
|
|
|
.map_err(|_| "Failed to write audio init segment".to_string())?;
|
|
|
|
|
|
|
|
self.start_segment(true);
|
|
|
|
self.format.write_packet_null()?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn write_segment(&mut self) -> Result<(), String> {
|
|
|
|
if self.segment == Some(0) {
|
|
|
|
self.write_header()?;
|
|
|
|
self.header_written = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if !self.header_written {
|
|
|
|
self.format.avio_inner_mut().unwrap().buffer();
|
|
|
|
self.start_segment(true);
|
|
|
|
self.format.write_packet_null()?;
|
|
|
|
self.header_written = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if let Some(avio) = self.format.avio.as_mut() {
|
|
|
|
avio.flush()
|
|
|
|
}
|
|
|
|
|
|
|
|
let mut segment = self.format.avio_inner_mut().unwrap().buffer();
|
|
|
|
|
|
|
|
if self.segment_target.unwrap_or(self.segment.unwrap()) == self.segment.unwrap() {
|
|
|
|
self.segment_target = None;
|
|
|
|
File::create(format!(
|
|
|
|
"{}/audio-segment-{:0>5}.m4s",
|
|
|
|
self.output_path,
|
|
|
|
self.segment.unwrap()
|
|
|
|
))
|
|
|
|
.unwrap()
|
|
|
|
.write_all(&mut segment)
|
|
|
|
.map_err(|_| format!("Failed to write audio segment {}", self.segment.unwrap()))?;
|
|
|
|
println!("Wrote segment (audio) {}", self.segment.unwrap());
|
|
|
|
self.last_written_segment = self.segment;
|
|
|
|
self.latest_written_segment =
|
|
|
|
max(self.latest_written_segment, Some(self.segment.unwrap()));
|
|
|
|
} else {
|
|
|
|
println!(
|
|
|
|
"Won't write segment (audio) {} (searching for {})",
|
|
|
|
self.segment.unwrap(),
|
|
|
|
self.segment_target.unwrap()
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
self.start_segment(false);
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn encode(&mut self) -> Result<(), String> {
|
|
|
|
while let Some(frame) = self.frame_buffer.pop_first() {
|
|
|
|
if self.last_pts > frame.pts() {
|
|
|
|
println!("WARN: out of order frame");
|
|
|
|
self.last_pts = frame.pts();
|
|
|
|
}
|
|
|
|
|
|
|
|
if self.last_pts == 0 {
|
|
|
|
self.last_pts = frame.pts();
|
|
|
|
}
|
|
|
|
|
|
|
|
self.current_pts = frame.pts()
|
|
|
|
% (self.input_stream.time_base().den() as u32 * self.seconds_per_segment) as i64;
|
|
|
|
self.segment = Some(
|
|
|
|
(frame.pts() as f64 / self.input_stream.time_base().den() as f64).floor() as u32
|
|
|
|
/ self.seconds_per_segment,
|
|
|
|
);
|
|
|
|
|
|
|
|
if self.current_pts == 0 && Some(0) < self.segment {
|
|
|
|
self.segment = Some(self.segment.unwrap() - 1)
|
|
|
|
}
|
|
|
|
|
|
|
|
let (should_skip, peek) = if let Some(peek) = self.frame_buffer.first_key() {
|
|
|
|
(
|
|
|
|
(self.current_pts + (peek - frame.pts()))
|
|
|
|
< (self.seconds_per_segment * self.input_stream.time_base().den() as u32)
|
|
|
|
as i64,
|
|
|
|
peek,
|
|
|
|
)
|
|
|
|
} else {
|
|
|
|
(false, frame.pts())
|
|
|
|
};
|
|
|
|
|
|
|
|
let pts_passed = peek - frame.pts();
|
|
|
|
|
|
|
|
if self.segment == Some(2) {
|
|
|
|
println!(
|
|
|
|
">>>>>> {} {} {} {:?} {}",
|
|
|
|
self.current_pts, self.last_pts, pts_passed, should_skip, peek
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!should_skip || self.current_pts == 0)
|
|
|
|
&& ((pts_passed + self.current_pts)
|
|
|
|
> (self.seconds_per_segment * self.input_stream.time_base().den() as u32)
|
|
|
|
as i64
|
|
|
|
|| (self.current_pts == 0 && Some(0) < self.segment))
|
|
|
|
{
|
|
|
|
self.format.write_packet_null()?;
|
|
|
|
self.write_segment()?;
|
|
|
|
self.current_pts =
|
|
|
|
(pts_passed + self.current_pts) % self.input_stream.time_base().den() as i64;
|
|
|
|
} else {
|
|
|
|
self.current_pts += pts_passed
|
|
|
|
}
|
|
|
|
|
|
|
|
self.last_pts = frame.pts();
|
|
|
|
self.encoder.send_audio_frame(&frame)?;
|
|
|
|
while let Some(new_packet) = self.encoder.read_packet()? {
|
|
|
|
new_packet.set_pts(frame.pts());
|
|
|
|
new_packet.set_dts(new_packet.pts());
|
|
|
|
new_packet.set_duration(pts_passed);
|
|
|
|
new_packet.rescale(
|
|
|
|
self.input_stream.time_base(),
|
|
|
|
self.output_stream.time_base(),
|
|
|
|
);
|
|
|
|
new_packet.set_stream(0);
|
|
|
|
new_packet.data();
|
|
|
|
self.format.write_packet(&new_packet)?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn static_create_output(input: &Format<()>) -> Result<(Format<Buffer>, Stream), String> {
|
|
|
|
let audio_avio = AVIO::writer(Buffer::default());
|
|
|
|
let format = Format::output_avio(audio_avio, "mp4")?;
|
|
|
|
let output_stream = format.new_stream("aac")?;
|
|
|
|
format.set_flags(input.flags());
|
|
|
|
|
|
|
|
Ok((format, output_stream))
|
|
|
|
}
|
|
|
|
|
|
|
|
fn create_output(&mut self, input: &Format<()>) -> Result<(), String> {
|
|
|
|
let (format, stream) = Self::static_create_output(input)?;
|
|
|
|
self.output_stream = stream;
|
|
|
|
self.format = format;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn open_output(&self) -> Result<(), String> {
|
|
|
|
Transcoder::static_open_output(&self.format, None)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct Transcoder {
|
|
|
|
input: Format<()>,
|
|
|
|
input_video: Stream,
|
|
|
|
input_frame_rate: Ratio<i32>,
|
|
|
|
video_output: Format<Buffer>,
|
|
|
|
output_path: String,
|
|
|
|
output_video: Stream,
|
|
|
|
video_frame_buffer: SortedFrameBuffer,
|
|
|
|
video_encoder: Encoder,
|
|
|
|
video_decoder: Decoder,
|
|
|
|
frame_scaler: Scaler,
|
|
|
|
last_pts: i64,
|
|
|
|
current_pts: i64,
|
|
|
|
highest_pts: i64,
|
|
|
|
video_segment: Option<u32>,
|
|
|
|
extra_data: Option<Vec<u8>>,
|
|
|
|
audio: Option<AudioTranscoder>,
|
|
|
|
segment_target: Option<u32>,
|
|
|
|
input_video_index: Option<i32>,
|
|
|
|
input_audio_index: Option<i32>,
|
|
|
|
seconds_per_segment: u32,
|
|
|
|
header_written: bool,
|
|
|
|
last_written_segment: Option<u32>,
|
|
|
|
latest_written_segment: Option<u32>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Transcoder {
|
|
|
|
pub fn create(
|
|
|
|
input_path: &str,
|
|
|
|
output_path: &str,
|
|
|
|
video_index: Option<i32>,
|
|
|
|
audio_index: Option<i32>,
|
|
|
|
) -> Result<Transcoder, String> {
|
|
|
|
let input = Format::open(input_path, None).expect("Failed to open media");
|
|
|
|
let output_path = output_path.to_string();
|
|
|
|
|
|
|
|
let input_video = input
|
|
|
|
.stream(Some(AVMEDIA_TYPE_VIDEO), video_index, None)
|
|
|
|
.map_err(|err| format!("Failed to find video stream: {}", err))?
|
|
|
|
.ok_or("Failed to find video stream".to_string())?;
|
|
|
|
|
|
|
|
let input_audio = input
|
|
|
|
.stream(
|
|
|
|
Some(AVMEDIA_TYPE_AUDIO),
|
|
|
|
audio_index,
|
|
|
|
Some(input_video.index()),
|
|
|
|
)
|
|
|
|
.map_err(|err| format!("Failed to find audio stream: {}", err))?;
|
|
|
|
if audio_index.is_some() && input_audio.is_none() {
|
|
|
|
return Err("Failed to find audio stream".to_string());
|
|
|
|
}
|
|
|
|
|
|
|
|
let input_frame_rate = input_video.avg_frame_rate(&input).unwrap().to_num();
|
|
|
|
|
|
|
|
let (video_output, output_video) = Self::create_streams(&input, &input_video)?;
|
|
|
|
let audio = if let Some(input_stream) = input_audio {
|
|
|
|
let (format, output_stream) = AudioTranscoder::static_create_output(&input)?;
|
|
|
|
let decoder = input_stream.decoder(None).ok_or(format!(
|
|
|
|
"Couldn't find encoder for input audio with codec: {:?}",
|
|
|
|
input_stream.codec()
|
|
|
|
))?;
|
|
|
|
decoder.configure(&input_stream)?;
|
|
|
|
decoder.open()?;
|
|
|
|
decoder.set_time_base(input_stream.time_base());
|
|
|
|
|
|
|
|
let encoder = output_stream
|
|
|
|
.encoder(None)
|
|
|
|
.ok_or("Couldn't find encoder for AAC".to_string())?;
|
|
|
|
encoder.set_channels(decoder.channels());
|
|
|
|
encoder.set_channel_layout(decoder.channel_layout());
|
|
|
|
encoder.set_sample_format(
|
|
|
|
encoder
|
|
|
|
.sample_formats()
|
|
|
|
.first()
|
|
|
|
.copied()
|
|
|
|
.ok_or("No sample formats found for AAC")?,
|
|
|
|
);
|
|
|
|
encoder.set_sample_rate(decoder.sample_rate());
|
|
|
|
encoder.set_time_base(input_stream.time_base());
|
|
|
|
encoder.set_time_base(Ratio::new(1, decoder.sample_rate()));
|
|
|
|
output_stream.set_time_base(encoder.time_base());
|
|
|
|
encoder.set_frame_size(decoder.frame_size() * 4);
|
|
|
|
encoder.open()?;
|
|
|
|
encoder.configure(&output_stream)?;
|
|
|
|
|
|
|
|
let resampler = Resampler::from_coder(&decoder, &encoder);
|
|
|
|
Transcoder::static_open_output(&format, None)?;
|
|
|
|
|
|
|
|
Some(AudioTranscoder {
|
|
|
|
frame_buffer: SortedFrameBuffer::new(),
|
|
|
|
encoder,
|
|
|
|
decoder,
|
|
|
|
format,
|
|
|
|
output_stream,
|
|
|
|
input_stream,
|
|
|
|
output_path: output_path.to_string(),
|
|
|
|
current_pts: 0,
|
|
|
|
last_pts: 0,
|
|
|
|
segment: None,
|
|
|
|
resampler,
|
|
|
|
seconds_per_segment: SECONDS_PER_SEGMENT,
|
|
|
|
segment_target: None,
|
|
|
|
header_written: false,
|
|
|
|
latest_written_segment: None,
|
|
|
|
last_written_segment: None,
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
|
|
|
|
|
|
|
let video_decoder = input_video.decoder_select(None, |d| {
|
|
|
|
d.configure(&input_video)?;
|
|
|
|
d.open()?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
})?;
|
|
|
|
|
|
|
|
let video_encoder = output_video.encoder_select(None, |encoder| {
|
|
|
|
encoder.set_pixel_format(AVPixelFormat::AV_PIX_FMT_YUV420P);
|
|
|
|
encoder.set_color_range(video_decoder.color_range());
|
|
|
|
encoder.set_color_primaries(video_decoder.color_primaries());
|
|
|
|
encoder.set_color_trc(video_decoder.color_trc());
|
|
|
|
encoder.set_height(video_decoder.height());
|
|
|
|
encoder.set_width(video_decoder.width());
|
|
|
|
encoder.set_time_base(input_frame_rate.invert());
|
|
|
|
encoder.open()?;
|
|
|
|
encoder.configure(&output_video)?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
})?;
|
|
|
|
|
|
|
|
Self::static_open_output(&video_output, Some((&input_video, &video_decoder)))?;
|
|
|
|
|
|
|
|
let frame_scaler = Scaler::from_coder(&video_decoder, &video_encoder, SWS_BILINEAR);
|
|
|
|
let video_frame_buffer = SortedFrameBuffer::new();
|
|
|
|
|
|
|
|
Ok(Transcoder {
|
|
|
|
input,
|
|
|
|
input_video,
|
|
|
|
input_frame_rate,
|
|
|
|
video_output,
|
|
|
|
output_video,
|
|
|
|
audio,
|
|
|
|
segment_target: None,
|
|
|
|
input_video_index: None,
|
|
|
|
output_path,
|
|
|
|
video_encoder,
|
|
|
|
video_decoder,
|
|
|
|
frame_scaler,
|
|
|
|
video_frame_buffer,
|
|
|
|
last_pts: 0,
|
|
|
|
current_pts: 0,
|
|
|
|
video_segment: None,
|
|
|
|
extra_data: None,
|
|
|
|
input_audio_index: None,
|
|
|
|
seconds_per_segment: SECONDS_PER_SEGMENT,
|
|
|
|
header_written: false,
|
|
|
|
latest_written_segment: None,
|
|
|
|
last_written_segment: None,
|
|
|
|
highest_pts: 0,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
fn create_output(&mut self) -> Result<(), String> {
|
|
|
|
let (video_output, output_video) = Self::create_streams(&self.input, &self.input_video)?;
|
|
|
|
self.video_output = video_output;
|
|
|
|
self.output_video = output_video;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn create_streams(
|
|
|
|
input: &Format<()>,
|
|
|
|
input_video: &Stream,
|
|
|
|
) -> Result<(Format<Buffer>, Stream), String> {
|
|
|
|
let video_avio = AVIO::writer(Buffer::default());
|
|
|
|
let video_output = Format::output_avio(video_avio, "mp4")?;
|
|
|
|
let output_video = video_output.new_stream("h264")?;
|
|
|
|
output_video.params().copy_from(&input_video.params())?;
|
|
|
|
output_video.set_sample_aspect_ratio(input_video.sample_aspect_ratio());
|
|
|
|
video_output.set_flags(input.flags());
|
|
|
|
|
|
|
|
Ok((video_output, output_video))
|
|
|
|
}
|
|
|
|
|
|
|
|
fn open_output(&self) -> Result<(), String> {
|
|
|
|
Self::static_open_output(
|
|
|
|
&self.video_output,
|
|
|
|
Some((&self.output_video, &self.video_decoder)),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn static_open_output(
|
|
|
|
output: &Format<Buffer>,
|
|
|
|
video: Option<(&Stream, &Decoder)>,
|
|
|
|
) -> Result<(), String> {
|
|
|
|
let mut options = Dictionary::new();
|
|
|
|
options.set("movflags", "+dash+delay_moov+skip_trailer+frag_custom");
|
|
|
|
|
|
|
|
if let Some((video, video_decoder)) = video {
|
|
|
|
let param = video.params();
|
|
|
|
param.set_height(video_decoder.height());
|
|
|
|
param.set_width(video_decoder.width());
|
|
|
|
param.set_pixel_format(AV_PIX_FMT_YUV420P);
|
|
|
|
}
|
|
|
|
output.init_output(options)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn video_encoder(&self) -> &Encoder {
|
|
|
|
&self.video_encoder
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn video_decoder(&self) -> &Decoder {
|
|
|
|
&self.video_decoder
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn reset_output(&mut self) -> Result<(), String> {
|
|
|
|
let time_base = self.output_video.time_base();
|
|
|
|
self.create_output()?;
|
|
|
|
self.output_video
|
|
|
|
.set_time_base(self.video_encoder.time_base());
|
|
|
|
self.video_encoder.configure(&self.output_video)?;
|
|
|
|
self.open_output()?;
|
|
|
|
self.video_encoder.flush();
|
|
|
|
self.output_video.set_time_base(time_base);
|
|
|
|
self.video_segment = None;
|
|
|
|
self.header_written = false;
|
|
|
|
let mut options = Dictionary::new();
|
|
|
|
options.set("movflags", "+dash+delay_moov+skip_trailer+frag_custom");
|
|
|
|
self.video_output.write_header(Some(options)).unwrap();
|
|
|
|
|
|
|
|
if let Some(audio) = self.audio.as_mut() {
|
|
|
|
let time_base = audio.output_stream.time_base();
|
|
|
|
audio.create_output(&self.input)?;
|
|
|
|
audio.output_stream.set_time_base(audio.encoder.time_base());
|
|
|
|
audio.encoder.configure(&audio.output_stream)?;
|
|
|
|
audio.open_output()?;
|
|
|
|
audio.encoder.flush();
|
|
|
|
audio.output_stream.set_time_base(time_base);
|
|
|
|
audio.segment = None;
|
|
|
|
audio.header_written = false;
|
|
|
|
let mut options = Dictionary::new();
|
|
|
|
options.set("movflags", "+dash+delay_moov+skip_trailer+frag_custom");
|
|
|
|
audio.format.write_header(Some(options)).unwrap();
|
|
|
|
audio.last_pts = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn seek(&mut self, segment: u32, stream_index: Option<i32>) -> Result<(), String> {
|
|
|
|
self.input.seek(
|
|
|
|
segment * self.seconds_per_segment,
|
|
|
|
stream_index,
|
|
|
|
segment < self.last_written_segment().unwrap_or(0),
|
|
|
|
)?;
|
|
|
|
self.reset_output()?;
|
|
|
|
self.video_frame_buffer.clear();
|
|
|
|
self.segment_target = Some(segment);
|
|
|
|
self.video_segment = None;
|
|
|
|
if let Some(audio) = self.audio.as_mut() {
|
|
|
|
audio.frame_buffer.clear();
|
|
|
|
audio.segment_target = Some(segment);
|
|
|
|
audio.segment = None;
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn open(&mut self) -> Result<(), String> {
|
|
|
|
DirBuilder::new()
|
|
|
|
.recursive(true)
|
|
|
|
.create(self.output_path.to_string())
|
|
|
|
.map_err(|_| "Failed to create target directory".to_string())?;
|
|
|
|
let mut options = Dictionary::new();
|
|
|
|
options.set("movflags", "+dash+delay_moov+skip_trailer+frag_custom");
|
|
|
|
self.video_output.write_header(Some(options)).unwrap();
|
|
|
|
self.input_video_index = Some(self.input_video.index());
|
|
|
|
self.input_audio_index = self.audio.as_ref().map(|ia| ia.input_stream.index());
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn last_frame_secs(&self) -> f64 {
|
|
|
|
self.last_pts as f64 / self.input_video.time_base().den() as f64
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn latest_frame_secs(&self) -> f64 {
|
|
|
|
self.highest_pts as f64 / self.input_video.time_base().den() as f64
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn duration_secs(&self) -> f64 {
|
|
|
|
self.input.duration() as f64 / AV_TIME_BASE as f64
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn has_audio(&self) -> bool {
|
|
|
|
self.audio.is_some()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn transcode(&mut self) -> Result<bool, String> {
|
|
|
|
if let Some(packet) = self.input.next_packet() {
|
|
|
|
if self.input_video_index == Some(packet.stream()) {
|
|
|
|
self.video_process_packet(packet)?;
|
|
|
|
} else if self.input_audio_index == Some(packet.stream()) {
|
|
|
|
if let Some(ref mut audio) = &mut self.audio {
|
|
|
|
audio.process_packet(packet)?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Ok(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
self.video_frame_buffer.close();
|
|
|
|
self.encode_video()?;
|
|
|
|
if let Some(audio) = self.audio.as_mut() {
|
|
|
|
audio.frame_buffer.close();
|
|
|
|
audio.encode()?;
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(false)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn avg_frame_rate(&self) -> Option<impl Rational> {
|
|
|
|
self.video_stream().avg_frame_rate(&self.input)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn video_stream(&self) -> &Stream {
|
|
|
|
&self.input_video
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn audio(&self) -> Option<&AudioTranscoder> {
|
|
|
|
self.audio.as_ref()
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
pub fn audio_stream(&self) -> Option<&Stream> {
|
|
|
|
if let Some(ref audio) = self.audio {
|
|
|
|
Some(audio.input_stream())
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn seeking(&self) -> bool {
|
|
|
|
self.segment_target.is_some()
|
|
|
|
|| self
|
|
|
|
.audio
|
|
|
|
.as_ref()
|
|
|
|
.map_or(false, |audio| audio.segment_target.is_some())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn last_written_audio_segment(&self) -> Option<u32> {
|
|
|
|
self.audio.as_ref().and_then(|x| x.last_written_segment)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn last_written_segment(&self) -> Option<u32> {
|
|
|
|
self.last_written_segment
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn latest_written_segment(&self) -> Option<u32> {
|
|
|
|
if let Some(audio) = self.audio.as_ref() {
|
|
|
|
min(self.latest_written_segment, audio.latest_written_segment)
|
|
|
|
} else {
|
|
|
|
self.latest_written_segment
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn segment(&self) -> u32 {
|
|
|
|
min(
|
|
|
|
self.video_segment.unwrap_or(0),
|
|
|
|
self.audio
|
|
|
|
.as_ref()
|
|
|
|
.map_or(u32::MAX, |audio| audio.segment.unwrap_or(u32::MAX)),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn finish(&mut self) -> Result<(), String> {
|
|
|
|
self.encode_video()?;
|
|
|
|
self.video_output.write_trailer()?;
|
|
|
|
self.video_write_segment()?;
|
|
|
|
|
|
|
|
if let Some(audio) = self.audio.as_mut() {
|
|
|
|
audio.encode()?;
|
|
|
|
audio.format.write_trailer()?;
|
|
|
|
audio.write_segment()?;
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn video_process_packet(&mut self, packet: Packet) -> Result<(), String> {
|
|
|
|
self.video_decoder.send_packet(&packet)?;
|
|
|
|
while let Some(frame) = self.video_decoder.read_frame()? {
|
|
|
|
let segment: u32 = (self
|
|
|
|
.input_video
|
|
|
|
.time_base()
|
|
|
|
.mul(packet.pts() as i32)
|
|
|
|
.to_integer()
|
|
|
|
/ self.seconds_per_segment as i32) as u32;
|
|
|
|
if let Some(target) = self.segment_target {
|
|
|
|
if (target as i64 - 1) > (segment as i64) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let pts = frame.pts();
|
|
|
|
|
|
|
|
let frame = self
|
|
|
|
.frame_scaler
|
|
|
|
.scale(frame)
|
|
|
|
.expect("Failed to scale video frame");
|
|
|
|
frame.set_pts(pts);
|
|
|
|
self.video_frame_buffer.insert_frame(frame);
|
|
|
|
self.encode_video()?;
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn video_write_header(&mut self) -> Result<(), String> {
|
|
|
|
File::create(format!("{}/video-init.mp4", &self.output_path))
|
|
|
|
.unwrap()
|
|
|
|
.write_all(&mut self.video_output.avio_inner_mut().unwrap().buffer())
|
|
|
|
.map_err(|_| "Failed to write video init segment".to_string())?;
|
|
|
|
|
|
|
|
self.start_segment(true);
|
|
|
|
self.video_output.write_packet_null()?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn video_write_segment(&mut self) -> Result<(), String> {
|
|
|
|
if self.video_segment == Some(0) {
|
|
|
|
self.video_write_header()?;
|
|
|
|
self.header_written = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if !self.header_written {
|
|
|
|
self.video_output.avio_inner_mut().unwrap().buffer();
|
|
|
|
self.start_segment(true);
|
|
|
|
self.video_output.write_packet_null()?;
|
|
|
|
self.header_written = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if let Some(avio) = self.video_output.avio.as_mut() {
|
|
|
|
avio.flush()
|
|
|
|
}
|
|
|
|
|
|
|
|
let segment = self.video_output.avio_inner_mut().unwrap().buffer();
|
|
|
|
if self.segment_target.unwrap_or(self.video_segment.unwrap()) == self.video_segment.unwrap()
|
|
|
|
{
|
|
|
|
self.segment_target = None;
|
|
|
|
let segment_res = annex_b_to_avc(segment, 4);
|
|
|
|
if let Err(_) = segment_res {
|
|
|
|
println!("oh");
|
|
|
|
}
|
|
|
|
let mut segment = segment_res?;
|
|
|
|
|
|
|
|
File::create(format!(
|
|
|
|
"{}/video-segment-{:0>5}.m4s",
|
|
|
|
self.output_path,
|
|
|
|
self.video_segment.unwrap()
|
|
|
|
))
|
|
|
|
.unwrap()
|
|
|
|
.write_all(&mut segment)
|
|
|
|
.map_err(|_| {
|
|
|
|
format!(
|
|
|
|
"Failed to write video segment {}",
|
|
|
|
self.video_segment.unwrap()
|
|
|
|
)
|
|
|
|
})?;
|
|
|
|
self.last_written_segment = self.video_segment;
|
|
|
|
self.latest_written_segment = max(
|
|
|
|
self.latest_written_segment,
|
|
|
|
Some(self.video_segment.unwrap()),
|
|
|
|
);
|
|
|
|
println!(
|
|
|
|
"Wrote segment (video) {} ({} -> {} / coder: {} {})",
|
|
|
|
self.video_segment.unwrap(),
|
|
|
|
self.input_video.time_base(),
|
|
|
|
self.output_video.time_base(),
|
|
|
|
self.video_decoder.time_base(),
|
|
|
|
self.video_encoder.time_base()
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
println!(
|
|
|
|
"Won't write segment (video) {} (searching for {})",
|
|
|
|
self.video_segment.unwrap(),
|
|
|
|
self.segment_target.unwrap()
|
|
|
|
)
|
|
|
|
}
|
|
|
|
self.start_segment(false);
|
|
|
|
self.video_encoder.flush();
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn encode_video(&mut self) -> Result<(), String> {
|
|
|
|
while let Some(frame) = self.video_frame_buffer.pop_first() {
|
|
|
|
// if self.video_segment == None || self.last_pts > frame.pts() {
|
|
|
|
self.last_pts = frame.pts()
|
|
|
|
- (self
|
|
|
|
.avg_frame_rate()
|
|
|
|
.unwrap()
|
|
|
|
.invert()
|
|
|
|
.to_num()
|
|
|
|
.mul(self.input_video.time_base().den() as i32))
|
|
|
|
.as_f64() as i64;
|
|
|
|
self.current_pts = frame.pts()
|
|
|
|
% (self.input_video.time_base().den() as u32 * self.seconds_per_segment) as i64;
|
|
|
|
self.video_segment = Some(
|
|
|
|
(frame.pts() as f64 / self.input_video.time_base().den() as f64).floor() as u32
|
|
|
|
/ self.seconds_per_segment,
|
|
|
|
);
|
|
|
|
|
|
|
|
if self.current_pts == 0 && Some(0) < self.video_segment {
|
|
|
|
self.video_segment = Some(self.video_segment.unwrap() - 1)
|
|
|
|
}
|
|
|
|
|
|
|
|
let pts_passed = frame.pts() - self.last_pts;
|
|
|
|
if (pts_passed + self.current_pts)
|
|
|
|
> (self.seconds_per_segment * self.input_video.time_base().den() as u32) as i64
|
|
|
|
|| (self.current_pts == 0 && Some(0) < self.video_segment)
|
|
|
|
{
|
|
|
|
self.video_output.write_packet_null()?;
|
|
|
|
self.video_write_segment()?;
|
|
|
|
self.current_pts =
|
|
|
|
(pts_passed + self.current_pts) % self.input_video.time_base().den() as i64;
|
|
|
|
frame.set_pict_type(AV_PICTURE_TYPE_I);
|
|
|
|
} else {
|
|
|
|
self.current_pts += pts_passed
|
|
|
|
}
|
|
|
|
|
|
|
|
self.last_pts = frame.pts();
|
|
|
|
self.highest_pts = max(self.highest_pts, self.last_pts);
|
|
|
|
self.video_encoder.send_video_frame(&frame)?;
|
|
|
|
|
|
|
|
while let Some(new_packet) = self.video_encoder.read_packet()? {
|
|
|
|
if self.extra_data.is_none() {
|
|
|
|
let items = NalBuffer::from_stream(new_packet.data())?;
|
|
|
|
let mut sps = None;
|
|
|
|
let mut pss = None;
|
|
|
|
|
|
|
|
for item in items {
|
|
|
|
if item.nal_unit.nal_unit_type == NalUnitType::PictureParameterSet {
|
|
|
|
pss = Some(item.to_vec());
|
|
|
|
} else if item.nal_unit.nal_unit_type == NalUnitType::SequenceParameterSet {
|
|
|
|
sps = Some(item.to_vec());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if let Some(sps) = sps {
|
|
|
|
if let Some(pss) = pss {
|
|
|
|
let config =
|
|
|
|
AvcDecoderConfigurationRecord::from_parameter_sets(sps, pss);
|
|
|
|
self.extra_data = Some(config.to_bytes()?);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if let Some(extra_data) = &self.extra_data {
|
|
|
|
self.output_video.params().set_extra_data(extra_data);
|
|
|
|
self.output_video
|
|
|
|
.params()
|
|
|
|
.set_sample_aspect_ratio(Ratio::new(1, 1));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
new_packet.set_pts(frame.pts());
|
|
|
|
new_packet.set_dts(new_packet.pts());
|
|
|
|
new_packet.set_duration(pts_passed);
|
|
|
|
new_packet.rescale(self.input_video.time_base(), self.output_video.time_base());
|
|
|
|
new_packet.set_stream(0);
|
|
|
|
self.video_output.write_packet(&new_packet)?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn video_stream_output(&self) -> &Stream {
|
|
|
|
&self.output_video
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn audio_stream_output(&self) -> Option<&Stream> {
|
|
|
|
self.audio.as_ref().map(|audio| &audio.output_stream)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn start_segment(&self, force: bool) {
|
|
|
|
if self.video_segment == Some(0) && !force {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsafe {
|
|
|
|
let pb = (*self.video_output.as_mut_ptr()).pb;
|
|
|
|
avio_wb32(pb, 24);
|
|
|
|
|
|
|
|
ffio_wfourcc(pb, b"styp");
|
|
|
|
ffio_wfourcc(pb, b"msdh");
|
|
|
|
avio_wb32(pb, 0); /* minor */
|
|
|
|
ffio_wfourcc(pb, b"msdh");
|
|
|
|
ffio_wfourcc(pb, b"msix");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn stop(self) {}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Default, Debug)]
|
|
|
|
struct Buffer {
|
|
|
|
buffer: Vec<u8>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Buffer {
|
|
|
|
fn buffer(&mut self) -> Vec<u8> {
|
|
|
|
std::mem::replace(&mut self.buffer, vec![])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AVIOWriter for Buffer {
|
|
|
|
fn write(&mut self, mut buffer: Vec<u8>) {
|
|
|
|
self.buffer.append(&mut buffer)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn ffio_wfourcc(pb: *mut AVIOContext, tag: &[u8]) {
|
|
|
|
let mut nr: u32 = 0;
|
|
|
|
nr |= tag[3] as u32;
|
|
|
|
nr |= (tag[2] as u32) << 8;
|
|
|
|
nr |= (tag[1] as u32) << 16;
|
|
|
|
nr |= (tag[0] as u32) << 24;
|
|
|
|
unsafe { avio_wb32(pb, nr) }
|
|
|
|
}
|