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 {
21 frames_per_blk: usize,
25 fn get_flavor(&self) -> usize;
26 fn get_block_size(&self) -> usize;
27 fn get_factor(&self) -> usize;
28 fn get_frames_per_block(&self) -> usize;
29 fn add_packet(&mut self, src: &[u8]) -> bool;
30 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)>;
33 fn get_frame_size(&self) -> usize { self.get_block_size() / self.get_frames_per_block() }
36 struct NoInterleaver {
40 impl Interleaver for NoInterleaver {
41 fn get_flavor(&self) -> usize { 0 }
42 fn get_block_size(&self) -> usize { self.frame_size }
43 fn get_factor(&self) -> usize { 1 }
44 fn get_frames_per_block(&self) -> usize { 1 }
45 fn add_packet(&mut self, src: &[u8]) -> bool {
46 if self.pkt.is_none() {
47 self.pkt = Some(src.to_vec());
53 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)> {
55 std::mem::swap(&mut self.pkt, &mut ret);
56 if let Some(pkt) = ret {
62 fn flush(&mut self) {}
65 struct Int4Interleaver {
76 impl Int4Interleaver {
77 fn new(frame_size: usize) -> MuxerResult<Self> {
78 let params = RA_28_8_INTERLEAVE_PARAMS;
79 for (flavor, entry) in params.iter().enumerate() {
80 if entry.block_size / entry.frames_per_blk == frame_size {
81 let full_size = entry.frames_per_blk * entry.factor;
82 let mut map = vec![0; full_size];
83 for i in 0..full_size {
84 let fval = i * entry.factor;
85 let mapped = (fval % full_size) + fval / full_size;
94 block_size: entry.block_size,
95 fpb: entry.frames_per_blk,
98 buf: vec![0; entry.block_size * entry.factor],
102 Err(MuxerError::UnsupportedFormat)
105 impl Interleaver for Int4Interleaver {
106 fn get_flavor(&self) -> usize { self.flavor }
107 fn get_block_size(&self) -> usize { self.block_size }
108 fn get_factor(&self) -> usize { self.factor }
109 fn get_frames_per_block(&self) -> usize { self.fpb }
110 fn add_packet(&mut self, src: &[u8]) -> bool {
111 if self.cur_frame == self.factor * self.fpb {
114 let pos = self.map[self.cur_frame];
115 self.buf[pos * self.frame_size..][..self.frame_size].copy_from_slice(&src);
119 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)> {
120 if self.cur_frame == self.factor * self.fpb {
121 let first = self.rd_block == 0;
122 let src = &self.buf[self.rd_block * self.block_size..][..self.block_size];
124 if self.rd_block == self.factor {
128 Some((src.to_vec(), first))
133 fn flush(&mut self) {
134 if self.cur_frame != 0 {
135 self.cur_frame = self.factor * self.fpb;
140 struct GenericInterleaver {
151 impl GenericInterleaver {
152 fn new(frame_size: usize, fcc: [u8; 4]) -> MuxerResult<Self> {
153 let params = match &fcc {
154 b"atrc" => ATRAC_INTERLEAVE_PARAMS,
155 b"cook" => COOK_INTERLEAVE_PARAMS,
156 b"sipr" => SIPRO_INTERLEAVE_PARAMS,
157 _ => return Err(MuxerError::UnsupportedFormat),
159 for (flavor, entry) in params.iter().enumerate() {
160 if entry.block_size / entry.frames_per_blk == frame_size {
161 let full_size = entry.frames_per_blk * entry.factor;
162 let mut map = vec![0; full_size];
167 for dst in map.iter_mut() {
168 let mapped = blk * entry.frames_per_blk + frm;
170 if blk >= entry.factor {
186 factor: entry.factor,
187 block_size: entry.block_size,
188 fpb: entry.frames_per_blk,
191 buf: vec![0; entry.block_size * entry.factor],
195 Err(MuxerError::UnsupportedFormat)
198 impl Interleaver for GenericInterleaver {
199 fn get_flavor(&self) -> usize { self.flavor }
200 fn get_block_size(&self) -> usize { self.block_size }
201 fn get_factor(&self) -> usize { self.factor }
202 fn get_frames_per_block(&self) -> usize { self.fpb }
203 fn add_packet(&mut self, src: &[u8]) -> bool {
204 if self.cur_frame == self.factor * self.fpb {
207 let pos = self.map[self.cur_frame];
208 self.buf[pos * self.frame_size..][..self.frame_size].copy_from_slice(&src);
212 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)> {
213 if self.cur_frame == self.factor * self.fpb {
214 let first = self.rd_block == 0;
215 let src = &self.buf[self.rd_block * self.block_size..][..self.block_size];
217 if self.rd_block == self.factor {
221 Some((src.to_vec(), first))
226 fn flush(&mut self) {
227 if self.cur_frame != 0 {
228 self.cur_frame = self.factor * self.fpb;
233 struct SiproInterleaver {
241 impl SiproInterleaver {
242 fn new(mut frame_size: usize) -> MuxerResult<Self> {
244 return Err(MuxerError::UnsupportedFormat);
246 while frame_size < 200 {
249 for (flavor, entry) in SIPRO_INTERLEAVE_PARAMS.iter().enumerate() {
250 if entry.block_size == frame_size {
252 block_size: entry.block_size,
253 factor: entry.factor,
255 buf: vec![0; entry.block_size * entry.factor],
261 Err(MuxerError::UnsupportedFormat)
264 impl Interleaver for SiproInterleaver {
265 fn get_flavor(&self) -> usize { self.flavor }
266 fn get_block_size(&self) -> usize { self.block_size }
267 fn get_factor(&self) -> usize { self.factor }
268 fn get_frames_per_block(&self) -> usize { 1 }
269 fn add_packet(&mut self, src: &[u8]) -> bool {
270 if self.wr_pos < self.factor {
271 self.buf[self.wr_pos * self.block_size..][..self.block_size].copy_from_slice(src);
278 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)> {
279 if self.wr_pos == self.factor {
280 let first = self.rd_pos == 0;
281 if self.rd_pos == 0 {
282 sipro_scramble(&mut self.buf, self.factor, self.block_size);
284 let ret = self.buf[self.rd_pos * self.block_size..][..self.block_size].to_vec();
286 if self.rd_pos == self.factor {
295 fn flush(&mut self) {
296 if self.wr_pos != self.factor {
297 self.wr_pos = self.factor;
302 fn sipro_scramble(buf: &mut [u8], factor: usize, fsize: usize) {
303 let stride = factor * fsize * 2 / 96;
304 for &swap_pair in SIPRO_SWAPS.iter() {
305 let mut sidx = usize::from(swap_pair[0]) * stride;
306 let mut didx = usize::from(swap_pair[1]) * stride;
308 let in0 = buf[sidx >> 1];
309 let in1 = buf[didx >> 1];
310 let nib0 = (in0 >> ((sidx & 1) * 4)) & 0xF;
311 let nib1 = (in1 >> ((didx & 1) * 4)) & 0xF;
313 buf[didx >> 1] = (nib0 << (4 * (didx & 1))) | (in1 & (0xF << (4 * (!didx & 1))));
314 buf[sidx >> 1] = (nib1 << (4 * (sidx & 1))) | (in0 & (0xF << (4 * (!sidx & 1))));
322 struct AACInterleaver {
328 impl AACInterleaver {
329 fn new(frame_size: usize) -> Self {
332 data: Vec::with_capacity(frame_size * 3 / 2),
333 sizes: Vec::with_capacity((frame_size / 128).max(8)),
338 impl Interleaver for AACInterleaver {
339 fn get_flavor(&self) -> usize { 0 }
340 fn get_block_size(&self) -> usize { self.frame_size }
341 fn get_factor(&self) -> usize { 1 }
342 fn get_frames_per_block(&self) -> usize { 1 }
343 fn add_packet(&mut self, src: &[u8]) -> bool {
345 self.data.extend_from_slice(src);
346 self.sizes.push(src.len());
347 if self.data.len() >= self.frame_size {
355 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)> {
357 let mut dst = Vec::with_capacity(self.frame_size);
358 let mut gw = GrowableMemoryWriter::new_write(&mut dst);
359 let mut bw = ByteWriter::new(&mut gw);
360 bw.write_u16be((self.sizes.len() * 16) as u16).unwrap();
361 for &pkt_size in self.sizes.iter() {
362 bw.write_u16be(pkt_size as u16).unwrap();
364 bw.write_buf(&self.data).unwrap();
375 fn flush(&mut self) {
376 if !self.sizes.is_empty() {
382 struct InterleaveInfo {
391 struct AudioStreamWriter {
397 interleave: Box<dyn Interleaver>,
401 impl RMStreamWriter for AudioStreamWriter {
402 fn write_header(&mut self, bw: &mut ByteWriter, astream: &NAStream) -> MuxerResult<()> {
403 self.header_pos = bw.tell();
404 if self.version < 6 {
405 bw.write_buf(b".ra\xFD")?;
406 bw.write_u16be(self.version.into())?;
409 let il_info = InterleaveInfo {
412 block_size: self.interleave.get_block_size(),
413 frame_size: self.interleave.get_frame_size(),
414 factor: self.interleave.get_factor(),
415 flavor: self.interleave.get_flavor(),
419 3 => write_aformat3(bw, astream, &il_info)?,
420 4 => write_aformat4(bw, astream, &il_info)?,
421 5 => write_aformat5(bw, astream, &il_info)?,
422 6 => write_lsd(bw, astream)?,
427 fn queue_packet(&mut self, pkt: NAPacket) -> bool {
428 let src = pkt.get_buffer();
429 self.data_size += src.len();
430 let frame_size = self.interleave.get_frame_size();
433 for frame in src.chunks(frame_size) {
434 ret = self.interleave.add_packet(frame);
438 self.interleave.add_packet(&src)
441 fn get_packet(&mut self) -> Option<(Vec<u8>, bool)> { self.interleave.get_packet() }
442 fn flush(&mut self) { self.interleave.flush() }
443 fn finish(&mut self, bw: &mut ByteWriter) -> MuxerResult<()> {
444 let cur_pos = bw.tell();
447 bw.seek(SeekFrom::Start(self.header_pos + 18))?;
448 bw.write_u32be(self.data_size as u32)?;
451 bw.seek(SeekFrom::Start(self.header_pos + 12))?;
452 bw.write_u32be(self.data_size/*+header_size*/ as u32)?;
453 bw.seek(SeekFrom::Current(12))?;
454 bw.write_u32be(self.data_size as u32)?;
456 6 => unimplemented!(),
459 bw.seek(SeekFrom::Start(cur_pos))?;
464 fn write_audio_metadata(bw: &mut ByteWriter) -> MuxerResult<()> {
465 bw.write_byte(0)?; // title_string_length
466 bw.write_byte(0)?; // author_string_length
467 bw.write_byte(0)?; // copyright_string_length
468 bw.write_byte(0)?; // user_string_length
472 fn write_aformat3(bw: &mut ByteWriter, _stream: &NAStream, il_info: &InterleaveInfo) -> MuxerResult<()> {
473 let start = bw.tell();
474 bw.write_u16be(0)?; // header_bytes
475 bw.write_u16be(il_info.flavor as u16)?;
476 bw.write_u32be(il_info.frame_size as u32)?; // granularity
477 bw.write_u32be(0)?; // bytes per minute
478 bw.write_u32be(0)?; // total bytes
479 write_audio_metadata(bw)?;
480 bw.write_byte(0)?; //can_copy
481 bw.write_byte(4)?; // FCC length
482 bw.write_buf(&il_info.fcc)?;
484 bw.seek(SeekFrom::Start(start))?;
485 bw.write_u16be((end - start - 2) as u16)?;
486 bw.seek(SeekFrom::Start(end))?;
491 fn write_aformat4(bw: &mut ByteWriter, stream: &NAStream, il_info: &InterleaveInfo) -> MuxerResult<()> {
492 let info = stream.get_info().get_properties().get_audio_info().unwrap();
495 let start = bw.tell();
496 bw.write_buf(b".ra4")?;
497 bw.write_u32be(0)?; // data size
498 bw.write_u16be(4)?; // version
499 bw.write_u16be(0)?; // revision
500 bw.write_u16be(0)?; // header_bytes
501 bw.write_u16be(il_info.flavor as u16)?;
502 bw.write_u32be(il_info.frame_size as u32)?; // granularity
503 bw.write_u32be(0)?; // total bytes
504 bw.write_u32be(0)?; // bytes_per_minute
505 bw.write_u32be(0)?; // bytes_per_minute2
506 bw.write_u16be(il_info.factor as u16)?;
507 bw.write_u16be(il_info.block_size as u16)?;
508 bw.write_u16be(0)?; // user data
509 bw.write_u32be(info.sample_rate)?; // sample rate
510 bw.write_u32be(info.format.bits.into())?; // sample size
511 bw.write_u16be(info.channels.into())?; // num channels
512 bw.write_byte(4)?; // ileave ID len
513 bw.write_buf(&il_info.il_fcc)?;
514 bw.write_byte(4)?; // codec ID len
515 bw.write_buf(&il_info.fcc)?;
516 bw.write_byte(if &il_info.il_fcc == b"Int0" { 0 } else { 1 })?;
517 bw.write_byte(7)?; // can_copy
518 bw.write_byte(0)?; // stream_type
519 write_audio_metadata(bw)?;
521 bw.seek(SeekFrom::Start(start + 12))?;
522 bw.write_u16be((end - start - 4) as u16)?;
523 bw.seek(SeekFrom::Start(end))?;
528 fn write_aformat5(bw: &mut ByteWriter, stream: &NAStream, il_info: &InterleaveInfo) -> MuxerResult<()> {
529 let info = stream.get_info().get_properties().get_audio_info().unwrap();
532 let start = bw.tell();
533 bw.write_buf(b".ra5")?;
534 bw.write_u32be(0)?; // data size
535 bw.write_u16be(5)?; // version
536 bw.write_u16be(0)?; // revision
537 bw.write_u16be(0)?; // header_bytes
538 bw.write_u16be(il_info.flavor as u16)?;
539 bw.write_u32be(il_info.block_size as u32)?; // granularity
540 bw.write_u32be(0)?; // total bytes
541 bw.write_u32be(0)?; // bytes_per_minute
542 bw.write_u32be(0)?; // bytes_per_minute2
543 bw.write_u16be(il_info.factor as u16)?;
544 bw.write_u16be(il_info.block_size as u16)?;
545 bw.write_u16be(il_info.frame_size as u16)?;
546 bw.write_u16be(0)?; // user data
547 bw.write_u32be(info.sample_rate)?; // sample rate
548 bw.write_u32be(info.sample_rate)?; // actual sample rate
549 bw.write_u32be(info.format.bits.into())?; // sample size
550 bw.write_u16be(info.channels.into())?; // num channels
551 bw.write_buf(&il_info.il_fcc)?;
552 bw.write_buf(&il_info.fcc)?;
553 bw.write_byte(if &il_info.il_fcc == b"Int0" { 0 } else { 1 })?;
554 bw.write_byte(7)?; // can_copy
555 bw.write_byte(0)?; // stream_type
556 bw.write_byte(0)?; // has_interleave_pattern
557 if let Some(edata) = stream.get_info().get_extradata() {
558 if !matches!(&il_info.fcc, b"raac" | b"racp") {
559 bw.write_u32be(edata.len() as u32)?;
560 bw.write_buf(&edata)?;
562 bw.write_u32be((edata.len() + 1) as u32)?;
564 bw.write_buf(&edata)?;
570 bw.seek(SeekFrom::Start(start + 12))?;
571 bw.write_u16be((end - start - 4) as u16)?;
572 bw.seek(SeekFrom::Start(end))?;
577 fn write_lsd(bw: &mut ByteWriter, stream: &NAStream) -> MuxerResult<()> {
578 if let Some(edata) = stream.get_info().get_extradata() {
579 bw.write_buf(&edata)?;
584 fn create_interleaver(id: [u8; 4], fcc: [u8; 4], ainfo: NAAudioInfo) -> MuxerResult<Box<dyn Interleaver>> {
585 let frame_size = ainfo.block_len;
587 b"Int0" => Ok(Box::new(NoInterleaver{ frame_size, pkt: None })),
588 b"Int4" => Ok(Box::new(Int4Interleaver::new(frame_size)?)),
589 b"sipr" => Ok(Box::new(SiproInterleaver::new(frame_size)?)),
590 b"genr" => Ok(Box::new(GenericInterleaver::new(frame_size, fcc)?)),
591 b"vbrs" | b"vbrf" => Ok(Box::new(AACInterleaver::new(1024))),
592 _ => unimplemented!(),
596 pub fn create_audio_stream(stream: &NAStream) -> MuxerResult<Box<dyn RMStreamWriter>> {
597 let info = stream.get_info();
598 let cname = info.get_name();
599 let mut fourcc = [0u8; 4];
600 let mut ileave = [0u8; 4];
602 for &(fcc, name, ileaver, cversion) in AUDIO_CODEC_REGISTRY.iter() {
611 let ainfo = info.get_properties().get_audio_info().unwrap();
612 Ok(Box::new(AudioStreamWriter {
615 is_raw: &ileave == b"Int0",
617 interleave: create_interleaver(ileave, fourcc, ainfo)?,
622 Err(MuxerError::UnsupportedFormat)
626 const SIPRO_SWAPS: [[u8; 2]; 38] = [
627 [ 0, 63 ], [ 1, 22 ], [ 2, 44 ], [ 3, 90 ],
628 [ 5, 81 ], [ 7, 31 ], [ 8, 86 ], [ 9, 58 ],
629 [ 10, 36 ], [ 12, 68 ], [ 13, 39 ], [ 14, 73 ],
630 [ 15, 53 ], [ 16, 69 ], [ 17, 57 ], [ 19, 88 ],
631 [ 20, 34 ], [ 21, 71 ], [ 24, 46 ], [ 25, 94 ],
632 [ 26, 54 ], [ 28, 75 ], [ 29, 50 ], [ 32, 70 ],
633 [ 33, 92 ], [ 35, 74 ], [ 38, 85 ], [ 40, 56 ],
634 [ 42, 87 ], [ 43, 65 ], [ 45, 59 ], [ 48, 79 ],
635 [ 49, 93 ], [ 51, 89 ], [ 55, 95 ], [ 61, 76 ],
636 [ 67, 83 ], [ 77, 80 ]
639 const RA_28_8_INTERLEAVE_PARAMS: &[InterleaveParams] = &[
640 InterleaveParams { block_size: 228, factor: 12, frames_per_blk: 6 },
642 const SIPRO_INTERLEAVE_PARAMS: &[InterleaveParams] = &[
643 InterleaveParams { block_size: 232, factor: 6, frames_per_blk: 16 },
644 InterleaveParams { block_size: 304, factor: 6, frames_per_blk: 16 },
645 InterleaveParams { block_size: 296, factor: 6, frames_per_blk: 16 },
646 InterleaveParams { block_size: 320, factor: 6, frames_per_blk: 16 }
648 const ATRAC_INTERLEAVE_PARAMS: &[InterleaveParams] = &[
649 InterleaveParams { block_size: 768, factor: 20, frames_per_blk: 4 },
650 InterleaveParams { block_size: 1088, factor: 20, frames_per_blk: 4 },
651 InterleaveParams { block_size: 912, factor: 30, frames_per_blk: 3 },
652 InterleaveParams { block_size: 1152, factor: 30, frames_per_blk: 3 },
653 InterleaveParams { block_size: 1272, factor: 30, frames_per_blk: 3 },
654 InterleaveParams { block_size: 1024, factor: 30, frames_per_blk: 2 },
655 InterleaveParams { block_size: 768, factor: 10, frames_per_blk: 1 },
656 InterleaveParams { block_size: 1024, factor: 10, frames_per_blk: 1 }
658 const COOK_INTERLEAVE_PARAMS: &[InterleaveParams] = &[
659 InterleaveParams { block_size: 288, factor: 8, frames_per_blk: 9 },
660 InterleaveParams { block_size: 352, factor: 8, frames_per_blk: 11 },
661 InterleaveParams { block_size: 564, factor: 8, frames_per_blk: 12 },
662 InterleaveParams { block_size: 600, factor: 9, frames_per_blk: 10 },
663 InterleaveParams { block_size: 651, factor: 14, frames_per_blk: 7 },
664 InterleaveParams { block_size: 640, factor: 15, frames_per_blk: 5 },
665 InterleaveParams { block_size: 744, factor: 20, frames_per_blk: 4 },
666 InterleaveParams { block_size: 558, factor: 16, frames_per_blk: 6 },
667 InterleaveParams { block_size: 288, factor: 6, frames_per_blk: 12 },
668 InterleaveParams { block_size: 580, factor: 10, frames_per_blk: 10 },
669 InterleaveParams { block_size: 564, factor: 14, frames_per_blk: 6 },
670 InterleaveParams { block_size: 640, factor: 16, frames_per_blk: 5 },
671 InterleaveParams { block_size: 744, factor: 20, frames_per_blk: 4 },
672 InterleaveParams { block_size: 834, factor: 30, frames_per_blk: 3 },
673 InterleaveParams { block_size: 644, factor: 20, frames_per_blk: 4 },
674 InterleaveParams { block_size: 600, factor: 9, frames_per_blk: 10 },
675 InterleaveParams { block_size: 651, factor: 14, frames_per_blk: 7 },
676 InterleaveParams { block_size: 528, factor: 8, frames_per_blk: 11 },
677 InterleaveParams { block_size: 600, factor: 10, frames_per_blk: 10 },
678 InterleaveParams { block_size: 600, factor: 10, frames_per_blk: 10 },
679 InterleaveParams { block_size: 465, factor: 16, frames_per_blk: 5 },
680 InterleaveParams { block_size: 465, factor: 16, frames_per_blk: 5 },
681 InterleaveParams { block_size: 640, factor: 16, frames_per_blk: 5 },
682 InterleaveParams { block_size: 640, factor: 16, frames_per_blk: 5 },
683 InterleaveParams { block_size: 930, factor: 16, frames_per_blk: 5 },
684 InterleaveParams { block_size: 1400, factor: 16, frames_per_blk: 5 },
685 InterleaveParams { block_size: 376, factor: 8, frames_per_blk: 11 },
686 InterleaveParams { block_size: 930, factor: 16, frames_per_blk: 5 },
687 InterleaveParams { block_size: 1400, factor: 16, frames_per_blk: 5 },
688 InterleaveParams { block_size: 640, factor: 16, frames_per_blk: 5 },
689 InterleaveParams { block_size: 1395, factor: 16, frames_per_blk: 5 },
690 InterleaveParams { block_size: 1143, factor: 10, frames_per_blk: 3 },
691 InterleaveParams { block_size: 1064, factor: 10, frames_per_blk: 2 },
692 InterleaveParams { block_size: 778, factor: 1, frames_per_blk: 1 }