Support for them has been moved to na_game_tool.
[features]
default = ["all_decoders", "all_demuxers", "all_muxers"]
demuxers = []
-all_demuxers = ["demuxer_bmv", "demuxer_bmv3", "demuxer_fcmp", "demuxer_fst", "demuxer_gdv", "demuxer_seq", "demuxer_sga", "demuxer_smush", "demuxer_vmd"]
+all_demuxers = ["demuxer_bmv", "demuxer_bmv3", "demuxer_gdv", "demuxer_seq", "demuxer_sga", "demuxer_smush", "demuxer_vmd"]
demuxer_bmv = ["demuxers"]
demuxer_bmv3 = ["demuxers"]
demuxer_cnm = ["demuxers"]
-demuxer_fcmp = ["demuxers"]
-demuxer_fst = ["demuxers"]
demuxer_gdv = ["demuxers"]
demuxer_seq = ["demuxers"]
demuxer_sga = ["demuxers"]
all_decoders = ["all_video_decoders", "all_audio_decoders"]
decoders = []
-all_video_decoders = ["decoder_bmv", "decoder_bmv3", "decoder_fstvid", "decoder_gdvvid", "decoder_ipma", "decoder_kmvc", "decoder_midivid", "decoder_midivid3", "decoder_seq", "decoder_sga", "decoder_smush_video", "decoder_vmd"]
+all_video_decoders = ["decoder_bmv", "decoder_bmv3", "decoder_gdvvid", "decoder_ipma", "decoder_kmvc", "decoder_midivid", "decoder_midivid3", "decoder_seq", "decoder_sga", "decoder_smush_video", "decoder_vmd"]
decoder_bmv = ["decoders"]
decoder_bmv3 = ["decoders"]
-decoder_fstvid = ["decoders"]
decoder_gdvvid = ["decoders"]
decoder_ipma = ["decoders"]
decoder_kmvc = ["decoders"]
decoder_smush_video = ["decoders"]
decoder_vmd = ["decoders"]
-all_audio_decoders = ["decoder_fstaud", "decoder_lhst500f22", "decoder_smush_audio"]
-decoder_fstaud = ["decoders"]
+all_audio_decoders = ["decoder_lhst500f22", "decoder_smush_audio"]
decoder_lhst500f22 = ["decoders"]
decoder_smush_audio = ["decoders"]
+++ /dev/null
-use nihav_core::frame::*;
-use nihav_core::formats;
-#[cfg(feature="decoder_fstaud")]
-use nihav_core::formats::NAChannelMap;
-use nihav_core::codecs::*;
-#[cfg(feature="decoder_fstvid")]
-use nihav_core::io::byteio::*;
-#[cfg(feature="decoder_fstaud")]
-use nihav_codec_support::codecs::imaadpcm::IMAState;
-
-#[cfg(feature="decoder_fstvid")]
-struct FutureVisionVideoDecoder {
- info: NACodecInfoRef,
- pal: [u8; 768],
- frame: Vec<u8>,
- w: usize,
- h: usize,
-}
-
-#[cfg(feature="decoder_fstvid")]
-struct Bits8<'a> {
- src: &'a [u8],
- pos: usize,
- buf: u8,
- bit: u8,
-}
-
-#[cfg(feature="decoder_fstvid")]
-impl<'a> Bits8<'a> {
- fn new(src: &'a [u8]) -> Self { Bits8 { src, pos: 0, buf: 0, bit: 0 } }
- fn read_bit(&mut self) -> ByteIOResult<bool> {
- if self.bit == 0 {
- if self.pos < self.src.len() {
- self.buf = self.src[self.pos];
- self.pos += 1;
- self.bit = 8;
- } else {
- return Err(ByteIOError::ReadError);
- }
- }
- let bit = (self.buf & 0x80) != 0;
- self.buf <<= 1;
- self.bit -= 1;
- Ok(bit)
- }
-}
-
-#[cfg(feature="decoder_fstvid")]
-impl FutureVisionVideoDecoder {
- fn new() -> Self {
- FutureVisionVideoDecoder {
- info: NACodecInfoRef::default(),
- pal: [0; 768],
- frame: Vec::new(),
- w: 0,
- h: 0,
- }
- }
-
- fn output_frame(&mut self, bufinfo: &mut NABufferType, w: usize, h: usize) {
- let bufo = bufinfo.get_vbuf();
- let mut buf = bufo.unwrap();
- let paloff = buf.get_offset(1);
- let stride = buf.get_stride(0);
- let data = buf.get_data_mut().unwrap();
- let dst = data.as_mut_slice();
-
- dst[paloff..][..768].copy_from_slice(&self.pal);
- for (dline, sline) in dst.chunks_mut(stride).zip(self.frame.chunks(w)).take(h) {
- dline[..w].copy_from_slice(sline);
- }
- }
-}
-
-#[cfg(feature="decoder_fstvid")]
-impl NADecoder for FutureVisionVideoDecoder {
- fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
- if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
- let w = vinfo.get_width();
- let h = vinfo.get_height();
- validate!((w & 1) == 0 && (h & 1) == 0);
- let fmt = PAL8_FORMAT;
- let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
- self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
- self.w = w;
- self.h = h;
-
- self.frame.resize(w * h, 0);
- self.pal = [0; 768];
- Ok(())
- } else {
- Err(DecoderError::InvalidData)
- }
- }
- fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
- let src = pkt.get_buffer();
- validate!(src.len() >= 4);
-
- let bitsize = read_u16le(&src)? as usize;
- let bsize = (bitsize + 8) >> 3;
- validate!(bsize + 2 <= src.len());
-
- let mut flags = Bits8::new(&src[2..][..bsize]);
- let mut mr = MemoryReader::new_read(&src[2 + bsize..]);
- let mut br = ByteReader::new(&mut mr);
-
- if (bsize + 2 != src.len()) && flags.read_bit()? {
- for dst in self.pal.iter_mut() {
- let b = br.read_byte()?;
- *dst = (b << 2) | (b >> 4);
- }
- }
-
- let mut is_intra = true;
- let stride = self.w;
- // for some reason last row should not be decoded
- for row4 in self.frame.chunks_mut(stride * 4).take(self.h / 4 - 1) {
- for x in (0..self.w).step_by(4) {
- if flags.read_bit()? {
- if flags.read_bit()? {
- let c0 = br.read_byte()?;
- let c1 = br.read_byte()?;
- let mut mask = br.read_u16le()?;
- for dst in row4[x..].chunks_mut(stride) {
- for pix in dst.iter_mut().take(4) {
- *pix = if (mask & 0x8000) != 0 { c1 } else { c0 };
- mask <<= 1;
- }
- }
- } else {
- for dst in row4[x..].chunks_mut(stride) {
- br.read_buf(&mut dst[..4])?;
- }
- }
- } else {
- is_intra = false;
- }
- }
- }
-
- let mut bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;
-
- self.output_frame(&mut bufinfo, self.w, self.h);
-
- let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
- frm.set_keyframe(is_intra);
- frm.set_frame_type(if is_intra { FrameType::I } else { FrameType::P });
- Ok(frm.into_ref())
- }
- fn flush(&mut self) {
- }
-}
-
-#[cfg(feature="decoder_fstvid")]
-impl NAOptionHandler for FutureVisionVideoDecoder {
- fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
- fn set_options(&mut self, _options: &[NAOption]) { }
- fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
-}
-
-#[cfg(feature="decoder_fstvid")]
-pub fn get_decoder_video() -> Box<dyn NADecoder + Send> {
- Box::new(FutureVisionVideoDecoder::new())
-}
-
-#[cfg(feature="decoder_fstaud")]
-struct FutureVisionAudioDecoder {
- ainfo: NAAudioInfo,
- chmap: NAChannelMap,
- state: IMAState,
- count: usize,
-}
-
-#[cfg(feature="decoder_fstaud")]
-impl FutureVisionAudioDecoder {
- fn new() -> Self {
- FutureVisionAudioDecoder {
- ainfo: NAAudioInfo::new(0, 1, formats::SND_S16_FORMAT, 0),
- chmap: NAChannelMap::from_ms_mapping(0x4), //single channel
- state: IMAState::new(),
- count: 0,
- }
- }
-}
-
-#[cfg(feature="decoder_fstaud")]
-impl NADecoder for FutureVisionAudioDecoder {
- fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
- if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
- self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), 1, formats::SND_S16P_FORMAT, 1);
- Ok(())
- } else {
- Err(DecoderError::InvalidData)
- }
- }
- fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
- let info = pkt.get_stream().get_info();
- if let NACodecTypeInfo::Audio(_) = info.get_properties() {
- let pktbuf = pkt.get_buffer();
- let samples = pktbuf.len() * 2;
- let abuf = alloc_audio_buffer(self.ainfo, samples, self.chmap.clone())?;
- let mut adata = abuf.get_abuf_i16().unwrap();
- let buf = adata.get_data_mut().unwrap();
- for (dst, &val) in buf.chunks_exact_mut(2).zip(pktbuf.iter()) {
- dst[0] = self.state.expand_sample(val & 0xF);
- dst[1] = self.state.expand_sample(val >> 4);
- if self.count < 50 {
- dst[0] = 0;
- dst[1] = 0;
- }
- self.count += 2;
- }
- let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
- frm.set_duration(Some(samples as u64));
- frm.set_keyframe(false);
- Ok(frm.into_ref())
- } else {
- Err(DecoderError::InvalidData)
- }
- }
- fn flush(&mut self) {
- }
-}
-
-#[cfg(feature="decoder_fstaud")]
-impl NAOptionHandler for FutureVisionAudioDecoder {
- fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
- fn set_options(&mut self, _options: &[NAOption]) { }
- fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
-}
-
-#[cfg(feature="decoder_fstaud")]
-pub fn get_decoder_audio() -> Box<dyn NADecoder + Send> {
- Box::new(FutureVisionAudioDecoder::new())
-}
-
-#[cfg(test)]
-mod test {
- use nihav_core::codecs::RegisteredDecoders;
- use nihav_core::demuxers::RegisteredDemuxers;
- use nihav_codec_support::test::dec_video::*;
- use crate::game_register_all_decoders;
- use crate::game_register_all_demuxers;
-
- // samples come from the Harvester game
- #[test]
- fn test_fst_video() {
- let mut dmx_reg = RegisteredDemuxers::new();
- game_register_all_demuxers(&mut dmx_reg);
- let mut dec_reg = RegisteredDecoders::new();
- game_register_all_decoders(&mut dec_reg);
-
- test_decoding("fst", "fst-video", "assets/Game/alarm.fst", None, &dmx_reg, &dec_reg,
- ExpectedTestResult::MD5([0x4028440a, 0xcb8aed5b, 0x2a9f1ead, 0x269169f5]));
- }
- #[test]
- fn test_fst_audio() {
- let mut dmx_reg = RegisteredDemuxers::new();
- game_register_all_demuxers(&mut dmx_reg);
- let mut dec_reg = RegisteredDecoders::new();
- game_register_all_decoders(&mut dec_reg);
-
- test_decoding("fcmp", "fst-audio", "assets/Game/anxiety.cmp", None, &dmx_reg, &dec_reg,
- ExpectedTestResult::MD5([0xa45b65b3, 0xe0654352, 0xf553e90b, 0x5dce0023]));
- }
-}
pub mod bmv;
#[cfg(feature="decoder_bmv3")]
pub mod bmv3;
-#[cfg(any(feature="decoder_fstvid",feature="decoder_fstaud"))]
-pub mod futurevision;
#[cfg(feature="decoder_gdvvid")]
pub mod gremlinvideo;
#[cfg(feature="decoder_ipma")]
DecoderInfo { name: "bmv3-audio", get_decoder: bmv3::get_decoder_audio },
#[cfg(feature="decoder_bmv3")]
DecoderInfo { name: "bmv3-video", get_decoder: bmv3::get_decoder_video },
-#[cfg(feature="decoder_fstaud")]
- DecoderInfo { name: "fst-audio", get_decoder: futurevision::get_decoder_audio },
-#[cfg(feature="decoder_fstvid")]
- DecoderInfo { name: "fst-video", get_decoder: futurevision::get_decoder_video },
#[cfg(feature="decoder_ipma")]
DecoderInfo { name: "ipma", get_decoder: ipma::get_decoder },
#[cfg(feature="decoder_ipma")]
+++ /dev/null
-use nihav_core::frame::*;
-use nihav_core::demuxers::*;
-
-struct FutureVisionVideoDemuxer<'a> {
- src: &'a mut ByteReader<'a>,
- cur_frame: usize,
- apos: u64,
- vsize: Vec<usize>,
- asize: Vec<usize>,
- a_id: Option<usize>,
- v_id: Option<usize>,
- vframe: bool,
-}
-
-impl<'a> DemuxCore<'a> for FutureVisionVideoDemuxer<'a> {
- fn open(&mut self, strmgr: &mut StreamManager, _seek_index: &mut SeekIndex) -> DemuxerResult<()> {
- let src = &mut self.src;
-
- let magic = src.read_tag()?;
- validate!(&magic == b"2TSF");
- let width = src.read_u32le()? as usize;
- let height = src.read_u32le()? as usize;
- validate!(width != 0 && height != 0);
- let _flags = src.read_u32le()?;
- let nframes = src.read_u32le()? as usize;
- let fps = src.read_u32le()?;
- let arate = src.read_u32le()?;
- let abits = src.read_u32le()?;
-
- let vhdr = NAVideoInfo::new(width, height, false, PAL8_FORMAT);
- let vci = NACodecTypeInfo::Video(vhdr);
- let vinfo = NACodecInfo::new("fst-video", vci, None);
- self.v_id = strmgr.add_stream(NAStream::new(StreamType::Video, 0, vinfo, 1, fps, nframes as u64));
- if arate != 0 {
- validate!(abits == 8 || abits == 16);
- let ahdr = NAAudioInfo::new(arate, 1, if abits == 16 { SND_S16_FORMAT } else { SND_U8_FORMAT }, 2);
- let ainfo = NACodecInfo::new("pcm", NACodecTypeInfo::Audio(ahdr), None);
- self.a_id = strmgr.add_stream(NAStream::new(StreamType::Audio, 1, ainfo, 1, arate, 2));
- }
- self.vsize = Vec::with_capacity(nframes);
- self.asize = Vec::with_capacity(nframes);
- for _ in 0..nframes {
- let vsize = src.read_u32le()? as usize;
- let asize = src.read_u16le()? as usize;
- self.vsize.push(vsize);
- self.asize.push(asize);
- }
- self.vframe = true;
- self.cur_frame = 0;
- self.apos = 0;
- Ok(())
- }
-
- fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
- if self.cur_frame >= self.vsize.len() { return Err(DemuxerError::EOF); }
- let (id, size, pts) = if self.vframe {
- self.vframe = self.a_id.is_none();
-
- (self.v_id.unwrap_or(0), self.vsize[self.cur_frame], self.cur_frame as u64)
- } else {
- self.vframe = true;
- let apos = self.apos;
- self.apos += (self.asize[self.cur_frame] as u64) * 2;
-
- (self.a_id.unwrap_or(0), self.asize[self.cur_frame], apos)
- };
-
- if self.vframe {
- self.cur_frame += 1;
- }
-
- let stream = strmgr.get_stream(id).unwrap();
- let ts = stream.make_ts(Some(pts), None, None);
- self.src.read_packet(stream, ts, true, size)
- }
-
- fn seek(&mut self, _time: NATimePoint, _seek_index: &SeekIndex) -> DemuxerResult<()> {
- Err(DemuxerError::NotPossible)
- }
- fn get_duration(&self) -> u64 { 0 }
-}
-impl<'a> NAOptionHandler for FutureVisionVideoDemuxer<'a> {
- fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
- fn set_options(&mut self, _options: &[NAOption]) { }
- fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
-}
-impl<'a> FutureVisionVideoDemuxer<'a> {
- fn new(io: &'a mut ByteReader<'a>) -> Self {
- FutureVisionVideoDemuxer {
- src: io,
- cur_frame: 0,
- apos: 0,
- vsize: Vec::new(),
- asize: Vec::new(),
- a_id: None,
- v_id: None,
- vframe: false,
- }
- }
-}
-
-pub struct FSTDemuxerCreator { }
-
-impl DemuxerCreator for FSTDemuxerCreator {
- fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
- Box::new(FutureVisionVideoDemuxer::new(br))
- }
- fn get_name(&self) -> &'static str { "fst" }
-}
-
-struct FutureVisionAudioDemuxer<'a> {
- src: &'a mut ByteReader<'a>,
- a_id: usize,
- end: u64,
- arate: u32,
-}
-
-impl<'a> DemuxCore<'a> for FutureVisionAudioDemuxer<'a> {
- fn open(&mut self, strmgr: &mut StreamManager, _seek_index: &mut SeekIndex) -> DemuxerResult<()> {
- let src = &mut self.src;
-
- let magic = src.read_tag()?;
- validate!(&magic == b"FCMP");
- let size = u64::from(src.read_u32le()?);
- let arate = src.read_u32le()?;
- validate!(arate != 0);
- let abits = src.read_u16le()?;
- validate!(abits == 8 || abits == 16);
-
- let ahdr = NAAudioInfo::new(arate, 1, if abits == 16 { SND_S16_FORMAT } else { SND_U8_FORMAT }, 2);
- let ainfo = NACodecInfo::new("fst-audio", NACodecTypeInfo::Audio(ahdr), None);
- self.a_id = strmgr.add_stream(NAStream::new(StreamType::Audio, 0, ainfo, 1, arate, 2)).unwrap();
- self.end = self.src.tell() + size;
- self.arate = arate;
- Ok(())
- }
-
- fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
- if self.src.tell() >= self.end { return Err(DemuxerError::EOF); }
- let size = (self.end - self.src.tell()).min(0x2000) as usize;
- let pts = (self.src.tell() - 14) * 2;
-
- let stream = strmgr.get_stream(self.a_id).unwrap();
- let ts = stream.make_ts(Some(pts), None, None);
- self.src.read_packet(stream, ts, true, size)
- }
-
- fn seek(&mut self, _time: NATimePoint, _seek_index: &SeekIndex) -> DemuxerResult<()> {
- Err(DemuxerError::NotPossible)
- }
- fn get_duration(&self) -> u64 { (self.end - 14) * 2000 / u64::from(self.arate) }
-}
-impl<'a> NAOptionHandler for FutureVisionAudioDemuxer<'a> {
- fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
- fn set_options(&mut self, _options: &[NAOption]) { }
- fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
-}
-impl<'a> FutureVisionAudioDemuxer<'a> {
- fn new(io: &'a mut ByteReader<'a>) -> Self {
- FutureVisionAudioDemuxer {
- src: io,
- a_id: 0,
- end: 0,
- arate: 0,
- }
- }
-}
-
-pub struct FCMPDemuxerCreator { }
-
-impl DemuxerCreator for FCMPDemuxerCreator {
- fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
- Box::new(FutureVisionAudioDemuxer::new(br))
- }
- fn get_name(&self) -> &'static str { "fcmp" }
-}
-
-#[cfg(test)]
-mod test {
- use super::*;
- use std::fs::File;
-
- // samples from the Harvester game
- #[test]
- fn test_fst_demux() {
- let mut file = File::open("assets/Game/c007.fst").unwrap();
- let mut fr = FileReader::new_read(&mut file);
- let mut br = ByteReader::new(&mut fr);
- let mut dmx = FutureVisionVideoDemuxer::new(&mut br);
- let mut sm = StreamManager::new();
- let mut si = SeekIndex::new();
- dmx.open(&mut sm, &mut si).unwrap();
- loop {
- let pktres = dmx.get_frame(&mut sm);
- if let Err(e) = pktres {
- if (e as i32) == (DemuxerError::EOF as i32) { break; }
- panic!("error");
- }
- let pkt = pktres.unwrap();
- println!("Got {}", pkt);
- }
- }
-
- #[test]
- fn test_fcmp_demux() {
- let mut file = File::open("assets/Game/anxiety.cmp").unwrap();
- let mut fr = FileReader::new_read(&mut file);
- let mut br = ByteReader::new(&mut fr);
- let mut dmx = FutureVisionAudioDemuxer::new(&mut br);
- let mut sm = StreamManager::new();
- let mut si = SeekIndex::new();
- dmx.open(&mut sm, &mut si).unwrap();
- loop {
- let pktres = dmx.get_frame(&mut sm);
- if let Err(e) = pktres {
- if (e as i32) == (DemuxerError::EOF as i32) { break; }
- panic!("error");
- }
- let pkt = pktres.unwrap();
- println!("Got {}", pkt);
- }
- }
-}
#[cfg(any(feature="demuxer_bmv",feature="demuxer_bmv3"))]
mod bmv;
-#[cfg(any(feature="demuxer_fst",feature="demuxer_fcmp"))]
-mod fst;
#[cfg(feature="demuxer_gdv")]
mod gdv;
#[cfg(feature="demuxer_seq")]
&bmv::BMVDemuxerCreator {},
#[cfg(feature="demuxer_bmv3")]
&bmv::BMV3DemuxerCreator {},
-#[cfg(feature="demuxer_fcmp")]
- &fst::FCMPDemuxerCreator {},
-#[cfg(feature="demuxer_fst")]
- &fst::FSTDemuxerCreator {},
#[cfg(feature="demuxer_gdv")]
&gdv::GDVDemuxerCreator {},
#[cfg(feature="demuxer_seq")]
conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"DKIF\x00\x00")},
CheckItem{offs: 6, cond: &CC::Ge(Arg::U16LE(32))}],
},
- DetectConditions {
- demux_name: "fcmp",
- extensions: ".cmp",
- conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"FCMP")}],
- },
- DetectConditions {
- demux_name: "fst",
- extensions: ".fst",
- conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"2TSF")}],
- },
DetectConditions {
demux_name: "gdv",
extensions: ".gdv",
projects / nihav.git / commitdiff