1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum AudioCodingFormat {
  UncompressedNativeEndian,
  Adpcm,
  Mp3,
  UncompressedLittleEndian,
  Nellymoser16,
  Nellymoser8,
  Nellymoser,
  Speex,
}

#[derive(Debug, PartialEq, Eq)]
pub enum SoundRate {
  SoundRate5500,
  SoundRate11000,
  SoundRate22000,
  SoundRate44000,
}

impl ::serde::Serialize for SoundRate {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
      S: ::serde::Serializer,
  {
    let sound_rate: u64 = match self {
      SoundRate::SoundRate5500 => 5500,
      SoundRate::SoundRate11000 => 11000,
      SoundRate::SoundRate22000 => 22000,
      SoundRate::SoundRate44000 => 44000,
    };
    return serializer.serialize_u64(sound_rate);
  }
}

impl<'de> ::serde::Deserialize<'de> for SoundRate {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
      D: ::serde::Deserializer<'de>,
  {
    struct Visitor;

    impl<'de> ::serde::de::Visitor<'de> for Visitor {
      type Value = SoundRate;

      fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter.write_str("5500, 11000, 22000 or 44000")
      }

      fn visit_u64<E>(self, value: u64) -> Result<SoundRate, E>
        where
          E: ::serde::de::Error,
      {
        match value {
          5500 => Ok(SoundRate::SoundRate5500),
          11000 => Ok(SoundRate::SoundRate11000),
          22000 => Ok(SoundRate::SoundRate22000),
          44000 => Ok(SoundRate::SoundRate44000),
          _ => Err(E::custom(format!("unknown SoundRate value: {}", value))),
        }
      }
    }

    // Deserialize the enum from a u64.
    deserializer.deserialize_u64(Visitor)
  }
}

#[derive(Debug, PartialEq, Eq)]
pub enum SoundSize {
  SoundSize8,
  SoundSize16,
}


impl ::serde::Serialize for SoundSize {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
      S: ::serde::Serializer,
  {
    let sound_size: u64 = match self {
      SoundSize::SoundSize8 => 8,
      SoundSize::SoundSize16 => 16,
    };
    return serializer.serialize_u64(sound_size);
  }
}

impl<'de> ::serde::Deserialize<'de> for SoundSize {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
      D: ::serde::Deserializer<'de>,
  {
    struct Visitor;

    impl<'de> ::serde::de::Visitor<'de> for Visitor {
      type Value = SoundSize;

      fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        formatter.write_str("8 or 16")
      }

      fn visit_u64<E>(self, value: u64) -> Result<SoundSize, E>
        where
          E: ::serde::de::Error,
      {
        match value {
          8 => Ok(SoundSize::SoundSize8),
          16 => Ok(SoundSize::SoundSize16),
          _ => Err(E::custom(format!("unknown SoundSize value: {}", value))),
        }
      }
    }

    // Deserialize the enum from a u64.
    deserializer.deserialize_u64(Visitor)
  }
}

#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum SoundType {
  Mono,
  Stereo,
}