home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Multimedia / AVStoDVD / AVStoDVD_Portable.exe / AVStoDVD_Portable / Wavi / src / silence.c < prev    next >
C/C++ Source or Header  |  2007-06-26  |  8KB  |  257 lines
  1. #include <windows.h>
  2. #include <stdio.h>
  3.  
  4. #define VERSION "1.04"
  5. /*
  6. 1.04: added support for floating-point samples (thanks to tebasuna51)
  7. 1.04: added support fot files > 4G; use Win32 API
  8. 1.03: fixed size field in data chunk header (thanks to tebasuna51)
  9. 1.03: removed annoying debug message
  10. */
  11.  
  12. #define WAVE_FORMAT_IEEE_FLOAT 3
  13.  
  14. int main (int argc, char * argv[])
  15. {
  16.     WAVEFORMATEX waveFormat;
  17.     double       length = 1.0;
  18.     LPSTR        outputFile = NULL;
  19.     BOOL         bitsPerSampleGiven = FALSE;
  20.     double       sampleCount;
  21.     DWORD        noOfSamples;
  22.     DWORD        sampleSize;
  23.     DWORDLONG    fileSize;
  24.     BYTE         wavHeader[44];
  25.     DWORD        headerPos = 0;
  26.     HANDLE       outputHandle;
  27.     DWORD        bufferSize;
  28.     DWORD        samplesInBuffer;
  29.     DWORD        nextSample = 0;
  30.     LPVOID       buffer = NULL;
  31.     DWORD        bytesWritten;
  32.     
  33.     waveFormat.wFormatTag     = WAVE_FORMAT_PCM;
  34.     waveFormat.nChannels      = 1;
  35.     waveFormat.nSamplesPerSec = 48000;
  36.     waveFormat.wBitsPerSample = 16;
  37.     waveFormat.cbSize         = 0;
  38.     
  39.     if (argc < 2) {
  40.         fprintf(stderr, 
  41.             "SILENCE v" VERSION " - Create silent WAV files\n"
  42.             "(c) 2007 Tamas Kurucsai\n"
  43.             "Licensed under the terms of the GNU General Public License\n"
  44.             "\n"
  45.             "Usage: SILENCE <wav-file> -f -l <length> -c <channels>\n"
  46.             "               -s <sample-rate> -b <bits-per-sample>\n"
  47.             "-f tells that that floating-point samples shall be used.\n"
  48.             "\n"
  49.             "If <wav-file> is not given, the WAV file will be written\n"
  50.             "to the standard output.\n"
  51.             "\n"
  52.             "Defaults for options are: -l 1.0 -c 1 -s 48000 -b 16\n");
  53.         exit(1);
  54.     } else {
  55.         int arg = 0;
  56.         while (argv[++arg]) {
  57.             if (argv[arg][0] != '-') {
  58.                 if (outputFile) {
  59.                     fprintf(stderr, "Too many parameters\n");
  60.                     exit(1);
  61.                 } else {
  62.                     outputFile = argv[arg];
  63.                 }
  64.             } else {
  65.                 switch(argv[arg][1]) {
  66.                 case 'f':
  67.                 case 'F':
  68.                     waveFormat.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
  69.                     if (! bitsPerSampleGiven) {
  70.                         waveFormat.wBitsPerSample = 32;
  71.                     }
  72.                     break;
  73.                 case 'l':
  74.                 case 'L':
  75.                     if (argv[++arg]) {
  76.                         length = atof(argv[arg]);
  77.                         if (length <= 0.0) {
  78.                             fprintf(stderr, "Invalid length given after -l\n");
  79.                             exit(1);
  80.                         }
  81.                     } else {
  82.                         fprintf(stderr, "Missing length after -l\n");
  83.                         exit(1);
  84.                     }
  85.                     break;
  86.                 case 'c':
  87.                 case 'C':
  88.                     if (argv[++arg]) {
  89.                         int channels;
  90.                         channels = atoi(argv[arg]);
  91.                         if (channels <= 0 || 65535 < channels) {
  92.                             fprintf(stderr, "Invalid no. of channels given after -c\n");
  93.                             exit(1);
  94.                         }
  95.                         waveFormat.nChannels = channels;
  96.                     } else {
  97.                         fprintf(stderr, "Missing no. of channels after -c\n");
  98.                         exit(1);
  99.                     }
  100.                     break;
  101.                 case 's':
  102.                 case 'S':
  103.                     if (argv[++arg]) {
  104.                         int samplesPerSec;
  105.                         samplesPerSec = atoi(argv[arg]);
  106.                         if (samplesPerSec <= 0) {
  107.                             fprintf(stderr, "Invalid sample rate given after -s\n");
  108.                             exit(1);
  109.                         }
  110.                         waveFormat.nSamplesPerSec = samplesPerSec;                        
  111.                     } else {
  112.                         fprintf(stderr, "Missing sample rate after -s\n");
  113.                         exit(1);
  114.                     }
  115.                     break;
  116.                 case 'b':
  117.                 case 'B':
  118.                     if (argv[++arg]) {
  119.                         int bitsPerSample;
  120.                         bitsPerSample = atoi(argv[arg]);
  121.                         if (bitsPerSample <= 0 || 65535 < bitsPerSample) {
  122.                             fprintf(stderr, "Invalid bits per sample given after -b\n");
  123.                             exit(1);
  124.                         }
  125.                         waveFormat.wBitsPerSample = bitsPerSample;
  126.                         bitsPerSampleGiven = TRUE;
  127.                     } else {
  128.                         fprintf(stderr, "Missing bits per sample after -b\n");
  129.                         exit(1);
  130.                     }
  131.                     break;
  132.                 case 0:
  133.                     break;
  134.                 default:
  135.                     fprintf(stderr, "Invalid option -%c\n", argv[arg][1]);
  136.                     exit(1);
  137.                 }
  138.             }
  139.         }
  140.     }
  141.  
  142.     sampleCount = length * waveFormat.nSamplesPerSec;
  143.     if (sampleCount > 1.0 * 0xFFFFFFFF) {
  144.         fprintf(stderr, "Error: WAV file would be too long.\n");
  145.         exit(1);
  146.     }
  147.     noOfSamples = (DWORD) (sampleCount);
  148.     sampleSize = waveFormat.nChannels * ((waveFormat.wBitsPerSample + 7) / 8);
  149.     fileSize = UInt32x32To64(sampleSize, noOfSamples);
  150.     if (fileSize > 0xFFFFFFFF - 36) {
  151.         fprintf(stderr, "Warning: WAV file will be larger than 4 GB.\n");
  152.         fileSize = sampleSize * ((0xFFFFFFFF - 36) / sampleSize);
  153.     }
  154.     waveFormat.nAvgBytesPerSec = sampleSize * waveFormat.nSamplesPerSec;
  155.     waveFormat.nBlockAlign     = sampleSize;
  156.     
  157.     wavHeader[headerPos++] = 'R';
  158.     wavHeader[headerPos++] = 'I';
  159.     wavHeader[headerPos++] = 'F';
  160.     wavHeader[headerPos++] = 'F';
  161.     *(LPDWORD)(wavHeader + headerPos) = (DWORD) fileSize + 36;
  162.     headerPos += 4;
  163.     wavHeader[headerPos++] = 'W';
  164.     wavHeader[headerPos++] = 'A';
  165.     wavHeader[headerPos++] = 'V';
  166.     wavHeader[headerPos++] = 'E';
  167.     wavHeader[headerPos++] = 'f';
  168.     wavHeader[headerPos++] = 'm';
  169.     wavHeader[headerPos++] = 't';
  170.     wavHeader[headerPos++] = ' ';
  171.     *(LPDWORD)(wavHeader + headerPos) = 16;
  172.     headerPos += 4;
  173.     *(LPWORD)(wavHeader + headerPos)  = waveFormat.wFormatTag;
  174.     headerPos += 2;
  175.     *(LPWORD)(wavHeader + headerPos)  = waveFormat.nChannels;
  176.     headerPos += 2;
  177.     *(LPDWORD)(wavHeader + headerPos) = waveFormat.nSamplesPerSec;
  178.     headerPos += 4;
  179.     *(LPDWORD)(wavHeader + headerPos) = waveFormat.nAvgBytesPerSec;
  180.     headerPos += 4;
  181.     *(LPWORD)(wavHeader + headerPos)  = waveFormat.nBlockAlign;
  182.     headerPos += 2;
  183.     *(LPWORD)(wavHeader + headerPos)  = waveFormat.wBitsPerSample;
  184.     headerPos += 2;
  185.     wavHeader[headerPos++] = 'd';
  186.     wavHeader[headerPos++] = 'a';
  187.     wavHeader[headerPos++] = 't';
  188.     wavHeader[headerPos++] = 'a';
  189.     *(LPDWORD)(wavHeader + headerPos) = (DWORD) fileSize;
  190.     headerPos += 4;
  191.  
  192.     if (! outputFile) {
  193.         outputHandle = GetStdHandle(STD_OUTPUT_HANDLE);
  194.         fprintf(stderr, "Writing WAV file...\n");
  195.     } else {
  196.         outputHandle = CreateFile(outputFile, GENERIC_WRITE, FILE_SHARE_READ, 
  197.             NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  198.         if (outputHandle == INVALID_HANDLE_VALUE) {
  199.             fprintf(stderr, "Error: Could not create file \"%s\".\n", outputFile);
  200.             exit(1);
  201.         }
  202.         fprintf(stderr, "Writing WAV file \"%s\"...\n", outputFile);
  203.     }
  204.         
  205.     if (! WriteFile(outputHandle, wavHeader, headerPos, & bytesWritten, NULL) || (bytesWritten != headerPos)) {
  206.         if (! outputFile) {
  207.             fprintf(stderr, "Error: Could not write to the standard output.\n");
  208.         } else {
  209.             fprintf(stderr, "Error: Could not write file \"%s\".\n", outputFile);
  210.             CloseHandle(outputHandle);
  211.         }
  212.         exit(1);
  213.     }
  214.     
  215.     bufferSize = 1024 * 1024;
  216.     samplesInBuffer = bufferSize / sampleSize;
  217.     if (! samplesInBuffer) {
  218.         samplesInBuffer = 1;
  219.         bufferSize = sampleSize * samplesInBuffer;
  220.     }
  221.     buffer = (LPVOID) LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, bufferSize);
  222.     if (! buffer) {
  223.         fprintf(stderr, "Error: Out of memory.\n");
  224.         if (outputFile) CloseHandle(outputHandle);
  225.         exit(1);
  226.     }
  227.  
  228.     while (nextSample < noOfSamples) {
  229.         if (noOfSamples - nextSample < samplesInBuffer) {
  230.             bufferSize = (noOfSamples - nextSample) * sampleSize;
  231.         }
  232.         if (! WriteFile(outputHandle, buffer, bufferSize, & bytesWritten, NULL) || (bytesWritten != bufferSize)) {
  233.             LocalFree((HLOCAL) buffer);
  234.             if (! outputFile) {
  235.                 fprintf(stderr, "Error: Could not write to the standard output.\n");
  236.             } else {
  237.                 fprintf(stderr, "Error: Could not write file \"%s\".\n", outputFile);
  238.                 CloseHandle(outputHandle);
  239.             }
  240.             exit(1);
  241.         }
  242.         nextSample += samplesInBuffer;
  243.     }
  244.     
  245.     LocalFree((HLOCAL) buffer);
  246.     
  247.     if (outputFile && ! CloseHandle(outputHandle)) {
  248.         fprintf(stderr, "Error: Could not write file \"%s\".\n", outputFile);
  249.         exit(1);
  250.     }
  251.     
  252.     fprintf(stderr, "WAV file written successfully.\n");
  253.     return 0;
  254. }
  255.  
  256.  
  257.