← Back to branch summary

~ubuntu-branches/ubuntu/feisty/avidemux/feisty

« back to all changes in this revision

Viewing changes to avidemux/ADM_audiocodec/ADM_audiocodec.h

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T Chen
  • Date: 2006-12-15 17:13:20 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20061215171320-w79pvpehxx2fr217
Tags: 1:2.3.0-0.0ubuntu1
* Merge from debian-multimedia.org, remaining Ubuntu change:
  - desktop file,
  - no support for ccache and make -j.
* Closes Ubuntu: #69614.

Show diffs side-by-side

added added

removed removed

Lines of Context:
avidemux/ADM_audiocodec/ADM_audiocodec.h
16
16
 ***************************************************************************/
17
17
#ifndef ADMAUDIOCODEC
18
18
#define ADMAUDIOCODEC
19
 
 
 
19
#define SCRATCH_PAD_SIZE (80000*2)
 
20
extern uint8_t scratchPad[];
20
21
#define  ADMAC_BUFFER (48000*4)
21
 
 class ADM_Audiocodec
22
 
 {
23
 
    protected:
24
 
                                        uint8_t         _running;
25
 
                                uint8_t _init;
26
 
                        
27
 
    public:
28
 
                                                ADM_Audiocodec( uint32_t fourcc );
29
 
                        virtual                 ~ADM_Audiocodec() ;
30
 
                                virtual         void    purge( void ) {};
31
 
                 virtual                        uint8_t beginDecompress( void )=0;
32
 
                 virtual                        uint8_t endDecompress( void )=0;
33
 
                 virtual                        uint8_t run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr,   uint32_t * nbOut)=0;
34
 
                 virtual                        uint8_t isCompressed( void )=0;
35
 
                 virtual                        uint8_t isDecompressable( void )=0;
36
 
                
37
 
 
 
22
class ADM_Audiocodec
 
23
{
 
24
        protected:
 
25
                uint8_t _init;
 
26
                WAVHeader *_wavHeader;
 
27
        public:
 
28
                ADM_Audiocodec(uint32_t fourcc);
 
29
                virtual ~ADM_Audiocodec();
 
30
                virtual void purge(void) {}
 
31
                virtual uint8_t beginDecompress(void)=0;
 
32
                virtual uint8_t endDecompress(void)=0;
 
33
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut)=0;
 
34
                virtual uint8_t isCompressed(void)=0;
 
35
                virtual uint8_t isDecompressable(void)=0;
38
36
 };
39
37
 
40
 
 ADM_Audiocodec *getAudioCodec(uint32_t fourcc,WAVHeader *info=NULL,uint32_t extra=0,uint8_t *extraData=NULL);
41
 
 
42
 
 class ADM_AudiocodecWav : public     ADM_Audiocodec
43
 
 {
44
 
    protected:
45
 
    public:
46
 
                                                                ADM_AudiocodecWav( uint32_t fourcc );;
47
 
                        virtual                 ~ADM_AudiocodecWav();
48
 
                                virtual         void    purge( void );
49
 
                 virtual                        uint8_t beginDecompress( void );
50
 
                 virtual                        uint8_t endDecompress( void ) ;
51
 
                 virtual                        uint8_t run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr,   uint32_t * nbOut);
52
 
                 virtual                        uint8_t isCompressed( void ) ;
53
 
                 virtual                        uint8_t isDecompressable(void );
54
 
 
55
 
   };
 
38
ADM_Audiocodec  *getAudioCodec(uint32_t fourcc, WAVHeader *info, uint32_t extra=0, uint8_t *extraData=NULL);
 
39
 
 
40
class ADM_AudiocodecWav : public     ADM_Audiocodec
 
41
{
 
42
        public:
 
43
                ADM_AudiocodecWav(uint32_t fourcc);
 
44
                virtual ~ADM_AudiocodecWav();
 
45
                virtual uint8_t beginDecompress(void);
 
46
                virtual uint8_t endDecompress(void);
 
47
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t * nbOut);
 
48
                virtual uint8_t isCompressed(void);
 
49
                virtual uint8_t isDecompressable(void);
 
50
};
56
51
 
57
52
class ADM_AudiocodecWavSwapped : public     ADM_Audiocodec
58
 
 {
59
 
    protected:
60
 
                                                uint8_t _hold;
61
 
                                                uint8_t _instore;
62
 
    public:
63
 
                                                ADM_AudiocodecWavSwapped( uint32_t fourcc );;
64
 
                virtual                 ~ADM_AudiocodecWavSwapped();
65
 
                virtual                         void    purge( void );
66
 
                 virtual                        uint8_t beginDecompress( void );
67
 
                 virtual                        uint8_t endDecompress( void ) ;
68
 
                 virtual                        uint8_t run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr,   uint32_t * nbOut);
69
 
                 virtual                        uint8_t isCompressed( void ) ;
70
 
                 virtual                        uint8_t isDecompressable(void );
71
 
 
72
 
   };
73
 
 
74
 
   class ADM_AudiocodecUnknown : public     ADM_Audiocodec
75
 
 {
76
 
    protected:                          
77
 
    public:
78
 
                                                ADM_AudiocodecUnknown( uint32_t fourcc )  : ADM_Audiocodec(fourcc){};;
79
 
                                                ~ADM_AudiocodecUnknown();
80
 
                                virtual         void    purge( void ) {};
81
 
                                                uint8_t beginDecompress( void ) { return 0;};
82
 
                                                uint8_t endDecompress( void ){ return 0;};
83
 
                                                uint8_t run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr,   uint32_t * nbOut);
84
 
                                                uint8_t isCompressed( void ){ return 1;};
85
 
                                                uint8_t isDecompressable(void ){ return 0;};
86
 
 
87
 
   };
 
53
{
 
54
        public:
 
55
                ADM_AudiocodecWavSwapped(uint32_t fourcc);
 
56
                virtual ~ADM_AudiocodecWavSwapped();
 
57
                virtual uint8_t beginDecompress(void);
 
58
                virtual uint8_t endDecompress(void);
 
59
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut);
 
60
                virtual uint8_t isCompressed(void);
 
61
                virtual uint8_t isDecompressable(void);
 
62
 
 
63
   };
 
64
 
 
65
class ADM_AudiocodecUnknown : public     ADM_Audiocodec
 
66
{
 
67
        public:
 
68
                ADM_AudiocodecUnknown(uint32_t fourcc) : ADM_Audiocodec(fourcc) {}
 
69
                ~ADM_AudiocodecUnknown() {}
 
70
                uint8_t beginDecompress(void) {return 0;}
 
71
                uint8_t endDecompress(void) {return 0;}
 
72
                uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut) {return 1;}
 
73
                uint8_t isCompressed(void) {return 1;}
 
74
                uint8_t isDecompressable(void) {return 0;}
 
75
};
 
76
 
88
77
#ifdef USE_AC3
89
 
    class ADM_AudiocodecAC3 : public     ADM_Audiocodec
90
 
 {
91
 
    protected:                          
92
 
    public:
93
 
                                                                ADM_AudiocodecAC3( uint32_t fourcc );
94
 
                        virtual                 ~ADM_AudiocodecAC3();
95
 
                                virtual         void    purge( void ) {};
96
 
                 virtual                        uint8_t beginDecompress( void );
97
 
                 virtual                        uint8_t endDecompress( void );
98
 
                 virtual                        uint8_t run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr,   uint32_t * nbOut);
99
 
                 virtual                        uint8_t isCompressed( void ){ return 1;};
100
 
                 virtual                        uint8_t isDecompressable(void ){ return 1;};
101
 
 
102
 
   };
103
 
#endif
104
 
 
105
 
    class ADM_Audiocodec8Bits : public     ADM_Audiocodec
106
 
 {
107
 
    protected:
108
 
                uint8_t                         _unsign;
109
 
    public:
110
 
                                                                ADM_Audiocodec8Bits( uint32_t fourcc );
111
 
                        virtual                 ~ADM_Audiocodec8Bits() ;
112
 
                                virtual         void    purge( void ) {};
113
 
                 virtual                        uint8_t beginDecompress( void ) {return 1;};
114
 
                 virtual                        uint8_t endDecompress( void ) {return 1;}
115
 
                 virtual                        uint8_t run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr,   uint32_t * nbOut);
116
 
                 virtual                        uint8_t isCompressed( void ){ return 1;};
117
 
                 virtual                        uint8_t isDecompressable(void ){ return 1;};
118
 
 
119
 
   };
 
78
#define ADM_AC3_BUFFER (50000*2)
 
79
class ADM_AudiocodecAC3 : public     ADM_Audiocodec
 
80
{
 
81
        protected:
 
82
                void *ac3_handle;
 
83
                void *ac3_sample;
 
84
                uint32_t _downmix;
 
85
 
 
86
        public:
 
87
                ADM_AudiocodecAC3(uint32_t fourcc, WAVHeader *info);
 
88
                virtual ~ADM_AudiocodecAC3();
 
89
                virtual uint8_t beginDecompress(void);
 
90
                virtual uint8_t endDecompress(void);
 
91
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut);
 
92
                virtual uint8_t isCompressed(void) {return 1;}
 
93
                virtual uint8_t isDecompressable(void) {return 1;}
 
94
 
 
95
   };
 
96
#endif
 
97
 
 
98
#ifdef USE_LIBDCA
 
99
class ADM_AudiocodecDCA : public     ADM_Audiocodec
 
100
{
 
101
        protected:
 
102
                void *dts_handle;
 
103
 
 
104
        public:
 
105
                ADM_AudiocodecDCA(uint32_t fourcc, WAVHeader *info);
 
106
                virtual ~ADM_AudiocodecDCA();
 
107
                virtual uint8_t beginDecompress(void);
 
108
                virtual uint8_t endDecompress(void);
 
109
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut);
 
110
                virtual uint8_t isCompressed(void) {return 1;}
 
111
                virtual uint8_t isDecompressable(void) {return 1;}
 
112
 
 
113
   };
 
114
#endif
 
115
 
 
116
class ADM_Audiocodec8Bits : public     ADM_Audiocodec
 
117
{
 
118
        protected:
 
119
                uint8_t _unsign;
 
120
 
 
121
        public:
 
122
                ADM_Audiocodec8Bits(uint32_t fourcc);
 
123
                virtual ~ADM_Audiocodec8Bits();
 
124
                virtual uint8_t beginDecompress(void) {return 1;}
 
125
                virtual uint8_t endDecompress(void) {return 1;}
 
126
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut);
 
127
                virtual uint8_t isCompressed(void) {return 1;}
 
128
                virtual uint8_t isDecompressable(void) {return 1;}
 
129
};
120
130
 
121
131
#ifdef USE_MP3
122
 
 
123
132
#define ADM_MP3_BUFFER (48*1024)
124
 
    class ADM_AudiocodecMP3 : public     ADM_Audiocodec
125
 
 {
126
 
    protected:
127
 
                                uint32_t        _head;
128
 
                                uint32_t        _tail;
129
 
                                uint8_t         _buffer[ADM_MP3_BUFFER];
130
 
                                void            *_stream;
131
 
                                void            *_frame;
132
 
                                void            *_synth;
133
 
    public:
134
 
                                                ADM_AudiocodecMP3( uint32_t fourcc );
135
 
                virtual                         ~ADM_AudiocodecMP3() ;
136
 
                virtual         void            purge( void ) {};
137
 
                 virtual        uint8_t         beginDecompress( void ) ;
138
 
                 virtual        uint8_t         endDecompress( void );
139
 
                 virtual        uint8_t         run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr,   uint32_t * nbOut);
140
 
                 virtual        uint8_t         isCompressed( void ){ return 1;};
141
 
                 virtual        uint8_t         isDecompressable(void ){ return 1;};
 
133
class ADM_AudiocodecMP3 : public     ADM_Audiocodec
 
134
{
 
135
        protected:
 
136
                uint32_t _head;
 
137
                uint32_t _tail;
 
138
                uint8_t _buffer[ADM_MP3_BUFFER];
 
139
                void *_stream;
 
140
                void *_frame;
 
141
                void *_synth;
142
142
 
143
 
   };
 
143
        public:
 
144
                ADM_AudiocodecMP3(uint32_t fourcc);
 
145
                virtual ~ADM_AudiocodecMP3() ;
 
146
                virtual uint8_t beginDecompress(void);
 
147
                virtual uint8_t endDecompress(void);
 
148
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut);
 
149
                virtual uint8_t isCompressed(void) {return 1;}
 
150
                virtual uint8_t isDecompressable(void) {return 1;}
 
151
};
144
152
#endif
145
153
 
146
154
#ifdef USE_VORBIS
147
 
  class ADM_vorbis : public     ADM_Audiocodec
148
 
 {
149
 
    protected:
150
 
                                void                    *_contextVoid;                          
151
 
    public:
152
 
                                                        ADM_vorbis( uint32_t fourcc ,WAVHeader *info,
153
 
                                                                uint32_t l,uint8_t *d);
154
 
                                virtual                 ~ADM_vorbis() ;
155
 
                                virtual         void    purge( void ) {};
156
 
                 virtual                        uint8_t run( uint8_t * ptr, uint32_t nbIn, 
157
 
                                                                uint8_t * outptr,   uint32_t * nbOut);
158
 
                 virtual                        uint8_t isCompressed( void ){ return 1;};
159
 
                 virtual                        uint8_t isDecompressable(void ){ return 1;};
160
 
                 virtual                        uint8_t beginDecompress( void ) { return 1;};
161
 
                 virtual                        uint8_t endDecompress( void );
162
 
          
163
 
 
164
 
   };
165
 
 
166
 
 
167
 
 
 
155
class ADM_vorbis : public     ADM_Audiocodec
 
156
{
 
157
        protected:
 
158
                void *_contextVoid;
 
159
 
 
160
        public:
 
161
                ADM_vorbis(uint32_t fourcc, WAVHeader *info, uint32_t l, uint8_t *d);
 
162
                virtual ~ADM_vorbis();
 
163
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut);
 
164
                virtual uint8_t isCompressed(void) {return 1;}
 
165
                virtual uint8_t isDecompressable(void) {return 1;}
 
166
                virtual uint8_t beginDecompress(void) {return 1;}
 
167
                virtual uint8_t endDecompress(void);
 
168
};
168
169
#endif
 
170
 
169
171
#ifdef USE_FAAD
170
172
#define FAAD_BUFFER 2048
171
 
  class ADM_faad : public     ADM_Audiocodec
172
 
 {
173
 
    protected:
174
 
                                                uint8_t _inited;
175
 
                                                void    *_instance;
176
 
                                                uint8_t _buffer[FAAD_BUFFER];
177
 
                                                uint32_t _inbuffer;     
178
 
    public:
179
 
                                                        ADM_faad( uint32_t fourcc ,WAVHeader *info,
180
 
                                                                uint32_t l,uint8_t *d);
181
 
                                virtual                 ~ADM_faad() ;
182
 
                                virtual         void    purge( void );
183
 
                 virtual                        uint8_t run( uint8_t * ptr, uint32_t nbIn, 
184
 
                                                                uint8_t * outptr,   uint32_t * nbOut);
185
 
                 virtual                        uint8_t isCompressed( void ){ return 1;};
186
 
                 virtual                        uint8_t isDecompressable(void ){ return 1;};
187
 
                 virtual                        uint8_t beginDecompress( void ) ;
188
 
                 virtual                        uint8_t endDecompress( void ) ;
189
 
          
190
 
 
191
 
   };
192
 
 
193
 
 
194
 
 
 
173
class ADM_faad : public     ADM_Audiocodec
 
174
{
 
175
        protected:
 
176
                uint8_t _inited;
 
177
                void    *_instance;
 
178
                uint8_t _buffer[FAAD_BUFFER];
 
179
                uint32_t _inbuffer;     
 
180
 
 
181
        public:
 
182
                ADM_faad(uint32_t fourcc, WAVHeader *info, uint32_t l, uint8_t *d);
 
183
                virtual ~ADM_faad();
 
184
                virtual void purge(void);
 
185
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut);
 
186
                virtual uint8_t isCompressed(void) {return 1;}
 
187
                virtual uint8_t isDecompressable(void) {return 1;}
 
188
                virtual uint8_t beginDecompress(void);
 
189
                virtual uint8_t endDecompress(void);
 
190
};
195
191
#endif
196
192
 
197
193
#define ADMWA_BUF (4*1024*16) // 64 kB internal
198
 
   class ADM_AudiocodecWMA : public     ADM_Audiocodec
199
 
 {
200
 
    protected:
201
 
                            void                    *_contextVoid;
202
 
                            uint8_t                 _buffer[ ADMWA_BUF];
203
 
                            uint32_t                _tail,_head;
204
 
                            uint32_t                _blockalign;
205
 
    public:
206
 
                                                ADM_AudiocodecWMA( uint32_t fourcc ,WAVHeader *info,uint32_t l,uint8_t *d);
207
 
                virtual                         ~ADM_AudiocodecWMA() ;
208
 
                virtual                         void    purge( void ) {};
209
 
                virtual     uint8_t             beginDecompress( void ) ;
210
 
                virtual     uint8_t             endDecompress( void );
211
 
                virtual     uint8_t             run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr,   uint32_t * nbOut);
212
 
                virtual     uint8_t             isCompressed( void ){ return 1;};
213
 
                virtual     uint8_t             isDecompressable(void ){ return 1;};
214
 
 
215
 
   };
216
 
   //****************************************************
217
 
   #define ADM_AMR_BUFFER (16*1024) // 16 kB internal
218
 
    class ADM_AudiocodecAMR : public     ADM_Audiocodec
219
 
 {
220
 
    protected:
221
 
                                void            *_contextVoid;
222
 
                                uint8_t         _buffer[ ADM_AMR_BUFFER];
223
 
                                uint32_t        _head,_tail;
224
 
    public:
225
 
                                                ADM_AudiocodecAMR( uint32_t fourcc ,WAVHeader *info);
226
 
                 virtual                       ~ADM_AudiocodecAMR() ;
227
 
                 virtual                        void    purge( void ) {};
228
 
                 virtual                        uint8_t beginDecompress( void ) ;
229
 
                 virtual                        uint8_t endDecompress( void );
230
 
                 virtual                        uint8_t run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr,   uint32_t * nbOut);
231
 
                 virtual                        uint8_t isCompressed( void ){ return 1;};
232
 
                 virtual                        uint8_t isDecompressable(void ){ return 1;};
233
 
 
234
 
   };
235
 
   //****************************************************
236
 
  class ADM_AudiocodecUlaw : public     ADM_Audiocodec
237
 
 {
238
 
    protected:
239
 
                                uint32_t                _inStock;                               
240
 
    public:
241
 
                                                ADM_AudiocodecUlaw( uint32_t fourcc ,WAVHeader *info);
242
 
                        virtual                 ~ADM_AudiocodecUlaw() ;
243
 
                                virtual         void    purge( void ) {};
244
 
                 virtual                        uint8_t beginDecompress( void ) {return 1;};
245
 
                 virtual                        uint8_t endDecompress( void ) {return 1;};
246
 
                 virtual                        uint8_t run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr, 
247
 
                                                          uint32_t * nbOut);
248
 
                 virtual                        uint8_t isCompressed( void ){ return 1;};
249
 
                 virtual                        uint8_t isDecompressable(void ){ return 1;};
250
 
 
251
 
   };
252
 
 
253
 
 //****************************************************
 
194
class ADM_AudiocodecWMA : public     ADM_Audiocodec
 
195
{
 
196
        protected:
 
197
                void *_contextVoid;
 
198
                uint8_t _buffer[ ADMWA_BUF];
 
199
                uint32_t _tail,_head;
 
200
                uint32_t _blockalign;
 
201
 
 
202
        public:
 
203
                ADM_AudiocodecWMA(uint32_t fourcc, WAVHeader *info, uint32_t l, uint8_t *d);
 
204
                virtual ~ADM_AudiocodecWMA() ;
 
205
                virtual uint8_t beginDecompress(void);
 
206
                virtual uint8_t endDecompress(void);
 
207
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut);
 
208
                virtual uint8_t isCompressed(void) {return 1;}
 
209
                virtual uint8_t isDecompressable(void) {return 1;}
 
210
};
 
211
 
 
212
#define ADM_AMR_BUFFER (16*1024) // 16 kB internal
 
213
class ADM_AudiocodecAMR : public     ADM_Audiocodec
 
214
{
 
215
        protected:
 
216
                void *_contextVoid;
 
217
                uint8_t  _buffer[ ADM_AMR_BUFFER];
 
218
                uint32_t _head,_tail;
 
219
 
 
220
        public:
 
221
                ADM_AudiocodecAMR(uint32_t fourcc, WAVHeader *info);
 
222
                virtual ~ADM_AudiocodecAMR() ;
 
223
                virtual uint8_t beginDecompress(void) ;
 
224
                virtual uint8_t endDecompress(void);
 
225
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut);
 
226
                virtual uint8_t isCompressed(void) {return 1;}
 
227
                virtual uint8_t isDecompressable(void) {return 1;}
 
228
};
 
229
 
 
230
 class ADM_AudiocodecUlaw : public     ADM_Audiocodec
 
231
 {
 
232
        public:
 
233
                ADM_AudiocodecUlaw(uint32_t fourcc, WAVHeader *info);
 
234
                virtual ~ADM_AudiocodecUlaw() ;
 
235
                virtual uint8_t beginDecompress(void) {return 1;}
 
236
                virtual uint8_t endDecompress(void) {return 1;}
 
237
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut);
 
238
                virtual uint8_t isCompressed(void) {return 1;}
 
239
                virtual uint8_t isDecompressable(void) {return 1;}
 
240
};
 
241
 
254
242
#define IMA_BUFFER 4096*8
255
 
  class ADM_AudiocodecImaAdpcm : public     ADM_Audiocodec
256
 
 {
257
 
    protected:
258
 
                       uint32_t                _inStock,_me,_channels;
259
 
                       int                     ss_div,ss_mul; // ???
260
 
                                void            *_contextVoid;
261
 
                                uint8_t         _buffer[ IMA_BUFFER];
262
 
                                uint32_t        _head,_tail;
263
 
 
264
 
    public:
265
 
                                ADM_AudiocodecImaAdpcm( uint32_t fourcc ,WAVHeader *info);
266
 
                virtual         ~ADM_AudiocodecImaAdpcm() ;
267
 
                virtual void    purge( void ) {};
268
 
                virtual uint8_t beginDecompress( void ) {_head=_tail=0;return 1;};
269
 
                virtual uint8_t endDecompress( void ) {_head=_tail=0;return 1;};
270
 
                virtual uint8_t run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr, 
271
 
                                                          uint32_t * nbOut);
272
 
                virtual uint8_t isCompressed( void ){ return 1;};
273
 
                virtual uint8_t isDecompressable(void ){ return 1;};
274
 
 
275
 
   };
 
243
class ADM_AudiocodecImaAdpcm : public     ADM_Audiocodec
 
244
{
 
245
        protected:
 
246
                uint32_t _inStock,_me,_channels;
 
247
                int ss_div,ss_mul; // ???
 
248
                void *_contextVoid;
 
249
                uint8_t _buffer[ IMA_BUFFER];
 
250
                uint32_t _head,_tail;
 
251
 
 
252
        public:
 
253
                ADM_AudiocodecImaAdpcm(uint32_t fourcc, WAVHeader *info);
 
254
                virtual ~ADM_AudiocodecImaAdpcm();
 
255
                virtual uint8_t beginDecompress(void) {_head=_tail=0;return 1;}
 
256
                virtual uint8_t endDecompress(void) {_head=_tail=0;return 1;}
 
257
                virtual uint8_t run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut);
 
258
                virtual uint8_t isCompressed(void) {return 1;}
 
259
                virtual uint8_t isDecompressable(void) {return 1;}
 
260
};
276
261
 
277
262
#endif