--- /dev/null
+use nihav_core::codecs::*;
+use nihav_core::io::byteio::*;
+
+const VB_FLAG_GMC: u16 = 0x0001;
+const VB_FLAG_AUDIO: u16 = 0x0004;
+const VB_FLAG_VIDEO: u16 = 0x0008;
+const VB_FLAG_PALETTE: u16 = 0x0010;
+
+const RGB555_FORMAT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
+ comp_info: [
+ Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 10, comp_offs: 0, next_elem: 2 }),
+ Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 5, comp_offs: 1, next_elem: 2 }),
+ Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 0, comp_offs: 2, next_elem: 2 }),
+ None, None],
+ elem_size: 2, be: false, alpha: false, palette: false };
+
+fn check_size(x: usize, row_no: usize, dx: i16, dy: i16, stride: usize, len: usize) -> Option<usize> {
+ let start = (x as i32) + i32::from(dx) + ((row_no * 4) as i32 + i32::from(dy)) * (stride as i32);
+ if start >= 0 {
+ let start = start as usize;
+ let end = start + 4 + stride * 3;
+
+ if end <= len {
+ Some(start)
+ } else {
+ None
+ }
+ } else {
+ None
+ }
+}
+
+fn decode_video8(br: &mut ByteReader, dst: &mut [u8], prev_frame: &[u8], width: usize, gmv: [i16; 2]) -> DecoderResult<FrameType> {
+ let mut ftype = FrameType::I;
+
+ let mut btc = 0;
+ let mut btypes = 0;
+ for (row_no, strip) in dst.chunks_mut(width * 4).enumerate() {
+ for x in (0..width).step_by(4) {
+ if btc == 0 {
+ btypes = br.read_byte()?;
+ btc = 4;
+ }
+ match btypes & 0xC0 {
+ 0xC0 => {
+ let t = br.read_byte()?;
+ let mut pattern = VB_PATTERNS[(t & 0x3F) as usize];
+ let op = t >> 6;
+ validate!(op != 3);
+ if op == 0 {
+ let mut clr = [0; 2];
+ br.read_buf(&mut clr)?;
+ for dline in strip[x..].chunks_mut(width).take(4) {
+ for el in dline[..4].iter_mut() {
+ *el = clr[(pattern & 1) as usize];
+ pattern >>= 1;
+ }
+ }
+ } else {
+ if op == 2 {
+ pattern = !pattern;
+ }
+ let clr = br.read_byte()?;
+
+ if let Some(start) = check_size(x, row_no, gmv[0], gmv[1], width, prev_frame.len()) {
+ for (dline, sline) in strip[x..].chunks_mut(width).zip(prev_frame[start..].chunks(width)).take(4) {
+ for (dst, &src) in dline[..4].iter_mut().zip(sline.iter()) {
+ *dst = if (pattern & 1) != 0 { clr } else { src };
+ pattern >>= 1;
+ }
+ }
+ } else {
+ return Err(DecoderError::InvalidData);
+ }
+
+ ftype = FrameType::P;
+ }
+ },
+ 0x80 => {
+ let clr = br.read_byte()?;
+ for dline in strip[x..].chunks_mut(width).take(4) {
+ for el in dline[..4].iter_mut() {
+ *el = clr;
+ }
+ }
+ },
+ 0x40 => {
+ let mv = br.read_byte()?;
+ if mv == 0 {
+ for dline in strip[x..].chunks_mut(width).take(4) {
+ br.read_buf(&mut dline[..4])?;
+ }
+ } else {
+ let mvx = (((mv & 0xF) ^ 8) as i16) - 8;
+ let mvy = (((mv >> 4) ^ 8) as i16) - 8;
+ if let Some(start) = check_size(x, row_no, gmv[0] + mvx, gmv[1] + mvy, width, prev_frame.len()) {
+ for (dline, sline) in strip[x..].chunks_mut(width).zip(prev_frame[start..].chunks(width)).take(4) {
+ dline[..4].copy_from_slice(&sline[..4]);
+ }
+ } else {
+ return Err(DecoderError::InvalidData);
+ }
+ ftype = FrameType::P;
+ }
+ },
+ _ => {
+ if let Some(start) = check_size(x, row_no, gmv[0], gmv[1], width, prev_frame.len()) {
+ for (dline, sline) in strip[x..].chunks_mut(width).zip(prev_frame[start..].chunks(width)).take(4) {
+ dline[..4].copy_from_slice(&sline[..4]);
+ }
+ } else {
+ return Err(DecoderError::InvalidData);
+ }
+ ftype = FrameType::P;
+ },
+ }
+
+ btypes <<= 2;
+ btc -= 1;
+ }
+ }
+
+ Ok(ftype)
+}
+
+struct OldData {
+ pal: [u8; 768],
+ prev_frame: Vec<u8>,
+ cur_frame: Vec<u8>,
+ width: usize,
+ flags: u16,
+}
+
+impl OldData {
+ fn new(w: usize, h: usize, flags: u16) -> Self {
+ Self {
+ pal: [0; 768],
+ prev_frame: vec![0; w * h],
+ cur_frame: vec![0; w * h],
+ width: w,
+ flags,
+ }
+ }
+ fn decode(&mut self, br: &mut ByteReader, vbuf: &mut NAVideoBufferRef<u8>) -> DecoderResult<FrameType> {
+ let asize = br.read_u16le()? as usize;
+ let _smth = br.read_u16le()? as usize;
+ let pal_size = br.read_u16le()? as usize;
+ if pal_size > 0 {
+ let pal_start = br.read_u16le()? as usize;
+ validate!(pal_start + pal_size <= 256);
+ br.read_buf(&mut self.pal[pal_start * 3..][..pal_size * 3])?;
+ }
+ br.read_skip(asize)?;
+
+ let (gmv_x, gmv_y) = if (self.flags & 0x2000) != 0 {
+ let mvx = br.read_u16le()? as i16;
+ let mvy = br.read_u16le()? as i16;
+ (mvx, mvy)
+ } else {
+ (0, 0)
+ };
+
+ std::mem::swap(&mut self.cur_frame, &mut self.prev_frame);
+
+ let ftype = decode_video8(br, &mut self.cur_frame, &self.prev_frame, self.width, [gmv_x, gmv_y])?;
+
+ let stride = vbuf.get_stride(0);
+ let pal_off = vbuf.get_offset(1);
+ let data = vbuf.get_data_mut().unwrap();
+
+ for (dline, sline) in data.chunks_mut(stride).zip(self.cur_frame.chunks(self.width)) {
+ dline[..self.width].copy_from_slice(sline);
+ }
+ data[pal_off..][..768].copy_from_slice(&self.pal);
+
+ Ok(ftype)
+ }
+}
+
+struct Data8 {
+ pal: [u8; 768],
+ prev_frame: Vec<u8>,
+ cur_frame: Vec<u8>,
+ width: usize,
+}
+
+impl Data8 {
+ fn new(w: usize, h: usize) -> Self {
+ Self {
+ pal: [0; 768],
+ prev_frame: vec![0; w * h],
+ cur_frame: vec![0; w * h],
+ width: w,
+ }
+ }
+ fn decode(&mut self, br: &mut ByteReader, vbuf: &mut NAVideoBufferRef<u8>) -> DecoderResult<FrameType> {
+ let flags = br.read_u16le()?;
+ let (gmv_x, gmv_y) = if (flags & VB_FLAG_GMC) != 0 {
+ let mvx = br.read_u16le()? as i16;
+ let mvy = br.read_u16le()? as i16;
+ (mvx, mvy)
+ } else {
+ (0, 0)
+ };
+ if (flags & VB_FLAG_AUDIO) != 0 {
+ let asize = br.read_u32le()? as usize;
+ validate!(asize >= 4 && asize <= (br.left() as usize));
+ br.read_skip(asize - 4)?;
+ }
+ let mut ftype = FrameType::Skip;
+ if (flags & VB_FLAG_VIDEO) != 0 {
+ std::mem::swap(&mut self.cur_frame, &mut self.prev_frame);
+
+ let vsize = br.read_u32le()? as u64;
+ validate!(vsize > 4);
+ let end = br.tell() + vsize - 4;
+
+ ftype = decode_video8(br, &mut self.cur_frame, &self.prev_frame, self.width, [gmv_x, gmv_y])?;
+
+ validate!(br.tell() == end);
+ }
+ if (flags & VB_FLAG_PALETTE) != 0 {
+ let pal_size = br.read_u32le()? as usize;
+ validate!(pal_size > 6);
+ validate!(br.left() as usize >= pal_size - 4);
+ let start = br.read_byte()? as usize;
+ let mut size = br.read_byte()? as usize;
+ if size == 0 {
+ size = 256;
+ }
+ validate!(start + size <= 256);
+ validate!(size * 3 + 6 == pal_size);
+ br.read_buf(&mut self.pal[start * 3..][..size * 3])?;
+ }
+
+ let stride = vbuf.get_stride(0);
+ let pal_off = vbuf.get_offset(1);
+ let data = vbuf.get_data_mut().unwrap();
+
+ for (dline, sline) in data.chunks_mut(stride).zip(self.cur_frame.chunks(self.width)) {
+ dline[..self.width].copy_from_slice(sline);
+ }
+ data[pal_off..][..768].copy_from_slice(&self.pal);
+
+ Ok(ftype)
+ }
+}
+
+struct Data16 {
+ prev_frame: Vec<u16>,
+ cur_frame: Vec<u16>,
+ pal: [u16; 256],
+ width: usize,
+}
+
+impl Data16 {
+ fn new(w: usize, h: usize) -> Self {
+ Self {
+ prev_frame: vec![0; w * h],
+ cur_frame: vec![0; w * h],
+ pal: [0; 256],
+ width: w,
+ }
+ }
+ fn decode(&mut self, br: &mut ByteReader, vbuf: &mut NAVideoBufferRef<u16>) -> DecoderResult<FrameType> {
+ let flags = br.read_u16le()?;
+ let (gmv_x, gmv_y) = if (flags & VB_FLAG_GMC) != 0 {
+ let mvx = br.read_u16le()? as i16;
+ let mvy = br.read_u16le()? as i16;
+ (mvx, mvy)
+ } else {
+ (0, 0)
+ };
+ if (flags & VB_FLAG_AUDIO) != 0 {
+ let asize = br.read_u32le()? as usize;
+ validate!(asize <= (br.left() as usize));
+ br.read_skip(asize - 4)?;
+ }
+ let mut ftype = FrameType::Skip;
+ if (flags & VB_FLAG_VIDEO) != 0 {
+ let vsize = br.read_u32le()? as u64;
+ validate!(vsize > 4);
+ let end = br.tell() + vsize - 4;
+ let has_pal = (flags & VB_FLAG_PALETTE) != 0;
+ if has_pal {
+ let cur_off = br.tell();
+ br.seek(SeekFrom::Current((vsize - 4) as i64))?;
+ let psize = br.read_u32le()? as usize;
+ validate!(psize > 4 && psize <= 0x204 && (psize & 1) == 0);
+ for el in self.pal[..(psize - 4)/ 2].iter_mut() {
+ *el = br.read_u16le()?;
+ }
+ br.seek(SeekFrom::Start(cur_off))?;
+ }
+
+ std::mem::swap(&mut self.cur_frame, &mut self.prev_frame);
+
+ let mut btc = 0;
+ let mut btypes = 0;
+ ftype = FrameType::I;
+ for (row_no, strip) in self.cur_frame.chunks_mut(self.width * 4).enumerate() {
+ for x in (0..self.width).step_by(4) {
+ if btc == 0 {
+ btypes = br.read_byte()?;
+ btc = 4;
+ }
+ match btypes & 0xC0 {
+ 0xC0 => {
+ let t = br.read_byte()?;
+ let mut pattern = VB_PATTERNS[(t & 0x3F) as usize];
+ let op = t >> 6;
+ validate!(op != 3);
+ if op == 0 {
+ let mut clr = [0; 2];
+ if has_pal {
+ clr[0] = self.pal[br.read_byte()? as usize];
+ clr[1] = self.pal[br.read_byte()? as usize];
+ } else {
+ clr[0] = br.read_u16le()?;
+ clr[1] = br.read_u16le()?;
+ }
+ for dline in strip[x..].chunks_mut(self.width).take(4) {
+ for el in dline[..4].iter_mut() {
+ *el = clr[(pattern & 1) as usize];
+ pattern >>= 1;
+ }
+ }
+ } else {
+ if op == 2 {
+ pattern = !pattern;
+ }
+ let clr = if has_pal {
+ self.pal[br.read_byte()? as usize]
+ } else {
+ br.read_u16le()?
+ };
+
+ if let Some(start) = check_size(x, row_no, gmv_x, gmv_y, self.width, self.prev_frame.len()) {
+ for (dline, sline) in strip[x..].chunks_mut(self.width).zip(self.prev_frame[start..].chunks(self.width)).take(4) {
+ for (dst, &src) in dline[..4].iter_mut().zip(sline.iter()) {
+ *dst = if (pattern & 1) != 0 { clr } else { src };
+ pattern >>= 1;
+ }
+ }
+ } else {
+ return Err(DecoderError::InvalidData);
+ }
+ ftype = FrameType::P;
+ }
+ },
+ 0x80 => {
+ let clr = if has_pal {
+ self.pal[br.read_byte()? as usize]
+ } else {
+ br.read_u16le()?
+ };
+ for dline in strip[x..].chunks_mut(self.width).take(4) {
+ for el in dline[..4].iter_mut() {
+ *el = clr;
+ }
+ }
+ },
+ 0x40 => {
+ let mv = br.read_byte()?;
+ if mv == 0 {
+ if has_pal {
+ for dline in strip[x..].chunks_mut(self.width).take(4) {
+ for el in dline[..4].iter_mut() {
+ *el = self.pal[br.read_byte()? as usize];
+ }
+ }
+ } else {
+ for dline in strip[x..].chunks_mut(self.width).take(4) {
+ for el in dline[..4].iter_mut() {
+ *el = br.read_u16le()?;
+ }
+ }
+ }
+ } else {
+ let mvx = (((mv & 0xF) ^ 8) as i16) - 8;
+ let mvy = (((mv >> 4) ^ 8) as i16) - 8;
+ if let Some(start) = check_size(x, row_no, gmv_x + mvx, gmv_y + mvy, self.width, self.prev_frame.len()) {
+ for (dline, sline) in strip[x..].chunks_mut(self.width).zip(self.prev_frame[start..].chunks(self.width)).take(4) {
+ dline[..4].copy_from_slice(&sline[..4]);
+ }
+ } else {
+ return Err(DecoderError::InvalidData);
+ }
+ ftype = FrameType::P;
+ }
+ },
+ _ => {
+ if let Some(start) = check_size(x, row_no, gmv_x, gmv_y, self.width, self.prev_frame.len()) {
+ for (dline, sline) in strip[x..].chunks_mut(self.width).zip(self.prev_frame[start..].chunks(self.width)).take(4) {
+ dline[..4].copy_from_slice(&sline[..4]);
+ }
+ } else {
+ return Err(DecoderError::InvalidData);
+ }
+ ftype = FrameType::P;
+ },
+ }
+
+ btypes <<= 2;
+ btc -= 1;
+ }
+ }
+ validate!(br.tell() == end);
+ }
+ if (flags & VB_FLAG_PALETTE) != 0 {
+ let psize = br.read_u32le()? as usize;
+ br.read_skip(psize - 4)?;
+ }
+
+ let stride = vbuf.get_stride(0);
+ let data = vbuf.get_data_mut().unwrap();
+
+ for (dline, sline) in data.chunks_mut(stride).zip(self.cur_frame.chunks(self.width)) {
+ dline[..self.width].copy_from_slice(sline);
+ }
+
+ Ok(ftype)
+ }
+}
+
+enum FrameData {
+ Old(OldData),
+ Pal(Data8),
+ New(Data16),
+ None,
+}
+
+struct BeamVideoDecoder {
+ info: NACodecInfoRef,
+ data: FrameData,
+ fcp: bool,
+}
+
+impl BeamVideoDecoder {
+ fn new(fcp: bool) -> Self {
+ Self {
+ info: NACodecInfoRef::default(),
+ data: FrameData::None,
+ fcp,
+ }
+ }
+}
+
+impl NADecoder for BeamVideoDecoder {
+ fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
+ if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
+ let width = vinfo.get_width();
+ let height = vinfo.get_height();
+ validate!((width & 3) == 0 && (height & 3) == 0);
+ let fmt = match vinfo.bits {
+ _ if self.fcp => {
+ let edata = info.get_extradata();
+ validate!(edata.is_some());
+ let edata = edata.unwrap();
+ validate!(edata.len() >= 2);
+ let flags = read_u16le(&edata)?;
+ self.data = FrameData::Old(OldData::new(width, height, flags));
+ PAL8_FORMAT
+ },
+ 8 => {
+ self.data = FrameData::Pal(Data8::new(width, height));
+ PAL8_FORMAT
+ },
+ 16 => {
+ self.data = FrameData::New(Data16::new(width, height));
+ RGB555_FORMAT
+ },
+ _ => return Err(DecoderError::InvalidData),
+ };
+
+ let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(vinfo.get_width(), vinfo.get_height(), false, fmt));
+ self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
+
+ Ok(())
+ } else {
+ Err(DecoderError::InvalidData)
+ }
+ }
+ fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
+ let src = pkt.get_buffer();
+ validate!(src.len() > 1);
+
+ let mut mr = MemoryReader::new_read(&src);
+ let mut br = ByteReader::new(&mut mr);
+
+ let mut bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 0)?;
+
+ let ftype = match (&mut self.data, &mut bufinfo) {
+ (FrameData::Old(ref mut data), NABufferType::Video(ref mut vbuf)) => data.decode(&mut br, vbuf)?,
+ (FrameData::Pal(ref mut data), NABufferType::Video(ref mut vbuf)) => data.decode(&mut br, vbuf)?,
+ (FrameData::New(ref mut data), NABufferType::Video16(ref mut vbuf)) => data.decode(&mut br, vbuf)?,
+ _ => unreachable!(),
+ };
+
+ let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
+ frm.set_keyframe(ftype == FrameType::I);
+ frm.set_frame_type(ftype);
+ Ok(frm.into_ref())
+ }
+ fn flush(&mut self) {
+ }
+}
+
+impl NAOptionHandler for BeamVideoDecoder {
+ fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
+ fn set_options(&mut self, _options: &[NAOption]) { }
+ fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
+}
+
+pub fn get_decoder_vbv() -> Box<dyn NADecoder + Send> {
+ Box::new(BeamVideoDecoder::new(false))
+}
+
+pub fn get_decoder_fcp() -> Box<dyn NADecoder + Send> {
+ Box::new(BeamVideoDecoder::new(true))
+}
+
+#[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;
+ #[test]
+ fn test_beam_fcp() {
+ 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);
+
+ // sample from The Dame was Loaded
+ test_decoding("siff", "beam-fcp", "assets/Game/siff/BEAM.FCP", Some(1000), &dmx_reg, &dec_reg,
+ ExpectedTestResult::MD5Frames(vec![
+ [0xa31342c0, 0x7afe5a76, 0x4111f17a, 0x30ec3a18],
+ [0xa31342c0, 0x7afe5a76, 0x4111f17a, 0x30ec3a18],
+ [0xa31342c0, 0x7afe5a76, 0x4111f17a, 0x30ec3a18],
+ [0xa31342c0, 0x7afe5a76, 0x4111f17a, 0x30ec3a18],
+ [0xa31342c0, 0x7afe5a76, 0x4111f17a, 0x30ec3a18],
+ [0x447870bf, 0x9bb22dab, 0x1f557dae, 0xc41575ad],
+ [0xeb3bd749, 0xc72811d3, 0x23d430b2, 0xc31dbd85],
+ [0x34bb16b4, 0x8e6066fe, 0xf3f6170a, 0xae4ec54e],
+ [0xee12f3ff, 0x4000ed43, 0x446336d7, 0x6cc344bf],
+ [0xfe6ba9e1, 0xcc97f503, 0xf6fc8f14, 0x40c334c0],
+ [0xb4229527, 0x8591ac0b, 0x1ba40ea8, 0x15aa5710]]));
+ }
+ #[test]
+ fn test_beam_video_8bit() {
+ 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);
+
+ // sample from Lost Vikings 2
+ test_decoding("siff", "beam-video", "assets/Game/siff/BEAM.VB", Some(1000), &dmx_reg, &dec_reg,
+ ExpectedTestResult::MD5Frames(vec![
+ [0x23604e03, 0x5781ea8a, 0x6b28d338, 0xc32d52d6],
+ [0xba68d1af, 0xacf630b7, 0x3899073d, 0x07135315],
+ [0xb10cd159, 0xd787a566, 0x523123ca, 0x8a757f9e],
+ [0x7f4dfb53, 0x581884ab, 0x71de61c0, 0xfec72a11],
+ [0xc2a40282, 0x729548e1, 0xc63211bf, 0x586158fc],
+ [0xb8bf753c, 0x53686fb2, 0x7d307625, 0xdab70698],
+ [0xa2e90475, 0x076ef58a, 0xe2276941, 0x9c47ca14],
+ [0x80f785df, 0x19e015ab, 0x93beaf9b, 0xff1d0907],
+ [0x957a9a60, 0xc8a8ae09, 0xad5ecf6c, 0x06097f03],
+ [0xdfd331d4, 0x2f6ba92b, 0x5bfcb6f8, 0x85bab2b9],
+ [0xf37d42c1, 0x7f54d6bd, 0xc2dca688, 0x60d64e8c],
+ [0x97a0e18b, 0xce9ea101, 0x56eea57c, 0xeb48e8b3],
+ [0x7043048c, 0x373fdf9d, 0x1b27d5b3, 0x3e4e9c7a]]));
+ }
+ #[test]
+ fn test_beam_video_16bit() {
+ 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);
+
+ // sample from Alien Earth
+ test_decoding("siff", "beam-video", "assets/Game/siff/beamlogo.vbc", Some(500), &dmx_reg, &dec_reg,
+ ExpectedTestResult::MD5Frames(vec![
+ [0x90aeded9, 0x922cf894, 0x6ea78586, 0x35493724],
+ [0x90aeded9, 0x922cf894, 0x6ea78586, 0x35493724],
+ [0xa19daf5e, 0xa4858d72, 0x6700fc4d, 0x95c5e5dd],
+ [0x57d556af, 0x95c5c5f4, 0xe943f1e3, 0xb86941e1],
+ [0xa63351ae, 0x12ed21ee, 0x7246d1f4, 0xf3a5a79a],
+ [0x5930e388, 0x4891d37b, 0x619ea7ff, 0xc8dac16d],
+ [0x36eeaf75, 0x767e5e5e, 0x397e0100, 0xfa306811],
+ [0xb4722a6d, 0x61cc8483, 0xe4966f11, 0xa67cd0f4],
+ [0x62be7367, 0xcbeb77b2, 0xcb438480, 0xda39b47a],
+ [0x568b020d, 0x4992bc7f, 0xcbe20b5c, 0x697a35bc],
+ [0x35e5a6a8, 0x903c0d07, 0xbacf7734, 0xd1c54b6d],
+ [0xd3450588, 0xfae0a9ec, 0x72a8fce6, 0x7c57e3c1],
+ [0x90f0cc47, 0xd7e7d3ef, 0x46d81b4d, 0xf4495aa2]]));
+ }
+}
+
+const VB_PATTERNS: [u16; 64] = [
+ 0x0660, 0xFF00, 0xCCCC, 0xF000, 0x8888, 0x000F, 0x1111, 0xFEC8,
+ 0x8CEF, 0x137F, 0xF731, 0xC800, 0x008C, 0x0013, 0x3100, 0xCC00,
+ 0x00CC, 0x0033, 0x3300, 0x0FF0, 0x6666, 0x00F0, 0x0F00, 0x2222,
+ 0x4444, 0xF600, 0x8CC8, 0x006F, 0x1331, 0x318C, 0xC813, 0x33CC,
+ 0x6600, 0x0CC0, 0x0066, 0x0330, 0xF900, 0xC88C, 0x009F, 0x3113,
+ 0x6000, 0x0880, 0x0006, 0x0110, 0xCC88, 0xFC00, 0x00CF, 0x88CC,
+ 0x003F, 0x1133, 0x3311, 0xF300, 0x6FF6, 0x0603, 0x08C6, 0x8C63,
+ 0xC631, 0x6310, 0xC060, 0x0136, 0x136C, 0x36C8, 0x6C80, 0x324C
+];
--- /dev/null
+use nihav_core::frame::*;
+use nihav_core::demuxers::*;
+
+const DEFAULT_FCP_DELAY: u64 = 100;
+const DEFAULT_VBV_DELAY: u64 = 80;
+
+#[derive(Clone,Copy,Debug,PartialEq)]
+enum SIFFType {
+ None,
+ FCP,
+ VBV,
+ Sound,
+}
+
+struct SIFFDemuxer<'a> {
+ src: &'a mut ByteReader<'a>,
+ subtype: SIFFType,
+ size: u32,
+ ablock: usize,
+ nframes: usize,
+ cframe: usize,
+ vpts: u64,
+ abuf: Vec<u8>,
+ apts: u64,
+ ver: u8,
+}
+
+impl<'a> SIFFDemuxer<'a> {
+ fn new(io: &'a mut ByteReader<'a>) -> Self {
+ Self {
+ src: io,
+ subtype: SIFFType::None,
+ size: 0,
+ ablock: 0,
+ nframes: 0,
+ cframe: 0,
+ vpts: 0,
+ abuf: Vec::new(),
+ apts: 0,
+ ver: 0,
+ }
+ }
+
+ fn parse_fcp_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
+ let tag = self.src.read_tag()?;
+ validate!(&tag == b"FCHD");
+ let hdr_size = self.src.read_u32be()? as usize;
+ validate!(hdr_size >= 16);
+ let mut flags = vec![0; 2];
+ self.src.read_buf(&mut flags)?;
+ let width = self.src.read_u16le()? as usize;
+ let height = self.src.read_u16le()? as usize;
+ validate!(width > 0 && height > 0);
+ self.nframes = self.src.read_u16le()? as usize;
+ self.src.read_skip(8)?;
+ self.src.read_skip(hdr_size - 16)?;
+
+ let vhdr = NAVideoInfo::new(width, height, false, PAL8_FORMAT);
+ let vci = NACodecTypeInfo::Video(vhdr);
+ let vinfo = NACodecInfo::new("beam-fcp", vci, Some(flags));
+ if strmgr.add_stream(NAStream::new(StreamType::Video, 0, vinfo, 1, 1000, self.nframes as u64 * DEFAULT_FCP_DELAY)).is_none() {
+ return Err(DemuxerError::MemoryError);
+ }
+
+ self.ablock = 1;
+ let srate = 22050;
+ let ahdr = NAAudioInfo::new(srate, 1, SND_U8_FORMAT, 1);
+ let ainfo = NACodecInfo::new("pcm", NACodecTypeInfo::Audio(ahdr), None);
+ if strmgr.add_stream(NAStream::new(StreamType::Audio, 1, ainfo, 1, srate, 0)).is_none() {
+ return Err(DemuxerError::MemoryError);
+ }
+
+ self.vpts = 0;
+ self.apts = 0;
+ self.cframe = 0;
+
+ Ok(())
+ }
+ fn get_fcp_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
+ if self.cframe >= self.nframes {
+ return Err(DemuxerError::EOF);
+ }
+ let size = self.src.read_u16le()? as usize;
+ validate!(size > 8);
+ let stream = strmgr.get_stream(0).unwrap();
+ let (tb_num, tb_den) = stream.get_timebase();
+ let ts = NATimeInfo::new(Some(self.vpts), None, None, tb_num, tb_den);
+ let kframe = self.vpts == 0;
+ self.cframe += 1;
+ let pkt = self.src.read_packet(stream, ts, kframe, size - 2)?;
+ let buf = pkt.get_buffer();
+
+ let mut mr = MemoryReader::new_read(buf.as_slice());
+ let mut br = ByteReader::new(&mut mr);
+ let asize = br.read_u16le()? as usize;
+ let duration = br.read_u16le()? as u64;
+ validate!(asize < buf.len());
+ if asize > 0 {
+ let nclrs = br.read_u16le()? as usize;
+ if nclrs > 0 {
+ br.read_skip(nclrs * 3 + 2)?;
+ }
+ self.abuf.resize(asize, 0);
+ br.read_buf(&mut self.abuf)?;
+ }
+
+ if duration > 0 {
+ self.vpts += duration;
+ } else {
+ self.vpts += DEFAULT_FCP_DELAY;
+ }
+
+ Ok(pkt)
+ }
+
+ fn parse_vbv_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
+ let tag = self.src.read_tag()?;
+ validate!(&tag == b"VBHD");
+ let hdr_size = self.src.read_u32be()? as usize;
+ validate!(hdr_size >= 32);
+ let version = self.src.read_u16le()?;
+ validate!(version == 1 || version == 2);
+ self.ver = version as u8;
+ let width = self.src.read_u16le()? as usize;
+ let height = self.src.read_u16le()? as usize;
+ validate!(width > 0 && height > 0);
+ self.src.read_skip(4)?;
+ self.nframes = self.src.read_u16le()? as usize;
+ let flags = self.src.read_u16le()?;
+ let bits = flags as u8;
+ let channels = if (flags & 0x100) != 0 { 2 } else { 1 };
+ validate!(bits == 0 || bits >= 8);
+ let srate = self.src.read_u16le()? as u32;
+ self.ablock = (bits as usize) * (channels as usize) / 8;
+ self.src.read_skip(16)?;
+ self.src.read_skip(hdr_size - 32)?;
+
+ let mut vhdr = NAVideoInfo::new(width, height, false, if version == 1 { PAL8_FORMAT } else { RGB565_FORMAT });
+ vhdr.bits = version as u8 * 8;
+ let vci = NACodecTypeInfo::Video(vhdr);
+ let vinfo = NACodecInfo::new("beam-video", vci, None);
+ if strmgr.add_stream(NAStream::new(StreamType::Video, 0, vinfo, 1, 1000, self.nframes as u64 * DEFAULT_VBV_DELAY)).is_none() {
+ return Err(DemuxerError::MemoryError);
+ }
+
+ if srate > 0 && bits > 0 {
+ let ahdr = NAAudioInfo::new(srate, channels, if bits == 8 { SND_U8_FORMAT } else { SND_S16_FORMAT }, self.ablock);
+ let ainfo = NACodecInfo::new("pcm", NACodecTypeInfo::Audio(ahdr), None);
+ if strmgr.add_stream(NAStream::new(StreamType::Audio, 1, ainfo, 1, srate, 0)).is_none() {
+ return Err(DemuxerError::MemoryError);
+ }
+ }
+
+ self.vpts = 0;
+ self.apts = 0;
+ self.cframe = 0;
+
+ Ok(())
+ }
+ fn get_vbv_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
+ if self.cframe >= self.nframes {
+ return Err(DemuxerError::EOF);
+ }
+ let size = self.src.read_u32le()? as usize;
+ validate!(size > 6);
+ let stream = strmgr.get_stream(0).unwrap();
+ let (tb_num, tb_den) = stream.get_timebase();
+ let ts = NATimeInfo::new(Some(self.vpts), None, None, tb_num, tb_den);
+ let kframe = self.vpts == 0;
+ self.cframe += 1;
+ let pkt = self.src.read_packet(stream, ts, kframe, size - 4)?;
+ let buf = pkt.get_buffer();
+
+ let mut mr = MemoryReader::new_read(buf.as_slice());
+ let mut br = ByteReader::new(&mut mr);
+ let flags = br.read_u16le()?;
+ if (flags & 0x01) != 0 {
+ br.read_skip(4)?;
+ }
+ if (flags & 0x04) != 0 {
+ let asize = br.read_u32le()? as usize;
+ validate!((asize > 4) && asize < (buf.len() - (br.tell() as usize)));
+ self.abuf.resize(asize - 4, 0);
+ br.read_buf(&mut self.abuf)?;
+ }
+ if (flags & 0x08) != 0 {
+ let vsize = br.read_u32le()? as usize;
+ validate!(vsize > 4);
+ br.read_skip(vsize - 4)?;
+ }
+ if (flags & 0x10) != 0 {
+ let psize = br.read_u32le()? as usize;
+ validate!(psize > 4);
+ br.read_skip(psize - 4)?;
+ }
+ let delay = if (flags & 0x20) != 0 {
+ br.read_u16le()? as u64
+ } else { 0 };
+ self.vpts += if delay > 0 { delay } else { DEFAULT_VBV_DELAY };
+
+ Ok(pkt)
+ }
+
+ fn parse_snd_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
+ let tag = self.src.read_tag()?;
+ validate!(&tag == b"SHDR");
+ let hdr_size = self.src.read_u32be()? as usize;
+ validate!(hdr_size >= 8);
+ let snd_size = self.src.read_u32le()?;
+ let srate = self.src.read_u16le()? as u32;
+ let flags = self.src.read_u16le()?;
+ let bits = flags as u8;
+ validate!(bits >= 8);
+ let channels = if (flags & 0x100) != 0 { 2 } else { 1 };
+ self.ablock = (bits as usize) * (channels as usize);
+ self.src.read_skip(hdr_size - 8)?;
+
+ let duration = u64::from(snd_size) / u64::from(channels) * 8 / u64::from(bits);
+
+ let fmt = match bits {
+ 8 => SND_U8_FORMAT,
+ 16 => SND_S16_FORMAT,
+ 12 => NASoniton::new(12, SONITON_FLAG_PACKED | SONITON_FLAG_SIGNED),
+ _ => return Err(DemuxerError::NotImplemented),
+ };
+ let ahdr = NAAudioInfo::new(srate, channels, fmt, self.ablock);
+ let ainfo = NACodecInfo::new("pcm", NACodecTypeInfo::Audio(ahdr), None);
+ if strmgr.add_stream(NAStream::new(StreamType::Audio, 0, ainfo, 1, srate, duration)).is_none() {
+ return Err(DemuxerError::MemoryError);
+ }
+
+ Ok(())
+ }
+ fn get_snd_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
+ if self.size == 0 {
+ return Err(DemuxerError::EOF);
+ }
+ let cur_size = self.size.min(1024 * (self.ablock as u32));
+
+ let stream = strmgr.get_stream(0).unwrap();
+ let (tb_num, tb_den) = stream.get_timebase();
+ let ts = NATimeInfo::new(None, None, None, tb_num, tb_den);
+ let pkt = self.src.read_packet(stream, ts, true, cur_size as usize)?;
+ self.size -= cur_size;
+
+ Ok(pkt)
+ }
+}
+
+impl<'a> DemuxCore<'a> for SIFFDemuxer<'a> {
+ fn open(&mut self, strmgr: &mut StreamManager, _seek_index: &mut SeekIndex) -> DemuxerResult<()> {
+ let magic = self.src.read_tag()?;
+ validate!(&magic == b"SIFF");
+ self.size = self.src.read_u32be()?;
+ let tag = self.src.read_tag()?;
+ self.subtype = match &tag {
+ b"FCPK" => SIFFType::FCP,
+ b"VBV1" => SIFFType::VBV,
+ b"SOUN" => SIFFType::Sound,
+ _ => return Err(DemuxerError::NotImplemented),
+ };
+
+ match self.subtype {
+ SIFFType::FCP => self.parse_fcp_header(strmgr)?,
+ SIFFType::VBV => self.parse_vbv_header(strmgr)?,
+ SIFFType::Sound => self.parse_snd_header(strmgr)?,
+ _ => unreachable!(),
+ };
+
+ let tag = self.src.read_tag()?;
+ validate!(&tag == b"BODY");
+ let body_size = self.src.read_u32be()?;
+ validate!(self.src.tell() + u64::from(body_size) <= u64::from(self.size) + 8);
+ self.size = body_size;
+
+ Ok(())
+ }
+
+ fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
+ if !self.abuf.is_empty() {
+ let mut buf = Vec::new();
+ std::mem::swap(&mut buf, &mut self.abuf);
+
+ if let Some(stream) = strmgr.get_stream(1) {
+ let (tb_num, tb_den) = stream.get_timebase();
+ let ts = NATimeInfo::new(Some(self.apts), None, None, tb_num, tb_den);
+ self.apts += (buf.len() / self.ablock) as u64;
+ return Ok(NAPacket::new(stream, ts, true, buf));
+ }
+ }
+ match self.subtype {
+ SIFFType::FCP => self.get_fcp_frame(strmgr),
+ SIFFType::VBV => self.get_vbv_frame(strmgr),
+ SIFFType::Sound => self.get_snd_frame(strmgr),
+ _ => unreachable!(),
+ }
+ }
+
+ fn seek(&mut self, _time: NATimePoint, _seek_index: &SeekIndex) -> DemuxerResult<()> {
+ Err(DemuxerError::NotPossible)
+ }
+ fn get_duration(&self) -> u64 { 0 }
+}
+
+impl<'a> NAOptionHandler for SIFFDemuxer<'a> {
+ fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
+ fn set_options(&mut self, _options: &[NAOption]) { }
+ fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
+}
+
+pub struct SIFFDemuxerCreator { }
+
+impl DemuxerCreator for SIFFDemuxerCreator {
+ fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
+ Box::new(SIFFDemuxer::new(br))
+ }
+ fn get_name(&self) -> &'static str { "siff" }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use std::fs::File;
+
+ fn test_siff_demux(name: &str) {
+ let mut file = File::open(name).unwrap();
+ let mut fr = FileReader::new_read(&mut file);
+ let mut br = ByteReader::new(&mut fr);
+ let mut dmx = SIFFDemuxer::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_siff_demux_fcp() {
+ // sample from The Dame was Loaded game
+ test_siff_demux("assets/Game/siff/BEAM.FCP");
+ }
+ #[test]
+ fn test_siff_demux_anim_8bit() {
+ // sample from Lost Vikings 2 game
+ test_siff_demux("assets/Game/siff/BEAM.VB");
+ }
+ #[test]
+ fn test_siff_demux_anim_16bit() {
+ // sample from Alien Earth game
+ test_siff_demux("assets/Game/siff/beamlogo.vbc");
+ }
+ #[test]
+ fn test_siff_demux_snd() {
+ // sample from The Dame was Loaded game
+ test_siff_demux("assets/Game/siff/01AFIRST.SON");
+ // sample from Lost Vikings 2 game
+ test_siff_demux("assets/Game/siff/01THEME.SON");
+ }
+}
projects / nihav.git / commitdiff