rhino/demo/c/dr_libs/tests/mp3/dr_mp3_playback.c

Go to the documentation of this file.

#include "dr_mp3_common.c"
 
#define MA_NO_DECODING
#define MA_NO_ENCODING
#define MINIAUDIO_IMPLEMENTATION
#include "../external/miniaudio/miniaudio.h"
 
void data_callback(ma_device* pDevice, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount)
{
    drmp3* pMP3;
 
    pMP3 = (drmp3*)pDevice->pUserData;
    DRMP3_ASSERT(pMP3 != NULL);
 
    if (pDevice->playback.format == ma_format_f32) {
        drmp3_read_pcm_frames_f32(pMP3, frameCount, pFramesOut);
    } else if (pDevice->playback.format == ma_format_s16) {
        drmp3_read_pcm_frames_s16(pMP3, frameCount, pFramesOut);
    } else {
        DRMP3_ASSERT(DRMP3_FALSE);  /* Should never get here. */
    }
 
    (void)pFramesIn;
}
 
int do_decoding_validation(const char* pFilePath)
{
    int result = 0;
    drmp3 mp3Memory;
    drmp3 mp3File;
    size_t dataSize;
    void* pData;
 
    /*
    When opening from a memory buffer, dr_mp3 will take a different path for decoding which is optimized to reduce data movement. Since it's
    running on a separate path, we need to ensure it's returning consistent results with the other code path which will be used when decoding
    from a file.
    */
    
    /* Initialize the memory decoder. */
    pData = dr_open_and_read_file(pFilePath, &dataSize);
    if (pData == NULL) {
        printf("Failed to open file \"%s\"", pFilePath);
        return -1;
    }
 
    if (!drmp3_init_memory(&mp3Memory, pData, dataSize, NULL)) {
        free(pData);
        printf("Failed to init MP3 decoder \"%s\"", pFilePath);
        return -1;
    }
 
 
    /* Initialize the file decoder. */
    if (!drmp3_init_file(&mp3File, pFilePath, NULL)) {
        drmp3_uninit(&mp3Memory);
        free(pData);
        printf("Failed to open file \"%s\"", pFilePath);
        return -1;
    }
 
    DRMP3_ASSERT(mp3Memory.channels == mp3File.channels);
 
 
    /* Compare. */
    for (;;) {
        drmp3_uint64 iSample;
        drmp3_uint64 pcmFrameCountMemory;
        drmp3_uint64 pcmFrameCountFile;
        drmp3_int16 pcmFramesMemory[4096];
        drmp3_int16 pcmFramesFile[4096];
 
        pcmFrameCountMemory = drmp3_read_pcm_frames_s16(&mp3Memory, DRMP3_COUNTOF(pcmFramesMemory) / mp3Memory.channels, pcmFramesMemory);
        pcmFrameCountFile   = drmp3_read_pcm_frames_s16(&mp3File,   DRMP3_COUNTOF(pcmFramesFile)   / mp3File.channels,   pcmFramesFile);
 
        /* Check the frame count first. */
        if (pcmFrameCountMemory != pcmFrameCountFile) {
            printf("Frame counts differ: memory = %d; file = %d\n", (int)pcmFrameCountMemory, (int)pcmFrameCountFile);
            result = -1;
            break;
        }
 
        /* Check individual frames. */
        DRMP3_ASSERT(pcmFrameCountMemory == pcmFrameCountFile);
        for (iSample = 0; iSample < pcmFrameCountMemory * mp3Memory.channels; iSample += 1) {
            if (pcmFramesMemory[iSample] != pcmFramesFile[iSample]) {
                printf("Samples differ: memory = %d; file = %d\n", (int)pcmFramesMemory[iSample], (int)pcmFramesFile[iSample]);
                result = -1;
                break;
            }
        }
 
        /* We've reached the end if we didn't return any PCM frames. */
        if (pcmFrameCountMemory == 0 || pcmFrameCountFile == 0) {
            break;
        }
    }
 
 
    drmp3_uninit(&mp3File);
    drmp3_uninit(&mp3Memory);
    free(pData);
    return result;
}
 
int main(int argc, char** argv)
{
    drmp3 mp3;
    ma_result resultMA;
    ma_device_config deviceConfig;
    ma_device device;
    const char* pInputFilePath;
 
    if (argc < 2) {
        printf("No input file.\n");
        return -1;
    }
 
    pInputFilePath = argv[1];
 
    /* Quick validation test first. */
    if (do_decoding_validation(pInputFilePath) != 0) {
        return -1;
    }
 
 
    if (!drmp3_init_file(&mp3, pInputFilePath, NULL)) {
        printf("Failed to open file \"%s\"", pInputFilePath);
        return -1;
    }
 
    deviceConfig = ma_device_config_init(ma_device_type_playback);
    deviceConfig.playback.format   = ma_format_s16;
    deviceConfig.playback.channels = mp3.channels;
    deviceConfig.sampleRate        = mp3.sampleRate;
    deviceConfig.dataCallback      = data_callback;
    deviceConfig.pUserData         = &mp3;
    resultMA = ma_device_init(NULL, &deviceConfig, &device);
    if (resultMA != MA_SUCCESS) {
        drmp3_uninit(&mp3);
        printf("Failed to initialize playback device: %s.\n", ma_result_description(resultMA));
        return -1;
    }
 
    resultMA = ma_device_start(&device);
    if (resultMA != MA_SUCCESS) {
        ma_device_uninit(&device);
        drmp3_uninit(&mp3);
        printf("Failed to start playback device: %s.\n", ma_result_description(resultMA));
        return -1;
    }
 
    printf("Press Enter to quit...");
    getchar();
 
    /* We're done. */
    ma_device_uninit(&device);
    drmp3_uninit(&mp3);
    
    return 0;
}