path: root/nihav-rad/src/codecs/binkaudenc.rs

use std::collections::VecDeque;

use nihav_core::codecs::*;
use nihav_core::io::bitwriter::*;
use nihav_codec_support::dsp::dct::*;
use nihav_codec_support::dsp::fft::*;
use super::binkauddata::*;

trait WriteBinkFloat {
    fn write_float(&mut self, val: f32);
}

impl WriteBinkFloat for BitWriter {
    fn write_float(&mut self, val: f32) {
        let bits = val.to_bits();
        let sign = bits >> 31;
        let nexp = ((bits >> 23).wrapping_sub(0x7E)) & 0x1F;
        let mant = bits & ((1 << 23) - 1);
        self.write(nexp, 5);
        self.write(mant, 23);
        self.write(sign, 1);
    }
}

#[derive(Default)]
struct RateControl {
    quality:        u8,
    bitrate:        u32,
    bitpool:        u32,
    spos:           u32,
    srate:          u32,
    blk_size:       u32,
    lambda:         f32,
}

impl RateControl {
    fn init(&mut self, quality: u8, bitrate: u32, srate: u32, blk_size: u32) {
        self.quality  = quality;
        self.bitrate  = bitrate;
        self.bitpool  = bitrate;
        self.srate    = srate;
        self.spos     = 0;
        self.blk_size = blk_size;
        self.lambda   = if self.quality != 0 {
                ((100 - self.quality) as f32) / 20.0
            } else {
                1.0
            };
    }
    fn get_tgt_size(&self) -> usize {
        if self.bitrate > 0 {
            (self.bitpool * self.blk_size / (self.srate - self.spos)) as usize
        } else {
            0
        }
    }
    fn update(&mut self, real_size: usize) {
        if self.bitrate == 0 {
            return;
        }

        let tgt_size = self.get_tgt_size();

        if real_size < tgt_size - tgt_size / 8 {
            self.lambda -= 0.2;
            if self.lambda < 0.0 {
                self.lambda = 0.0;
            }
        }
        if real_size > tgt_size + tgt_size / 8 {
            self.lambda += 0.5;
        }

        self.spos += self.blk_size;
        while self.spos >= self.srate {
            self.spos -= self.srate;
            self.bitpool += self.bitrate;
        }
        self.bitpool = self.bitpool.saturating_sub(real_size as u32);
    }
}

#[derive(Default)]
struct SampleBuffer {
    samples:        Vec<f32>,
    read_pos:       usize,
    frame_len:      usize,
    step_size:      usize,
}

impl SampleBuffer {
    fn reset(&mut self) {
        self.samples.clear();
        self.read_pos = 0;
    }
    fn num_avail(&self) -> usize { self.samples.len() - self.read_pos }
    fn add_mono(&mut self, src: &[f32]) {
        self.samples.extend_from_slice(src);
    }
    fn add_stereo(&mut self, left: &[f32], right: &[f32]) {
        for (&l, &r) in left.iter().zip(right.iter()) {
            self.samples.push(l);
            self.samples.push(r);
        }
    }
    fn norm(&mut self) {
        if self.read_pos == self.samples.len() {
            self.read_pos = 0;
            self.samples.clear();
        } else if self.read_pos * 2 >= self.samples.len() {
            let len = self.num_avail();
            let (head, tail) = self.samples.split_at_mut(self.read_pos);
            head[..tail.len()].copy_from_slice(tail);
            self.read_pos = 0;
            self.samples.truncate(len);
        }
    }
    fn read_frame(&self, dst: &mut [f32]) {
        let src = &self.samples[self.read_pos..];
        let len = dst.len().min(src.len()).min(self.frame_len);
        dst[..len].copy_from_slice(&src[..len]);
        let ovl_len = self.frame_len - self.step_size;
        for (i, sample) in dst[..ovl_len].iter_mut().enumerate() {
            *sample *= (i as f32) / (ovl_len as f32);
        }
        for (i, sample) in dst[self.step_size..][..ovl_len].iter_mut().rev().enumerate() {
            *sample *= (i as f32) / (ovl_len as f32);
        }
    }
    fn consume_frame(&mut self) {
        self.read_pos += self.step_size;
        if self.read_pos > self.samples.len() {
            self.read_pos = self.samples.len();
        }
        self.norm();
    }
}

fn find_quant(src: &[f32], quants: &[f32; 96], lambda: f32) -> usize {
    let maxval = src.iter().fold(0.0f32, |acc, &a| acc.max(a.abs()));

    let mut best = 0;
    let mut best_dist = maxval * maxval * (src.len() as f32);
    for (i, &q) in quants.iter().enumerate() {
        if maxval / q > 32767.0 { continue; }
        if q > maxval * 2.0 { break; }
        let mut dist = 0.0;
        let mut maxqv = 0.0f32;
        let mut signs = 0u32;
        for &el in src.iter() {
            let qval = (el.abs() / q).round();
            let iqval = qval * q;
            dist += (el.abs() - iqval) * (el.abs() - iqval);
            maxqv = maxqv.max(qval);
            if qval > 0.0 {
                signs += 1;
            }
        }
        let bits = if maxqv > 0.0 {
                maxqv.log2().ceil() * (src.len() as f32) + (signs as f32)
            } else { 0.0 };
        let metric = (dist + 1.0).log2() * 10.0 + bits * lambda;
        if metric < best_dist {
            best_dist = metric;
            best = i;
        }
    }
    best
}

enum Transform {
    None,
    DCT(DCT),
    RDFT(RDFT),
}

struct BinkAudioEncoder {
    stream:         Option<NAStreamRef>,
    version:        char,
    stereo:         bool,

    frm_size:       usize,
    frame_bits:     u8,
    overlap_size:   usize,

    apts:           u64,
    use_dct:        bool,
    preload:        usize,

    samples:        SampleBuffer,
    transform:      Transform,
    scale:          f32,
    quants:         [f32; 96],
    num_bands:      usize,
    bands:          [usize; MAX_BANDS + 1],
    first_frame:    bool,
    sample_step:    usize,
    leftover:       usize,

    tmp:            Vec<f32>,

    packets:        VecDeque<NAPacket>,
    rc:             RateControl,

    print_stats:    bool,
    blk_bits:       usize,
    nblks:          usize,
    nsamples:       usize,
    nframes:        usize,
    qstats:         [usize; 96],
    bstats:         [usize; 16],
}

impl BinkAudioEncoder {
    fn new(use_dct: bool) -> Self {
        Self {
            stream:         None,
            version:        'b',
            stereo:         false,

            frm_size:       0,
            frame_bits:     0,
            overlap_size:   0,

            apts:           0,
            use_dct,
            preload:        16,

            samples:        SampleBuffer::default(),
            transform:      Transform::None,
            scale:          0.0,
            quants:         get_quants_table(),
            num_bands:      0,
            bands:          [0; MAX_BANDS + 1],
            first_frame:    true,
            sample_step:    0,
            leftover:       0,

            tmp:            Vec::new(),

            packets:        VecDeque::new(),
            rc:             RateControl::default(),

            print_stats:    false,
            blk_bits:       0,
            nblks:          0,
            nsamples:       0,
            nframes:        0,
            qstats:         [0; 96],
            bstats:         [0; 16],
        }
    }
    #[allow(clippy::transmute_ptr_to_ptr)]
    fn encode_block(&mut self, bw: &mut BitWriter) {
        match self.transform {
            Transform::None => unreachable!(),
            Transform::DCT(ref mut _dct) => unimplemented!(),
            Transform::RDFT(ref mut rdft) => {
                unsafe {
                    let buf = std::mem::transmute::<&mut [f32], &mut [FFTComplex]>(self.tmp.as_mut_slice());
                    rdft.do_rdft_inplace(buf);
                }
            },
        };
        for el in self.tmp.iter_mut() {
            *el *= self.samples.frame_len as f32;
        }
        if self.version == 'b' {
            bw.write(self.tmp[0].to_bits(), 32);
            bw.write(self.tmp[1].to_bits(), 32);
        } else {
            bw.write_float(self.tmp[0]);
            bw.write_float(self.tmp[1]);
        }

        let mut quants = [0; MAX_BANDS];
        for (range, quant) in self.bands.windows(2).take(self.num_bands).zip(quants.iter_mut()) {
            let region = &mut self.tmp[range[0]..range[1]];
            *quant = find_quant(region, &self.quants, self.rc.lambda);
            for el in region.iter_mut() {
                *el /= self.quants[*quant];
            }
        }

        let mut rec_bits = [0u8; 4096];
        for (bval, &coef) in rec_bits.iter_mut().zip(self.tmp.iter()).skip(2) {
            let aval = coef.abs().round() as u32;
            *bval = if aval > 0 { (32 - aval.leading_zeros()) as u8 } else { 0 };
        }

        for &quant in quants[..self.num_bands].iter() {
            self.qstats[quant] += 1;
        }

        for &quant in quants[..self.num_bands].iter() {
            bw.write(quant as u32, 8);
        }
        if self.version == 'b' {
            for (coef_reg, bits_reg) in self.tmp[2..].chunks(16).zip(rec_bits[2..].chunks(16)) {
                let max_bits = bits_reg.iter().fold(0u8, |acc, &a| acc.max(a)).min(15);
                bw.write(u32::from(max_bits), 4);
                self.bstats[usize::from(max_bits)] += coef_reg.len();
                if max_bits != 0 {
                    for &coef in coef_reg.iter() {
                        let bval = (coef.abs().round() as u32).min((1 << max_bits) - 1);
                        bw.write(bval, max_bits);
                        if bval != 0 {
                            bw.write_bit(coef < 0.0);
                        }
                    }
                }
            }
        } else {
            unimplemented!();
        }
    }
    fn encode_packet(&mut self, last: bool) -> EncoderResult<bool> {
        let nsamples = if last {
                self.samples.num_avail()
            } else if self.first_frame {
                self.preload.max(1) * self.frm_size * if self.stereo { 2 } else { 1 }
            } else {
                (self.leftover + self.sample_step) * if self.stereo { 2 } else { 1 }
            };

        let nblocks = if !last {
                let nblk = (nsamples / self.frm_size).max(1);
                if self.samples.num_avail() < nblk * self.frm_size + self.overlap_size {
                    return Ok(false);
                }
                self.leftover = (self.leftover + self.sample_step) % self.frm_size;
                nblk
            } else {
                (nsamples + self.frm_size - 1) / self.frm_size
            };
        let nsamples = if !last { nblocks * self.frm_size } else { nsamples };

        self.nsamples += nsamples >> (self.stereo as u8);
        self.nframes += 1;

        let mut bw = BitWriter::new(Vec::new(), BitWriterMode::LE);
        bw.write((nsamples * 2) as u32, 32); // number of raw audio bytes

        for _nblk in 0..nblocks {
            let start = bw.tell();

            if last {
                for el in self.tmp.iter_mut() {
                    *el = 0.0;
                }
            }
            self.samples.read_frame(&mut self.tmp);
            self.encode_block(&mut bw);
            while (bw.tell() & 0x1F) != 0 {
                bw.write0();
            }
            self.samples.consume_frame();

            let blk_bits = bw.tell() - start;
            self.rc.update(blk_bits);
            self.blk_bits += blk_bits;
            self.nblks += 1;
        }

        if self.first_frame {
            self.first_frame = false;
        }

        let dbuf = bw.end();
        let stream = self.stream.clone().unwrap();
        let (tb_num, tb_den) = stream.get_timebase();
        let ts = NATimeInfo::new(Some(self.apts), None, Some(nsamples as u64), tb_num, tb_den);
        self.apts += (nsamples / if self.stereo { 2 } else { 1 }) as u64;
        self.packets.push_back(NAPacket::new(self.stream.clone().unwrap(), ts, true, dbuf));

        Ok(true)
    }
}

impl NAEncoder for BinkAudioEncoder {
    fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
        match encinfo.format {
            NACodecTypeInfo::None => {
                Ok(EncodeParameters {
                    format: NACodecTypeInfo::Audio(NAAudioInfo::new(0, 1, SND_F32P_FORMAT, 512)),
                    ..Default::default() })
            },
            NACodecTypeInfo::Video(_) => Err(EncoderError::FormatError),
            NACodecTypeInfo::Audio(ainfo) => {
                let mut outinfo = ainfo;
                outinfo.channels = if !self.use_dct { 2 } else { ainfo.channels.min(2).max(1) };
                outinfo.format = SND_F32P_FORMAT;
                let mut ofmt = *encinfo;
                ofmt.format = NACodecTypeInfo::Audio(outinfo);
                Ok(ofmt)
            }
        }
    }
    fn get_capabilities(&self) -> u64 { ENC_CAPS_CBR }
    fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> {
        match encinfo.format {
            NACodecTypeInfo::None => Err(EncoderError::FormatError),
            NACodecTypeInfo::Video(_) => Err(EncoderError::FormatError),
            NACodecTypeInfo::Audio(ainfo) => {
                if ainfo.format != SND_F32P_FORMAT {
                    return Err(EncoderError::FormatError);
                }

                let srate = ainfo.get_sample_rate();
                let mut frame_bits = if srate < 22050 { 9 } else if srate < 44100 { 10 } else { 11 };

                if self.version < 'i' && self.use_dct {
                    println!("DCT is supported starting from version 'i'");
                    return Err(EncoderError::FormatError);
                }

                if !self.use_dct && self.version != 'b' {
                    frame_bits += 1;
                }
                self.frame_bits = frame_bits;
                self.stereo = ainfo.channels == 2;
                let mut duration = (1 << frame_bits) - (1 << (frame_bits - 4));
                let single = !self.use_dct && self.stereo; // RDFT codes samples interleaved as single buffer
                if single {
                    duration >>= 1;
                }

                self.transform = if !self.use_dct {
                        Transform::RDFT(RDFTBuilder::new_rdft(1 << (frame_bits - 1), true, false))
                    } else {
                        Transform::DCT(DCT::new(DCTMode::DCT_II, 1 << frame_bits))
                    };
                self.scale = if !self.use_dct {
                        1.0 / (32768.0 * ((1 << frame_bits) as f32).sqrt())
                    } else {
                        (2.0 / ((1 << frame_bits) as f32)).sqrt() / 1024.0
                    };
                let s_srate = if single { srate } else { srate >> 1 } as usize;
                init_bands(s_srate, 1 << frame_bits, &mut self.num_bands, &mut self.bands);
                self.first_frame = true;

                self.samples.reset();
                self.samples.frame_len = 1 << frame_bits;
                self.samples.step_size = duration * usize::from(ainfo.channels);
                self.frm_size = duration * usize::from(ainfo.channels);
                self.overlap_size = self.frm_size / 15;
                self.tmp = vec![0.0; 1 << frame_bits];

                let blk_len = ((1 << frame_bits) - (1 << (frame_bits - 4))) >> if self.stereo { 1 } else { 0 };
                self.rc.init(encinfo.quality, encinfo.bitrate, srate, blk_len as u32);

                let edata = vec![b'B', b'I', b'K', self.version as u8];

                let out_ainfo = NAAudioInfo::new(ainfo.sample_rate, ainfo.channels, SND_F32P_FORMAT, self.frm_size);
                let name = if !self.use_dct { "bink-audio-rdft" } else { "bink-audio-dct" };
                let info = NACodecInfo::new(name, NACodecTypeInfo::Audio(out_ainfo), Some(edata));
                let mut stream = NAStream::new(StreamType::Audio, stream_id, info, self.frm_size as u32, ainfo.sample_rate, 0);
                stream.set_num(stream_id as usize);
                let stream = stream.into_ref();

                self.stream = Some(stream.clone());
                self.sample_step = (encinfo.tb_num as usize) * (ainfo.sample_rate as usize) / (encinfo.tb_den as usize);

                Ok(stream)
            },
        }
    }
    fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> {
        if let Some(ref abuf) = frm.get_buffer().get_abuf_f32() {
            let src = abuf.get_data();
            let length = abuf.get_length();

            if abuf.get_info().get_channels() == 2 {
                let offset = abuf.get_offset(1);
                self.samples.add_stereo(&src[..length], &src[offset..][..length]);
            } else {
                self.samples.add_mono(&src[..length]);
            }

            while self.encode_packet(false)? {
            }

            Ok(())
        } else {
            Err(EncoderError::InvalidParameters)
        }
    }
    fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> {
        Ok(self.packets.pop_front())
    }
    fn flush(&mut self) -> EncoderResult<()> {
        if self.samples.num_avail() > 0 {
            self.encode_packet(true)?;
        }
        Ok(())
    }
}

impl Drop for BinkAudioEncoder {
    fn drop(&mut self) {
        if self.print_stats && self.nblks > 0 {
            println!("encoded {} block(s) in {} frame(s), {} samples total ({}s)",
                    self.nblks, self.nframes, self.nsamples,
                    (self.nsamples as f32) / (self.rc.srate as f32));

            let bitrate = (self.blk_bits as u64) * u64::from(self.rc.srate) / (self.nsamples as u64);
            let br_fmt = if bitrate >= 10_000_000 {
                    format!("{}mbps", bitrate / 1000000)
                } else if bitrate >= 10_000 {
                    format!("{}kbps", bitrate / 1000)
                } else {
                    format!("{}bps", bitrate)
                };
            println!("average bitrate {}", br_fmt);

            let mut end = self.qstats.len();
            for (i, &cnt) in self.qstats.iter().enumerate().rev() {
                if cnt != 0 {
                    break;
                }
                end = i;
            }
            print!("quants used:");
            for &cnt in self.qstats.iter().take(end) {
                print!(" {}", cnt);
            }
            println!();

            let mut end = self.bstats.len();
            for (i, &cnt) in self.bstats.iter().enumerate().rev() {
                if cnt != 0 {
                    break;
                }
                end = i;
            }
            print!("coefficient bits:");
            for &cnt in self.bstats.iter().take(end) {
                print!(" {}", cnt);
            }
            println!();
        }
    }
}

const ENCODER_OPTS: &[NAOptionDefinition] = &[
    NAOptionDefinition {
        name: "version", description: "codec version",
        opt_type: NAOptionDefinitionType::String(Some(&["b", "f", "g", "h", "i", "k"])) },
    NAOptionDefinition {
        name: "preload", description: "number of audio frames to preload",
        opt_type: NAOptionDefinitionType::Int(Some(1), Some(256)) },
    NAOptionDefinition {
        name: "print_stats", description: "print encoder statistics",
        opt_type: NAOptionDefinitionType::Bool },
];

impl NAOptionHandler for BinkAudioEncoder {
    fn get_supported_options(&self) -> &[NAOptionDefinition] { ENCODER_OPTS }
    fn set_options(&mut self, options: &[NAOption]) {
        for option in options.iter() {
            for opt_def in ENCODER_OPTS.iter() {
                if opt_def.check(option).is_ok() {
                    match option.name {
                        "version" => {
                            if let NAValue::String(ref strval) = option.value {
                                match strval.as_str() {
                                    "b" => self.version = 'b',
                                    _ => {
                                        println!("versions beside 'b' are not supported");
                                    },
                                };
                            }
                        },
                        "preload" => {
                            if let NAValue::Int(ival) = option.value {
                                self.preload = ival as usize;
                            }
                        },
                        "print_stats" => {
                            if let NAValue::Bool(bval) = option.value {
                                self.print_stats = bval;
                            }
                        },
                        _ => {},
                    };
                }
            }
        }
    }
    fn query_option_value(&self, name: &str) -> Option<NAValue> {
        match name {
            "version" => Some(NAValue::String(self.version.to_string())),
            "preload" => Some(NAValue::Int(self.preload as i64)),
            "print_stats" => Some(NAValue::Bool(self.print_stats)),
            _ => None,
        }
    }
}

pub fn get_encoder_rdft() -> Box<dyn NAEncoder + Send> { Box::new(BinkAudioEncoder::new(false)) }
#[allow(dead_code)]
pub fn get_encoder_dct() -> Box<dyn NAEncoder + Send> { Box::new(BinkAudioEncoder::new(true)) }

#[cfg(test)]
mod test {
    use nihav_core::codecs::*;
    use nihav_core::demuxers::*;
    use nihav_core::muxers::*;
    use nihav_codec_support::test::enc_video::*;
    use crate::*;
    use nihav_commonfmt::*;

    fn test_encoder(name: &'static str, enc_options: &[NAOption],
                    bitrate: u32, quality: u8, channels: u8, hash: &[u32; 4]) {
        let mut dmx_reg = RegisteredDemuxers::new();
        generic_register_all_demuxers(&mut dmx_reg);
        let mut dec_reg = RegisteredDecoders::new();
        generic_register_all_decoders(&mut dec_reg);
        let mut mux_reg = RegisteredMuxers::new();
        rad_register_all_muxers(&mut mux_reg);
        let mut enc_reg = RegisteredEncoders::new();
        rad_register_all_encoders(&mut enc_reg);

        // sample from a private collection
        let dec_config = DecoderTestParams {
                demuxer:        "wav",
                in_name:        "assets/test-stereo.wav",
                stream_type:    StreamType::Audio,
                limit:          None,//Some(20),
                dmx_reg, dec_reg,
            };
        let enc_config = EncoderTestParams {
                muxer:          "bink",
                enc_name:       "bink-audio-rdft",
                out_name:       name,
                mux_reg, enc_reg,
            };
        let dst_ainfo = NAAudioInfo {
                sample_rate:    0,
                channels,
                format:         SND_F32P_FORMAT,
                block_len:      1024,
            };
        let enc_params = EncodeParameters {
                format:  NACodecTypeInfo::Audio(dst_ainfo),
                quality,
                bitrate: bitrate * 1000,
                tb_num:  0,
                tb_den:  0,
                flags:   0,
            };
        //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);

        test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options, hash);
    }
    #[test]
    fn test_binkaud_encoder_b_q100() {
        let enc_options = &[
            NAOption{name: "version", value: NAValue::String("b".to_owned())},
            //NAOption{name: "print_stats", value: NAValue::Bool(true)},
        ];
        test_encoder("bink-aud-b-q80.bik", enc_options, 0, 100, 2,
            &[0x45c13e44, 0x36ab1efb, 0x84c93f1a, 0x4aa49831]);
    }
    #[test]
    fn test_binkaud_encoder_b_q80() {
        let enc_options = &[
            NAOption{name: "version", value: NAValue::String("b".to_owned())},
            //NAOption{name: "print_stats", value: NAValue::Bool(true)},
        ];
        test_encoder("bink-aud-b-q80.bik", enc_options, 0, 80, 2,
            &[0x3835b6ff, 0xd2da247b, 0xae8ff168, 0x464b4c31]);
    }
    #[test]
    fn test_binkaud_encoder_b_q40() {
        let enc_options = &[
            NAOption{name: "version", value: NAValue::String("b".to_owned())},
            //NAOption{name: "print_stats", value: NAValue::Bool(true)},
        ];
        test_encoder("bink-aud-b-q80.bik", enc_options, 0, 40, 2,
            &[0xe99882b0, 0x12f9be7c, 0xc634c1a7, 0xd88e1c9b]);
    }
    #[test]
    fn test_binkaud_encoder_b_q1() {
        let enc_options = &[
            NAOption{name: "version", value: NAValue::String("b".to_owned())},
            //NAOption{name: "print_stats", value: NAValue::Bool(true)},
        ];
        test_encoder("bink-aud-b-q80.bik", enc_options, 0, 1, 2,
            &[0x783d68e1, 0x9db89348, 0x5348e677, 0x337133fa]);
    }
    #[test]
    fn test_binkaud_encoder_b_br240() {
        let enc_options = &[
            NAOption{name: "version", value: NAValue::String("b".to_owned())},
            //NAOption{name: "print_stats", value: NAValue::Bool(true)},
        ];
        test_encoder("bink-aud-b-180k.bik", enc_options, 240, 0, 2,
            &[0xad33939e, 0x945413f1, 0xf5edc6be, 0xcf8eebd3]);
    }
    #[test]
    fn test_binkaud_encoder_b_br180() {
        let enc_options = &[
            NAOption{name: "version", value: NAValue::String("b".to_owned())},
            //NAOption{name: "print_stats", value: NAValue::Bool(true)},
        ];
        test_encoder("bink-aud-b-180k.bik", enc_options, 180, 0, 2,
            &[0x4d33f1be, 0xb1e662ad, 0x71bd0486, 0x327e053a]);
    }
    #[test]
    fn test_binkaud_encoder_b_br120() {
        let enc_options = &[
            NAOption{name: "version", value: NAValue::String("b".to_owned())},
            //NAOption{name: "print_stats", value: NAValue::Bool(true)},
        ];
        test_encoder("bink-aud-b-120k.bik", enc_options, 120, 0, 2,
            &[0xa1e17945, 0xd837677a, 0x48cd0b3a, 0x3e7c1a03]);
    }
    #[test]
    fn test_binkaud_encoder_b_br60() {
        let enc_options = &[
            NAOption{name: "version", value: NAValue::String("b".to_owned())},
            //NAOption{name: "print_stats", value: NAValue::Bool(true)},
        ];
        test_encoder("bink-aud-b-60k.bik", enc_options, 60, 0, 2,
            &[0xf48cae2e, 0x038ec363, 0x17cb1606, 0x4756f854]);
    }
}