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