1 use nihav_core::demuxers::*;
3 const VIDEO_CODECS: &[(i32, &str)] = &[
9 ( 17, "movingblockshq"),
10 ( 19, "supermovingblocks"),
24 fn read_string(&mut self) -> DemuxerResult<Vec<u8>>;
27 impl<'a> ReadString for ByteReader<'a> {
28 fn read_string(&mut self) -> DemuxerResult<Vec<u8>> {
29 let mut res = Vec::new();
31 let c = self.read_byte()?;
32 if c == b'\n' || c == 0 {
36 validate!(res.len() < (1 << 10)); // insanity check
42 fn parse_int(src: &[u8]) -> DemuxerResult<i32> {
44 let mut parsed = false;
46 for &c in src.iter() {
48 b'-' if !parsed => { sign = true; },
49 b'-' => return Err(DemuxerError::InvalidData),
51 val = val * 10 + ((c - b'0') as i32);
53 return Err(DemuxerError::InvalidData);
57 b' ' | b'\t' if !parsed => {},
62 Ok(if !sign { val } else { -val })
64 Err(DemuxerError::InvalidData)
68 fn parse_uint(src: &[u8]) -> DemuxerResult<u32> {
69 let val = parse_int(src)?;
70 if val < 0 { return Err(DemuxerError::InvalidData); }
74 fn parse_float(src: &[u8]) -> DemuxerResult<f32> {
76 let mut parsed = false;
77 let mut frac_part = 1.0;
78 for &c in src.iter() {
82 val = val * 10.0 + ((c - b'0') as f32);
84 return Err(DemuxerError::InvalidData);
87 val += ((c - b'0') as f32) * frac_part;
92 b'.' if frac_part != 1.0 => return Err(DemuxerError::InvalidData),
103 Err(DemuxerError::InvalidData)
107 #[allow(clippy::while_let_on_iterator)]
108 fn split_sound_str(string: &[u8]) -> DemuxerResult<Vec<&[u8]>> {
110 let mut ret = Vec::new();
111 let mut ref_trk_id = 2;
113 let mut iter = string.iter().enumerate();
114 while let Some((pos, &c)) = iter.next() {
116 ret.push(&string[start..pos]);
118 validate!(pos + 2 < string.len());
120 let mut num_end = pos + 2;
121 while let Some((pos2, c)) = iter.next() {
122 if !c.is_ascii_digit() {
127 let trk_id = parse_uint(&string[pos + 1..num_end])?;
128 validate!(trk_id == ref_trk_id);
133 if start < string.len() {
134 ret.push(&string[start..]);
151 struct ARMovieDemuxer<'a> {
152 src: &'a mut ByteReader<'a>,
153 chunk_offs: Vec<ChunkInfo>,
156 video_id: Option<usize>,
157 audio_ids: Vec<usize>,
160 impl<'a> ARMovieDemuxer<'a> {
161 fn new(src: &'a mut ByteReader<'a>) -> Self {
164 chunk_offs: Vec::new(),
166 state: ReadState::None,
168 audio_ids: Vec::new(),
171 fn parse_catalogue(&mut self, offset: u32, num_chunks: usize, even_csize: usize, odd_csize: usize, aud_tracks: usize) -> DemuxerResult<()> {
172 self.src.seek(SeekFrom::Start(u64::from(offset)))?;
173 self.chunk_offs.clear();
174 for i in 0..num_chunks {
175 let cur_chunk_size = if (i & 1) == 0 { even_csize } else { odd_csize };
177 let entry = self.src.read_string()?;
178 let comma_pos = entry.iter().position(|&c| c == b',');
179 let semicolon_pos = entry.iter().position(|&c| c == b';');
180 if let (Some(c_pos), Some(sc_pos)) = (comma_pos, semicolon_pos) {
181 validate!(c_pos > 0 && c_pos + 1 < sc_pos);
182 let offset = parse_uint(&entry[..c_pos])?;
183 let vid_size = parse_uint(&entry[c_pos + 1..sc_pos])?;
184 let astring = &entry[sc_pos + 1..];
185 let asizes = split_sound_str(astring)?;
187 let mut aud_sizes = Vec::with_capacity(aud_tracks);
189 let aud_size = parse_uint(asizes[0])?;
190 aud_sizes.push(aud_size);
192 for &aud_entry in asizes.iter().skip(1) {
193 let aud_size = parse_uint(aud_entry)?;
194 aud_sizes.push(aud_size);
197 let tot_size: u32 = vid_size + aud_sizes.iter().sum::<u32>();
198 validate!((tot_size as usize) <= cur_chunk_size);
199 self.chunk_offs.push(ChunkInfo { offset, vid_size, aud_sizes });
201 return Err(DemuxerError::InvalidData);
209 impl<'a> RawDemuxCore<'a> for ARMovieDemuxer<'a> {
210 #[allow(clippy::neg_cmp_op_on_partial_ord)]
211 fn open(&mut self, strmgr: &mut StreamManager, _seek_index: &mut SeekIndex) -> DemuxerResult<()> {
212 let magic = self.src.read_string()?;
213 validate!(&magic == b"ARMovie");
214 let _name = self.src.read_string()?;
215 let _date_and_copyright = self.src.read_string()?;
216 let _author = self.src.read_string()?;
218 let video_id = self.src.read_string()?;
219 let video_codec = parse_int(&video_id)?;
220 let width = self.src.read_string()?;
221 let width = parse_int(&width)?;
222 let height = self.src.read_string()?;
223 let height = parse_int(&height)?;
224 validate!((video_codec <= 0) || (width > 0 && height > 0));
225 let width = width as usize;
226 let height = height as usize;
227 let vformat = self.src.read_string()?;
228 let fps = self.src.read_string()?;
229 let fps = parse_float(&fps)?;
231 let sound_id = self.src.read_string()?;
232 let sound_ids = split_sound_str(&sound_id)?;
233 let mut num_sound = sound_ids.len();
235 let sound_codec = parse_int(sound_ids[0])?;
240 let srate = self.src.read_string()?;
241 let srates = split_sound_str(&srate)?;
242 let chan = self.src.read_string()?;
243 let channels = split_sound_str(&chan)?;
244 let sndformat = self.src.read_string()?;
245 let sndformats = split_sound_str(&sndformat)?;
247 let frm_per_chunk = self.src.read_string()?;
248 let frm_per_chunk = parse_uint(&frm_per_chunk)? as usize;
249 validate!(frm_per_chunk > 0);
250 let num_chunks = self.src.read_string()?;
251 let num_chunks = parse_uint(&num_chunks)? as usize + 1;
252 let even_chunk_size = self.src.read_string()?;
253 let even_chunk_size = parse_uint(&even_chunk_size)? as usize;
254 let odd_chunk_size = self.src.read_string()?;
255 let odd_chunk_size = parse_uint(&odd_chunk_size)? as usize;
256 let cat_offset = self.src.read_string()?;
257 let cat_offset = parse_uint(&cat_offset)?;
259 let _sprite_offset = self.src.read_string()?;
260 let _sprite_size = self.src.read_string()?;
261 let _kf_offset_res = self.src.read_string(); // may be not present for older ARMovies
263 self.parse_catalogue(cat_offset, num_chunks, even_chunk_size, odd_chunk_size, num_sound)?;
265 let mut stream_id = 0;
267 let codec_name = if let Some(idx) = VIDEO_CODECS.iter().position(|&(id, _)| id == video_codec) {
272 validate!(fps > 1.0e-4);
275 while tbase.fract() > 1.0e-4 {
279 let tb_den = tbase as u32;
281 let mut edata = vec![video_codec as u8, (video_codec >> 8) as u8];
282 edata.extend_from_slice(&vformat);
284 let fmt = match video_codec {
286 601 => RGB565_FORMAT,
290 let vci = NACodecTypeInfo::Video(NAVideoInfo::new(width, height, false, fmt));
291 let vinfo = NACodecInfo::new(codec_name, vci, Some(edata));
292 let ret = strmgr.add_stream(NAStream::new(StreamType::Video, stream_id, vinfo, tb_num, tb_den, (frm_per_chunk * num_chunks) as u64));
297 return Err(DemuxerError::MemoryError);
302 validate!(sound_ids.len() == srates.len());
303 validate!(sound_ids.len() == channels.len());
304 validate!(sound_ids.len() == sndformats.len());
305 for ((&id, &sratestr), (&chan, &fmt)) in sound_ids.iter().zip(srates.iter())
306 .zip(channels.iter().zip(sndformats.iter())) {
307 let codec_id = parse_uint(id)?;
308 let codec_name = if codec_id == 1 { "arm_rawaudio" } else { "unknown" };
309 let channels = parse_uint(chan)?;
310 validate!(channels > 0 && channels < 16);
311 let edata = fmt.to_owned();
312 let bits = parse_uint(fmt)?;
313 let mut srate = parse_uint(sratestr)?;
314 if srate > 0 && srate < 1000 { // probably in microseconds instead of Hertz
315 srate = 1000000 / srate;
317 //println!(" codec id {codec_id} srate {srate} chan {channels} bits {bits}");
318 let fmt = if bits == 8 { SND_U8_FORMAT } else { SND_S16_FORMAT };
320 let aci = NACodecTypeInfo::Audio(NAAudioInfo::new(srate, channels as u8, fmt, 0));
321 let ainfo = NACodecInfo::new(codec_name, aci, Some(edata));
322 let ret = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_id, ainfo, 1, srate, 0));
323 if let Some(id) = ret {
324 self.audio_ids.push(id);
327 return Err(DemuxerError::MemoryError);
335 fn get_data(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NARawData> {
336 while self.cur_chunk < self.chunk_offs.len() {
337 let chunk = &self.chunk_offs[self.cur_chunk];
340 self.src.seek(SeekFrom::Start(u64::from(chunk.offset)))?;
341 self.state = ReadState::Video;
343 ReadState::Video => {
344 self.state = ReadState::Audio(0);
345 if chunk.vid_size > 0 {
346 validate!(self.video_id.is_some());
347 if let Some(stream) = strmgr.get_stream(self.video_id.unwrap_or(0)) {
348 let mut buf = vec![0; chunk.vid_size as usize];
349 self.src.read_buf(&mut buf)?;
350 return Ok(NARawData::new(stream, buf));
352 return Err(DemuxerError::InvalidData);
356 ReadState::Audio(idx) => {
357 if idx < chunk.aud_sizes.len() {
358 self.state = ReadState::Audio(idx + 1);
359 if chunk.aud_sizes[idx] > 0 {
360 if let Some(stream) = strmgr.get_stream(self.audio_ids[idx]) {
361 let mut buf = vec![0; chunk.aud_sizes[idx] as usize];
362 self.src.read_buf(&mut buf)?;
363 return Ok(NARawData::new(stream, buf));
365 return Err(DemuxerError::InvalidData);
370 self.state = ReadState::None;
376 Err(DemuxerError::EOF)
379 fn seek(&mut self, _time: NATimePoint, _seek_index: &SeekIndex) -> DemuxerResult<()> {
380 Err(DemuxerError::NotPossible)
382 fn get_duration(&self) -> u64 { 0 }
385 impl<'a> NAOptionHandler for ARMovieDemuxer<'a> {
386 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
387 fn set_options(&mut self, _options: &[NAOption]) { }
388 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
391 pub struct ARMovieDemuxerCreator { }
393 impl RawDemuxerCreator for ARMovieDemuxerCreator {
394 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn RawDemuxCore<'a> + 'a> {
395 Box::new(ARMovieDemuxer::new(br))
397 fn get_name(&self) -> &'static str { "armovie" }
398 fn check_format(&self, br: &mut ByteReader) -> bool {
399 let mut hdr = [0; 8];
400 br.read_buf(&mut hdr).is_ok() && &hdr == b"ARMovie\n"
410 fn test_armovie_demux() {
411 // a sample from Acorn Replay Demonstration Disc 2
412 let mut file = File::open("assets/Acorn/CHEMSET2").unwrap();
413 let mut fr = FileReader::new_read(&mut file);
414 let mut br = ByteReader::new(&mut fr);
415 let mut dmx = ARMovieDemuxer::new(&mut br);
416 let mut sm = StreamManager::new();
417 let mut si = SeekIndex::new();
418 dmx.open(&mut sm, &mut si).unwrap();
421 let pktres = dmx.get_data(&mut sm);
422 if let Err(e) = pktres {
423 if e == DemuxerError::EOF { break; }
426 let pkt = pktres.unwrap();
427 println!("Got {}", pkt);