ref: fbd0eed489f59a6fbca4eee56eef7e3f8ad52e29
dir: /examples/dumbplay.c/
#include <argtable2.h>
#include <dumb.h>
#include <stdint.h>
#include <string.h>
#include <signal.h>
#include <stdbool.h>
#include <SDL2/SDL.h>
// How many samples we should handle per callback call
#define SAMPLES 8192
// How many chars wide the progress bar is
#define PROGRESSBAR_LENGTH 25
typedef struct {
// Library contexts
DUH_SIGRENDERER *renderer;
DUH *src;
SDL_AudioDeviceID dev;
sample_t **sig_samples;
long sig_samples_size;
// Runtime vars
float delta;
int spos; // Samples read
int ssize; // Total samples available
int sbytes; // bytes per sample
bool ended;
// Config switches
int bits;
int freq;
int quality;
int n_channels;
bool no_progress;
float volume;
const char *input;
} streamer_t;
// Set to true if SIGTERM or SIGINT is caught
static bool stop_signal = false;
// Simple signal handler function
static void sig_fn(int signo) { stop_signal = true; }
// This is called from SDL2, and should read data from a source and hand it over
// to SDL2 via the stream buffer.
void stream_audio(void *userdata, Uint8 *stream, int len) {
streamer_t *streamer = (streamer_t *)userdata;
// Read samples from libdumb save them to the SDL buffer. Note that we are
// reading SAMPLES, not bytes!
int r_samples = len / streamer->sbytes;
int got =
duh_render_int(streamer->renderer, &streamer->sig_samples,
&streamer->sig_samples_size, streamer->bits, 0,
streamer->volume, streamer->delta, r_samples, stream);
if (got == 0) {
streamer->ended = true;
}
// Get current position from libdumb for the playback display. If we get
// position that is 0, it probably means that the song ended and
// duh_sigrenderer_get_position points to the start of the file.
streamer->spos = duh_sigrenderer_get_position(streamer->renderer);
if (streamer->spos == 0) {
streamer->spos = streamer->ssize;
}
}
// Simply formats timestamp to string
void format_ms(int ticks) {
int total_seconds = ticks / 1000;
int hours = 0;
int minutes = 0;
int seconds = 0;
// Calculate hours, minutes and seconds
if (total_seconds > 3600) {
hours = total_seconds / 3600;
total_seconds = total_seconds % 3600;
}
if (total_seconds > 60) {
minutes = total_seconds / 60;
total_seconds = total_seconds % 60;
}
seconds = total_seconds;
// If necessary, show hours. Otherwise only minutes and seconds.
if (hours > 0) {
printf("%02d:%02d:%02d", hours, minutes, seconds);
} else {
printf("%02d:%02d", minutes, seconds);
}
}
// Shows progressbar and time played
void show_progress(int width, float progress, int ticks) {
int d = progress * width;
printf("%3d%% [", (int)(progress * 100));
for (int x = 0; x < d; x++) {
printf("=");
}
for (int x = 0; x < (width - d); x++) {
printf(" ");
}
printf("] ");
format_ms(ticks);
printf("\r");
fflush(stdout);
}
int main(int argc, char *argv[]) {
int retcode = 1;
int nerrors = 0;
streamer_t streamer;
memset(&streamer, 0, sizeof(streamer_t));
// Signal handlers
signal(SIGINT, sig_fn);
signal(SIGTERM, sig_fn);
// Initialize SDL2
if (SDL_Init(SDL_INIT_AUDIO) != 0) {
fprintf(stderr, "%s\n", SDL_GetError());
return 1;
}
// Defaults
streamer.freq = 44100;
streamer.n_channels = 2;
streamer.bits = 16;
streamer.volume = 1.0f;
streamer.quality = DUMB_RQ_CUBIC;
// commandline argument parser options
struct arg_lit *arg_help =
arg_lit0("h", "help", "print this help and exits");
struct arg_dbl *arg_volume =
arg_dbl0("v", "volume", "<volume",
"sets the output volume (-8.0 to +8.0, default 1.0)");
struct arg_int *arg_samplerate = arg_int0(
"s", "samplerate", "<freq>", "sets the sampling rate (default 44100)");
struct arg_int *arg_quality = arg_int0(
"r", "quality", "<quality>", "specify the resampling quality to use");
struct arg_lit *arg_mono =
arg_lit0("m", "mono", "generate mono output instead of stereo");
struct arg_lit *arg_eight =
arg_lit0("8", "eight", "generate 8-bit instead of 16-bit");
struct arg_lit *arg_noprogress =
arg_lit0("n", "noprogress", "hide progress bar");
struct arg_file *arg_output =
arg_file0("o", "output", "<file>", "output file");
struct arg_file *arg_input =
arg_file1(NULL, NULL, "<file>", "input module file");
struct arg_end *arg_fend = arg_end(20);
void *argtable[] = {arg_help, arg_input, arg_volume,
arg_samplerate, arg_quality, arg_mono,
arg_eight, arg_noprogress, arg_fend};
const char *progname = "dumbplay";
// Make sure everything got allocated
if (arg_nullcheck(argtable) != 0) {
fprintf(stderr, "%s: insufficient memory\n", progname);
goto exit_0;
}
// Parse inputs
nerrors = arg_parse(argc, argv, argtable);
// Handle help
if (arg_help->count > 0) {
fprintf(stderr, "Usage: %s", progname);
arg_print_syntax(stderr, argtable, "\n");
fprintf(stderr, "\nArguments:\n");
arg_print_glossary(stderr, argtable, "%-25s %s\n");
goto exit_0;
}
// Handle libargtable errors
if (nerrors > 0) {
arg_print_errors(stderr, arg_fend, progname);
fprintf(stderr, "Try '%s --help' for more information.\n", progname);
goto exit_0;
}
// Handle the switch options
streamer.input = arg_input->filename[0];
if (arg_eight->count > 0) {
streamer.bits = 8;
}
if (arg_mono->count > 0) {
streamer.n_channels = 1;
}
if (arg_noprogress->count > 0) {
streamer.no_progress = true;
}
if (arg_volume->count > 0) {
streamer.volume = arg_volume->dval[0];
if (streamer.volume < -8.0f || streamer.volume > 8.0f) {
fprintf(stderr, "Volume must be between -8.0f and 8.0f.\n");
goto exit_0;
}
}
if (arg_samplerate->count > 0) {
streamer.freq = arg_samplerate->ival[0];
if (streamer.freq < 1 || streamer.freq > 96000) {
fprintf(stderr, "Sampling rate must be between 1 and 96000.\n");
goto exit_0;
}
}
if (arg_quality->count > 0) {
streamer.quality = arg_quality->ival[0];
if (streamer.quality < 0 || streamer.quality >= DUMB_RQ_N_LEVELS) {
fprintf(stderr, "Quality must be between %d and %d.\n", 0,
DUMB_RQ_N_LEVELS - 1);
goto exit_0;
}
}
// Load source file.
dumb_register_stdfiles();
streamer.src = dumb_load_any(streamer.input, 0, 0);
if (!streamer.src) {
fprintf(stderr, "Unable to load file %s for playback!\n",
streamer.input);
goto exit_0;
}
// Set up playback
streamer.renderer =
duh_start_sigrenderer(streamer.src, 0, streamer.n_channels, 0);
streamer.delta = 65536.0f / streamer.freq;
streamer.sbytes = (streamer.bits / 8) * streamer.n_channels;
streamer.ssize = duh_get_length(streamer.src);
// Stop producing samples on module end
DUMB_IT_SIGRENDERER *itsr = duh_get_it_sigrenderer(streamer.renderer);
dumb_it_set_loop_callback(itsr, &dumb_it_callback_terminate, NULL);
dumb_it_set_xm_speed_zero_callback(itsr, &dumb_it_callback_terminate, NULL);
dumb_it_set_resampling_quality(itsr, streamer.quality);
// Set up the SDL2 format we want for playback.
SDL_AudioSpec want;
SDL_zero(want);
want.freq = streamer.freq;
want.format = (streamer.bits == 16) ? AUDIO_S16 : AUDIO_S8;
want.channels = streamer.n_channels;
want.samples = SAMPLES;
want.callback = stream_audio;
want.userdata = &streamer;
// Find SDL2 audio device, and request the format we just set up.
// SDL2 will tell us what we got in the "have" struct.
SDL_AudioSpec have;
streamer.dev = SDL_OpenAudioDevice(NULL, 0, &want, &have, 0);
if (streamer.dev == 0) {
fprintf(stderr, "%s\n", SDL_GetError());
goto exit_1;
}
// Make sure we got the format we wanted. If not, stop here.
if (have.format != want.format) {
fprintf(stderr, "Could not get correct playback format.\n");
goto exit_2;
}
// Play file
SDL_PauseAudioDevice(streamer.dev, 0);
// Show initial state of the progress bar (if it is enabled)
int time_start = SDL_GetTicks();
float seek = 0.0f;
int ms_played = 0;
if (!streamer.no_progress) {
show_progress(PROGRESSBAR_LENGTH, seek, ms_played);
}
// Loop while dumb is still giving data. Update progressbar if enabled.
while (!stop_signal && !streamer.ended) {
if (!streamer.no_progress) {
seek = ((float)streamer.spos) / ((float)streamer.ssize);
ms_played = SDL_GetTicks() - time_start;
show_progress(PROGRESSBAR_LENGTH, seek, ms_played);
}
SDL_Delay(100);
}
// We made it this far without crashing, so let's just exit with no error :)
retcode = 0;
// Free up resources and exit.
if (streamer.sig_samples) {
destroy_sample_buffer(streamer.sig_samples);
}
exit_2:
SDL_CloseAudioDevice(streamer.dev);
exit_1:
if (streamer.renderer) {
duh_end_sigrenderer(streamer.renderer);
}
if (streamer.src) {
unload_duh(streamer.src);
}
exit_0:
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
SDL_Quit();
return retcode;
}