CLAM-Development  1.4.0
AudioFileFormats.hxx
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2001-2004 MUSIC TECHNOLOGY GROUP (MTG)
3  * UNIVERSITAT POMPEU FABRA
4  *
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  *
20  */
21 
22 #ifndef __AUDIOFILEFORMATS__
23 #define __AUDIOFILEFORMATS__
24 
25 #if USE_SNDFILE != 1
26 #error USE_SNDFILE was not set to 1 in your settings.cfg file, but you are including files that require this. Please fix your settings.cfg
27 #endif
28 
29 #include <sndfile.h>
30 #include "Enum.hxx"
31 #include <string>
32 #include <list>
33 #include <utility>
34 
35 namespace CLAM
36 {
37 
39  class EAudioFileCodec : public Enum
40  {
41  public:
43  EAudioFileCodec( tValue val ) : Enum(EnumValues(), val) {}
44  EAudioFileCodec( std::string s ) : Enum(EnumValues(), s) {}
45  virtual Component* Species() const { return new EAudioFileCodec; }
46 
47  enum {
48  ePCM, /* String value: "PCM". Some variant of good ol' Pulse Code Modulation */
49  eOggVorbis, /* String value: "Ogg/Vorbis". Compressed with OggVorbis scheme */
50  eMpeg, /* String value: "Mpeg Audio". Compressed with MPEG-1 Layer 3 scheme */
51  eUnknown /* For error handling */
52  } tEnum;
53 
54  static tValue DefaultValue() { return ePCM; }
55  static tEnumValue * EnumValues()
56  {
57  static tEnumValue sEnumValues[] = {
58  { ePCM, "PCM" },
59  { eOggVorbis, "Ogg/Vorbis" },
60  { eMpeg, "Mpeg Audio" },
61  { eUnknown, "Unknown" },
62  { 0, NULL }
63  };
64  return sEnumValues;
65  }
66 
67  };
68 
70  class EAudioFileFormat : public Enum
71  {
72  public:
74  EAudioFileFormat( tValue val ) : Enum(EnumValues(), val) {}
75  EAudioFileFormat( std::string s ) : Enum(EnumValues(), s) {}
76  virtual Component* Species() const { return new EAudioFileFormat; }
77 
78  enum
79  {
80  eWAV = SF_FORMAT_WAV, /* Microsoft WAV (little endian)*/
81  eAIFF = SF_FORMAT_AIFF, /* Apple/SGI AIFF (big endian)*/
82  eAU = SF_FORMAT_AU, /* Sun/NeXT AU (big endian)*/
83  eRAW = SF_FORMAT_RAW, /* RAW PCM */
84  ePAF = SF_FORMAT_PAF, /* Ensoniq PARIS File format */
85  eSVX = SF_FORMAT_SVX, /* Amiga IFF / SVX8 / SV16 */
86  eNIST = SF_FORMAT_NIST, /* Sphere NIST */
87  eVOC = SF_FORMAT_VOC, /* VOC */
88  eIRCAM = SF_FORMAT_IRCAM, /* Berkeley / IRCAM / CARL */
89  eW64 = SF_FORMAT_W64, /* Sonic Foundry's 64 RIFF/WAV */
90  eMAT4 = SF_FORMAT_MAT4, /* MATLAB 4.2 - GNU Octave 2.0 */
91  eMAT5 = SF_FORMAT_MAT5, /* MATLAB 5.2 - GNU Octave 2.1 */
92  eVorbisMk1 = 1000 + SF_FORMAT_MAT5,
93  eMpegLayer1 = 1001 + SF_FORMAT_MAT5,
94  eMpegLayer2 = 1002 + SF_FORMAT_MAT5,
95  eMpegLayer3 = 1003 + SF_FORMAT_MAT5
96  };
97 
98  static tValue DefaultValue() { return eWAV; }
100  {
101  static tEnumValue sEnumValues[] = {
102  { eWAV, "WAV" },
103  { eAIFF, "AIFF" },
104  { eAU, "AU" },
105  { eRAW, "RAW" },
106  { ePAF, "PAF" },
107  { eSVX, "SVX" },
108  { eNIST, "NIST" },
109  { eVOC, "VOC" },
110  { eIRCAM, "IRCAM" },
111  { eW64, "W64" },
112  { eMAT4, "MAT4" },
113  { eMAT5, "MAT5" },
114  { eVorbisMk1, "VorbisMk1"},
115  { eMpegLayer1, "Mpeg Audio Layer 1"},
116  { eMpegLayer2, "Mpeg Audio Layer 2"},
117  { eMpegLayer3, "Mpeg Audio Layer 3"},
118  { 0, 0 }
119  };
120  return sEnumValues;
121  }
122 
123  public:
124 
125  static EAudioFileFormat FormatFromFilename( std::string filename );
126 
127  };
128 
130  class EAudioFileEncoding : public Enum
131  {
132  public:
135  EAudioFileEncoding( std::string s ) : Enum(EnumValues(), s) {}
136  virtual Component* Species() const { return new EAudioFileEncoding; }
137 
138  enum
139  {
140  ePCM_S8 = SF_FORMAT_PCM_S8, /* Signed 8-bit PCM */
141  ePCM_16 = SF_FORMAT_PCM_16, /* Signed 16-bit PCM */
142  ePCM_24 = SF_FORMAT_PCM_24, /* Signed 24-bit PCM */
143  ePCM_32 = SF_FORMAT_PCM_32, /* Signed 32-bit PCM */
144  ePCM_U8 = SF_FORMAT_PCM_U8, /* Unsigned 8-bit PCM */
145  eFLOAT = SF_FORMAT_FLOAT, /* IEEE-7354 32-bit floating point */
146  eDOUBLE = SF_FORMAT_DOUBLE, /* IEEE-7354 64-bit floating point */
147  eU_LAW = SF_FORMAT_ULAW, /* u-Law */
148  eA_LAW = SF_FORMAT_ALAW, /* a-Law */
149  eIMA_ADPCM = SF_FORMAT_IMA_ADPCM, /* IMA ADPCM */
150  eMS_ADPCM = SF_FORMAT_MS_ADPCM, /* Microsoft ADPCM */
151  eGSM610 = SF_FORMAT_GSM610, /* GSM 6.10 */
152  eVOX_ADPCM = SF_FORMAT_VOX_ADPCM, /* Oki ADPCM */
153  eG721_32 = SF_FORMAT_G721_32, /* 32kbs G721 ADPCM */
154  eG723_24 = SF_FORMAT_G723_24, /* 24kbs G723 ADPCM */
155  eG723_40 = SF_FORMAT_G723_40, /* 40kbs G723 ADPCM */
156  eDWVW_12 = SF_FORMAT_DWVW_12, /* 12-bit Delta Width Variable Word */
157  eDWVW_16 = SF_FORMAT_DWVW_16, /* 16-bit Delta Width Variable Word */
158  eDWVW_24 = SF_FORMAT_DWVW_24, /* 24-bit Delta Width Variable Word */
159  eDWVW_N = SF_FORMAT_DWVW_N, /* N-bit Delta Width Variable Word */
160  eDefault = 1000 + SF_FORMAT_DWVW_N, /*Format's default encoding*/
161  e5015US = 1001 + SF_FORMAT_DWVW_N,
162  eCCITTJ17 = 1002 + SF_FORMAT_DWVW_N
163  };
164  static tValue DefaultValue() { return ePCM_16; }
166  {
167  static tEnumValue sEnumValues[] = {
168  { ePCM_S8, "signed 8-bit" },
169  { ePCM_16, "signed 16-bit" },
170  { ePCM_24, "signed 24-bit" },
171  { ePCM_32, "signed 32-bit" },
172  { ePCM_U8, "unsigned 8-bit" },
173  { eFLOAT, "float 32-bit"},
174  { eDOUBLE, "float 64-bit"},
175  { eU_LAW, "u-law"},
176  { eA_LAW, "a-law"},
177  { eIMA_ADPCM, "IMA ADPCM" },
178  { eMS_ADPCM, "MS ADPCM "},
179  { eGSM610, "GSM 6.10"},
180  { eVOX_ADPCM, "Oki ADPCM"},
181  { eG721_32, "32k G721 ADPCM"},
182  { eG723_24, "24k G723 ADPCM"},
183  { eG723_40, "40k G723 ADPCM"},
184  { eDWVW_12, "DWVW 12-bit"},
185  { eDWVW_16, "DWVW 16-bit"},
186  { eDWVW_24, "DWVW 24-bit"},
187  { eDWVW_N, "DWVW N-bit"},
188  { eDefault, "Format Default"},
189  { e5015US, "Emphasis 50/15 US"},
190  { eCCITTJ17, "Emphasis CCITT J.17"},
191  { 0, NULL }
192  };
193  return sEnumValues;
194  }
195  };
196 
198  class EAudioFileEndianess : public Enum
199  {
200  public:
203  EAudioFileEndianess( std::string s ) : Enum(EnumValues(), s) {}
204  virtual Component* Species() const { return new EAudioFileEndianess; }
205 
206  enum
207  {
208  eDefault = SF_ENDIAN_FILE, /* Default format endianess */
209  eLittle = SF_ENDIAN_LITTLE, /* Force little endianess (if supported by format)*/
210  eBig = SF_ENDIAN_BIG, /* Force big endianess (if supported by format)*/
211  eHost = SF_ENDIAN_CPU /* Force host CPU endianess (if supported by format)*/
212  };
213  static tValue DefaultValue() { return eDefault; }
215  {
216  static tEnumValue sEnumValues[] = {
217  { eDefault, "Format Default" },
218  { eLittle, "Little Endian"},
219  { eBig, "Big Endian"},
220  { eHost, "Host CPU Endianess"},
221  { 0, NULL }
222  };
223  return sEnumValues;
224  }
225  };
226 
227 }
228 
229 #endif // AudioFileFormats.hxx
230