1 use nihav_core::frame::*;
2 use nihav_core::muxers::*;
3 use super::RMStreamWriter;
5 // fourcc, codec name, interleaver, version
6 static AUDIO_CODEC_REGISTRY: &[(&[u8;4], &str, &[u8;4], u8)] = &[
7 (b"lpcJ", "ra14.4", b"Int0", 3),
8 (b"28_8", "ra28.8", b"Int4", 4),
9 (b"cook", "cook", b"genr", 5),
10 (b"dnet", "ac3", b"Int0", 4),
11 (b"sipr", "sipro", b"sipr", 4),
12 (b"atrc", "atrac3", b"genr", 5),
13 (b"LSD:", "ralf", b"Int0", 6),
14 (b"raac", "aac", b"vbrs", 5),
15 (b"racp", "aac", b"vbrf", 5),
18 struct InterleaveParams {
23 frames_per_blk: usize,
27 fn get_flavor(&self) -> usize;
28 fn get_block_size(&self) -> usize;
29 fn get_factor(&self) -> usize;
30 fn get_frames_per_block(&self) -> usize;
31 fn is_empty(&self) -> bool;
32 fn add_packet(&mut self, src: &[u8]) -> bool;
33 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)>;
36 fn get_frame_size(&self) -> usize { self.get_block_size() / self.get_frames_per_block() }
39 struct NoInterleaver {
43 impl Interleaver for NoInterleaver {
44 fn get_flavor(&self) -> usize { 0 }
45 fn get_block_size(&self) -> usize { self.frame_size }
46 fn get_factor(&self) -> usize { 1 }
47 fn get_frames_per_block(&self) -> usize { 1 }
48 fn is_empty(&self) -> bool { self.pkt.is_none() }
49 fn add_packet(&mut self, src: &[u8]) -> bool {
50 if self.pkt.is_none() {
51 self.pkt = Some(src.to_vec());
57 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)> {
59 std::mem::swap(&mut self.pkt, &mut ret);
60 if let Some(pkt) = ret {
66 fn flush(&mut self) {}
69 struct Int4Interleaver {
80 impl Int4Interleaver {
81 fn new(frame_size: usize) -> MuxerResult<Self> {
82 let params = RA_28_8_INTERLEAVE_PARAMS;
83 for (flavor, entry) in params.iter().enumerate() {
84 if entry.block_size / entry.frames_per_blk == frame_size {
85 let full_size = entry.frames_per_blk * entry.factor;
86 let mut map = vec![0; full_size];
87 for i in 0..full_size {
88 let fval = i * entry.factor;
89 let mapped = (fval % full_size) + fval / full_size;
98 block_size: entry.block_size,
99 fpb: entry.frames_per_blk,
102 buf: vec![0; entry.block_size * entry.factor],
106 Err(MuxerError::UnsupportedFormat)
109 impl Interleaver for Int4Interleaver {
110 fn get_flavor(&self) -> usize { self.flavor }
111 fn get_block_size(&self) -> usize { self.block_size }
112 fn get_factor(&self) -> usize { self.factor }
113 fn get_frames_per_block(&self) -> usize { self.fpb }
114 fn is_empty(&self) -> bool { self.cur_frame == 0 }
115 fn add_packet(&mut self, src: &[u8]) -> bool {
116 if self.cur_frame == self.factor * self.fpb {
119 let pos = self.map[self.cur_frame];
120 self.buf[pos * self.frame_size..][..self.frame_size].copy_from_slice(&src);
124 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)> {
125 if self.cur_frame == self.factor * self.fpb {
126 let first = self.rd_block == 0;
127 let src = &self.buf[self.rd_block * self.block_size..][..self.block_size];
129 if self.rd_block == self.factor {
133 Some((src.to_vec(), first))
138 fn flush(&mut self) {
139 if self.cur_frame != 0 {
140 self.cur_frame = self.factor * self.fpb;
145 struct GenericInterleaver {
156 impl GenericInterleaver {
157 fn new(ainfo: NAAudioInfo, frame_size: usize, fcc: [u8; 4]) -> MuxerResult<Self> {
158 let params = match &fcc {
159 b"atrc" => ATRAC_INTERLEAVE_PARAMS,
160 b"cook" => COOK_INTERLEAVE_PARAMS,
161 b"sipr" => SIPRO_INTERLEAVE_PARAMS,
162 _ => return Err(MuxerError::UnsupportedFormat),
164 for (flavor, entry) in params.iter().enumerate() {
165 if entry.sample_rate != 0 && entry.sample_rate != ainfo.sample_rate {
168 if entry.channels != 0 && entry.channels != ainfo.channels {
171 if entry.block_size / entry.frames_per_blk == frame_size {
172 let full_size = entry.frames_per_blk * entry.factor;
173 let mut map = vec![0; full_size];
178 for dst in map.iter_mut() {
179 let mapped = blk * entry.frames_per_blk + frm;
181 if blk >= entry.factor {
197 factor: entry.factor,
198 block_size: entry.block_size,
199 fpb: entry.frames_per_blk,
202 buf: vec![0; entry.block_size * entry.factor],
206 Err(MuxerError::UnsupportedFormat)
209 impl Interleaver for GenericInterleaver {
210 fn get_flavor(&self) -> usize { self.flavor }
211 fn get_block_size(&self) -> usize { self.block_size }
212 fn get_factor(&self) -> usize { self.factor }
213 fn get_frames_per_block(&self) -> usize { self.fpb }
214 fn is_empty(&self) -> bool { self.cur_frame == 0 }
215 fn add_packet(&mut self, src: &[u8]) -> bool {
216 if self.cur_frame == self.factor * self.fpb {
219 let pos = self.map[self.cur_frame];
220 self.buf[pos * self.frame_size..][..self.frame_size].copy_from_slice(&src);
224 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)> {
225 if self.cur_frame == self.factor * self.fpb {
226 let first = self.rd_block == 0;
227 let src = &self.buf[self.rd_block * self.block_size..][..self.block_size];
229 if self.rd_block == self.factor {
233 Some((src.to_vec(), first))
238 fn flush(&mut self) {
239 if self.cur_frame != 0 {
240 self.cur_frame = self.factor * self.fpb;
245 struct SiproInterleaver {
253 impl SiproInterleaver {
254 fn new(mut frame_size: usize) -> MuxerResult<Self> {
256 return Err(MuxerError::UnsupportedFormat);
258 while frame_size < 200 {
261 for (flavor, entry) in SIPRO_INTERLEAVE_PARAMS.iter().enumerate() {
262 if entry.block_size == frame_size {
264 block_size: entry.block_size,
265 factor: entry.factor,
267 buf: vec![0; entry.block_size * entry.factor],
273 Err(MuxerError::UnsupportedFormat)
276 impl Interleaver for SiproInterleaver {
277 fn get_flavor(&self) -> usize { self.flavor }
278 fn get_block_size(&self) -> usize { self.block_size }
279 fn get_factor(&self) -> usize { self.factor }
280 fn get_frames_per_block(&self) -> usize { 1 }
281 fn is_empty(&self) -> bool { self.wr_pos == 0 }
282 fn add_packet(&mut self, src: &[u8]) -> bool {
283 if self.wr_pos < self.factor {
284 self.buf[self.wr_pos * self.block_size..][..self.block_size].copy_from_slice(src);
291 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)> {
292 if self.wr_pos == self.factor {
293 let first = self.rd_pos == 0;
294 if self.rd_pos == 0 {
295 sipro_scramble(&mut self.buf, self.factor, self.block_size);
297 let ret = self.buf[self.rd_pos * self.block_size..][..self.block_size].to_vec();
299 if self.rd_pos == self.factor {
308 fn flush(&mut self) {
309 if self.wr_pos != self.factor {
310 self.wr_pos = self.factor;
315 fn sipro_scramble(buf: &mut [u8], factor: usize, fsize: usize) {
316 let stride = factor * fsize * 2 / 96;
317 for &swap_pair in SIPRO_SWAPS.iter() {
318 let mut sidx = usize::from(swap_pair[0]) * stride;
319 let mut didx = usize::from(swap_pair[1]) * stride;
321 let in0 = buf[sidx >> 1];
322 let in1 = buf[didx >> 1];
323 let nib0 = (in0 >> ((sidx & 1) * 4)) & 0xF;
324 let nib1 = (in1 >> ((didx & 1) * 4)) & 0xF;
326 buf[didx >> 1] = (nib0 << (4 * (didx & 1))) | (in1 & (0xF << (4 * (!didx & 1))));
327 buf[sidx >> 1] = (nib1 << (4 * (sidx & 1))) | (in0 & (0xF << (4 * (!sidx & 1))));
335 struct AACInterleaver {
341 impl AACInterleaver {
342 fn new(frame_size: usize) -> Self {
345 data: Vec::with_capacity(frame_size * 3 / 2),
346 sizes: Vec::with_capacity((frame_size / 128).max(8)),
351 impl Interleaver for AACInterleaver {
352 fn get_flavor(&self) -> usize { 0 }
353 fn get_block_size(&self) -> usize { self.frame_size }
354 fn get_factor(&self) -> usize { 1 }
355 fn get_frames_per_block(&self) -> usize { 1 }
356 fn is_empty(&self) -> bool { self.data.is_empty() }
357 fn add_packet(&mut self, src: &[u8]) -> bool {
359 self.data.extend_from_slice(src);
360 self.sizes.push(src.len());
361 if self.data.len() >= self.frame_size {
369 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)> {
371 let mut dst = Vec::with_capacity(self.frame_size);
372 let mut gw = GrowableMemoryWriter::new_write(&mut dst);
373 let mut bw = ByteWriter::new(&mut gw);
374 bw.write_u16be((self.sizes.len() * 16) as u16).unwrap();
375 for &pkt_size in self.sizes.iter() {
376 bw.write_u16be(pkt_size as u16).unwrap();
378 bw.write_buf(&self.data).unwrap();
389 fn flush(&mut self) {
390 if !self.sizes.is_empty() {
396 struct InterleaveInfo {
405 struct AudioStreamWriter {
411 interleave: Box<dyn Interleaver>,
419 impl RMStreamWriter for AudioStreamWriter {
420 fn write_header(&mut self, bw: &mut ByteWriter, astream: &NAStream) -> MuxerResult<()> {
421 self.header_pos = bw.tell();
422 if self.version < 6 {
423 bw.write_buf(b".ra\xFD")?;
424 bw.write_u16be(self.version.into())?;
427 let il_info = InterleaveInfo {
430 block_size: self.interleave.get_block_size(),
431 frame_size: self.interleave.get_frame_size(),
432 factor: self.interleave.get_factor(),
433 flavor: self.interleave.get_flavor(),
437 3 => write_aformat3(bw, astream, &il_info)?,
438 4 => write_aformat4(bw, astream, &il_info)?,
439 5 => write_aformat5(bw, astream, &il_info)?,
440 6 => write_lsd(bw, astream)?,
445 fn queue_packet(&mut self, pkt: NAPacket, ms: u32) -> bool {
446 let src = pkt.get_buffer();
447 self.data_size += src.len();
448 let frame_size = self.interleave.get_frame_size();
450 if self.interleave.is_empty() {
451 self.first_time = ms;
455 self.size_in += src.len() / frame_size;
459 for frame in src.chunks(frame_size) {
460 ret = self.interleave.add_packet(frame);
464 self.interleave.add_packet(&src)
467 fn get_packet(&mut self) -> Option<(Vec<u8>, u32, bool)> {
468 if let Some((pkt, first)) = self.interleave.get_packet() {
469 let time_add = if self.last_time > self.first_time && self.size_in > 0 {
470 let size = pkt.len();
471 let time_add = (self.size_out * ((self.last_time - self.first_time) as usize) / self.size_in) as u32;
472 self.size_out += size / self.interleave.get_frame_size();
477 Some((pkt, self.first_time + time_add, first))
482 fn flush(&mut self) { self.interleave.flush() }
483 fn finish(&mut self, bw: &mut ByteWriter) -> MuxerResult<()> {
484 let cur_pos = bw.tell();
487 bw.seek(SeekFrom::Start(self.header_pos + 18))?;
488 bw.write_u32be(self.data_size as u32)?;
491 bw.seek(SeekFrom::Start(self.header_pos + 12))?;
492 bw.write_u32be(self.data_size/*+header_size*/ as u32)?;
493 bw.seek(SeekFrom::Current(12))?;
494 bw.write_u32be(self.data_size as u32)?;
496 6 => unimplemented!(),
499 bw.seek(SeekFrom::Start(cur_pos))?;
502 fn set_pkt_size(&mut self, _pkt_size: usize) {}
505 fn write_audio_metadata(bw: &mut ByteWriter) -> MuxerResult<()> {
506 bw.write_byte(0)?; // title_string_length
507 bw.write_byte(0)?; // author_string_length
508 bw.write_byte(0)?; // copyright_string_length
509 bw.write_byte(0)?; // user_string_length
513 fn write_aformat3(bw: &mut ByteWriter, _stream: &NAStream, il_info: &InterleaveInfo) -> MuxerResult<()> {
514 let start = bw.tell();
515 bw.write_u16be(0)?; // header_bytes
516 bw.write_u16be(il_info.flavor as u16)?;
517 bw.write_u32be(il_info.frame_size as u32)?; // granularity
518 bw.write_u32be(0)?; // bytes per minute
519 bw.write_u32be(0)?; // total bytes
520 write_audio_metadata(bw)?;
521 bw.write_byte(0)?; //can_copy
522 bw.write_byte(4)?; // FCC length
523 bw.write_buf(&il_info.fcc)?;
525 bw.seek(SeekFrom::Start(start))?;
526 bw.write_u16be((end - start - 2) as u16)?;
527 bw.seek(SeekFrom::Start(end))?;
532 fn write_aformat4(bw: &mut ByteWriter, stream: &NAStream, il_info: &InterleaveInfo) -> MuxerResult<()> {
533 let info = stream.get_info().get_properties().get_audio_info().unwrap();
536 let start = bw.tell();
537 bw.write_buf(b".ra4")?;
538 bw.write_u32be(0)?; // data size
539 bw.write_u16be(4)?; // version
540 bw.write_u16be(0)?; // revision
541 bw.write_u16be(0)?; // header_bytes
542 bw.write_u16be(il_info.flavor as u16)?;
543 bw.write_u32be(il_info.frame_size as u32)?; // granularity
544 bw.write_u32be(0)?; // total bytes
545 bw.write_u32be(0)?; // bytes_per_minute
546 bw.write_u32be(0)?; // bytes_per_minute2
547 bw.write_u16be(il_info.factor as u16)?;
548 bw.write_u16be(il_info.block_size as u16)?;
549 bw.write_u16be(0)?; // user data
550 bw.write_u32be(info.sample_rate)?; // sample rate
551 bw.write_u32be(info.format.bits.into())?; // sample size
552 bw.write_u16be(info.channels.into())?; // num channels
553 bw.write_byte(4)?; // ileave ID len
554 bw.write_buf(&il_info.il_fcc)?;
555 bw.write_byte(4)?; // codec ID len
556 bw.write_buf(&il_info.fcc)?;
557 bw.write_byte(if &il_info.il_fcc == b"Int0" { 0 } else { 1 })?;
558 bw.write_byte(7)?; // can_copy
559 bw.write_byte(0)?; // stream_type
560 write_audio_metadata(bw)?;
562 bw.seek(SeekFrom::Start(start + 12))?;
563 bw.write_u16be((end - start - 4) as u16)?;
564 bw.seek(SeekFrom::Start(end))?;
569 fn write_aformat5(bw: &mut ByteWriter, stream: &NAStream, il_info: &InterleaveInfo) -> MuxerResult<()> {
570 let info = stream.get_info().get_properties().get_audio_info().unwrap();
573 let start = bw.tell();
574 bw.write_buf(b".ra5")?;
575 bw.write_u32be(0)?; // data size
576 bw.write_u16be(5)?; // version
577 bw.write_u16be(0)?; // revision
578 bw.write_u16be(0)?; // header_bytes
579 bw.write_u16be(il_info.flavor as u16)?;
580 bw.write_u32be(il_info.block_size as u32)?; // granularity
581 bw.write_u32be(0)?; // total bytes
582 bw.write_u32be(0)?; // bytes_per_minute
583 bw.write_u32be(0)?; // bytes_per_minute2
584 bw.write_u16be(il_info.factor as u16)?;
585 bw.write_u16be(il_info.block_size as u16)?;
586 bw.write_u16be(il_info.frame_size as u16)?;
587 bw.write_u16be(0)?; // user data
588 bw.write_u32be(info.sample_rate)?; // sample rate
589 bw.write_u32be(info.sample_rate)?; // actual sample rate
590 bw.write_u32be(info.format.bits.into())?; // sample size
591 bw.write_u16be(info.channels.into())?; // num channels
592 bw.write_buf(&il_info.il_fcc)?;
593 bw.write_buf(&il_info.fcc)?;
594 bw.write_byte(if &il_info.il_fcc == b"Int0" { 0 } else { 1 })?;
595 bw.write_byte(7)?; // can_copy
596 bw.write_byte(0)?; // stream_type
597 bw.write_byte(0)?; // has_interleave_pattern
598 if let Some(edata) = stream.get_info().get_extradata() {
599 if !matches!(&il_info.fcc, b"raac" | b"racp") {
600 bw.write_u32be(edata.len() as u32)?;
601 bw.write_buf(&edata)?;
603 bw.write_u32be((edata.len() + 1) as u32)?;
605 bw.write_buf(&edata)?;
611 bw.seek(SeekFrom::Start(start + 12))?;
612 bw.write_u16be((end - start - 4) as u16)?;
613 bw.seek(SeekFrom::Start(end))?;
618 fn write_lsd(bw: &mut ByteWriter, stream: &NAStream) -> MuxerResult<()> {
619 if let Some(edata) = stream.get_info().get_extradata() {
620 bw.write_buf(&edata)?;
625 fn create_interleaver(id: [u8; 4], fcc: [u8; 4], ainfo: NAAudioInfo) -> MuxerResult<Box<dyn Interleaver>> {
626 let frame_size = ainfo.block_len;
628 b"Int0" => Ok(Box::new(NoInterleaver{ frame_size, pkt: None })),
629 b"Int4" => Ok(Box::new(Int4Interleaver::new(frame_size)?)),
630 b"sipr" => Ok(Box::new(SiproInterleaver::new(frame_size)?)),
631 b"genr" => Ok(Box::new(GenericInterleaver::new(ainfo, frame_size, fcc)?)),
632 b"vbrs" | b"vbrf" => Ok(Box::new(AACInterleaver::new(1024))),
633 _ => unimplemented!(),
637 pub fn create_audio_stream(stream: &NAStream) -> MuxerResult<Box<dyn RMStreamWriter>> {
638 let info = stream.get_info();
639 let cname = info.get_name();
640 let mut fourcc = [0u8; 4];
641 let mut ileave = [0u8; 4];
643 for &(fcc, name, ileaver, cversion) in AUDIO_CODEC_REGISTRY.iter() {
652 let ainfo = info.get_properties().get_audio_info().unwrap();
653 Ok(Box::new(AudioStreamWriter {
656 is_raw: &ileave == b"Int0",
658 interleave: create_interleaver(ileave, fourcc, ainfo)?,
667 Err(MuxerError::UnsupportedFormat)
671 const SIPRO_SWAPS: [[u8; 2]; 38] = [
672 [ 0, 63 ], [ 1, 22 ], [ 2, 44 ], [ 3, 90 ],
673 [ 5, 81 ], [ 7, 31 ], [ 8, 86 ], [ 9, 58 ],
674 [ 10, 36 ], [ 12, 68 ], [ 13, 39 ], [ 14, 73 ],
675 [ 15, 53 ], [ 16, 69 ], [ 17, 57 ], [ 19, 88 ],
676 [ 20, 34 ], [ 21, 71 ], [ 24, 46 ], [ 25, 94 ],
677 [ 26, 54 ], [ 28, 75 ], [ 29, 50 ], [ 32, 70 ],
678 [ 33, 92 ], [ 35, 74 ], [ 38, 85 ], [ 40, 56 ],
679 [ 42, 87 ], [ 43, 65 ], [ 45, 59 ], [ 48, 79 ],
680 [ 49, 93 ], [ 51, 89 ], [ 55, 95 ], [ 61, 76 ],
681 [ 67, 83 ], [ 77, 80 ]
684 macro_rules! int_params {
685 ($rate:expr, $ch:expr, $bsize:expr, $factor:expr, $frm_per_blk:expr) => {
691 frames_per_blk: $frm_per_blk,
696 const RA_28_8_INTERLEAVE_PARAMS: &[InterleaveParams] = &[
697 int_params!(0, 1, 228, 12, 6)
699 const SIPRO_INTERLEAVE_PARAMS: &[InterleaveParams] = &[ //2,1,3,0
700 int_params!( 8000, 1, 232, 6, 16),
701 int_params!( 8000, 1, 304, 6, 16),
702 int_params!( 8000, 1, 296, 6, 16),
703 int_params!(16000, 1, 320, 6, 16),
705 const ATRAC_INTERLEAVE_PARAMS: &[InterleaveParams] = &[
706 int_params!(0, 0, 768, 20, 4),
707 int_params!(0, 0, 1088, 20, 4),
708 int_params!(0, 0, 912, 30, 3),
709 int_params!(0, 0, 1152, 30, 3),
710 int_params!(0, 0, 1272, 30, 3),
711 int_params!(0, 0, 1024, 30, 2),
712 int_params!(0, 0, 768, 10, 1),
713 int_params!(0, 0, 1024, 10, 1),
715 const COOK_INTERLEAVE_PARAMS: &[InterleaveParams] = &[
716 int_params!( 8000, 1, 288, 8, 9),
717 int_params!(11025, 1, 352, 8, 11),
718 int_params!(22050, 1, 564, 8, 12),
719 int_params!(22050, 1, 600, 9, 10),
720 int_params!(44100, 1, 651, 14, 7),
721 int_params!(44100, 1, 640, 15, 5),
722 int_params!(44100, 1, 744, 20, 4),
723 int_params!(22050, 1, 558, 16, 6),
724 int_params!( 8000, 1, 288, 6, 12),
725 int_params!(11025, 2, 580, 10, 10),
726 int_params!(22050, 2, 564, 14, 6),
727 int_params!(22050, 2, 640, 16, 5),
728 int_params!(44100, 2, 744, 20, 4),
729 int_params!(44100, 2, 834, 30, 3),
730 int_params!(44100, 1, 644, 20, 4),
731 int_params!(44100, 1, 600, 9, 10),
732 int_params!(44100, 1, 651, 14, 7),
733 int_params!(22050, 2, 528, 10, 10),
734 int_params!(22050, 2, 600, 10, 10),
735 int_params!(22050, 2, 600, 10, 10),
736 int_params!(22050, 2, 465, 16, 5),
737 int_params!(44100, 2, 465, 16, 5),
738 int_params!(44100, 2, 640, 16, 5),
739 int_params!(44100, 2, 640, 16, 5),
740 int_params!(44100, 2, 930, 16, 5),
741 int_params!(44100, 2, 1400, 16, 5),
742 int_params!(11025, 2, 376, 8, 11),
743 int_params!(44100, 2, 930, 16, 5),
744 int_params!(44100, 2, 1400, 16, 5),
745 int_params!(22050, 2, 640, 16, 5),
746 int_params!(44100, 5, 1395, 16, 5),
747 int_params!(44100, 6, 1143, 10, 3),
748 int_params!(44100, 6, 1064, 10, 2),
749 int_params!(44100, 6, 778, 1, 1),