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