falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1238 Commits
16 Branches
299MB
Tree: f0dcea3da9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f0dcea3da9'
${ noResults }
Carla/source/modules/stk/stk/FileRead.cpp

887 lines
28KB
Raw Blame History 

  1. /***************************************************/

  2. /*! \class FileRead

  3.     \brief STK audio file input class.

  4. 

  5.     This class provides input support for various

  6.     audio file formats.  Multi-channel (>2)

  7.     soundfiles are supported.  The file data is

  8.     returned via an external StkFrames object

  9.     passed to the read() function.  This class

  10.     does not store its own copy of the file data,

  11.     rather the data is read directly from disk.

  12. 

  13.     FileRead currently supports uncompressed WAV,

  14.     AIFF/AIFC, SND (AU), MAT-file (Matlab), and

  15.     STK RAW file formats.  Signed integer (8-,

  16.     16-, 24- and 32-bit) and floating-point (32- and

  17.     64-bit) data types are supported.  Compressed

  18.     data types are not supported.

  19. 

  20.     STK RAW files have no header and are assumed to

  21.     contain a monophonic stream of 16-bit signed

  22.     integers in big-endian byte order at a sample

  23.     rate of 22050 Hz.  MAT-file data should be saved

  24.     in an array with each data channel filling a

  25.     matrix row.  The sample rate for MAT-files should

  26.     be specified in a variable named "fs".  If no

  27.     such variable is found, the sample rate is

  28.     assumed to be 44100 Hz.

  29. 

  30.     by Perry R. Cook and Gary P. Scavone, 1995 - 2007.

  31. */

  32. /***************************************************/

  33. 

  34. #include "FileRead.h"

  35. #include <sys/stat.h>

  36. #include <sys/types.h>

  37. #include <cstring>

  38. #include <cmath>

  39. #include <cstdio>

  40. 

  41. namespace stk {

  42. 

  43. FileRead :: FileRead()

  44.   : fd_(0), fileSize_(0), channels_(0), dataType_(0), fileRate_(0.0)

  45. {

  46. }

  47. 

  48. FileRead :: FileRead( std::string fileName, bool typeRaw, unsigned int nChannels,

  49.                       StkFormat format, StkFloat rate )

  50.   : fd_(0)

  51. {

  52.   open( fileName, typeRaw, nChannels, format, rate );

  53. }

  54. 

  55. FileRead :: ~FileRead()

  56. {

  57.   if ( fd_ )

  58.     fclose( fd_ );

  59. }

  60. 

  61. void FileRead :: close( void )

  62. {

  63.   if ( fd_ ) fclose( fd_ );

  64.   fd_ = 0;

  65.   wavFile_ = false;

  66.   fileSize_ = 0;

  67.   channels_ = 0;

  68.   dataType_ = 0;

  69.   fileRate_ = 0.0;

  70. }

  71. 

  72. bool FileRead :: isOpen( void )

  73. {

  74.   if ( fd_ ) return true;

  75.   else return false;

  76. }

  77. 

  78. void FileRead :: open( std::string fileName, bool typeRaw, unsigned int nChannels,

  79.                        StkFormat format, StkFloat rate )

  80. {

  81.   // If another file is open, close it.

  82.   close();

  83. 

  84.   // Try to open the file.

  85.   fd_ = fopen( fileName.c_str(), "rb" );

  86.   if ( !fd_ ) {

  87.     oStream_ << "FileRead::open: could not open or find file (" << fileName << ")!";

  88.     handleError( StkError::FILE_NOT_FOUND );

  89.   }

  90. 

  91.   // Attempt to determine file type from header (unless RAW).

  92.   bool result = false;

  93.   if ( typeRaw )

  94.     result = getRawInfo( fileName.c_str(), nChannels, format, rate );

  95.   else {

  96.     char header[12];

  97.     if ( fread( &header, 4, 3, fd_ ) != 3 ) goto error;

  98.     if ( !strncmp( header, "RIFF", 4 ) &&

  99.          !strncmp( &header[8], "WAVE", 4 ) )

  100.       result = getWavInfo( fileName.c_str() );

  101.     else if ( !strncmp( header, ".snd", 4 ) )

  102.       result = getSndInfo( fileName.c_str() );

  103.     else if ( !strncmp( header, "FORM", 4 ) &&

  104.               ( !strncmp( &header[8], "AIFF", 4 ) || !strncmp(&header[8], "AIFC", 4) ) )

  105.       result = getAifInfo( fileName.c_str() );

  106.     else {

  107.       if ( fseek( fd_, 126, SEEK_SET ) == -1 ) goto error;

  108.       if ( fread( &header, 2, 1, fd_ ) != 1 ) goto error;

  109.       if ( !strncmp( header, "MI", 2 ) ||

  110.            !strncmp( header, "IM", 2 ) )

  111.         result = getMatInfo( fileName.c_str() );

  112.       else {

  113.         oStream_ << "FileRead::open: file (" << fileName << ") format unknown.";

  114.         handleError( StkError::FILE_UNKNOWN_FORMAT );

  115.       }

  116.     }

  117.   }

  118. 

  119.   // If here, we had a file type candidate but something else went wrong.

  120.   if ( result == false )

  121.     handleError( StkError::FILE_ERROR );

  122. 

  123.   // Check for empty files.

  124.   if ( fileSize_ == 0 ) {

  125.     oStream_ << "FileRead::open: file (" << fileName << ") data size is zero!";

  126.     handleError( StkError::FILE_ERROR );

  127.   }

  128. 

  129.   return;

  130. 

  131.  error:

  132.   oStream_ << "FileRead::open: error reading file (" << fileName << ")!";

  133.   handleError( StkError::FILE_ERROR );

  134. }

  135. 

  136. bool FileRead :: getRawInfo( const char *fileName, unsigned int nChannels, StkFormat format, StkFloat rate )

  137. {

  138.   // Use the system call "stat" to determine the file length.

  139.   struct stat filestat;

  140.   if ( stat(fileName, &filestat) == -1 ) {

  141.     oStream_ << "FileRead: Could not stat RAW file (" << fileName << ").";

  142.     return false;

  143.   }

  144. 

  145.   // Rawwave files have no header and by default, are assumed to

  146.   // contain a monophonic stream of 16-bit signed integers in

  147.   // big-endian byte order at a sample rate of 22050 Hz.  However,

  148.   // different parameters can be specified if desired.

  149.   dataOffset_ = 0;

  150.   channels_ = nChannels;

  151.   dataType_ = format;

  152.   fileRate_ = rate;

  153.   int sampleBytes = 0;

  154.   if ( format == STK_SINT8 ) sampleBytes = 1;

  155.   else if ( format == STK_SINT16 ) sampleBytes = 2;

  156.   else if ( format == STK_SINT32 || format == STK_FLOAT32 ) sampleBytes = 4;

  157.   else if ( format == STK_FLOAT64 ) sampleBytes = 8;

  158. 

  159.   fileSize_ = (long) filestat.st_size / sampleBytes / channels_;  // length in frames

  160. 

  161.   byteswap_ = false;

  162. #ifdef __LITTLE_ENDIAN__

  163.   byteswap_ = true;

  164. #endif

  165. 

  166.   return true;

  167. }

  168. 

  169. bool FileRead :: getWavInfo( const char *fileName )

  170. {

  171.   // Find "format" chunk ... it must come before the "data" chunk.

  172.   char id[4];

  173.   SINT32 chunkSize;

  174.   if ( fread(&id, 4, 1, fd_) != 1 ) goto error;

  175.   while ( strncmp(id, "fmt ", 4) ) {

  176.     if ( fread(&chunkSize, 4, 1, fd_) != 1 ) goto error;

  177. #ifndef __LITTLE_ENDIAN__

  178.     swap32((unsigned char *)&chunkSize);

  179. #endif

  180.     if ( fseek(fd_, chunkSize, SEEK_CUR) == -1 ) goto error;

  181.     if ( fread(&id, 4, 1, fd_) != 1 ) goto error;

  182.   }

  183. 

  184.   // Check that the data is not compressed.

  185.   unsigned short format_tag;

  186.   if ( fread(&chunkSize, 4, 1, fd_) != 1 ) goto error; // Read fmt chunk size.

  187.   if ( fread(&format_tag, 2, 1, fd_) != 1 ) goto error;

  188. #ifndef __LITTLE_ENDIAN__

  189.   swap16((unsigned char *)&format_tag);

  190.   swap32((unsigned char *)&chunkSize);

  191. #endif

  192.   if ( format_tag == 0xFFFE ) { // WAVE_FORMAT_EXTENSIBLE

  193.     dataOffset_ = ftell(fd_);

  194.     if ( fseek(fd_, 14, SEEK_CUR) == -1 ) goto error;

  195.     unsigned short extSize;

  196.     if ( fread(&extSize, 2, 1, fd_) != 1 ) goto error;

  197. #ifndef __LITTLE_ENDIAN__

  198.     swap16((unsigned char *)&extSize);

  199. #endif

  200.     if ( extSize == 0 ) goto error;

  201.     if ( fseek(fd_, 6, SEEK_CUR) == -1 ) goto error;

  202.     if ( fread(&format_tag, 2, 1, fd_) != 1 ) goto error;

  203. #ifndef __LITTLE_ENDIAN__

  204.     swap16((unsigned char *)&format_tag);

  205. #endif

  206.     if ( fseek(fd_, dataOffset_, SEEK_SET) == -1 ) goto error;

  207.   }

  208.   if ( format_tag != 1 && format_tag != 3 ) { // PCM = 1, FLOAT = 3

  209.     oStream_ << "FileRead: "<< fileName << " contains an unsupported data format type (" << format_tag << ").";

  210.     return false;

  211.   }

  212. 

  213.   // Get number of channels from the header.

  214.   SINT16 temp;

  215.   if ( fread(&temp, 2, 1, fd_) != 1 ) goto error;

  216. #ifndef __LITTLE_ENDIAN__

  217.   swap16((unsigned char *)&temp);

  218. #endif

  219.   channels_ = (unsigned int ) temp;

  220. 

  221.   // Get file sample rate from the header.

  222.   SINT32 srate;

  223.   if ( fread(&srate, 4, 1, fd_) != 1 ) goto error;

  224. #ifndef __LITTLE_ENDIAN__

  225.   swap32((unsigned char *)&srate);

  226. #endif

  227.   fileRate_ = (StkFloat) srate;

  228. 

  229.   // Determine the data type.

  230.   dataType_ = 0;

  231.   if ( fseek(fd_, 6, SEEK_CUR) == -1 ) goto error;   // Locate bits_per_sample info.

  232.   if ( fread(&temp, 2, 1, fd_) != 1 ) goto error;

  233. #ifndef __LITTLE_ENDIAN__

  234.   swap16((unsigned char *)&temp);

  235. #endif

  236.   if ( format_tag == 1 ) {

  237.     if ( temp == 8 )

  238.       dataType_ = STK_SINT8;

  239.     else if ( temp == 16 )

  240.       dataType_ = STK_SINT16;

  241.     else if ( temp == 24 )

  242.       dataType_ = STK_SINT24;

  243.     else if ( temp == 32 )

  244.       dataType_ = STK_SINT32;

  245.   }

  246.   else if ( format_tag == 3 ) {

  247.     if ( temp == 32 )

  248.       dataType_ = STK_FLOAT32;

  249.     else if ( temp == 64 )

  250.       dataType_ = STK_FLOAT64;

  251.   }

  252.   if ( dataType_ == 0 ) {

  253.     oStream_ << "FileRead: " << temp << " bits per sample with data format " << format_tag << " are not supported (" << fileName << ").";

  254.     return false;

  255.   }

  256. 

  257.   // Jump over any remaining part of the "fmt" chunk.

  258.   if ( fseek(fd_, chunkSize-16, SEEK_CUR) == -1 ) goto error;

  259. 

  260.   // Find "data" chunk ... it must come after the "fmt" chunk.

  261.   if ( fread(&id, 4, 1, fd_) != 1 ) goto error;

  262. 

  263.   while ( strncmp(id, "data", 4) ) {

  264.     if ( fread(&chunkSize, 4, 1, fd_) != 1 ) goto error;

  265. #ifndef __LITTLE_ENDIAN__

  266.     swap32((unsigned char *)&chunkSize);

  267. #endif

  268.     chunkSize += chunkSize % 2; // chunk sizes must be even

  269.     if ( fseek(fd_, chunkSize, SEEK_CUR) == -1 ) goto error;

  270.     if ( fread(&id, 4, 1, fd_) != 1 ) goto error;

  271.   }

  272. 

  273.   // Get length of data from the header.

  274.   SINT32 bytes;

  275.   if ( fread(&bytes, 4, 1, fd_) != 1 ) goto error;

  276. #ifndef __LITTLE_ENDIAN__

  277.   swap32((unsigned char *)&bytes);

  278. #endif

  279.   fileSize_ = bytes / temp / channels_;  // sample frames

  280.   fileSize_ *= 8;  // sample frames

  281. 

  282.   dataOffset_ = ftell(fd_);

  283.   byteswap_ = false;

  284. #ifndef __LITTLE_ENDIAN__

  285.   byteswap_ = true;

  286. #endif

  287. 

  288.   wavFile_ = true;

  289.   return true;

  290. 

  291.  error:

  292.   oStream_ << "FileRead: error reading WAV file (" << fileName << ").";

  293.   return false;

  294. }

  295. 

  296. bool FileRead :: getSndInfo( const char *fileName )

  297. {

  298.   // Determine the data type.

  299.   UINT32 format;

  300.   if ( fseek(fd_, 12, SEEK_SET) == -1 ) goto error;   // Locate format

  301.   if ( fread(&format, 4, 1, fd_) != 1 ) goto error;

  302. #ifdef __LITTLE_ENDIAN__

  303.     swap32((unsigned char *)&format);

  304. #endif

  305. 

  306.   if (format == 2) dataType_ = STK_SINT8;

  307.   else if (format == 3) dataType_ = STK_SINT16;

  308.   else if (format == 4) dataType_ = STK_SINT24;

  309.   else if (format == 5) dataType_ = STK_SINT32;

  310.   else if (format == 6) dataType_ = STK_FLOAT32;

  311.   else if (format == 7) dataType_ = STK_FLOAT64;

  312.   else {

  313.     oStream_ << "FileRead: data format in file " << fileName << " is not supported.";

  314.     return false;

  315.   }

  316. 

  317.   // Get file sample rate from the header.

  318.   UINT32 srate;

  319.   if ( fread(&srate, 4, 1, fd_) != 1 ) goto error;

  320. #ifdef __LITTLE_ENDIAN__

  321.   swap32((unsigned char *)&srate);

  322. #endif

  323.   fileRate_ = (StkFloat) srate;

  324. 

  325.   // Get number of channels from the header.

  326.   UINT32 chans;

  327.   if ( fread(&chans, 4, 1, fd_) != 1 ) goto error;

  328. #ifdef __LITTLE_ENDIAN__

  329.   swap32((unsigned char *)&chans);

  330. #endif

  331.   channels_ = chans;

  332. 

  333.   UINT32 offset;

  334.   if ( fseek(fd_, 4, SEEK_SET) == -1 ) goto error;

  335.   if ( fread(&offset, 4, 1, fd_) != 1 ) goto error;

  336. #ifdef __LITTLE_ENDIAN__

  337.   swap32((unsigned char *)&offset);

  338. #endif

  339.   dataOffset_ = offset;

  340. 

  341.   // Get length of data from the header.

  342.   if ( fread(&fileSize_, 4, 1, fd_) != 1 ) goto error;

  343. #ifdef __LITTLE_ENDIAN__

  344.   swap32((unsigned char *)&fileSize_);

  345. #endif

  346.   // Convert to sample frames.

  347.   if ( dataType_ == STK_SINT8 )

  348.     fileSize_ /= channels_;

  349.   if ( dataType_ == STK_SINT16 )

  350.     fileSize_ /= 2 * channels_;

  351.   else if ( dataType_ == STK_SINT24 )

  352.     fileSize_ /= 3 * channels_;

  353.   else if ( dataType_ == STK_SINT32 || dataType_ == STK_FLOAT32 )

  354.     fileSize_ /= 4 * channels_;

  355.   else if ( dataType_ == STK_FLOAT64 )

  356.     fileSize_ /= 8 * channels_;

  357. 

  358.   byteswap_ = false;

  359. #ifdef __LITTLE_ENDIAN__

  360.   byteswap_ = true;

  361. #endif

  362. 

  363.   return true;

  364. 

  365.  error:

  366.   oStream_ << "FileRead: Error reading SND file (" << fileName << ").";

  367.   return false;

  368. }

  369. 

  370. bool FileRead :: getAifInfo( const char *fileName )

  371. {

  372.   bool aifc = false;

  373.   char id[4];

  374. 

  375.   // Determine whether this is AIFF or AIFC.

  376.   if ( fseek(fd_, 8, SEEK_SET) == -1 ) goto error;

  377.   if ( fread(&id, 4, 1, fd_) != 1 ) goto error;

  378.   if ( !strncmp(id, "AIFC", 4) ) aifc = true;

  379. 

  380.   // Find "common" chunk

  381.   SINT32 chunkSize;

  382.   if ( fread(&id, 4, 1, fd_) != 1) goto error;

  383.   while ( strncmp(id, "COMM", 4) ) {

  384.     if ( fread(&chunkSize, 4, 1, fd_) != 1 ) goto error;

  385. #ifdef __LITTLE_ENDIAN__

  386.     swap32((unsigned char *)&chunkSize);

  387. #endif

  388.     chunkSize += chunkSize % 2; // chunk sizes must be even

  389.     if ( fseek(fd_, chunkSize, SEEK_CUR) == -1 ) goto error;

  390.     if ( fread(&id, 4, 1, fd_) != 1 ) goto error;

  391.   }

  392. 

  393.   // Get number of channels from the header.

  394.   SINT16 temp;

  395.   if ( fseek(fd_, 4, SEEK_CUR) == -1 ) goto error; // Jump over chunk size

  396.   if ( fread(&temp, 2, 1, fd_) != 1 ) goto error;

  397. #ifdef __LITTLE_ENDIAN__

  398.   swap16((unsigned char *)&temp);

  399. #endif

  400.   channels_ = temp;

  401. 

  402.   // Get length of data from the header.

  403.   SINT32 frames;

  404.   if ( fread(&frames, 4, 1, fd_) != 1 ) goto error;

  405. #ifdef __LITTLE_ENDIAN__

  406.   swap32((unsigned char *)&frames);

  407. #endif

  408.   fileSize_ = frames; // sample frames

  409. 

  410.   // Read the number of bits per sample.

  411.   if ( fread(&temp, 2, 1, fd_) != 1 ) goto error;

  412. #ifdef __LITTLE_ENDIAN__

  413.   swap16((unsigned char *)&temp);

  414. #endif

  415. 

  416.   // Get file sample rate from the header.  For AIFF files, this value

  417.   // is stored in a 10-byte, IEEE Standard 754 floating point number,

  418.   // so we need to convert it first.

  419.   unsigned char srate[10];

  420.   unsigned char exp;

  421.   unsigned long mantissa;

  422.   unsigned long last;

  423.   if ( fread(&srate, 10, 1, fd_) != 1 ) goto error;

  424.   mantissa = (unsigned long) *(unsigned long *)(srate+2);

  425. #ifdef __LITTLE_ENDIAN__

  426.   swap32((unsigned char *)&mantissa);

  427. #endif

  428.   exp = 30 - *(srate+1);

  429.   last = 0;

  430.   while (exp--) {

  431.     last = mantissa;

  432.     mantissa >>= 1;

  433.   }

  434.   if (last & 0x00000001) mantissa++;

  435.   fileRate_ = (StkFloat) mantissa;

  436. 

  437.   // Determine the data format.

  438.   dataType_ = 0;

  439.   if ( aifc == false ) {

  440.     if ( temp <= 8 ) dataType_ = STK_SINT8;

  441.     else if ( temp <= 16 ) dataType_ = STK_SINT16;

  442.     else if ( temp <= 24 ) dataType_ = STK_SINT24;

  443.     else if ( temp <= 32 ) dataType_ = STK_SINT32;

  444.   }

  445.   else {

  446.     if ( fread(&id, 4, 1, fd_) != 1 ) goto error;

  447.     if ( !strncmp(id, "NONE", 4) ) {

  448.       if ( temp <= 8 ) dataType_ = STK_SINT8;

  449.       else if ( temp <= 16 ) dataType_ = STK_SINT16;

  450.       else if ( temp <= 24 ) dataType_ = STK_SINT24;

  451.       else if ( temp <= 32 ) dataType_ = STK_SINT32;

  452.     }

  453.     else if ( (!strncmp(id, "fl32", 4) || !strncmp(id, "FL32", 4)) && temp == 32 ) dataType_ = STK_FLOAT32;

  454.     else if ( (!strncmp(id, "fl64", 4) || !strncmp(id, "FL64", 4)) && temp == 64 ) dataType_ = STK_FLOAT64;

  455.   }

  456.   if ( dataType_ == 0 ) {

  457.     oStream_ << "FileRead: AIFF/AIFC file (" << fileName << ") has unsupported data type (" << id << ").";

  458.     return false;

  459.   }

  460. 

  461.   // Start at top to find data (SSND) chunk ... chunk order is undefined.

  462.   if ( fseek(fd_, 12, SEEK_SET) == -1 ) goto error;

  463. 

  464.   // Find data (SSND) chunk

  465.   if ( fread(&id, 4, 1, fd_) != 1 ) goto error;

  466.   while ( strncmp(id, "SSND", 4) ) {

  467.     if ( fread(&chunkSize, 4, 1, fd_) != 1 ) goto error;

  468. #ifdef __LITTLE_ENDIAN__

  469.     swap32((unsigned char *)&chunkSize);

  470. #endif

  471.     chunkSize += chunkSize % 2; // chunk sizes must be even

  472.     if ( fseek(fd_, chunkSize, SEEK_CUR) == -1 ) goto error;

  473.     if ( fread(&id, 4, 1, fd_) != 1 ) goto error;

  474.   }

  475. 

  476.   // Skip over chunk size, offset, and blocksize fields

  477.   if ( fseek(fd_, 12, SEEK_CUR) == -1 ) goto error;

  478. 

  479.   dataOffset_ = ftell(fd_);

  480.   byteswap_ = false;

  481. #ifdef __LITTLE_ENDIAN__

  482.   byteswap_ = true;

  483. #endif

  484. 

  485.   return true;

  486. 

  487.  error:

  488.   oStream_ << "FileRead: Error reading AIFF file (" << fileName << ").";

  489.   return false;

  490. }

  491. 

  492. bool FileRead :: findNextMatArray( SINT32 *chunkSize, SINT32 *rows, SINT32 *columns, SINT32 *nametype )

  493. {

  494.   // Look for the next data array element. The file pointer should be

  495.   // at the data element type when this function is called.

  496.   SINT32 datatype;

  497.   *chunkSize = 0;

  498.   do {

  499.     if ( fseek(fd_, *chunkSize, SEEK_CUR) == -1 ) return false;

  500.     if ( fread(&datatype, 4, 1, fd_) != 1 ) return false;

  501.     if ( byteswap_ ) swap32((unsigned char *)&datatype);

  502.     if ( fread(chunkSize, 4, 1, fd_) != 1 ) return false;

  503.     if ( byteswap_ ) swap32((unsigned char *)chunkSize);

  504.   } while ( datatype != 14 );

  505. 

  506.   // Check dimension subelement size to make sure 2D

  507.   if ( fseek(fd_, 20, SEEK_CUR) == -1 ) return false;

  508.   SINT32 size;

  509.   if ( fread(&size, 4, 1, fd_) != 1 ) return false;

  510.   if ( byteswap_ ) swap32((unsigned char *)&size);

  511.   if ( size != 8 ) return false;

  512. 

  513.   // Read dimensions data

  514.   if ( fread(rows, 4, 1, fd_) != 1 ) return false;

  515.   if ( byteswap_ ) swap32((unsigned char *)rows);

  516.   if ( fread(columns, 4, 1, fd_) != 1 ) return false;

  517.   if ( byteswap_ ) swap32((unsigned char *)columns);

  518. 

  519.   // Read array name subelement type

  520.   if ( fread(nametype, 4, 1, fd_) != 1 ) return false;

  521.   if ( byteswap_ ) swap32((unsigned char *)nametype);

  522. 

  523.   return true;

  524. }

  525. 

  526. bool FileRead :: getMatInfo( const char *fileName )

  527. {

  528.   // MAT-file formatting information is available at:

  529.   // http://www.mathworks.com/access/helpdesk/help/pdf_doc/matlab/matfile_format.pdf

  530. 

  531.   // Verify this is a version 5 MAT-file format.

  532.   char head[5];

  533.   if ( fseek(fd_, 0, SEEK_SET) == -1 ) goto error;

  534.   if ( fread(&head, 4, 1, fd_) != 1 ) goto error;

  535.   // If any of the first 4 characters of the header = 0, then this is

  536.   // a Version 4 MAT-file.

  537.   head[4] = '\0';

  538.   if ( strstr(head, "0") ) {

  539.     oStream_ << "FileRead: " << fileName << " appears to be a Version 4 MAT-file, which is not currently supported.";

  540.     return false;

  541.   }

  542. 

  543.   // Determine the endian-ness of the file.

  544.   char mi[2];

  545.   byteswap_ = false;

  546.   // Locate "M" and "I" characters in header.

  547.   if ( fseek(fd_, 126, SEEK_SET) == -1 ) goto error;

  548.   if ( fread(&mi, 2, 1, fd_) != 1) goto error;

  549. #ifdef __LITTLE_ENDIAN__

  550.   if ( !strncmp(mi, "MI", 2) )

  551.     byteswap_ = true;

  552.   else if ( strncmp(mi, "IM", 2) ) goto error;

  553. #else

  554.   if ( !strncmp(mi, "IM", 2))

  555.     byteswap_ = true;

  556.   else if ( strncmp(mi, "MI", 2) ) goto error;

  557. #endif

  558. 

  559.   // We are expecting a data element containing the audio data and an

  560.   // optional data element containing the sample rate (with an array

  561.   // name of "fs").  Both elements should be stored as a Matlab array

  562.   // type (14).

  563. 

  564.   bool doneParsing, haveData, haveSampleRate;

  565.   SINT32 chunkSize, rows, columns, nametype;

  566.   int dataoffset;

  567.   doneParsing = false;

  568.   haveData = false;

  569.   haveSampleRate = false;

  570.   while ( !doneParsing ) {

  571. 

  572.     dataoffset = ftell( fd_ ); // save location in file

  573.     if ( findNextMatArray( &chunkSize, &rows, &columns, &nametype ) == false ) {

  574.       // No more Matlab array type chunks found.

  575.       if ( !haveData ) {

  576.         oStream_ << "FileRead: No audio data found in MAT-file (" << fileName << ").";

  577.         return false;

  578.       }

  579.       else if ( !haveSampleRate ) {

  580.         fileRate_ = 44100.0;

  581.         oStream_ << "FileRead: No sample rate found ... assuming 44100.0";

  582.         handleError( StkError::WARNING );

  583.         return true;

  584.       }

  585.       else return true;

  586.     }

  587. 

  588.     if ( !haveSampleRate && rows == 1 && columns == 1 ) { // Parse for sample rate.

  589. 

  590.       SINT32 namesize = 4;

  591.       if ( nametype == 1 ) { // array name > 4 characters

  592.         if ( fread(&namesize, 4, 1, fd_) != 1 ) goto error;

  593.         if ( byteswap_ ) swap32((unsigned char *)namesize);

  594.         if ( namesize != 2 ) goto tryagain; // expecting name = "fs"

  595.         namesize = 8; // field must be padded to multiple of 8 bytes

  596.       }

  597.       char name[3]; name[2] = '\0';

  598.       if ( fread(&name, 2, 1, fd_) != 1) goto error;

  599.       if ( strncmp(name, "fs", 2) ) goto tryagain;

  600. 

  601.       // Jump to real part data subelement, which is likely to be in a

  602.       // small data format.

  603.       if ( fseek(fd_, namesize-2, SEEK_CUR) == -1 ) goto error;

  604.       UINT32 type;

  605.       StkFloat srate;

  606.       if ( fread(&type, 4, 1, fd_) != 1 ) goto error;

  607.       if ( byteswap_ ) swap32((unsigned char *)&type);

  608.       if ( (type & 0xffff0000) != 0 ) // small data format

  609.         type = (type & 0x0000ffff);

  610.       else

  611.         if ( fseek(fd_, 4, SEEK_CUR) == -1 ) goto error;

  612.       if ( type == 1 ) { // SINT8

  613.         signed char rate;

  614.         if ( fread(&rate, 1, 1, fd_) != 1 ) goto error;

  615.         srate = (StkFloat) rate;

  616.       }

  617.       if ( type == 2 ) { // UINT8

  618.         unsigned char rate;

  619.         if ( fread(&rate, 1, 1, fd_) != 1 ) goto error;

  620.         srate = (StkFloat) rate;

  621.       }

  622.       else if ( type == 3 ) { // SINT16

  623.         SINT16 rate;

  624.         if ( fread(&rate, 2, 1, fd_) != 1 ) goto error;

  625.         if ( byteswap_ ) swap16((unsigned char *)&rate);

  626.         srate = (StkFloat) rate;

  627.       }

  628.       else if ( type == 4 ) { // UINT16

  629.         UINT16 rate;

  630.         if ( fread(&rate, 2, 1, fd_) != 1 ) goto error;

  631.         if ( byteswap_ ) swap16((unsigned char *)&rate);

  632.         srate = (StkFloat) rate;

  633.       }

  634.       else if ( type == 5 ) { // SINT32

  635.         SINT32 rate;

  636.         if ( fread(&rate, 4, 1, fd_) != 1 ) goto error;

  637.         if ( byteswap_ ) swap32((unsigned char *)&rate);

  638.         srate = (StkFloat) rate;

  639.       }

  640.       else if ( type == 6 ) { // UINT32

  641.         UINT32 rate;

  642.         if ( fread(&rate, 4, 1, fd_) != 1 ) goto error;

  643.         if ( byteswap_ ) swap32((unsigned char *)&rate);

  644.         srate = (StkFloat) rate;

  645.       }

  646.       else if ( type == 7 ) { // FLOAT32

  647.         FLOAT32 rate;

  648.         if ( fread(&rate, 4, 1, fd_) != 1 ) goto error;

  649.         if ( byteswap_ ) swap32((unsigned char *)&rate);

  650.         srate = (StkFloat) rate;

  651.       }

  652.       else if ( type == 9 ) { // FLOAT64

  653.         FLOAT64 rate;

  654.         if ( fread(&rate, 8, 1, fd_) != 1 ) goto error;

  655.         if ( byteswap_ ) swap64((unsigned char *)&rate);

  656.         srate = (StkFloat) rate;

  657.       }

  658.       else

  659.         goto tryagain;

  660. 

  661.       if ( srate > 0 ) fileRate_ = srate;

  662.       haveSampleRate = true;

  663.     }

  664.     else if ( !haveData ) { // Parse for data.

  665. 

  666.       // Assume channels = smaller of rows or columns.

  667.       if ( rows < columns ) {

  668.         channels_ = rows;

  669.         fileSize_ = columns;

  670.       }

  671.       else {

  672.         oStream_ << "FileRead: Transpose the MAT-file array so that audio channels fill matrix rows (not columns).";

  673.         return false;

  674.       }

  675. 

  676.       SINT32 namesize = 4;

  677.       if ( nametype == 1 ) { // array name > 4 characters

  678.         if ( fread(&namesize, 4, 1, fd_) != 1 ) goto error;

  679.         if ( byteswap_ ) swap32((unsigned char *)namesize);

  680.         namesize = (SINT32) ceil((float)namesize / 8);

  681.         if ( fseek( fd_, namesize*8, SEEK_CUR) == -1 ) goto error;  // jump over array name

  682.       }

  683.       else {

  684.         if ( fseek( fd_, 4, SEEK_CUR ) == -1 ) goto error;

  685.       }

  686. 

  687.       // Now at real part data subelement

  688.       SINT32 type;

  689.       if ( fread(&type, 4, 1, fd_) != 1 ) goto error;

  690.       if ( byteswap_ ) swap32((unsigned char *)&type);

  691.       if ( type == 1 )  dataType_ = STK_SINT8;

  692.       else if ( type == 3 ) dataType_ = STK_SINT16;

  693.       else if ( type == 5 ) dataType_ = STK_SINT32;

  694.       else if ( type == 7 ) dataType_ = STK_FLOAT32;

  695.       else if ( type == 9 ) dataType_ = STK_FLOAT64;

  696.       else {

  697.         oStream_ << "FileRead: The MAT-file array data format (" << type << ") is not supported.";

  698.         return false;

  699.       }

  700. 

  701.       // Jump to the data.

  702.       if ( fseek(fd_, 4, SEEK_CUR) == -1 ) goto error;

  703.       dataOffset_ = ftell(fd_);

  704.       haveData = true;

  705.     }

  706. 

  707.   tryagain:

  708.     if ( haveData && haveSampleRate ) doneParsing = true;

  709.     else // jump to end of data element and keep trying

  710.       if ( fseek( fd_, dataoffset+chunkSize+8, SEEK_SET) == -1 ) goto error;

  711.   }

  712. 

  713.   return true;

  714. 

  715.  error:

  716.   oStream_ << "FileRead: Error reading MAT-file (" << fileName << ") header.";

  717.   return false;

  718. }

  719. 

  720. void FileRead :: read( StkFrames& buffer, unsigned long startFrame, bool doNormalize )

  721. {

  722.   // Make sure we have an open file.

  723.   if ( fd_ == 0 ) {

  724.     oStream_ << "FileRead::read: a file is not open!";

  725.     Stk::handleError( StkError::WARNING ); return;

  726.   }

  727. 

  728.   // Check the buffer size.

  729.   unsigned int nFrames = buffer.frames();

  730.   if ( nFrames == 0 ) {

  731.     oStream_ << "FileRead::read: StkFrames buffer size is zero ... no data read!";

  732.     Stk::handleError( StkError::WARNING ); return;

  733.   }

  734. 

  735.   if ( buffer.channels() != channels_ ) {

  736.     oStream_ << "FileRead::read: StkFrames argument has incompatible number of channels!";

  737.     Stk::handleError( StkError::FUNCTION_ARGUMENT );

  738.   }

  739. 

  740.   // Check for file end.

  741.   if ( startFrame + nFrames >= fileSize_ )

  742.     nFrames = fileSize_ - startFrame;

  743. 

  744.   long i, nSamples = (long) ( nFrames * channels_ );

  745.   unsigned long offset = startFrame * channels_;

  746. 

  747.   // Read samples into StkFrames data buffer.

  748.   if ( dataType_ == STK_SINT16 ) {

  749.     SINT16 *buf = (SINT16 *) &buffer[0];

  750.     if ( fseek( fd_, dataOffset_+(offset*2), SEEK_SET ) == -1 ) goto error;

  751.     if ( fread( buf, nSamples * 2, 1, fd_ ) != 1 ) goto error;

  752.     if ( byteswap_ ) {

  753.       SINT16 *ptr = buf;

  754.       for ( i=nSamples-1; i>=0; i-- )

  755.         swap16( (unsigned char *) ptr++ );

  756.     }

  757.     if ( doNormalize ) {

  758.       StkFloat gain = 1.0 / 32768.0;

  759.       for ( i=nSamples-1; i>=0; i-- )

  760.         buffer[i] = buf[i] * gain;

  761.     }

  762.     else {

  763.       for ( i=nSamples-1; i>=0; i-- )

  764.         buffer[i] = buf[i];

  765.     }

  766.   }

  767.   else if ( dataType_ == STK_SINT32 ) {

  768.     SINT32 *buf = (SINT32 *) &buffer[0];

  769.     if ( fseek( fd_, dataOffset_+(offset*4 ), SEEK_SET ) == -1 ) goto error;

  770.     if ( fread( buf, nSamples * 4, 1, fd_ ) != 1 ) goto error;

  771.     if ( byteswap_ ) {

  772.       SINT32 *ptr = buf;

  773.       for ( i=nSamples-1; i>=0; i-- )

  774.         swap32( (unsigned char *) ptr++ );

  775.     }

  776.     if ( doNormalize ) {

  777.       StkFloat gain = 1.0 / 2147483648.0;

  778.       for ( i=nSamples-1; i>=0; i-- )

  779.         buffer[i] = buf[i] * gain;

  780.     }

  781.     else {

  782.       for ( i=nSamples-1; i>=0; i-- )

  783.         buffer[i] = buf[i];

  784.     }

  785.   }

  786.   else if ( dataType_ == STK_FLOAT32 ) {

  787.     FLOAT32 *buf = (FLOAT32 *) &buffer[0];

  788.     if ( fseek( fd_, dataOffset_+(offset*4), SEEK_SET ) == -1 ) goto error;

  789.     if ( fread( buf, nSamples * 4, 1, fd_ ) != 1 ) goto error;

  790.     if ( byteswap_ ) {

  791.       FLOAT32 *ptr = buf;

  792.       for ( i=nSamples-1; i>=0; i-- )

  793.         swap32( (unsigned char *) ptr++ );

  794.     }

  795.     for ( i=nSamples-1; i>=0; i-- )

  796.       buffer[i] = buf[i];

  797.   }

  798.   else if ( dataType_ == STK_FLOAT64 ) {

  799.     FLOAT64 *buf = (FLOAT64 *) &buffer[0];

  800.     if ( fseek( fd_, dataOffset_+(offset*8), SEEK_SET ) == -1 ) goto error;

  801.     if ( fread( buf, nSamples * 8, 1, fd_ ) != 1 ) goto error;

  802.     if ( byteswap_ ) {

  803.       FLOAT64 *ptr = buf;

  804.       for ( i=nSamples-1; i>=0; i-- )

  805.         swap64( (unsigned char *) ptr++ );

  806.     }

  807.     for ( i=nSamples-1; i>=0; i-- )

  808.       buffer[i] = buf[i];

  809.   }

  810.   else if ( dataType_ == STK_SINT8 && wavFile_ ) { // 8-bit WAV data is unsigned!

  811.     unsigned char *buf = (unsigned char *) &buffer[0];

  812.     if ( fseek( fd_, dataOffset_+offset, SEEK_SET ) == -1 ) goto error;

  813.     if ( fread( buf, nSamples, 1, fd_) != 1 ) goto error;

  814.     if ( doNormalize ) {

  815.       StkFloat gain = 1.0 / 128.0;

  816.       for ( i=nSamples-1; i>=0; i-- )

  817.         buffer[i] = ( buf[i] - 128 ) * gain;

  818.     }

  819.     else {

  820.       for ( i=nSamples-1; i>=0; i-- )

  821.         buffer[i] = buf[i] - 128.0;

  822.     }

  823.   }

  824.   else if ( dataType_ == STK_SINT8 ) { // signed 8-bit data

  825.     char *buf = (char *) &buffer[0];

  826.     if ( fseek( fd_, dataOffset_+offset, SEEK_SET ) == -1 ) goto error;

  827.     if ( fread( buf, nSamples, 1, fd_ ) != 1 ) goto error;

  828.     if ( doNormalize ) {

  829.       StkFloat gain = 1.0 / 128.0;

  830.       for ( i=nSamples-1; i>=0; i-- )

  831.         buffer[i] = buf[i] * gain;

  832.     }

  833.     else {

  834.       for ( i=nSamples-1; i>=0; i-- )

  835.         buffer[i] = buf[i];

  836.     }

  837.   }

  838.   else if ( dataType_ == STK_SINT24 ) {

  839.     // 24-bit values are harder to import efficiently since there is

  840.     // no native 24-bit type.  The following routine works but is much

  841.     // less efficient than that used for the other data types.

  842.     SINT32 temp;

  843.     unsigned char *ptr = (unsigned char *) &temp;

  844.     StkFloat gain = 1.0 / 2147483648.0;

  845.     if ( fseek(fd_, dataOffset_+(offset*3), SEEK_SET ) == -1 ) goto error;

  846.     for ( i=0; i<nSamples; i++ ) {

  847. #ifdef __LITTLE_ENDIAN__

  848.       if ( byteswap_ ) {

  849.         if ( fread( ptr, 3, 1, fd_ ) != 1 ) goto error;

  850.         temp &= 0x00ffffff;

  851.         swap32( (unsigned char *) ptr );

  852.       }

  853.       else {

  854.         if ( fread( ptr+1, 3, 1, fd_ ) != 1 ) goto error;

  855.         temp &= 0xffffff00;

  856.       }

  857. #else

  858.       if ( byteswap_ ) {

  859.         if ( fread( ptr+1, 3, 1, fd_ ) != 1 ) goto error;

  860.         temp &= 0xffffff00;

  861.         swap32( (unsigned char *) ptr );

  862.       }

  863.       else {

  864.         if ( fread( ptr, 3, 1, fd_ ) != 1 ) goto error;

  865.         temp &= 0x00ffffff;

  866.       }

  867. #endif

  868. 

  869.       if ( doNormalize ) {

  870.         buffer[i] = (StkFloat) temp * gain; // "gain" also  includes 1 / 256 factor.

  871.       }

  872.       else

  873.         buffer[i] = (StkFloat) temp / 256;  // right shift without affecting the sign bit

  874.     }

  875.   }

  876. 

  877.   buffer.setDataRate( fileRate_ );

  878. 

  879.   return;

  880. 

  881.  error:

  882.   oStream_ << "FileRead: Error reading file data.";

  883.   handleError( StkError::FILE_ERROR);

  884. }

  885. 

  886. } // stk namespace