MIDI set_sync_client fix, cleanups, compilation fixes for gcc 2.95 - Alex
[terminatorX.git] / src / tX_audiofile.cc
1 /*
2     terminatorX - realtime audio scratching software
3     Copyright (C) 1999-2003  Alexander K├Ânig
4  
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9  
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14  
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  
19     File: tX_audiofile.cc
20  
21     Description: This implements the new audiofile class. Unlike earlier
22                  versions of terminatorX where wav_read.c was evilishly
23                  "#ifdef"ed to support multiple loading strategies this new
24                  design allows multiple load_*()-methods/strategies at
25                  the same time. (e.g. tx can now try to load a wavfile
26                  with the builtin routines and if that fails it'll try
27                  to load the file through sox (if available)).
28                  
29     Changes:
30         
31         13 Sept 2002 -  Wrote a seperate loading routine to be used with
32                                 libmad, which is significantly better then piping mpg?1?.
33                                 Rewrote load_piped to use realloc() instead - much easier,
34                                 faster and uses less memory - wish I'd known about realloc()
35                                 when coding load_piped() for the first time ;)
36 */   
37
38
39 #include "tX_audiofile.h"
40
41 #include <string.h>
42 #include <malloc.h>
43 #include "wav_file.h"
44 #include "tX_loaddlg.h"
45 #include "tX_endian.h"
46
47 #ifdef USE_MAD_INPUT
48 #       include <mad.h>
49 #       include <sys/types.h>
50 #       include <unistd.h>
51 #       ifndef _POSIX_MAPPED_FILES
52 #               define _POSIX_MAPPED_FILES
53 #       endif
54 #       include <sys/stat.h>
55 #       include <fcntl.h>
56 #       include <sys/mman.h>
57 #endif
58
59 #ifdef USE_VORBIS_INPUT
60 #       include <vorbis/codec.h>
61 #       include <vorbis/vorbisfile.h>
62 #       include <errno.h>
63 #       include <sys/stat.h>
64 #       include <fcntl.h>
65 #       include <sys/mman.h>
66 #endif
67
68 #ifdef USE_AUDIOFILE_INPUT
69 #       include <audiofile.h>
70 #endif
71
72 #define min(a,b) ((a) < (b) ? (a) : (b))
73
74 tx_audiofile :: tx_audiofile()
75 {
76         mem_type=TX_AUDIO_UNDEFINED;
77         file_type=TX_FILE_UNDEFINED;
78         file=NULL;
79         strcpy(filename,"");
80         mem=NULL;
81         no_samples=0;
82         sample_rate=44100;
83 }
84
85 void tx_audiofile :: figure_file_type()
86 {
87         char *ext;
88         
89         ext=strrchr(filename, (int) '.');
90         
91         if (ext)
92         {
93                 if (strlen(ext) >3)
94                 {
95                         ext++;
96                         if (!strcasecmp("wav", ext)) file_type=TX_FILE_WAV;
97                         else if (!strncasecmp("mp", ext, 2)) file_type=TX_FILE_MPG123;
98                         else if (!strncasecmp("ogg", ext, 2)) file_type=TX_FILE_OGG123;
99                 }
100         }
101 }
102
103 tX_audio_error tx_audiofile :: load(char *p_file_name)
104 {
105         tX_audio_error load_err=TX_AUDIO_ERR_NOT_SUPPORTED;
106         
107         strcpy(filename, p_file_name);
108         
109         ld_set_progress(0);
110                 
111         figure_file_type();
112         
113         if (mem) { free(mem); mem=NULL; }
114
115 #ifdef USE_AUDIOFILE_INPUT
116         if ((load_err) && (file_type!=TX_FILE_MPG123) && (file_type!=TX_FILE_OGG123)) {
117                 load_err=load_af();
118         }
119 #endif
120         
121 #ifdef USE_BUILTIN_WAV
122         if ((load_err) && (file_type==TX_FILE_WAV)) {
123                 load_err=load_wav();    
124 //              if (load_err==TX_AUDIO_SUCCESS) return(load_err);
125         }
126 #endif  
127
128 #ifdef USE_MAD_INPUT
129         if ((load_err) && (file_type==TX_FILE_MPG123)) {
130                 load_err=load_mad();
131                 //if (load_err==TX_AUDIO_SUCCESS) return(load_err);
132         }
133 #endif  
134         
135 #ifdef USE_MPG123_INPUT
136         if ((load_err) && (file_type==TX_FILE_MPG123)) {
137                 load_err=load_mpg123();
138                 //return(load_err);
139         }
140 #endif  
141
142 #ifdef USE_VORBIS_INPUT
143         if ((load_err) && (file_type==TX_FILE_OGG123)) {
144                 load_err=load_vorbis();
145                 //if (load_err==TX_AUDIO_SUCCESS) return(load_err);
146         }
147 #endif
148         
149 #ifdef USE_OGG123_INPUT
150         if ((load_err) && (file_type==TX_FILE_OGG123)) {
151                 load_err=load_ogg123();
152                 //return(load_err);
153         }
154 #endif
155
156 #ifdef USE_SOX_INPUT
157         if (load_err) {
158                 load_err=load_sox();
159         }
160 #endif  
161
162         if (!load_err) {
163                 tX_debug("tx_audiofile::load() Set samplerate to %i for file %s.", sample_rate, filename);
164         }
165         return(load_err);
166 }
167
168 tx_audiofile :: ~tx_audiofile() {
169         if (mem) {
170                 free(mem);
171         }
172  }
173  
174 #ifdef NEED_PIPED 
175
176 tX_audio_error tx_audiofile :: load_piped()
177 {
178         int16_t *data=NULL;
179         ssize_t allbytes=0;
180         ssize_t prev_bytes;
181         ssize_t bytes=1;
182         unsigned char buffer[SOX_BLOCKSIZE];
183         unsigned char *ptr;
184         
185         /* Irritating the user... */
186         ld_set_progress(0.5);
187         mem_type=TX_AUDIO_LOAD; 
188         
189         while (bytes) {
190                 bytes = fread(buffer, 1, SOX_BLOCKSIZE, file);
191                 
192                 if (bytes>0) {
193                         prev_bytes=allbytes;
194                         allbytes+=bytes;
195                         int16_t *new_data=(int16_t *) realloc(data, allbytes);
196                         //printf("All: %i, Bytes: %i, new: %08x, old: %08x\n", allbytes, bytes, new_data, data);
197                         
198                         if (!new_data) {
199                                 pclose(file); file=NULL;
200                                 if (data) free(data);
201                                 data=NULL;
202                                 return TX_AUDIO_ERR_ALLOC;
203                         }
204                         
205                         data=new_data;
206                         ptr=(unsigned char *) data;
207                         memcpy((void *) &ptr[prev_bytes],(void *) buffer, bytes);
208                 }
209         }
210         
211         pclose(file); file=NULL;
212         
213         if (!allbytes) {
214                 // If we get here we read zero Bytes...
215                 if (data) free(data);
216                 return TX_AUDIO_ERR_PIPE_READ;
217         }
218         
219         no_samples=allbytes/sizeof(int16_t);
220         mem=data;
221         
222         /* Irritating the user just a little more ;)*/
223         ld_set_progress(1.0);
224         
225         return TX_AUDIO_SUCCESS;
226 }
227
228 #endif
229         
230 #ifdef USE_SOX_INPUT
231 tX_audio_error tx_audiofile :: load_sox() {
232         tX_debug("tx_audiofile::load_sox()");
233
234         char command[PATH_MAX*2];
235
236         sprintf(command, SOX_STR, filename);
237         file = popen(command, "r");
238         
239         if (!file) return TX_AUDIO_ERR_SOX;
240         
241         return load_piped();
242         
243 }
244 #endif  
245
246 #ifdef USE_MPG123_INPUT
247 tX_audio_error tx_audiofile :: load_mpg123() {
248         tX_debug("tx_audiofile::load_mpg123()");
249         
250         char command[PATH_MAX*2];
251         
252         sprintf(command, MPG123_STR, filename);
253         file = popen(command, "r");
254         
255         if (!file) return TX_AUDIO_ERR_MPG123;
256         
257         return load_piped();
258 }
259 #endif  
260
261 #ifdef USE_OGG123_INPUT
262 tX_audio_error tx_audiofile :: load_ogg123() {
263         tX_debug("tx_audiofile::load_ogg123()");
264         
265         char command[PATH_MAX*2];
266
267         sprintf(command, OGG123_STR, filename);
268         file = popen(command, "r");
269
270         if (!file) return TX_AUDIO_ERR_OGG123;
271
272         return load_piped();
273 }
274 #endif
275
276 #ifdef USE_BUILTIN_WAV
277 tX_audio_error tx_audiofile :: load_wav() {
278         tX_debug("tx_audiofile::load_wav()");
279         
280         wav_sig wav_in;
281         int16_t *data;
282         int16_t *p;
283         ssize_t allbytes=0;
284         ssize_t bytes=0;
285
286         mem_type=TX_AUDIO_LOAD;
287         
288         if (!init_wav_read(filename, &wav_in))
289         {
290                 return(TX_AUDIO_ERR_WAV_NOTFOUND);
291         }
292
293         if (wav_in.depth != 16)
294         {
295                 return(TX_AUDIO_ERR_NOT_16BIT);
296         }
297
298         if (wav_in.chans != 1)
299         {
300                 return(TX_AUDIO_ERR_NOT_MONO);
301         }
302
303         sample_rate=wav_in.srate;
304         
305         memsize=wav_in.len;
306         data = (int16_t *) malloc (memsize);
307                 
308         if (!data)
309         {
310                 return(TX_AUDIO_ERR_ALLOC);
311         }
312
313         p=data;
314 #ifdef ENABLE_DEBUG_OUTPUT
315         int output=1;
316 #endif  
317         while (wav_in.len>allbytes)
318         {       
319                 bytes = fread(p, 1, min(1024, wav_in.len-allbytes), wav_in.handle);
320
321 #ifdef ENABLE_DEBUG_OUTPUT
322                 if (output) { tX_debug("tX_audiofile::load_wav() read %i Bytes [%04x %04x %04x %04x %04x %04x ..]", bytes, (unsigned int) p[0],  (unsigned int) p[1], (unsigned int) p[2], (unsigned int) p[3], (unsigned int) p[4], (unsigned int) p[5]); }
323 #endif
324
325                 if (bytes<=0) {
326                         free(data);
327                         return (TX_AUDIO_ERR_WAV_READ);
328                 }
329
330 #ifdef BIG_ENDIAN_MACHINE
331                 swapbuffer(p, bytes/sizeof(int16_t));
332 #       ifdef ENABLE_DEBUG_OUTPUT
333                 if (output) { tX_debug("tX_audiofile::load_wav() swapped %i Bytes [%04x %04x %04x %04x %04x %04x ..]",
334                 bytes, (unsigned int) p[0],  (unsigned int) p[1], (unsigned int) p[2], (unsigned int) p[3], (unsigned int) p[4], (unsigned int) p[5]); }
335 #       endif
336 #endif          
337
338 #ifdef ENABLE_DEBUG_OUTPUT
339                 output=0;
340 #endif
341
342                 allbytes+=bytes;
343                 
344                 ld_set_progress((float) allbytes/(float)wav_in.len);
345                 
346                 p+=(ssize_t) bytes/sizeof(int16_t);
347         }
348         
349         wav_close(wav_in.handle);
350
351         mem=data;
352         no_samples=memsize/sizeof(int16_t);
353         
354         return (TX_AUDIO_SUCCESS);
355 }
356 #endif
357
358 #ifdef USE_MAD_INPUT
359 tX_audio_error tx_audiofile::load_mad() {
360         tX_debug("tx_audiofile::load_mad()");
361         
362         struct stat stat_dat;
363         int fd;
364         int res;
365         void *mp3_file;
366         
367         fd=open(filename, O_RDONLY);
368         if (!fd) return TX_AUDIO_ERR_MAD_OPEN;
369         
370         if (fstat(fd, &stat_dat) == -1 ||
371       stat_dat.st_size == 0) {
372                 return TX_AUDIO_ERR_MAD_STAT;
373         }
374         
375         mp3_file = mmap(0, stat_dat.st_size, PROT_READ, MAP_SHARED, fd, 0);
376         
377         if (mp3_file == MAP_FAILED) {
378                 return TX_AUDIO_ERR_MAD_MMAP;
379         }
380         
381         res=mad_decode((const unsigned char *) mp3_file, stat_dat.st_size);
382         
383         if (res) {
384                 return TX_AUDIO_ERR_MAD_DECODE;
385         }
386         
387         mem_type=TX_AUDIO_LOAD;
388         
389         if (munmap(mp3_file, stat_dat.st_size) == -1) {
390                 return TX_AUDIO_ERR_MAD_MUNMAP;
391         }
392         
393         return TX_AUDIO_SUCCESS;
394 }
395
396 #define TX_MAD_BLOCKSIZE 8096
397
398 typedef struct {
399         const unsigned char *start;
400         const unsigned char *end;
401         const unsigned char *last_frame;
402         bool first_call;
403         ssize_t size;
404         int16_t *target_buffer;
405         unsigned int target_samples;
406         unsigned int current_sample;
407         unsigned int sample_rate;
408         unsigned int lost_sync_counter;
409 } tX_mad_buffer;
410
411 const unsigned char *last_current=NULL;
412
413 static enum mad_flow tX_mad_input(void *data, struct mad_stream *stream) {
414         tX_mad_buffer *buffer = (tX_mad_buffer *) data;
415         ssize_t bs;
416         unsigned int pos;
417
418         if (buffer->first_call) {
419                 bs=min(TX_MAD_BLOCKSIZE, buffer->size);
420                 mad_stream_buffer(stream, buffer->start, bs);
421                 buffer->first_call=false;
422                 return MAD_FLOW_CONTINUE;
423         } else {
424                 if (!stream->next_frame) return MAD_FLOW_STOP;
425                 
426                 pos=stream->next_frame-buffer->start;
427                 bs=min(TX_MAD_BLOCKSIZE, buffer->size-pos);
428                 //tX_debug("last: %08x, new %08x, bs: %i, pos: %i",  buffer->last_frame, stream->next_frame, bs, pos);
429                 
430                 mad_stream_buffer(stream, stream->next_frame, bs);
431                 if (stream->next_frame==buffer->last_frame) {
432                         //tX_debug("tX_mad_input(): No new frame? Stopping.");
433                         return MAD_FLOW_STOP;
434                 }
435                 ld_set_progress((float) pos/(float) buffer->size);
436                 buffer->last_frame=stream->next_frame;
437
438                 return MAD_FLOW_CONTINUE;
439         }
440 }
441
442 static enum mad_flow tX_mad_error(void *data, struct mad_stream *stream, struct mad_frame *frame) {
443         tX_mad_buffer *buffer = (tX_mad_buffer *) data;
444         if (MAD_RECOVERABLE(stream->error)) {
445                 if ((stream->error==MAD_ERROR_LOSTSYNC) && (buffer->lost_sync_counter<3)) {
446                         /* Ignore at least two sync errors to not annoy people
447                            about ID3 tags.
448                         */
449                         buffer->lost_sync_counter++;
450                         return MAD_FLOW_CONTINUE;
451                 }
452                 tX_warning("mad reported stream error (%i) '%s'.", stream->error, mad_stream_errorstr(stream));
453                 return MAD_FLOW_CONTINUE;
454         }
455         tX_error("mad reported fatal stream error (%i) '%s'.", stream->error, mad_stream_errorstr(stream));
456         return MAD_FLOW_STOP;
457 }
458
459 /* From minimad.c of mad */
460 static inline signed int scale(mad_fixed_t sample) {
461 //#ifdef BIG_ENDIAN_MACHINE
462 //      swap32_inline(&sample);
463 //#endif
464   /* round */
465   sample += (1L << (MAD_F_FRACBITS - 16));
466
467   /* clip */
468   if (sample >= MAD_F_ONE)
469     sample = MAD_F_ONE - 1;
470   else if (sample < -MAD_F_ONE)
471     sample = -MAD_F_ONE;
472
473   /* quantize */
474   return sample >> (MAD_F_FRACBITS + 1 - 16);
475 }
476
477 static enum mad_flow tX_mad_output(void *data, struct mad_header const *header, struct mad_pcm *pcm) {
478         tX_mad_buffer *buffer=(tX_mad_buffer *) data;
479         unsigned int nchannels, nsamples;
480         mad_fixed_t const *left_ch, *right_ch;  
481
482         nchannels = pcm->channels;
483         nsamples  = pcm->length;
484         left_ch   = pcm->samples[0];
485         right_ch  = pcm->samples[1];
486         buffer->sample_rate = pcm->samplerate;
487         
488         buffer->target_samples+=nsamples;
489
490         buffer->target_buffer=(int16_t *) realloc(buffer->target_buffer, buffer->target_samples<<1);
491         if (!buffer->target_buffer) { 
492                         tX_error("tX_mad_output(): Failed allocating sample memory!\n");
493                         return MAD_FLOW_STOP;
494         }
495                 
496         while (nsamples--) {
497                 signed int sample;
498
499                 if (nchannels==1) {
500                         sample=scale(*left_ch++);
501                 } else {
502                         double sample_l=(double) (*left_ch++);
503                         double sample_r=(double) (*right_ch++); 
504                         double res=(sample_l+sample_r)/2.0;
505                         mad_fixed_t mad_res=(mad_fixed_t) res;
506                         
507                         sample=scale(mad_res);
508                 }
509                 
510                 buffer->target_buffer[buffer->current_sample]=sample;
511                 buffer->current_sample++;
512         }
513
514         return MAD_FLOW_CONTINUE;
515 }
516
517 int tx_audiofile::mad_decode(unsigned char const *start, unsigned long length) {
518         tX_mad_buffer buffer;
519         struct mad_decoder decoder;
520         int result;
521
522         buffer.start  = start;
523         buffer.end = &start[length];
524         buffer.last_frame = NULL;
525         buffer.size = length;
526         buffer.target_buffer = NULL;
527         buffer.target_samples = 0;
528         buffer.current_sample = 0;
529         buffer.first_call=true;
530         buffer.sample_rate=0;
531         buffer.lost_sync_counter=0;
532
533         tX_debug("tx_audiofile::mad_decode() - start %08x, length %i", (int) buffer.start, buffer.size);
534         /* configure input, output, and error functions */
535
536         mad_decoder_init(&decoder, &buffer, tX_mad_input, NULL, NULL, tX_mad_output, tX_mad_error, NULL);
537         result = mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC);
538
539         if (!result) {
540                 this->mem=buffer.target_buffer;
541                 this->no_samples=buffer.target_samples;
542         } else {
543                 if (buffer.target_buffer) free(buffer.target_buffer);
544         }
545         
546         /* release the decoder */
547         mad_decoder_finish(&decoder);  
548
549         sample_rate=buffer.sample_rate;
550   return result;
551 }
552
553 #endif
554
555 /* AARG - OGG loading is not threadsafe !*/
556 size_t tX_ogg_file_size;
557 long tX_ogg_file_read;
558
559 #ifdef USE_VORBIS_INPUT
560 typedef struct {
561   size_t (*read_func) (void *, size_t, size_t, FILE *);
562   int  (*seek_func) (void *, long, int);
563   int (*close_func) (FILE *);
564   long (*tell_func) (FILE *);
565 } tX_ov_callbacks;
566
567 int ogg_seek(void *ptr, long offset, int whence) {
568         /* ogg shall not seek ! */
569         return -1;
570         errno=EBADF;
571 }
572
573 size_t ogg_read(void  *ptr, size_t size, size_t nmemb, FILE *stream) {
574         size_t ret_val;
575         ret_val=fread(ptr, size, nmemb, stream);
576         if (ret_val>0) {
577                 tX_ogg_file_read+=ret_val*size;
578                 ld_set_progress((double) tX_ogg_file_read/(double) tX_ogg_file_size);   
579         }
580         return ret_val;
581 }
582
583 #define VORBIS_BUFF_SIZE 4096 /*recommended*/
584
585 tX_audio_error tx_audiofile::load_vorbis() {
586         tX_debug("tx_audiofile::load_vorbis()");
587         
588         /*  VORBIS Callbacks */
589         ov_callbacks org_callbacks;
590         /* evil casting - to make g++ shut up */
591         tX_ov_callbacks *callbacks=(tX_ov_callbacks *) &org_callbacks;
592         
593         /* buffer */
594         char pcmout[VORBIS_BUFF_SIZE];
595         OggVorbis_File vf;
596         bool eof=false;
597         int current_section=0;
598         unsigned int i;
599         struct stat stat_dat;
600                 
601         callbacks->read_func=ogg_read;
602         callbacks->seek_func=ogg_seek;
603         callbacks->close_func=fclose;
604         callbacks->tell_func=ftell;
605         
606         file=fopen(filename, "r");
607         if (!file) {
608                 return TX_AUDIO_ERR_WAV_NOTFOUND;               
609         }
610         
611         if (fstat(fileno(file), &stat_dat)  == -1 || stat_dat.st_size == 0) {
612                 return TX_AUDIO_ERR_MAD_STAT;
613         }
614         
615         tX_ogg_file_size=stat_dat.st_size;
616         tX_ogg_file_read=0;
617         
618         int res=ov_open_callbacks((void *) file, &vf, NULL, 0, org_callbacks);
619         if (res<0) {
620                 fclose(file); 
621                 file=NULL;
622                 return TX_AUDIO_ERR_VORBIS_OPEN;                
623         }
624         
625         vorbis_info *vi=ov_info(&vf,-1);
626         sample_rate=vi->rate;
627
628         unsigned int channels=vi->channels;     
629         unsigned int samples_read=0;
630         unsigned int mono_samples;
631         int16_t* data=NULL;
632         size_t bytes=0;
633         
634         while((!eof) && (!current_section)) {
635 #ifdef BIG_ENDIAN_MACHINE
636 #       define ENDIANP 1
637 #else
638 #       define ENDIANP 0                
639 #endif
640                 long ret=ov_read(&vf,pcmout,VORBIS_BUFF_SIZE,ENDIANP,2,1,&current_section);
641                 if (ret == 0) {
642                         eof=true;
643                 } else if (ret < 0) {
644                   /* ignore stream errors */
645                 } else {
646                         int16_t *new_data;
647                         bytes+=ret;
648                         new_data=(int16_t *) realloc(data, bytes/channels);
649                         if (!new_data) {
650                                 if (data) free(data);
651                                 return TX_AUDIO_ERR_ALLOC;\r
652                         }
653                         
654                         data=new_data;
655                         int16_t *src=(int16_t *) &pcmout;
656                         
657                         switch (channels) {
658                                 case 1:
659                                         mono_samples=ret/2;
660                                         for (i=0; i<mono_samples; i++) {
661                                                 data[samples_read+i]=src[i];
662                                         }
663                                         break;
664                                         
665                                 case 2:
666                                         mono_samples=ret/4;
667                                         for (i=0; i<mono_samples; i++) {
668                                                 double l_value, r_value;
669                                                 l_value=src[i*2];
670                                                 r_value=src[i*2+1];
671                                                 data[samples_read+i]=(int16_t) ((l_value+r_value)/2.0);
672                                         }
673                                         break;
674                                         
675                                 default:
676                                         mono_samples=(ret/2)/channels;
677                                         for (i=0; i<mono_samples; i++) {
678                                                 double value=0.0;
679                                 
680                                                 for (unsigned int c=0; c<channels; c++) {
681                                                         value+=(double) src[i*channels+c];
682                                                 }
683                                                 value/=(double) channels;
684                                                 data[samples_read+i]=(int16_t) value;
685                                         }               
686                         }
687                         samples_read+=mono_samples;
688                 }
689     }
690         
691         ov_clear(&vf);
692         
693         mem=(int16_t *) data;
694         no_samples=samples_read;
695         
696         if (no_samples==0) {
697                 if (mem) free(mem);
698                 mem=NULL;
699                 return TX_AUDIO_ERR_VORBIS_NODATA;
700         }
701         
702         return TX_AUDIO_SUCCESS;
703 }
704 #endif
705
706 #ifdef USE_AUDIOFILE_INPUT
707 #define TX_AF_SAMPLES_PER_BLOCK 2048
708
709 tX_audio_error tx_audiofile::load_af() {
710         tX_debug("tx_audiofile::load_af()");
711         
712         AFfilehandle af_file;
713         AFframecount    all_frames, frames_read=0, current_frames=1;
714         int16_t *data=NULL;
715         
716         af_file = afOpenFile(filename, "r", NULL);
717         if (af_file==AF_NULL_FILEHANDLE) {
718                 return TX_AUDIO_ERR_AF_OPEN;
719         }
720         
721         all_frames=afGetFrameCount(af_file, AF_DEFAULT_TRACK);
722         sample_rate=(unsigned int) afGetRate(af_file, AF_DEFAULT_TRACK);
723         afSetVirtualChannels(af_file, AF_DEFAULT_TRACK, 1);
724         afSetVirtualSampleFormat(af_file, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 16); // 2 == 16 Bit?
725 #ifdef BIG_ENDIAN_MACHINE
726         afSetVirtualByteOrder(af_file, AF_DEFAULT_TRACK, AF_BYTEORDER_BIGENDIAN);
727 #else
728         afSetVirtualByteOrder(af_file, AF_DEFAULT_TRACK, AF_BYTEORDER_LITTLEENDIAN);
729 #endif
730         
731         while (current_frames) {
732                 int16_t *new_data;
733                 
734                 new_data=(int16_t*) realloc(data, (frames_read+TX_AF_SAMPLES_PER_BLOCK)*2);
735                 if (!new_data) {
736                         if (data) free(data);
737                         afCloseFile(af_file);
738                         return TX_AUDIO_ERR_ALLOC;
739                 }
740                 data=new_data;
741                 current_frames=afReadFrames(af_file,AF_DEFAULT_TRACK,(void *) &data[frames_read],TX_AF_SAMPLES_PER_BLOCK);
742                 frames_read+=current_frames;
743                 ld_set_progress(((double) frames_read)/((double) all_frames));
744         }
745         afCloseFile(af_file);
746         
747         if (!frames_read) {
748                 if (data) free(data);
749                 return TX_AUDIO_ERR_AF_NODATA;
750         }
751         
752         /* shorten to the actually read size of samples */
753         if (!realloc(data, frames_read*2)) {
754                         if (data) free(data);
755                         return TX_AUDIO_ERR_ALLOC;
756         }
757         
758         mem=data;
759         no_samples=frames_read;
760         
761         return TX_AUDIO_SUCCESS;
762 }
763 #endif