Add simple audio converter.

tools/audioconverter/audioconverter.c

+/*
+USAGE: audioconverter [input file] [output file] [format] [channels] [rate]
+
+EXAMPLES:
+    audioconverter my_file.flac my_file.wav
+    audioconverter my_file.flac my_file.wav f32 44100 linear --linear-order 8
+    audioconverter my_file.flac my_file.wav s16 2 44100 speex --speex-quality 10
+*/
+
+/*
+Note about Speex resampling. If you decide to enable the Speex resampler with ENABLE_SPEEX, this program will use licensed third party code. If you compile and
+redistribute this program you need to include a copy of the license which can be found at https://github.com/xiph/opus-tools/blob/master/COPYING. You can also
+find a copy of this text in extras/speex_resampler/README.md in the miniaudio repository.
+*/
+#define _CRT_SECURE_NO_WARNINGS /* For stb_vorbis' usage of fopen() instead of fopen_s(). */
+
+#define DR_FLAC_IMPLEMENTATION
+#include "../../extras/dr_flac.h"       /* Enables FLAC decoding. */
+#define DR_MP3_IMPLEMENTATION
+#include "../../extras/dr_mp3.h"        /* Enables MP3 decoding. */
+#define DR_WAV_IMPLEMENTATION
+#include "../../extras/dr_wav.h"        /* Enables WAV decoding. */
+#define STB_VORBIS_HEADER_ONLY
+#include "../../extras/stb_vorbis.c"    /* Enables Vorbis decoding. */
+
+/* Enable Speex resampling, but only if requested on the command line at a build time. */
+#if defined(ENABLE_SPEEX)
+    #define MINIAUDIO_SPEEX_RESAMPLER_IMPLEMENTATION
+    #include "../../extras/speex_resampler/ma_speex_resampler.h"
+#endif
+
+#define MINIAUDIO_IMPLEMENTATION
+#include "../../miniaudio.h"
+
+#include <stdio.h>
+
+void print_usage()
+{
+    printf("USAGE: audioconverter [input file] [output file] [format] [channels] [rate]\n");
+    printf("  [format] is optional and can be one of the following:\n");
+    printf("    u8  8-bit unsigned integer\n");
+    printf("    s16 16-bit signed integer\n");
+    printf("    s24 24-bit signed integer (tightly packed)\n");
+    printf("    s32 32-bit signed integer\n");
+    printf("    f32 32-bit floating point\n");
+    printf("  [channels] is optional and in the range of %d and %d\n", MA_MIN_CHANNELS, MA_MAX_CHANNELS);
+    printf("  [rate] is optional and in the range of %d and %d\n", MA_MIN_SAMPLE_RATE, MA_MAX_SAMPLE_RATE);
+    printf("\n");
+    printf("PARAMETERS:\n");
+    printf("  --linear-order [0..%d]\n", MA_MAX_FILTER_ORDER);
+    printf("  --speex-quality [0..10]\n");
+}
+
+ma_result do_conversion(ma_decoder* pDecoder, ma_encoder* pEncoder, ma_format format, ma_uint32 rate)
+{
+    ma_result result = MA_SUCCESS;
+
+    MA_ASSERT(pDecoder != NULL);
+    MA_ASSERT(pEncoder != NULL);
+
+    /* Now we just read from the decoder, resample, then write to the encoder. */
+    for (;;) {
+        ma_uint8 pRawData[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+        ma_uint64 framesReadThisIteration;
+        ma_uint64 framesToReadThisIteration;
+
+        framesToReadThisIteration = sizeof(pRawData) / ma_get_bytes_per_frame(pDecoder->internalFormat, pDecoder->internalChannels);
+        framesReadThisIteration = ma_decoder_read_pcm_frames(pDecoder, pRawData, framesToReadThisIteration);
+        if (framesReadThisIteration == 0) {
+            break;  /* Reached the end. */
+        }
+
+        /* At this point we have the raw data from the decoder. We now just need to write it to the encoder. */
+        ma_encoder_write_pcm_frames(pEncoder, pRawData, framesReadThisIteration);
+
+        /* Get out of the loop if we've reached the end. */
+        if (framesReadThisIteration < framesToReadThisIteration) {
+            break;
+        }
+    }
+
+    return result;
+}
+
+ma_bool32 is_number(const char* str)
+{
+    if (str == NULL || str[0] == '\0') {
+        return MA_FALSE;
+    }
+
+    while (str[0] != '\0') {
+        if (str[0] < '0' || str[0] > '9') {
+            return MA_FALSE;
+        }
+
+        str += 1;
+    }
+
+    return MA_TRUE;
+}
+
+ma_bool32 try_parse_uint32_in_range(const char* str, ma_uint32* pValue, ma_uint32 lo, ma_uint32 hi)
+{
+    ma_uint32 x;
+
+    if (!is_number(str)) {
+        return MA_FALSE;    /* Not an integer. */
+    }
+
+    x = (ma_uint32)atoi(str);
+    if (x < lo || x > hi) {
+        return MA_FALSE;    /* Out of range. */
+    }
+
+    if (pValue != NULL) {
+        *pValue = x;
+    }
+    
+    return MA_TRUE;
+}
+
+ma_bool32 try_parse_format(const char* str, ma_format* pValue)
+{
+    ma_format format;
+
+    /*  */ if (strcmp(str, "u8") == 0) {
+        format = ma_format_u8;
+    } else if (strcmp(str, "s16") == 0) {
+        format = ma_format_s16;
+    } else if (strcmp(str, "s24") == 0) {
+        format = ma_format_s24;
+    } else if (strcmp(str, "s32") == 0) {
+        format = ma_format_s32;
+    } else if (strcmp(str, "f32") == 0) {
+        format = ma_format_f32;
+    } else {
+        return MA_FALSE;    /* Not a format. */
+    }
+
+    if (pValue != NULL) {
+        *pValue = format;
+    }
+
+    return MA_TRUE;;
+}
+
+ma_bool32 try_parse_channels(const char* str, ma_uint32* pValue)
+{
+    return try_parse_uint32_in_range(str, pValue, MA_MIN_CHANNELS, MA_MAX_CHANNELS);
+}
+
+ma_bool32 try_parse_sample_rate(const char* str, ma_uint32* pValue)
+{
+    return try_parse_uint32_in_range(str, pValue, MA_MIN_SAMPLE_RATE, MA_MAX_SAMPLE_RATE);
+}
+
+ma_bool32 try_parse_resample_algorithm(const char* str, ma_resample_algorithm* pValue)
+{
+    ma_resample_algorithm algorithm;
+
+    /*  */ if (strcmp(str, "linear") == 0) {
+        algorithm = ma_resample_algorithm_linear;
+    } else if (strcmp(str, "speex") == 0) {
+        algorithm = ma_resample_algorithm_speex;
+    } else {
+        return MA_FALSE;    /* Not a valid algorithm */
+    }
+
+    if (pValue != NULL) {
+        *pValue = algorithm;
+    }
+
+    return MA_TRUE;
+}
+
+int main(int argc, char** argv)
+{
+    ma_result result;
+    ma_decoder_config decoderConfig;
+    ma_decoder decoder;
+    ma_encoder_config encoderConfig;
+    ma_encoder encoder;
+    ma_resource_format outputResourceFormat;
+    ma_format format = ma_format_unknown;
+    ma_uint32 channels = 0;
+    ma_uint32 rate = 0;
+    ma_resample_algorithm resampleAlgorithm;
+    ma_uint32 linearOrder = 8;
+    ma_uint32 speexQuality = 3;
+    int iarg;
+    const char* pOutputFilePath;
+
+    print_usage();
+
+    /* Print help if requested. */
+    if (argc == 2) {
+        if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
+            print_usage();
+            return 0;
+        }
+    }
+
+    if (argc < 3) {
+        print_usage();
+        return -1;
+    }
+
+    /* Default to Speex if it's enabled. */
+#if defined(ENABLE_SPEEX)
+    resampleAlgorithm = ma_resample_algorithm_speex;
+#else
+    resampleAlgorithm = ma_resample_algorithm_linear;
+#endif
+
+    /*
+    The fourth and fifth arguments can be a format and/or rate specifier. It doesn't matter which order they are in as we can identify them by whether or
+    not it's a number. If it's a number we assume it's a sample rate, otherwise we assume it's a format specifier.
+    */
+    for (iarg = 3; iarg < argc; iarg += 1) {
+        if (strcmp(argv[iarg], "--linear-order") == 0) {
+            iarg += 1;
+            if (iarg >= argc) {
+                break;
+            }
+
+            if (!try_parse_uint32_in_range(argv[iarg], &linearOrder, 0, 8)) {
+                printf("Expecting a number between 0 and 8 for --linear-order.\n");
+                return -1;
+            }
+            
+            continue;
+        }
+
+        if (strcmp(argv[iarg], "--speex-quality") == 0) {
+            iarg += 1;
+            if (iarg >= argc) {
+                break;
+            }
+
+            if (!try_parse_uint32_in_range(argv[iarg], &speexQuality, 0, 10)) {
+                printf("Expecting a number between 0 and 10 for --speex-quality.\n");
+                return -1;
+            }
+            
+            continue;
+        }
+
+        if (try_parse_resample_algorithm(argv[iarg], &resampleAlgorithm)) {
+            continue;
+        }
+
+        if (try_parse_format(argv[iarg], &format)) {
+            continue;
+        }
+
+        if (try_parse_channels(argv[iarg], &channels)) {
+            continue;
+        }
+
+        if (try_parse_sample_rate(argv[iarg], &rate)) {
+            continue;
+        }
+
+        /* Getting here means we have an unknown parameter. */
+        printf("Warning: Unknown parameter \"%s\"", argv[iarg]);
+    }
+
+    /* Initialize a decoder for the input file. */
+    decoderConfig = ma_decoder_config_init(format, channels, rate);
+    decoderConfig.resampling.algorithm = resampleAlgorithm;
+    decoderConfig.resampling.linear.lpfOrder = linearOrder;
+#if defined(ENABLE_SPEEX)
+    decoderConfig.resampling.speex.quality = speexQuality;
+#endif
+
+    result = ma_decoder_init_file(argv[1], &decoderConfig, &decoder);
+    if (result != MA_SUCCESS) {
+        printf("Failed to open input file. Check the file exists and the format is supported. Supported input formats:\n");
+    #if defined(dr_opus_h)
+        printf("    Opus\n");
+    #endif
+    #if defined(dr_mp3_h)
+        printf("    MP3\n");
+    #endif    
+    #if defined(dr_flac_h)
+        printf("    FLAC\n");
+    #endif    
+    #if defined(STB_VORBIS_INCLUDE_STB_VORBIS_H)
+        printf("    Vorbis\n");
+    #endif
+    #if defined(dr_wav_h)
+        printf("    WAV\n");
+    #endif
+        return (int)result;
+    }
+
+
+    pOutputFilePath = argv[2];
+
+    outputResourceFormat = ma_resource_format_wav;  /* Wave by default in case we don't know the file extension. */
+    if (ma_path_extension_equal(pOutputFilePath, "wav")) {
+        outputResourceFormat = ma_resource_format_wav;
+    } else {
+        printf("Warning: Unknown file extension \"%s\". Encoding as WAV.\n", ma_path_extension(pOutputFilePath));
+    }
+
+    /* Initialize the encoder for the output file. */
+    encoderConfig = ma_encoder_config_init(ma_resource_format_wav, format, decoder.internalChannels, rate);
+    result = ma_encoder_init_file(pOutputFilePath, &encoderConfig, &encoder);
+    if (result != MA_SUCCESS) {
+        ma_decoder_uninit(&decoder);
+        printf("Failed to open output file. Check that the directory exists and that the file is not already opened by another process.");
+        return -1;
+    }
+
+
+    /* We have our decoder and encoder ready, so now we can do the conversion. */
+    result = do_conversion(&decoder, &encoder, format, rate);
+    
+    
+    /* Done. */
+    ma_encoder_uninit(&encoder);
+    ma_decoder_uninit(&decoder);
+
+    return (int)result;
+}
+
+
+/* stb_vorbis implementation must come after the implementation of miniaudio. */
+#undef STB_VORBIS_HEADER_ONLY
+#include "../../extras/stb_vorbis.c"