nihav-core/src/soundcvt/mod.rs

   1 pub use crate::formats::{NASoniton,NAChannelMap};
   2 pub use crate::frame::{NAAudioBuffer,NAAudioInfo,NABufferType};
   3 use crate::formats::NAChannelType;
   4 use crate::frame::alloc_audio_buffer;
   5 use crate::io::byteio::*;
   6 use std::f32::consts::SQRT_2;
   7
   8 #[derive(Clone,Copy,Debug,PartialEq)]
   9 pub enum SoundConvertError {
  10     InvalidInput,
  11     AllocError,
  12     Unsupported,
  13 }
  14
  15 enum ChannelOp {
  16     Passthrough,
  17     Reorder(Vec<usize>),
  18     Remix(Vec<f32>),
  19     DupMono(Vec<bool>),
  20 }
  21
  22 impl ChannelOp {
  23     fn is_remix(&self) -> bool {
  24         match *self {
  25             ChannelOp::Remix(_) => true,
  26             ChannelOp::DupMono(_) => true,
  27             _ => false,
  28         }
  29     }
  30 }
  31
  32 fn apply_channel_op<T:Copy>(ch_op: &ChannelOp, src: &Vec<T>, dst: &mut Vec<T>) {
  33     match *ch_op {
  34         ChannelOp::Passthrough => {
  35             dst.copy_from_slice(src.as_slice());
  36         },
  37         ChannelOp::Reorder(ref reorder) => {
  38             for (out, idx) in dst.iter_mut().zip(reorder.iter()) {
  39                 *out = src[*idx];
  40             }
  41         },
  42         _ => {},
  43     };
  44 }
  45
  46 fn remix_i32(ch_op: &ChannelOp, src: &Vec<i32>, dst: &mut Vec<i32>) {
  47     if let ChannelOp::Remix(ref remix_mat) = ch_op {
  48         let sch = src.len();
  49         for (out, coeffs) in dst.iter_mut().zip(remix_mat.chunks(sch)) {
  50             let mut sum = 0.0;
  51             for (inval, coef) in src.iter().zip(coeffs.iter()) {
  52                 sum += (*inval as f32) * *coef;
  53             }
  54             *out = sum as i32;
  55         }
  56     }
  57     if let ChannelOp::DupMono(ref dup_mat) = ch_op {
  58         let src = src[0];
  59         for (out, copy) in dst.iter_mut().zip(dup_mat.iter()) {
  60             *out = if *copy { src } else { 0 };
  61         }
  62     }
  63 }
  64
  65 fn remix_f32(ch_op: &ChannelOp, src: &Vec<f32>, dst: &mut Vec<f32>) {
  66     if let ChannelOp::Remix(ref remix_mat) = ch_op {
  67         let sch = src.len();
  68         for (out, coeffs) in dst.iter_mut().zip(remix_mat.chunks(sch)) {
  69             let mut sum = 0.0;
  70             for (inval, coef) in src.iter().zip(coeffs.iter()) {
  71                 sum += *inval * *coef;
  72             }
  73             *out = sum;
  74         }
  75     }
  76     if let ChannelOp::DupMono(ref dup_mat) = ch_op {
  77         let src = src[0];
  78         for (out, copy) in dst.iter_mut().zip(dup_mat.iter()) {
  79             *out = if *copy { src } else { 0.0 };
  80         }
  81     }
  82 }
  83
  84 fn read_samples<T:Copy>(src: &NAAudioBuffer<T>, mut idx: usize, dst: &mut Vec<T>) {
  85     let stride = src.get_stride();
  86     let data = src.get_data();
  87     for out in dst.iter_mut() {
  88         *out = data[idx];
  89         idx += stride;
  90     }
  91 }
  92
  93 trait FromFmt<T:Copy> {
  94     fn cvt_from(val: T) -> Self;
  95 }
  96
  97 impl FromFmt<u8> for u8 {
  98     fn cvt_from(val: u8) -> u8 { val }
  99 }
 100 impl FromFmt<u8> for i16 {
 101     fn cvt_from(val: u8) -> i16 { ((val as i16) - 128).wrapping_mul(0x101) }
 102 }
 103 impl FromFmt<u8> for i32 {
 104     fn cvt_from(val: u8) -> i32 { ((val as i32) - 128).wrapping_mul(0x01010101) }
 105 }
 106 impl FromFmt<u8> for f32 {
 107     fn cvt_from(val: u8) -> f32 { ((val as f32) - 128.0) / 128.0 }
 108 }
 109
 110 impl FromFmt<i16> for u8 {
 111     fn cvt_from(val: i16) -> u8 { ((val >> 8) + 128).min(255).max(0) as u8 }
 112 }
 113 impl FromFmt<i16> for i16 {
 114     fn cvt_from(val: i16) -> i16 { val }
 115 }
 116 impl FromFmt<i16> for i32 {
 117     fn cvt_from(val: i16) -> i32 { (val as i32).wrapping_mul(0x10001) }
 118 }
 119 impl FromFmt<i16> for f32 {
 120     fn cvt_from(val: i16) -> f32 { (val as f32) / 32768.0 }
 121 }
 122
 123 impl FromFmt<i32> for u8 {
 124     fn cvt_from(val: i32) -> u8 { ((val >> 24) + 128).min(255).max(0) as u8 }
 125 }
 126 impl FromFmt<i32> for i16 {
 127     fn cvt_from(val: i32) -> i16 { (val >> 16) as i16 }
 128 }
 129 impl FromFmt<i32> for i32 {
 130     fn cvt_from(val: i32) -> i32 { val }
 131 }
 132 impl FromFmt<i32> for f32 {
 133     fn cvt_from(val: i32) -> f32 { (val as f32) / 31.0f32.exp2() }
 134 }
 135
 136 impl FromFmt<f32> for u8 {
 137     fn cvt_from(val: f32) -> u8 { ((val * 128.0) + 128.0).min(255.0).max(0.0) as u8 }
 138 }
 139 impl FromFmt<f32> for i16 {
 140     fn cvt_from(val: f32) -> i16 { (val * 32768.0).min(16383.0).max(-16384.0) as i16 }
 141 }
 142 impl FromFmt<f32> for i32 {
 143     fn cvt_from(val: f32) -> i32 { (val * 31.0f32.exp2()) as i32 }
 144 }
 145 impl FromFmt<f32> for f32 {
 146     fn cvt_from(val: f32) -> f32 { val }
 147 }
 148
 149 trait IntoFmt<T:Copy> {
 150     fn cvt_into(self) -> T;
 151 }
 152
 153 impl<T:Copy, U:Copy> IntoFmt<U> for T where U: FromFmt<T> {
 154     fn cvt_into(self) -> U { U::cvt_from(self) }
 155 }
 156
 157
 158 fn read_samples_i32<T:Copy>(src: &NAAudioBuffer<T>, mut idx: usize, dst: &mut Vec<i32>) where i32: FromFmt<T> {
 159     let stride = src.get_stride();
 160     let data = src.get_data();
 161     for out in dst.iter_mut() {
 162         *out = i32::cvt_from(data[idx]);
 163         idx += stride;
 164     }
 165 }
 166
 167 fn read_samples_f32<T:Copy>(src: &NAAudioBuffer<T>, mut idx: usize, dst: &mut Vec<f32>) where f32: FromFmt<T> {
 168     let stride = src.get_stride();
 169     let data = src.get_data();
 170     for out in dst.iter_mut() {
 171         *out = f32::cvt_from(data[idx]);
 172         idx += stride;
 173     }
 174 }
 175
 176 fn read_packed<T:Copy>(src: &NAAudioBuffer<u8>, idx: usize, dst: &mut Vec<T>, fmt: &NASoniton) where u8: IntoFmt<T>, i16: IntoFmt<T>, i32: IntoFmt<T>, f32: IntoFmt<T> {
 177     if (fmt.bits & 7) != 0 { unimplemented!(); }
 178     let bytes = (fmt.bits >> 3) as usize;
 179     let mut offset = idx * bytes * dst.len();
 180     let data = src.get_data();
 181
 182     for el in dst.iter_mut() {
 183         let src = &data[offset..];
 184         *el = if !fmt.float {
 185                 match (bytes, fmt.be) {
 186                     (1, _)     => src[0].cvt_into(),
 187                     (2, true)  => (read_u16be(src).unwrap() as i16).cvt_into(),
 188                     (2, false) => (read_u16le(src).unwrap() as i16).cvt_into(),
 189                     (3, true)  => ((read_u24be(src).unwrap() << 8) as i32).cvt_into(),
 190                     (3, false) => ((read_u24be(src).unwrap() << 8) as i32).cvt_into(),
 191                     (4, true)  => (read_u32be(src).unwrap() as i32).cvt_into(),
 192                     (4, false) => (read_u32be(src).unwrap() as i32).cvt_into(),
 193                     _ => unreachable!(),
 194                 }
 195             } else {
 196                 match (bytes, fmt.be) {
 197                     (4, true)  => read_f32be(src).unwrap().cvt_into(),
 198                     (4, false) => read_f32le(src).unwrap().cvt_into(),
 199                     (8, true)  => (read_f64be(src).unwrap() as f32).cvt_into(),
 200                     (8, false) => (read_f64le(src).unwrap() as f32).cvt_into(),
 201                     (_, _) => unreachable!(),
 202                 }
 203             };
 204         offset += bytes;
 205     }
 206 }
 207
 208 fn store_samples<T:Copy, U:Copy>(dst: &mut NAAudioBuffer<T>, mut idx: usize, src: &Vec<U>) where U: IntoFmt<T> {
 209     let stride = dst.get_stride();
 210     let data = dst.get_data_mut().unwrap();
 211     for src_el in src.iter() {
 212         data[idx] = (*src_el).cvt_into();
 213         idx += stride;
 214     }
 215 }
 216
 217 fn store_packed<T:Copy>(dst: &mut NAAudioBuffer<u8>, idx: usize, src: &Vec<T>, fmt: &NASoniton) where u8: FromFmt<T>, i16: FromFmt<T>, i32: FromFmt<T>, f32: FromFmt<T> {
 218     if (fmt.bits & 7) != 0 { unimplemented!(); }
 219     let bytes = (fmt.bits >> 3) as usize;
 220     let mut offset = idx * bytes * src.len();
 221     let data = dst.get_data_mut().unwrap();
 222
 223     for el in src.iter() {
 224         let dst = &mut data[offset..];
 225         if !fmt.float {
 226             match (bytes, fmt.be) {
 227                 (1, _) => {
 228                     dst[0] = u8::cvt_from(*el);
 229                 },
 230                 (2, true)  => write_u16be(dst, i16::cvt_from(*el) as u16).unwrap(),
 231                 (2, false) => write_u16le(dst, i16::cvt_from(*el) as u16).unwrap(),
 232                 (3, true)  => write_u24be(dst, (i32::cvt_from(*el) >> 8) as u32).unwrap(),
 233                 (3, false) => write_u24le(dst, (i32::cvt_from(*el) >> 8) as u32).unwrap(),
 234                 (4, true)  => write_u32be(dst, i32::cvt_from(*el) as u32).unwrap(),
 235                 (4, false) => write_u32le(dst, i32::cvt_from(*el) as u32).unwrap(),
 236                 _ => unreachable!(),
 237             };
 238         } else {
 239             match (bytes, fmt.be) {
 240                 (4, true)  => write_f32be(dst, f32::cvt_from(*el)).unwrap(),
 241                 (4, false) => write_f32le(dst, f32::cvt_from(*el)).unwrap(),
 242                 (8, true)  => write_f64be(dst, f32::cvt_from(*el) as f64).unwrap(),
 243                 (8, false) => write_f64le(dst, f32::cvt_from(*el) as f64).unwrap(),
 244                 (_, _) => unreachable!(),
 245             };
 246         }
 247         offset += bytes;
 248     }
 249 }
 250
 251 pub fn convert_audio_frame(src: &NABufferType, dst_info: &NAAudioInfo, dst_chmap: &NAChannelMap) ->
 252 Result<NABufferType, SoundConvertError> {
 253     let nsamples = src.get_audio_length();
 254     if nsamples == 0 {
 255         return Err(SoundConvertError::InvalidInput);
 256     }
 257     let src_chmap = src.get_chmap().unwrap();
 258     let src_info  = src.get_audio_info().unwrap();
 259     if (src_chmap.num_channels() == 0) || (dst_chmap.num_channels() == 0) {
 260         return Err(SoundConvertError::InvalidInput);
 261     }
 262
 263     let needs_remix = src_chmap.num_channels() != dst_chmap.num_channels();
 264     let no_channel_needs = !needs_remix && channel_maps_equal(src_chmap, dst_chmap);
 265     let needs_reorder = !needs_remix && !no_channel_needs && channel_maps_reordered(src_chmap, dst_chmap);
 266
 267     let channel_op = if no_channel_needs {
 268             ChannelOp::Passthrough
 269         } else if needs_reorder {
 270             let reorder_mat = calculate_reorder_matrix(src_chmap, dst_chmap);
 271             ChannelOp::Reorder(reorder_mat)
 272         } else if src_chmap.num_channels() > 1 {
 273             let remix_mat = calculate_remix_matrix(src_chmap, dst_chmap);
 274             ChannelOp::Remix(remix_mat)
 275         } else {
 276             let mut dup_mat: Vec<bool> = Vec::with_capacity(dst_chmap.num_channels());
 277             for i in 0..dst_chmap.num_channels() {
 278                 let ch =  dst_chmap.get_channel(i);
 279                 if ch.is_left() || ch.is_right() || ch == NAChannelType::C {
 280                     dup_mat.push(true);
 281                 } else {
 282                     dup_mat.push(false);
 283                 }
 284             }
 285             ChannelOp::DupMono(dup_mat)
 286         };
 287
 288     let src_fmt = src_info.get_format();
 289     let dst_fmt = dst_info.get_format();
 290     let no_conversion = src_fmt == dst_fmt;
 291
 292     if no_conversion && no_channel_needs {
 293         return Ok(src.clone());
 294     }
 295
 296     let ret = alloc_audio_buffer(dst_info.clone(), nsamples, dst_chmap.clone());
 297     if ret.is_err() {
 298         return Err(SoundConvertError::AllocError);
 299     }
 300     let mut dst_buf = ret.unwrap();
 301
 302     if no_conversion {
 303         match (src, &mut dst_buf) {
 304             (NABufferType::AudioU8(sb), NABufferType::AudioU8(ref mut db)) => {
 305                 let mut svec = vec![0; src_chmap.num_channels()];
 306                 let mut tvec1 = vec![0; src_chmap.num_channels()];
 307                 let mut tvec2 = vec![0; dst_chmap.num_channels()];
 308                 let mut dvec = vec![0; dst_chmap.num_channels()];
 309                 for i in 0..nsamples {
 310                     read_samples(sb, i, &mut svec);
 311                     if !channel_op.is_remix() {
 312                         apply_channel_op(&channel_op, &svec, &mut dvec);
 313                     } else {
 314                         for (oel, iel) in tvec1.iter_mut().zip(svec.iter()) {
 315                             *oel = (*iel as i32) - 128;
 316                         }
 317                         remix_i32(&channel_op, &tvec1, &mut tvec2);
 318                         for (oel, iel) in dvec.iter_mut().zip(tvec2.iter()) {
 319                             *oel = (*iel + 128).min(255).max(0) as u8;
 320                         }
 321                     }
 322                     store_samples(db, i, &dvec);
 323                 }
 324             },
 325             (NABufferType::AudioI16(sb), NABufferType::AudioI16(ref mut db)) => {
 326                 let mut svec = vec![0; src_chmap.num_channels()];
 327                 let mut tvec1 = vec![0; src_chmap.num_channels()];
 328                 let mut tvec2 = vec![0; dst_chmap.num_channels()];
 329                 let mut dvec = vec![0; dst_chmap.num_channels()];
 330                 for i in 0..nsamples {
 331                     read_samples(sb, i, &mut svec);
 332                     if !channel_op.is_remix() {
 333                         apply_channel_op(&channel_op, &svec, &mut dvec);
 334                     } else {
 335                         for (oel, iel) in tvec1.iter_mut().zip(svec.iter()) {
 336                             *oel = *iel as i32;
 337                         }
 338                         remix_i32(&channel_op, &tvec1, &mut tvec2);
 339                         for (oel, iel) in dvec.iter_mut().zip(tvec2.iter()) {
 340                             *oel = (*iel).min(16383).max(-16384) as i16;
 341                         }
 342                     }
 343                     store_samples(db, i, &dvec);
 344                 }
 345             },
 346             (NABufferType::AudioI32(sb), NABufferType::AudioI32(ref mut db)) => {
 347                 let mut svec = vec![0; src_chmap.num_channels()];
 348                 let mut dvec = vec![0; dst_chmap.num_channels()];
 349                 for i in 0..nsamples {
 350                     read_samples(sb, i, &mut svec);
 351                     if !channel_op.is_remix() {
 352                         apply_channel_op(&channel_op, &svec, &mut dvec);
 353                     } else {
 354                         remix_i32(&channel_op, &svec, &mut dvec);
 355                     }
 356                     store_samples(db, i, &dvec);
 357                 }
 358             },
 359             (NABufferType::AudioF32(sb), NABufferType::AudioF32(ref mut db)) => {
 360                 let mut svec = vec![0.0; src_chmap.num_channels()];
 361                 let mut dvec = vec![0.0; dst_chmap.num_channels()];
 362                 for i in 0..nsamples {
 363                     read_samples(sb, i, &mut svec);
 364                     if !channel_op.is_remix() {
 365                         apply_channel_op(&channel_op, &svec, &mut dvec);
 366                     } else {
 367                         remix_f32(&channel_op, &svec, &mut dvec);
 368                     }
 369                     store_samples(db, i, &dvec);
 370                 }
 371             },
 372             _ => unimplemented!(),
 373         };
 374     } else {
 375         let into_float = dst_fmt.float;
 376         if !into_float {
 377             let mut svec = vec![0i32; src_chmap.num_channels()];
 378             let mut dvec = vec![0i32; dst_chmap.num_channels()];
 379             for i in 0..nsamples {
 380                 match src {
 381                     NABufferType::AudioU8 (ref sb) => read_samples_i32(sb, i, &mut svec),
 382                     NABufferType::AudioI16(ref sb) => read_samples_i32(sb, i, &mut svec),
 383                     NABufferType::AudioI32(ref sb) => read_samples_i32(sb, i, &mut svec),
 384                     NABufferType::AudioF32(ref sb) => read_samples_i32(sb, i, &mut svec),
 385                     NABufferType::AudioPacked(ref sb) => read_packed(sb, i, &mut svec, &src_fmt),
 386                     _ => unreachable!(),
 387                 };
 388                 if !channel_op.is_remix() {
 389                     apply_channel_op(&channel_op, &svec, &mut dvec);
 390                 } else {
 391                     remix_i32(&channel_op, &svec, &mut dvec);
 392                 }
 393                 match dst_buf {
 394                     NABufferType::AudioU8 (ref mut db) => store_samples(db, i, &dvec),
 395                     NABufferType::AudioI16(ref mut db) => store_samples(db, i, &dvec),
 396                     NABufferType::AudioI32(ref mut db) => store_samples(db, i, &dvec),
 397                     NABufferType::AudioF32(ref mut db) => store_samples(db, i, &dvec),
 398                     NABufferType::AudioPacked(ref mut buf) => store_packed(buf, i, &dvec, &dst_fmt),
 399                     _ => unreachable!(),
 400                 };
 401             }
 402         } else {
 403             let mut svec = vec![0.0f32; src_chmap.num_channels()];
 404             let mut dvec = vec![0.0f32; dst_chmap.num_channels()];
 405             for i in 0..nsamples {
 406                 match src {
 407                     NABufferType::AudioU8 (ref sb) => read_samples_f32(sb, i, &mut svec),
 408                     NABufferType::AudioI16(ref sb) => read_samples_f32(sb, i, &mut svec),
 409                     NABufferType::AudioI32(ref sb) => read_samples_f32(sb, i, &mut svec),
 410                     NABufferType::AudioF32(ref sb) => read_samples_f32(sb, i, &mut svec),
 411                     NABufferType::AudioPacked(ref sb) => read_packed(sb, i, &mut svec, &src_fmt),
 412                     _ => unreachable!(),
 413                 };
 414                 if !channel_op.is_remix() {
 415                     apply_channel_op(&channel_op, &svec, &mut dvec);
 416                 } else {
 417                     remix_f32(&channel_op, &svec, &mut dvec);
 418                 }
 419                 match dst_buf {
 420                     NABufferType::AudioU8 (ref mut db) => store_samples(db, i, &dvec),
 421                     NABufferType::AudioI16(ref mut db) => store_samples(db, i, &dvec),
 422                     NABufferType::AudioI32(ref mut db) => store_samples(db, i, &dvec),
 423                     NABufferType::AudioF32(ref mut db) => store_samples(db, i, &dvec),
 424                     NABufferType::AudioPacked(ref mut buf) => store_packed(buf, i, &dvec, &dst_fmt),
 425                     _ => unreachable!(),
 426                 };
 427             }
 428         }
 429     }
 430
 431     Ok(dst_buf)
 432 }
 433
 434 pub fn channel_maps_equal(a: &NAChannelMap, b: &NAChannelMap) -> bool {
 435     if a.num_channels() != b.num_channels() { return false; }
 436     for i in 0..a.num_channels() {
 437         if a.get_channel(i) != b.get_channel(i) {
 438             return false;
 439         }
 440     }
 441     true
 442 }
 443
 444 pub fn channel_maps_reordered(a: &NAChannelMap, b: &NAChannelMap) -> bool {
 445     if a.num_channels() != b.num_channels() { return false; }
 446     let mut count_a = [0u8; 32];
 447     let mut count_b = [0u8; 32];
 448     for i in 0..a.num_channels() {
 449         count_a[a.get_channel(i) as usize] += 1;
 450         count_b[b.get_channel(i) as usize] += 1;
 451     }
 452     for (c0, c1) in count_a.iter().zip(count_b.iter()) {
 453         if *c0 != *c1 {
 454             return false;
 455         }
 456     }
 457     true
 458 }
 459
 460 pub fn calculate_reorder_matrix(src: &NAChannelMap, dst: &NAChannelMap) -> Vec<usize> {
 461     if src.num_channels() != dst.num_channels() { return Vec::new(); }
 462     let num_channels = src.num_channels();
 463     let mut reorder: Vec<usize> = Vec::with_capacity(num_channels);
 464     for i in 0..num_channels {
 465         let dst_ch = dst.get_channel(i);
 466         for j in 0..num_channels {
 467             if src.get_channel(j) == dst_ch {
 468                 reorder.push(j);
 469                 break;
 470             }
 471         }
 472     }
 473     if reorder.len() != num_channels { reorder.clear(); }
 474     reorder
 475 }
 476
 477 fn is_stereo(chmap: &NAChannelMap) -> bool {
 478     (chmap.num_channels() == 2) &&
 479     (chmap.get_channel(0) == NAChannelType::L) &&
 480     (chmap.get_channel(1) == NAChannelType::R)
 481 }
 482
 483 pub fn calculate_remix_matrix(src: &NAChannelMap, dst: &NAChannelMap) -> Vec<f32> {
 484     if is_stereo(src) && dst.num_channels() == 1 &&
 485         (dst.get_channel(0) == NAChannelType::L || dst.get_channel(0) == NAChannelType::C) {
 486         return vec![0.5, 0.5];
 487     }
 488     if src.num_channels() >= 5 && is_stereo(dst) {
 489         let src_nch = src.num_channels();
 490         let mut mat = vec![0.0f32; src_nch * 2];
 491         let (l_mat, r_mat) = mat.split_at_mut(src_nch);
 492         for ch in 0..src_nch {
 493             match src.get_channel(ch) {
 494                 NAChannelType::L    => l_mat[ch] = 1.0,
 495                 NAChannelType::R    => r_mat[ch] = 1.0,
 496                 NAChannelType::C    => { l_mat[ch] = SQRT_2 / 2.0; r_mat[ch] = SQRT_2 / 2.0; },
 497                 NAChannelType::Ls   => l_mat[ch] = SQRT_2 / 2.0,
 498                 NAChannelType::Rs   => r_mat[ch] = SQRT_2 / 2.0,
 499                 _ => {},
 500             };
 501         }
 502         return mat;
 503     }
 504 unimplemented!();
 505 }
 506
 507 #[cfg(test)]
 508 mod test {
 509     use super::*;
 510     use std::str::FromStr;
 511     use crate::formats::*;
 512
 513     #[test]
 514     fn test_matrices() {
 515         let chcfg51 = NAChannelMap::from_str("L,R,C,LFE,Ls,Rs").unwrap();
 516         let chcfg52 = NAChannelMap::from_str("C,L,R,Ls,Rs,LFE").unwrap();
 517         let stereo  = NAChannelMap::from_str("L,R").unwrap();
 518         let reorder = calculate_reorder_matrix(&chcfg51, &chcfg52);
 519         assert_eq!(reorder.as_slice(), [ 2, 0, 1, 4, 5, 3]);
 520         let remix   = calculate_remix_matrix(&chcfg51, &stereo);
 521         assert_eq!(remix.as_slice(), [ 1.0, 0.0, SQRT_2 / 2.0, 0.0, SQRT_2 / 2.0, 0.0,
 522                                        0.0, 1.0, SQRT_2 / 2.0, 0.0, 0.0, SQRT_2 / 2.0 ]);
 523     }
 524     #[test]
 525     fn test_conversion() {
 526         const CHANNEL_VALUES: [u8; 6] = [ 140, 90, 130, 128, 150, 70 ];
 527         let chcfg51 = NAChannelMap::from_str("L,R,C,LFE,Ls,Rs").unwrap();
 528         let stereo  = NAChannelMap::from_str("L,R").unwrap();
 529         let src_ainfo = NAAudioInfo {
 530                             sample_rate:    44100,
 531                             channels:       chcfg51.num_channels() as u8,
 532                             format:         SND_U8_FORMAT,
 533                             block_len:      512,
 534                         };
 535         let mut dst_ainfo = NAAudioInfo {
 536                             sample_rate:    44100,
 537                             channels:       stereo.num_channels() as u8,
 538                             format:         SND_S16P_FORMAT,
 539                             block_len:      512,
 540                         };
 541         let mut src_frm = alloc_audio_buffer(src_ainfo, 42, chcfg51.clone()).unwrap();
 542         if let NABufferType::AudioPacked(ref mut abuf) = src_frm {
 543             let data = abuf.get_data_mut().unwrap();
 544             let mut idx = 0;
 545             for _ in 0..42 {
 546                 for ch in 0..chcfg51.num_channels() {
 547                     data[idx] = CHANNEL_VALUES[ch];
 548                     idx += 1;
 549                 }
 550             }
 551         } else {
 552             panic!("wrong buffer type");
 553         }
 554
 555         let out_frm = convert_audio_frame(&src_frm, &dst_ainfo, &stereo).unwrap();
 556         if let NABufferType::AudioI16(ref abuf) = out_frm {
 557             let off0 = abuf.get_offset(0);
 558             let off1 = abuf.get_offset(1);
 559             let data = abuf.get_data();
 560             let l = data[off0];
 561             let r = data[off1];
 562             assert_eq!(l, 7445);
 563             assert_eq!(r, -19943);
 564         } else {
 565             panic!("wrong buffer type");
 566         }
 567
 568         dst_ainfo.format = SND_F32P_FORMAT;
 569         let out_frm = convert_audio_frame(&src_frm, &dst_ainfo, &stereo).unwrap();
 570         if let NABufferType::AudioF32(ref abuf) = out_frm {
 571             let off0 = abuf.get_offset(0);
 572             let off1 = abuf.get_offset(1);
 573             let data = abuf.get_data();
 574             let l = data[off0];
 575             let r = data[off1];
 576             assert_eq!(l,  0.22633252);
 577             assert_eq!(r, -0.6062342);
 578         } else {
 579             panic!("wrong buffer type");
 580         }
 581     }
 582 }