00a60eb14dbf3c5130d7af268ec351f1187035b1
[terminatorX.git] / src / tX_audiofile.cc
1 /*
2     terminatorX - realtime audio scratching software
3     Copyright (C) 1999-2002  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 #endif
64
65 tx_audiofile :: tx_audiofile()
66 {
67         mem_type=TX_AUDIO_UNDEFINED;
68         file_type=TX_FILE_UNDEFINED;
69         file=NULL;
70         strcpy(filename,"");
71         mem=NULL;
72         no_samples=0;
73         sample_rate=44100;
74 }
75
76 void tx_audiofile :: figure_file_type()
77 {
78         char *ext;
79         
80         ext=strrchr(filename, (int) '.');
81         
82         if (ext)
83         {
84                 if (strlen(ext) >3)
85                 {
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 #ifdef USE_BUILTIN_WAV
105         if ((load_err) && (file_type==TX_FILE_WAV)) {
106                 load_err=load_wav();    
107 //              if (load_err==TX_AUDIO_SUCCESS) return(load_err);
108         }
109 #endif  
110
111 #ifdef USE_MAD_INPUT
112         if ((load_err) && (file_type==TX_FILE_MPG123)) {
113                 load_err=load_mad();
114                 //if (load_err==TX_AUDIO_SUCCESS) return(load_err);
115         }
116 #endif  
117         
118 #ifdef USE_MPG123_INPUT
119         if ((load_err) && (file_type==TX_FILE_MPG123)) {
120                 load_err=load_mpg123();
121                 //return(load_err);
122         }
123 #endif  
124
125 #ifdef USE_VORBIS_INPUT
126         if ((load_err) && (file_type==TX_FILE_OGG123)) {
127                 load_err=load_vorbis();
128                 //if (load_err==TX_AUDIO_SUCCESS) return(load_err);
129         }
130 #endif
131         
132 #ifdef USE_OGG123_INPUT
133         if ((load_err) && (file_type==TX_FILE_OGG123)) {
134                 load_err=load_ogg123();
135                 //return(load_err);
136         }
137 #endif
138
139 #ifdef USE_SOX_INPUT
140         if (load_err) {
141                 load_err=load_sox();
142         }
143 #endif  
144
145         if (!load_err) {
146                 printf("samplerate is :%i\n", sample_rate);
147         }
148         return(load_err);
149 }
150
151 tx_audiofile :: ~tx_audiofile() {
152         switch (mem_type) {
153                 case TX_AUDIO_MMAP: break;
154                 case TX_AUDIO_LOAD: {
155                         free(mem);
156                         break;
157                 }
158         }       
159
160         if (file) {
161                 if (mem_type==TX_AUDIO_MMAP) {
162                         // free mmap
163                 }
164         }
165  }
166  
167 #ifdef NEED_PIPED 
168
169 tX_audio_error tx_audiofile :: load_piped()
170 {
171         int16_t *data=NULL;
172         ssize_t allbytes=0;
173         ssize_t prev_bytes;
174         ssize_t bytes=1;
175         unsigned char buffer[SOX_BLOCKSIZE];
176         unsigned char *ptr;
177         
178         /* Irritating the user... */
179         ld_set_progress(0.5);
180         mem_type=TX_AUDIO_LOAD; 
181         
182         while (bytes) {
183                 bytes = fread(buffer, 1, SOX_BLOCKSIZE, file);
184                 
185                 if (bytes>0) {
186                         prev_bytes=allbytes;
187                         allbytes+=bytes;
188                         int16_t *new_data=(int16_t *) realloc(data, allbytes);
189                         //printf("All: %i, Bytes: %i, new: %08x, old: %08x\n", allbytes, bytes, new_data, data);
190                         
191                         if (!new_data) {
192                                 pclose(file); file=NULL;
193                                 if (data) free(data);
194                                 data=NULL;
195                                 return TX_AUDIO_ERR_ALLOC;
196                         }
197                         
198                         data=new_data;
199                         ptr=(unsigned char *) data;
200                         memcpy((void *) &ptr[prev_bytes],(void *) buffer, bytes);
201                 }
202         }
203         
204         pclose(file); file=NULL;
205         
206         if (!allbytes) {
207                 // If we get here we read zero Bytes...
208                 if (data) free(data);
209                 return TX_AUDIO_ERR_PIPE_READ;
210         }
211         
212         no_samples=allbytes/sizeof(int16_t);
213         mem=data;
214         
215         /* Irritating the user just a little more ;)*/
216         ld_set_progress(1.0);
217         
218         return TX_AUDIO_SUCCESS;
219 }
220
221 #endif
222         
223 #ifdef USE_SOX_INPUT
224 tX_audio_error tx_audiofile :: load_sox()
225 {
226         char command[PATH_MAX*2];
227
228         sprintf(command, SOX_STR, filename);
229         file = popen(command, "r");
230         
231         if (!file) return TX_AUDIO_ERR_SOX;
232         
233         return load_piped();
234         
235 }
236 #endif  
237
238 #ifdef USE_MPG123_INPUT
239 tX_audio_error 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 {
255         char command[PATH_MAX*2];
256
257         sprintf(command, OGG123_STR, filename);
258         file = popen(command, "r");
259
260         if (!file) return TX_AUDIO_ERR_OGG123;
261
262         return load_piped();
263 }
264 #endif
265
266 #ifdef USE_BUILTIN_WAV
267 #define min(a,b) ((a) < (b) ? (a) : (b))
268 tX_audio_error tx_audiofile :: load_wav()
269 {
270         wav_sig wav_in;
271         int16_t *data;
272         int16_t *p;
273         ssize_t allbytes=0;
274         ssize_t bytes=0;
275         int i;
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 #ifdef USE_CONSOLE
285         printf("Loading: %s\n", filename);
286         if (parms.verbose) printf("File: %i Bytes Data, %i Bit Depth, %i Hz Samplerate.\n", wav_in.len, wav_in.depth, wav_in.srate);    
287 #endif  
288
289         if (wav_in.depth != 16)
290         {
291                 return(TX_AUDIO_ERR_NOT_16BIT);
292         }
293
294         if (wav_in.chans != 1)
295         {
296                 return(TX_AUDIO_ERR_NOT_MONO);
297         }
298
299         sample_rate=wav_in.srate;
300         
301 #ifdef USE_CONSOLE      
302         if (wav_in.srate != 44100) 
303         {
304                 puts("[load_wav] Warning: Wave-File was not recorded at 44.100 Hz!");
305         }
306         if (wav_in.blkalign != 2)
307         {
308                 printf("[load_wav] Warning: Unexpected block alignment: %i.\n", wav_in.blkalign);
309         }
310 #endif
311
312         memsize=wav_in.len;
313         data = (int16_t *) malloc (memsize);
314                 
315         if (!data)
316         {
317                 return(TX_AUDIO_ERR_ALLOC);
318         }
319
320         p=data;
321 #ifdef ENABLE_DEBUG_OUTPUT
322         int output=1;
323         unsigned char *debug_p=(unsigned char *) p;
324 #endif  
325         while (wav_in.len>allbytes)
326         {       
327                 bytes = fread(p, 1, min(1024, wav_in.len-allbytes), wav_in.handle);
328
329 #ifdef ENABLE_DEBUG_OUTPUT
330                 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]); }
331 #endif
332
333                 if (bytes<=0) {
334                         free(data);
335                         return (TX_AUDIO_ERR_WAV_READ);
336                 }
337
338 #ifdef BIG_ENDIAN_MACHINE
339                 swapbuffer(p, bytes/sizeof(int16_t));
340 #       ifdef ENABLE_DEBUG_OUTPUT
341                 if (output) { tX_debug("tX_audiofile::load_wav() swapped %i Bytes [%04x %04x %04x %04x %04x %04x ..]",
342                 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]); }
343 #       endif
344 #endif          
345
346 #ifdef ENABLE_DEBUG_OUTPUT
347                 output=0;
348 #endif
349
350                 allbytes+=bytes;
351                 
352                 ld_set_progress((float) allbytes/(float)wav_in.len);
353                 
354                 p+=(ssize_t) bytes/sizeof(int16_t);
355         }
356         
357         wav_close(wav_in.handle);
358
359         mem=data;
360         no_samples=memsize/sizeof(int16_t);
361         
362         return (TX_AUDIO_SUCCESS);
363 }
364 #endif
365
366 #ifdef USE_MAD_INPUT
367 tX_audio_error tx_audiofile::load_mad() {
368         struct stat stat_dat;
369         int fd;
370         int res;
371         void *mp3_file;
372         
373         fd=open(filename, O_RDONLY);
374         if (!fd) return TX_AUDIO_ERR_MAD_OPEN;
375         
376         if (fstat(fd, &stat_dat) == -1 ||
377       stat_dat.st_size == 0) {
378                 return TX_AUDIO_ERR_MAD_STAT;
379         }
380         
381         mp3_file = mmap(0, stat_dat.st_size, PROT_READ, MAP_SHARED, fd, 0);
382         
383         if (mp3_file == MAP_FAILED) {
384                 return TX_AUDIO_ERR_MAD_MMAP;
385         }
386         
387         res=mad_decode((const unsigned char *) mp3_file, stat_dat.st_size);
388         
389         if (res) {
390                 return TX_AUDIO_ERR_MAD_DECODE;
391         }
392         
393         mem_type=TX_AUDIO_LOAD;
394         
395         if (munmap(mp3_file, stat_dat.st_size) == -1) {
396                 return TX_AUDIO_ERR_MAD_MUNMAP;
397         }
398         
399         return TX_AUDIO_SUCCESS;
400 }
401
402 #define TX_MAD_BLOCKSIZE 8096
403
404 typedef struct {
405         const unsigned char *start;
406         const unsigned char *end;
407         const unsigned char *last_frame;
408         bool first_call;
409         ssize_t size;
410         int16_t *target_buffer;
411         unsigned int target_samples;
412         unsigned int current_sample;
413         unsigned int sample_rate;
414 } tX_mad_buffer;
415
416 const unsigned char *last_current=NULL;
417
418 static enum mad_flow tX_mad_input(void *data, struct mad_stream *stream) {
419         tX_mad_buffer *buffer = (tX_mad_buffer *) data;
420         ssize_t bs;
421         unsigned int pos;
422
423         if (buffer->first_call) {
424                 bs=min(TX_MAD_BLOCKSIZE, buffer->size);
425                 mad_stream_buffer(stream, buffer->start, bs);
426                 buffer->first_call=false;
427                 return MAD_FLOW_CONTINUE;
428         } else {
429                 if (!stream->next_frame) return MAD_FLOW_STOP;
430                 
431                 pos=stream->next_frame-buffer->start;
432                 bs=min(TX_MAD_BLOCKSIZE, buffer->size-pos);
433                 //tX_debug("last: %08x, new %08x, bs: %i, pos: %i",  buffer->last_frame, stream->next_frame, bs, pos);
434                 
435                 mad_stream_buffer(stream, stream->next_frame, bs);
436                 if (stream->next_frame==buffer->last_frame) {
437                         //tX_debug("tX_mad_input(): No new frame? Stopping.");
438                         return MAD_FLOW_STOP;
439                 }
440                 ld_set_progress((float) pos/(float) buffer->size);
441                 buffer->last_frame=stream->next_frame;
442
443                 return MAD_FLOW_CONTINUE;
444         }
445 }
446
447 static enum mad_flow tX_mad_error(void *data, struct mad_stream *stream, struct mad_frame *frame) {
448         tX_mad_buffer *buffer = (tX_mad_buffer *) data;
449         tX_error("Error 0x%04x loading via mad: (%s)\n", stream->error, mad_stream_errorstr(stream));
450         return MAD_FLOW_CONTINUE;
451 }
452
453 /* From minimad.c of mad */
454 static inline signed int scale(mad_fixed_t sample) {
455 #ifdef BIG_ENDIAN_MACHINE
456         swap32_inline(&sample);
457 #endif
458   /* round */
459   sample += (1L << (MAD_F_FRACBITS - 16));
460
461   /* clip */
462   if (sample >= MAD_F_ONE)
463     sample = MAD_F_ONE - 1;
464   else if (sample < -MAD_F_ONE)
465     sample = -MAD_F_ONE;
466
467   /* quantize */
468   return sample >> (MAD_F_FRACBITS + 1 - 16);
469 }
470
471 static enum mad_flow tX_mad_output(void *data, struct mad_header const *header, struct mad_pcm *pcm) {
472         tX_mad_buffer *buffer=(tX_mad_buffer *) data;
473         unsigned int nchannels, nsamples;
474         mad_fixed_t const *left_ch, *right_ch;  
475
476         nchannels = pcm->channels;
477         nsamples  = pcm->length;
478         left_ch   = pcm->samples[0];
479         right_ch  = pcm->samples[1];
480         buffer->sample_rate = pcm->samplerate;
481         
482         buffer->target_samples+=nsamples;
483
484         buffer->target_buffer=(int16_t *) realloc(buffer->target_buffer, buffer->target_samples<<1);
485         if (!buffer->target_buffer) { 
486                         tX_error("Failed allocating sample memory!\n");
487                         return MAD_FLOW_STOP;
488         }
489                 
490         while (nsamples--) {
491                 signed int sample;
492
493                 if (nchannels==1) {
494                         sample=scale(*left_ch++);
495                 } else {
496                         double sample_l=(double) (*left_ch++);
497                         double sample_r=(double) (*right_ch++); 
498                         double res=(sample_l+sample_r)/2.0;
499                         mad_fixed_t mad_res=(mad_fixed_t) res;
500                         
501                         sample=scale(mad_res);
502                 }
503                 
504                 buffer->target_buffer[buffer->current_sample]=sample;
505                 buffer->current_sample++;
506         }
507
508         return MAD_FLOW_CONTINUE;
509 }
510
511 int tx_audiofile::mad_decode(unsigned char const *start, unsigned long length) {
512         tX_mad_buffer buffer;
513         struct mad_decoder decoder;
514         int result;
515
516         buffer.start  = start;
517         buffer.end = &start[length];
518         buffer.last_frame = NULL;
519         buffer.size = length;
520         //buffer.next_block = 0;  
521         //buffer.blocks = length/TX_MAD_BLOCKSIZE + (length%TX_MAD_BLOCKSIZE ? 1 : 0);
522         buffer.target_buffer = NULL;
523         buffer.target_samples = 0;
524         buffer.current_sample = 0;
525         buffer.first_call=true;
526         buffer.sample_rate=0;
527
528         tX_debug("tx_audiofile::mad_decode() - start %08x, length %i", buffer.start, buffer.size);
529         /* configure input, output, and error functions */
530
531         mad_decoder_init(&decoder, &buffer, tX_mad_input, NULL, NULL, tX_mad_output, tX_mad_error, NULL);
532         result = mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC);
533
534         if (!result) {
535                 this->mem=buffer.target_buffer;
536                 this->no_samples=buffer.target_samples;
537         } else {
538                 if (buffer.target_buffer) free(buffer.target_buffer);
539         }
540         
541         /* release the decoder */
542         mad_decoder_finish(&decoder);  
543
544         sample_rate=buffer.sample_rate;
545   return result;
546 }
547
548 #endif
549
550 /* AARG - OGG loading is not threadsafe !*/
551 size_t tX_ogg_file_size;
552 long tX_ogg_file_read;
553
554 #ifdef USE_VORBIS_INPUT
555 typedef struct {
556   size_t (*read_func) (void *, size_t, size_t, FILE *);
557   int  (*seek_func) (void *, long, int);
558   int (*close_func) (FILE *);
559   long (*tell_func) (FILE *);
560 } tX_ov_callbacks;
561
562 int ogg_seek(void *ptr, long offset, int whence) {
563         /* ogg shall not seek ! */
564         return -1;
565         errno=EBADF;
566 }
567
568 size_t ogg_read(void  *ptr, size_t size, size_t nmemb, FILE *stream) {
569         size_t ret_val;
570         ret_val=fread(ptr, size, nmemb, stream);
571         if (ret_val>0) {
572                 tX_ogg_file_read+=ret_val*size;
573                 ld_set_progress((double) tX_ogg_file_read/(double) tX_ogg_file_size);   
574         }
575         return ret_val;
576 }
577
578 #define VORBIS_BUFF_SIZE 4096 /*recommended*/
579
580 tX_audio_error tx_audiofile::load_vorbis() {
581         /*  VORBIS Callbacks */
582         ov_callbacks org_callbacks;
583         /* evil casting - to make g++ shut up */
584         tX_ov_callbacks *callbacks=(tX_ov_callbacks *) &org_callbacks;
585         
586         /* buffer */
587         char pcmout[VORBIS_BUFF_SIZE];
588         char mono[VORBIS_BUFF_SIZE];
589         OggVorbis_File vf;
590         bool eof=false;
591         int current_section=0;
592         
593         struct stat stat_dat;
594                 
595         callbacks->read_func=ogg_read;
596         callbacks->seek_func=ogg_seek;
597         callbacks->close_func=fclose;
598         callbacks->tell_func=ftell;
599         
600         file=fopen(filename, "r");
601         if (!file) {
602                 return TX_AUDIO_ERR_WAV_NOTFOUND;               
603         }
604         
605         if (fstat(fileno(file), &stat_dat)  == -1 || stat_dat.st_size == 0) {
606                 return TX_AUDIO_ERR_MAD_STAT;
607         }
608         
609         tX_ogg_file_size=stat_dat.st_size;
610         tX_ogg_file_read=0;
611         
612         int res=ov_open_callbacks((void *) file, &vf, NULL, 0, org_callbacks);
613         if (res<0) {
614                 fclose(file); 
615                 file=NULL;
616                 return TX_AUDIO_ERR_VORBIS_OPEN;                
617         }
618         
619         vorbis_info *vi=ov_info(&vf,-1);
620         sample_rate=vi->rate;
621
622         unsigned int channels=vi->channels;     
623         unsigned int samples_read=0;
624         int16_t* data=NULL;
625         size_t bytes=0;
626         
627         while((!eof) && (!current_section)){
628 #ifdef BIG_ENDIAN_MACHINE
629 #       define ENDIANP 1
630 #else
631 #       define ENDIANP 0                
632 #endif
633                 long ret=ov_read(&vf,pcmout,VORBIS_BUFF_SIZE,ENDIANP,2,1,&current_section);
634                 if (ret == 0) {
635                         eof=true;
636                 } else if (ret < 0) {
637                   /* ignore stream errors */
638                 } else {
639                         int16_t *new_data;
640                         
641                         bytes+=ret;
642                         new_data=(int16_t *) realloc(data, bytes/channels);
643                         if (!new_data) {
644                                 if (data) free(data);
645                                 return TX_AUDIO_ERR_ALLOC;\r
646                         }
647                         data=new_data;
648                         
649                         int mono_samples=(ret/2)/channels;
650                         
651                         int i=0;                        
652                         while (i<mono_samples) {
653                                 int16_t *src=(int16_t *) &pcmout;                               
654                                 double value=0.0;
655                                 
656                                 for (int c=0; c<channels; c++) {
657                                         value+=(double) src[i*channels+c];
658                                 }
659                                 value/=(double) channels;
660                                 
661                                 data[samples_read+i]=(int16_t) value;
662                                 i++;
663                         }
664                         samples_read+=mono_samples;
665                         
666                         //memcpy(&data[last_pos], pcmout, ret);
667                 }
668                 //printf("current %i\n", current_section);
669     }
670         
671         ov_clear(&vf);
672         
673         mem=(int16_t *) data;
674         //no_samples=bytes>>1;
675         no_samples=samples_read;
676         
677         return TX_AUDIO_SUCCESS;
678 }
679 #endif