[Stk] RtAudio - Read entire file to memory

[TJF]

Stephen Sinclair schrieb:
> On Tue, Mar 30, 2010 at 12:57 PM, TJF <tjfoerster at web.de> wrote:
>   
>> I did this (s.b.), compiling with warning "conversion from 'double' in
>> 'MY_TYPE'" for this line:
>>
>>  *out++ = 0.0;
>>
>> I changed "int i;" to "unsigned int i;"
>>     
>
> Sorry about that, yes the type is integer so it should have been "*out++ = 0;"
>
>   
>> The compiled code has the same behaviour (doesn't output) ...
>>     
>
> In any case, I can't debug all your code for you, but do you
> understand what it is doing?
>   
I will study it in detail. In my last compiled version "count" was going 
lost... I put it in now (s.b.). Now I can compile it without errors or 
new warnings - but I cannot get it to play... (the old behaviour).

Regards
Thomas


/******************************************/
/*
  playraw.cpp
  by Gary P. Scavone, 2007

  Play a specified raw file.  It is necessary
  that the file be of the same data format as
  defined below.
*/
/******************************************/

#include "RtAudio.h"
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <stdio.h>

/*
typedef char  MY_TYPE;
#define FORMAT RTAUDIO_SINT8
#define SCALE  127.0
*/

typedef signed short  MY_TYPE;
#define FORMAT RTAUDIO_SINT16
#define SCALE  32767.0

/*
typedef signed long  MY_TYPE;
#define FORMAT RTAUDIO_SINT24
#define SCALE  8388607.0

typedef signed long  MY_TYPE;
#define FORMAT RTAUDIO_SINT32
#define SCALE  2147483647.0

typedef float  MY_TYPE;
#define FORMAT RTAUDIO_FLOAT32
#define SCALE  1.0;

typedef double  MY_TYPE;
#define FORMAT RTAUDIO_FLOAT64
#define SCALE  1.0;
*/

// Platform-dependent sleep routines.
#if defined( __WINDOWS_ASIO__ ) || defined( __WINDOWS_DS__ )
  #include <windows.h>
  #define SLEEP( milliseconds ) Sleep( (DWORD) milliseconds )
#else // Unix variants
  #include <unistd.h>
  #define SLEEP( milliseconds ) usleep( (unsigned long) (milliseconds * 
1000.0) )
#endif

void usage( void ) {
  // Error function in case of incorrect command-line
  // argument specifications
  std::cout << "\nuseage: playraw N fs file <device> <channelOffset>\n";
  std::cout << "    where N = number of channels,\n";
  std::cout << "    fs = the sample rate, \n";
  std::cout << "    file = the raw file to play,\n";
  std::cout << "    device = optional device to use (default = 0),\n";
  std::cout << "    and channelOffset = an optional channel offset on 
the device (default = 0).\n\n";
  exit( 0 );
}

struct OutputData {
  FILE *fd;
  void *buffer;
  unsigned int position;
  unsigned int count;
  unsigned int channels;
};

// Interleaved buffers
int output( void *outputBuffer, void *inputBuffer, unsigned int 
nBufferFrames,
            double streamTime, RtAudioStreamStatus status, void *data )
{
  unsigned int i;
  OutputData *oData = (OutputData*) data;
  unsigned int count = fread( outputBuffer, oData->channels * sizeof( 
MY_TYPE ), nBufferFrames, oData->fd);
  if ( count < nBufferFrames ) {
    unsigned int bytes = (nBufferFrames - count) * oData->channels * 
sizeof( MY_TYPE );
    unsigned int startByte = count * oData->channels * sizeof( MY_TYPE );
    memset( (char *)(outputBuffer)+startByte, 0, bytes );
    return 1;
  }
  MY_TYPE *out = (MY_TYPE *)outputBuffer;
  MY_TYPE *buf = &((MY_TYPE *)oData->buffer)[oData->position];
  for (i=0; i < nBufferFrames; i++) {
    if (oData->position < oData->count) {
        *out++ = *buf++;
        ++oData->position;
    } else
        *out++ = 0;
  }
  return (oData->position >= oData->count);
}
           
/*           
{
  OutputData *oData = (OutputData*) data;

  // In general, it's not a good idea to do file input in the audio
  // callback function but I'm doing it here because I don't know the
  // length of the file we are reading.
  unsigned int data.count = fread( outputBuffer, oData->channels * 
sizeof( MY_TYPE ), nBufferFrames, oData->fd);
  if ( count < nBufferFrames ) {
    unsigned int bytes = (nBufferFrames - data.count) * oData->channels 
* sizeof( MY_TYPE );
    unsigned int startByte = data.count * oData->channels * sizeof( 
MY_TYPE );
    memset( (char *)(outputBuffer)+startByte, 0, bytes );
    return 1;
  }

  return 0;
}
*/

int main( int argc, char *argv[] )
{
  unsigned int channels, fs, bufferFrames, device = 0, offset = 0;
  char *file;

  // minimal command-line checking
  if ( argc < 4 || argc > 6 ) usage();

  RtAudio dac;
  if ( dac.getDeviceCount() < 1 ) {
    std::cout << "\nNo audio devices found!\n";
    exit( 0 );
  }

  channels = (unsigned int) atoi( argv[1]) ;
  fs = (unsigned int) atoi( argv[2] );
  file = argv[3];
  if ( argc > 4 )
    device = (unsigned int) atoi( argv[4] );
  if ( argc > 5 )
    offset = (unsigned int) atoi( argv[5] );

// -------- original section playraw.cpp - beginning 
------------------------------------
/*
 OutputData data;
 data.fd = fopen( file, "rb" );
 if ( !data.fd ) {
   std::cout << "Unable to find or open file!\n";
   exit( 1 );
 }
*/
// -------- original - end 
--------------------------------------------------------------

// -------- replaced code - beginning 
---------------------------------------------------

   OutputData data;
   int Size;
   size_t result;
   data.fd = fopen ( file , "rb" );
   std::cout << "\ndata.fd1 " << data.fd << std::endl;
   if (data.fd==NULL) {
       std::cout << "Unable to find or open file!\n";
       exit (1);
   }
   fseek (data.fd , 0 , SEEK_END);
   Size = ftell (data.fd);
   data.buffer = calloc (Size,1);
   std::cout << "\nbuffer:  " << data.buffer << std::endl;
   if (data.buffer == NULL) {
       std::cout << "Memory error!\n";
       exit (2);
   }
   rewind (data.fd);
   result = fread (data.buffer,1,Size,data.fd);
   std::cout << "\ndata.fd2 " << data.fd << std::endl;
   if (result != Size) {
       std::cout << "Reading error!\n";
       exit (3);
   }

// -------- replaced code - end 
---------------------------------------------------------


  // Set our stream parameters for output only.
  bufferFrames = 512;
  RtAudio::StreamParameters oParams;
  oParams.deviceId = device;
  oParams.nChannels = channels;
  oParams.firstChannel = offset;

  data.channels = channels;
  try {
    dac.openStream( &oParams, NULL, FORMAT, fs, &bufferFrames, &output, 
(void *)&data );
    dac.startStream();
  }
  catch ( RtError& e ) {
    std::cout << '\n' << e.getMessage() << '\n' << std::endl;
    goto cleanup;
  }

  std::cout << "\nPlaying raw file " << file << " (buffer frames = " << 
bufferFrames << ")." << std::endl;
  while ( 1 ) {
    SLEEP( 100 ); // wake every 100 ms to check if we're done
    if ( dac.isStreamRunning() == false ) break;
  }

 cleanup:
  fclose( data.fd );
  dac.closeStream();

  return 0;
}