examples/alrecord.c

   1 /*
   2  * OpenAL Recording Example
   3  *
   4  * Copyright (c) 2017 by Chris Robinson <chris.kcat@gmail.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 /* This file contains a relatively simple recorder. */
  26
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <errno.h>
  31 #include <math.h>
  32
  33 #include "AL/al.h"
  34 #include "AL/alc.h"
  35 #include "AL/alext.h"
  36
  37 #include "common/alhelpers.h"
  38
  39
  40 #if defined(_WIN64)
  41 #define SZFMT "%I64u"
  42 #elif defined(_WIN32)
  43 #define SZFMT "%u"
  44 #else
  45 #define SZFMT "%zu"
  46 #endif
  47
  48
  49 #if defined(_MSC_VER) && (_MSC_VER < 1900)
  50 static float msvc_strtof(const char *str, char **end)
  51 { return (float)strtod(str, end); }
  52 #define strtof msvc_strtof
  53 #endif
  54
  55
  56 static void fwrite16le(ALushort val, FILE *f)
  57 {
  58     ALubyte data[2] = { val&0xff, (val>>8)&0xff };
  59     fwrite(data, 1, 2, f);
  60 }
  61
  62 static void fwrite32le(ALuint val, FILE *f)
  63 {
  64     ALubyte data[4] = { val&0xff, (val>>8)&0xff, (val>>16)&0xff, (val>>24)&0xff };
  65     fwrite(data, 1, 4, f);
  66 }
  67
  68
  69 typedef struct Recorder {
  70     ALCdevice *mDevice;
  71
  72     FILE *mFile;
  73     long mDataSizeOffset;
  74     ALuint mDataSize;
  75     float mRecTime;
  76
  77     int mChannels;
  78     int mBits;
  79     int mSampleRate;
  80     ALuint mFrameSize;
  81     ALbyte *mBuffer;
  82     ALsizei mBufferSize;
  83 } Recorder;
  84
  85 int main(int argc, char **argv)
  86 {
  87     static const char optlist[] =
  88 "    --channels/-c <channels>  Set channel count (1 or 2)\n"
  89 "    --bits/-b <bits>          Set channel count (8, 16, or 32)\n"
  90 "    --rate/-r <rate>          Set sample rate (8000 to 96000)\n"
  91 "    --time/-t <time>          Time in seconds to record (1 to 10)\n"
  92 "    --outfile/-o <filename>   Output filename (default: record.wav)";
  93     const char *fname = "record.wav";
  94     const char *devname = NULL;
  95     const char *progname;
  96     Recorder recorder;
  97     long total_size;
  98     ALenum format;
  99     ALCenum err;
 100
 101     progname = argv[0];
 102     if(argc < 2)
 103     {
 104         fprintf(stderr, "Record from a device to a wav file.\n\n"
 105                 "Usage: %s [-device <name>] [options...]\n\n"
 106                 "Available options:\n%s\n", progname, optlist);
 107         return 0;
 108     }
 109
 110     recorder.mDevice = NULL;
 111     recorder.mFile = NULL;
 112     recorder.mDataSizeOffset = 0;
 113     recorder.mDataSize = 0;
 114     recorder.mRecTime = 4.0f;
 115     recorder.mChannels = 1;
 116     recorder.mBits = 16;
 117     recorder.mSampleRate = 44100;
 118     recorder.mFrameSize = recorder.mChannels * recorder.mBits / 8;
 119     recorder.mBuffer = NULL;
 120     recorder.mBufferSize = 0;
 121
 122     argv++; argc--;
 123     if(argc > 1 && strcmp(argv[0], "-device") == 0)
 124     {
 125         devname = argv[1];
 126         argv += 2;
 127         argc -= 2;
 128     }
 129
 130     while(argc > 0)
 131     {
 132         char *end;
 133         if(strcmp(argv[0], "--") == 0)
 134             break;
 135         else if(strcmp(argv[0], "--channels") == 0 || strcmp(argv[0], "-c") == 0)
 136         {
 137             if(argc < 2)
 138             {
 139                 fprintf(stderr, "Missing argument for option: %s\n", argv[0]);
 140                 return 1;
 141             }
 142
 143             recorder.mChannels = strtol(argv[1], &end, 0);
 144             if((recorder.mChannels != 1 && recorder.mChannels != 2) || (end && *end != '\0'))
 145             {
 146                 fprintf(stderr, "Invalid channels: %s\n", argv[1]);
 147                 return 1;
 148             }
 149             argv += 2;
 150             argc -= 2;
 151         }
 152         else if(strcmp(argv[0], "--bits") == 0 || strcmp(argv[0], "-b") == 0)
 153         {
 154             if(argc < 2)
 155             {
 156                 fprintf(stderr, "Missing argument for option: %s\n", argv[0]);
 157                 return 1;
 158             }
 159
 160             recorder.mBits = strtol(argv[1], &end, 0);
 161             if((recorder.mBits != 8 && recorder.mBits != 16 && recorder.mBits != 32) ||
 162                (end && *end != '\0'))
 163             {
 164                 fprintf(stderr, "Invalid bit count: %s\n", argv[1]);
 165                 return 1;
 166             }
 167             argv += 2;
 168             argc -= 2;
 169         }
 170         else if(strcmp(argv[0], "--rate") == 0 || strcmp(argv[0], "-r") == 0)
 171         {
 172             if(argc < 2)
 173             {
 174                 fprintf(stderr, "Missing argument for option: %s\n", argv[0]);
 175                 return 1;
 176             }
 177
 178             recorder.mSampleRate = strtol(argv[1], &end, 0);
 179             if(!(recorder.mSampleRate >= 8000 && recorder.mSampleRate <= 96000) || (end && *end != '\0'))
 180             {
 181                 fprintf(stderr, "Invalid sample rate: %s\n", argv[1]);
 182                 return 1;
 183             }
 184             argv += 2;
 185             argc -= 2;
 186         }
 187         else if(strcmp(argv[0], "--time") == 0 || strcmp(argv[0], "-t") == 0)
 188         {
 189             if(argc < 2)
 190             {
 191                 fprintf(stderr, "Missing argument for option: %s\n", argv[0]);
 192                 return 1;
 193             }
 194
 195             recorder.mRecTime = strtof(argv[1], &end);
 196             if(!(recorder.mRecTime >= 1.0f && recorder.mRecTime <= 10.0f) || (end && *end != '\0'))
 197             {
 198                 fprintf(stderr, "Invalid record time: %s\n", argv[1]);
 199                 return 1;
 200             }
 201             argv += 2;
 202             argc -= 2;
 203         }
 204         else if(strcmp(argv[0], "--outfile") == 0 || strcmp(argv[0], "-o") == 0)
 205         {
 206             if(argc < 2)
 207             {
 208                 fprintf(stderr, "Missing argument for option: %s\n", argv[0]);
 209                 return 1;
 210             }
 211
 212             fname = argv[1];
 213             argv += 2;
 214             argc -= 2;
 215         }
 216         else if(strcmp(argv[0], "--help") == 0 || strcmp(argv[0], "-h") == 0)
 217         {
 218             fprintf(stderr, "Record from a device to a wav file.\n\n"
 219                     "Usage: %s [-device <name>] [options...]\n\n"
 220                     "Available options:\n%s\n", progname, optlist);
 221             return 0;
 222         }
 223         else
 224         {
 225             fprintf(stderr, "Invalid option '%s'.\n\n"
 226                     "Usage: %s [-device <name>] [options...]\n\n"
 227                     "Available options:\n%s\n", argv[0], progname, optlist);
 228             return 0;
 229         }
 230     }
 231
 232     recorder.mFrameSize = recorder.mChannels * recorder.mBits / 8;
 233
 234     format = AL_NONE;
 235     if(recorder.mChannels == 1)
 236     {
 237         if(recorder.mBits == 8)
 238             format = AL_FORMAT_MONO8;
 239         else if(recorder.mBits == 16)
 240             format = AL_FORMAT_MONO16;
 241         else if(recorder.mBits == 32)
 242             format = AL_FORMAT_MONO_FLOAT32;
 243     }
 244     else if(recorder.mChannels == 2)
 245     {
 246         if(recorder.mBits == 8)
 247             format = AL_FORMAT_STEREO8;
 248         else if(recorder.mBits == 16)
 249             format = AL_FORMAT_STEREO16;
 250         else if(recorder.mBits == 32)
 251             format = AL_FORMAT_STEREO_FLOAT32;
 252     }
 253
 254     recorder.mDevice = alcCaptureOpenDevice(devname, recorder.mSampleRate, format, 32768);
 255     if(!recorder.mDevice)
 256     {
 257         fprintf(stderr, "Failed to open %s, %s %d-bit, %s, %dhz (%d samples)\n",
 258             devname ? devname : "default device",
 259             (recorder.mBits == 32) ? "Float" :
 260             (recorder.mBits !=  8) ? "Signed" : "Unsigned", recorder.mBits,
 261             (recorder.mChannels == 1) ? "Mono" : "Stereo", recorder.mSampleRate,
 262             32768
 263         );
 264         return 1;
 265     }
 266     fprintf(stderr, "Opened \"%s\"\n", alcGetString(
 267         recorder.mDevice, ALC_CAPTURE_DEVICE_SPECIFIER
 268     ));
 269
 270     recorder.mFile = fopen(fname, "wb");
 271     if(!recorder.mFile)
 272     {
 273         fprintf(stderr, "Failed to open '%s' for writing\n", fname);
 274         alcCaptureCloseDevice(recorder.mDevice);
 275         return 1;
 276     }
 277
 278     fputs("RIFF", recorder.mFile);
 279     fwrite32le(0xFFFFFFFF, recorder.mFile); // 'RIFF' header len; filled in at close
 280
 281     fputs("WAVE", recorder.mFile);
 282
 283     fputs("fmt ", recorder.mFile);
 284     fwrite32le(18, recorder.mFile); // 'fmt ' header len
 285
 286     // 16-bit val, format type id (1 = integer PCM, 3 = float PCM)
 287     fwrite16le((recorder.mBits == 32) ? 0x0003 : 0x0001, recorder.mFile);
 288     // 16-bit val, channel count
 289     fwrite16le(recorder.mChannels, recorder.mFile);
 290     // 32-bit val, frequency
 291     fwrite32le(recorder.mSampleRate, recorder.mFile);
 292     // 32-bit val, bytes per second
 293     fwrite32le(recorder.mSampleRate * recorder.mFrameSize, recorder.mFile);
 294     // 16-bit val, frame size
 295     fwrite16le(recorder.mFrameSize, recorder.mFile);
 296     // 16-bit val, bits per sample
 297     fwrite16le(recorder.mBits, recorder.mFile);
 298     // 16-bit val, extra byte count
 299     fwrite16le(0, recorder.mFile);
 300
 301     fputs("data", recorder.mFile);
 302     fwrite32le(0xFFFFFFFF, recorder.mFile); // 'data' header len; filled in at close
 303
 304     recorder.mDataSizeOffset = ftell(recorder.mFile) - 4;
 305     if(ferror(recorder.mFile) || recorder.mDataSizeOffset < 0)
 306     {
 307         fprintf(stderr, "Error writing header: %s\n", strerror(errno));
 308         fclose(recorder.mFile);
 309         alcCaptureCloseDevice(recorder.mDevice);
 310         return 1;
 311     }
 312
 313     fprintf(stderr, "Recording '%s', %s %d-bit, %s, %dhz (%g second%s)\n", fname,
 314         (recorder.mBits == 32) ? "Float" :
 315         (recorder.mBits !=  8) ? "Signed" : "Unsigned", recorder.mBits,
 316         (recorder.mChannels == 1) ? "Mono" : "Stereo", recorder.mSampleRate,
 317         recorder.mRecTime, (recorder.mRecTime != 1.0f) ? "s" : ""
 318     );
 319
 320     alcCaptureStart(recorder.mDevice);
 321     while((double)recorder.mDataSize/(double)recorder.mSampleRate < recorder.mRecTime &&
 322           (err=alcGetError(recorder.mDevice)) == ALC_NO_ERROR && !ferror(recorder.mFile))
 323     {
 324         ALCint count = 0;
 325         fprintf(stderr, "\rCaptured %u samples", recorder.mDataSize);
 326         alcGetIntegerv(recorder.mDevice, ALC_CAPTURE_SAMPLES, 1, &count);
 327         if(count < 1)
 328         {
 329             al_nssleep(10000000);
 330             continue;
 331         }
 332         if(count > recorder.mBufferSize)
 333         {
 334             ALbyte *data = calloc(recorder.mFrameSize, count);
 335             free(recorder.mBuffer);
 336             recorder.mBuffer = data;
 337             recorder.mBufferSize = count;
 338         }
 339         alcCaptureSamples(recorder.mDevice, recorder.mBuffer, count);
 340 #if defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN
 341         /* Byteswap multibyte samples on big-endian systems (wav needs little-
 342          * endian, and OpenAL gives the system's native-endian).
 343          */
 344         if(recorder.mBits == 16)
 345         {
 346             ALCint i;
 347             for(i = 0;i < count*recorder.mChannels;i++)
 348             {
 349                 ALbyte b = recorder.mBuffer[i*2 + 0];
 350                 recorder.mBuffer[i*2 + 0] = recorder.mBuffer[i*2 + 1];
 351                 recorder.mBuffer[i*2 + 1] = b;
 352             }
 353         }
 354         else if(recorder.mBits == 32)
 355         {
 356             ALCint i;
 357             for(i = 0;i < count*recorder.mChannels;i++)
 358             {
 359                 ALbyte b0 = recorder.mBuffer[i*4 + 0];
 360                 ALbyte b1 = recorder.mBuffer[i*4 + 1];
 361                 recorder.mBuffer[i*4 + 0] = recorder.mBuffer[i*4 + 3];
 362                 recorder.mBuffer[i*4 + 1] = recorder.mBuffer[i*4 + 2];
 363                 recorder.mBuffer[i*4 + 2] = b1;
 364                 recorder.mBuffer[i*4 + 3] = b0;
 365             }
 366         }
 367 #endif
 368         recorder.mDataSize += (ALuint)fwrite(recorder.mBuffer, recorder.mFrameSize, count,
 369                                              recorder.mFile);
 370     }
 371     alcCaptureStop(recorder.mDevice);
 372     fprintf(stderr, "\rCaptured %u samples\n", recorder.mDataSize);
 373     if(err != ALC_NO_ERROR)
 374         fprintf(stderr, "Got device error 0x%04x: %s\n", err, alcGetString(recorder.mDevice, err));
 375
 376     alcCaptureCloseDevice(recorder.mDevice);
 377     recorder.mDevice = NULL;
 378
 379     free(recorder.mBuffer);
 380     recorder.mBuffer = NULL;
 381     recorder.mBufferSize = 0;
 382
 383     total_size = ftell(recorder.mFile);
 384     if(fseek(recorder.mFile, recorder.mDataSizeOffset, SEEK_SET) == 0)
 385     {
 386         fwrite32le(recorder.mDataSize*recorder.mFrameSize, recorder.mFile);
 387         if(fseek(recorder.mFile, 4, SEEK_SET) == 0)
 388             fwrite32le(total_size - 8, recorder.mFile);
 389     }
 390
 391     fclose(recorder.mFile);
 392     recorder.mFile = NULL;
 393
 394     return 0;
 395 }