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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use bytecodec::{ErrorKind, Result};

/// AAC packet type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum AacPacketType {
    /// AAC sequence header
    SequenceHeader = 0,

    /// AAC raw
    Raw = 1,
}
impl AacPacketType {
    pub(crate) fn from_u8(b: u8) -> Result<Self> {
        Ok(match b {
            0 => AacPacketType::SequenceHeader,
            1 => AacPacketType::Raw,
            _ => track_panic!(ErrorKind::InvalidInput, "Unknown aac packet type: {}", b),
        })
    }
}

/// Audio format(codec) identifier.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum SoundFormat {
    /// Linear PCM,platform endian
    LinearPcmPlatformEndian = 0,

    /// ADPCM
    Adpcm = 1,

    /// MP3
    Mp3 = 2,

    /// Linear PCM, little endian
    LinearPcmLittleEndian = 3,

    /// Nellymoser 16-kHz mono
    Nellymoser16khzMono = 4,

    /// Nellymoser 8-kHz mono
    Nellymoser8KhzMono = 5,

    /// Nellymoser
    Nellymoser = 6,

    /// G.711 A-law logarithmic PCM
    G711AlawLogarithmicPcm = 7,

    /// G.711 mu-law logarithmic PCM
    G711MuLawLogarithmicPcm = 8,

    /// AAC
    Aac = 10,

    /// Speex
    Speex = 11,

    /// MP3 8-kHz
    Mp3_8khz = 14,

    ///  Device-specific sound
    DeviceSpecificSound = 15,
}
impl SoundFormat {
    pub(crate) fn from_u8(b: u8) -> Result<Self> {
        Ok(match b {
            0 => SoundFormat::LinearPcmPlatformEndian,
            1 => SoundFormat::Adpcm,
            2 => SoundFormat::Mp3,
            3 => SoundFormat::LinearPcmLittleEndian,
            4 => SoundFormat::Nellymoser16khzMono,
            5 => SoundFormat::Nellymoser8KhzMono,
            6 => SoundFormat::Nellymoser,
            7 => SoundFormat::G711AlawLogarithmicPcm,
            8 => SoundFormat::G711MuLawLogarithmicPcm,
            10 => SoundFormat::Aac,
            11 => SoundFormat::Speex,
            14 => SoundFormat::Mp3_8khz,
            15 => SoundFormat::DeviceSpecificSound,
            _ => track_panic!(ErrorKind::InvalidInput, "Unknown FLV sound format: {}", b),
        })
    }
}

/// Audio sampling rate.
///
/// Note that if the format is `SoundFormat::Aac`, `SoundRate::Khz44` always be used.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum SoundRate {
    /// 5.5-kHz
    Khz5 = 0,

    /// 11-kHz
    Khz11 = 1,

    /// 22-kHz
    Khz22 = 2,

    /// 44-kHz
    Khz44 = 3,
}
impl SoundRate {
    pub(crate) fn from_u8(b: u8) -> Result<Self> {
        Ok(match b {
            0 => SoundRate::Khz5,
            1 => SoundRate::Khz11,
            2 => SoundRate::Khz22,
            3 => SoundRate::Khz44,
            _ => track_panic!(ErrorKind::InvalidInput, "Unknown FLV sound rate: {}", b),
        })
    }
}

/// Size of each audio sample.
///
/// Note that this parameter only pertains to uncompressed formats.
/// Compressed formats always decode to 16 bits internally.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum SoundSize {
    /// 8-bits
    Bit8 = 0,

    /// 16-bits
    Bit16 = 1,
}
impl SoundSize {
    pub(crate) fn from_bool(b: bool) -> Self {
        if b {
            SoundSize::Bit16
        } else {
            SoundSize::Bit8
        }
    }
}

/// Mono or stereo sound.
///
/// Nellymoser and AAC always use `Mono` and `Stereo` respectively.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum SoundType {
    /// Monoral
    Mono = 0,

    /// Stereo
    Stereo = 1,
}
impl SoundType {
    pub(crate) fn from_bool(b: bool) -> Self {
        if b {
            SoundType::Stereo
        } else {
            SoundType::Mono
        }
    }
}