From 59918f98256e74d0dfc5fb76caacf648df631e20 Mon Sep 17 00:00:00 2001 From: xufulong Date: Sun, 17 Oct 2021 16:46:55 +0800 Subject: [PATCH] add example1.c --- app/src/main/cpp/sox/example1.c | 167 ++++++++++++++++++++++++++++++++ 1 file changed, 167 insertions(+) create mode 100644 app/src/main/cpp/sox/example1.c diff --git a/app/src/main/cpp/sox/example1.c b/app/src/main/cpp/sox/example1.c new file mode 100644 index 0000000..3dd6199 --- /dev/null +++ b/app/src/main/cpp/sox/example1.c @@ -0,0 +1,167 @@ +/* Simple example of using SoX libraries + * + * Copyright (c) 2007-8 robs@users.sourceforge.net + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General + * Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef NDEBUG /* N.B. assert used with active statements so enable always. */ +#undef NDEBUG /* Must undef above assert.h or other that might include it. */ +#endif + +#include "sox.h" +#include +#include +#include + +static sox_format_t * in, * out; /* input and output files */ + +/* The function that will be called to input samples into the effects chain. + * In this example, we get samples to process from a SoX-openned audio file. + * In a different application, they might be generated or come from a different + * part of the application. */ +static int input_drain( + sox_effect_t * effp, sox_sample_t * obuf, size_t * osamp) +{ + (void)effp; /* This parameter is not needed in this example */ + + /* ensure that *osamp is a multiple of the number of channels. */ + *osamp -= *osamp % effp->out_signal.channels; + + /* Read up to *osamp samples into obuf; store the actual number read + * back to *osamp */ + *osamp = sox_read(in, obuf, *osamp); + + /* sox_read may return a number that is less than was requested; only if + * 0 samples is returned does it indicate that end-of-file has been reached + * or an error has occurred */ + if (!*osamp && in->sox_errno) + fprintf(stderr, "%s: %s\n", in->filename, in->sox_errstr); + return *osamp? SOX_SUCCESS : SOX_EOF; +} + +/* The function that will be called to output samples from the effects chain. + * In this example, we store the samples in a SoX-opened audio file. + * In a different application, they might perhaps be analysed in some way, + * or displayed as a wave-form */ +static int output_flow(sox_effect_t *effp LSX_UNUSED, sox_sample_t const * ibuf, + sox_sample_t * obuf LSX_UNUSED, size_t * isamp, size_t * osamp) +{ + /* Write out *isamp samples */ + size_t len = sox_write(out, ibuf, *isamp); + + /* len is the number of samples that were actually written out; if this is + * different to *isamp, then something has gone wrong--most often, it's + * out of disc space */ + if (len != *isamp) { + fprintf(stderr, "%s: %s\n", out->filename, out->sox_errstr); + return SOX_EOF; + } + + /* Outputting is the last `effect' in the effect chain so always passes + * 0 samples on to the next effect (as there isn't one!) */ + *osamp = 0; + + (void)effp; /* This parameter is not needed in this example */ + + return SOX_SUCCESS; /* All samples output successfully */ +} + +/* A `stub' effect handler to handle inputting samples to the effects + * chain; the only function needed for this example is `drain' */ +static sox_effect_handler_t const * input_handler(void) +{ + static sox_effect_handler_t handler = { + "input", NULL, SOX_EFF_MCHAN, NULL, NULL, NULL, input_drain, NULL, NULL, 0 + }; + return &handler; +} + +/* A `stub' effect handler to handle outputting samples from the effects + * chain; the only function needed for this example is `flow' */ +static sox_effect_handler_t const * output_handler(void) +{ + static sox_effect_handler_t handler = { + "output", NULL, SOX_EFF_MCHAN, NULL, NULL, output_flow, NULL, NULL, NULL, 0 + }; + return &handler; +} + +/* + * Reads input file, applies vol & flanger effects, stores in output file. + * E.g. example1 monkey.au monkey.aiff + */ +int main(int argc, char * argv[]) +{ + sox_effects_chain_t * chain; + sox_effect_t * e; + char * vol[] = {"3dB"}; + + assert(argc == 3); + + /* All libSoX applications must start by initialising the SoX library */ + assert(sox_init() == SOX_SUCCESS); + + /* Open the input file (with default parameters) */ + assert(in = sox_open_read(argv[1], NULL, NULL, NULL)); + + /* Open the output file; we must specify the output signal characteristics. + * Since we are using only simple effects, they are the same as the input + * file characteristics */ + assert(out = sox_open_write(argv[2], &in->signal, NULL, NULL, NULL, NULL)); + + /* Create an effects chain; some effects need to know about the input + * or output file encoding so we provide that information here */ + chain = sox_create_effects_chain(&in->encoding, &out->encoding); + + /* The first effect in the effect chain must be something that can source + * samples; in this case, we have defined an input handler that inputs + * data from an audio file */ + e = sox_create_effect(input_handler()); + /* This becomes the first `effect' in the chain */ + assert(sox_add_effect(chain, e, &in->signal, &in->signal) == SOX_SUCCESS); + free(e); + + /* Create the `vol' effect, and initialise it with the desired parameters: */ + e = sox_create_effect(sox_find_effect("vol")); + assert(sox_effect_options(e, 1, vol) == SOX_SUCCESS); + /* Add the effect to the end of the effects processing chain: */ + assert(sox_add_effect(chain, e, &in->signal, &in->signal) == SOX_SUCCESS); + free(e); + + /* Create the `flanger' effect, and initialise it with default parameters: */ + e = sox_create_effect(sox_find_effect("flanger")); + assert(sox_effect_options(e, 0, NULL) == SOX_SUCCESS); + /* Add the effect to the end of the effects processing chain: */ + assert(sox_add_effect(chain, e, &in->signal, &in->signal) == SOX_SUCCESS); + free(e); + + /* The last effect in the effect chain must be something that only consumes + * samples; in this case, we have defined an output handler that outputs + * data to an audio file */ + e = sox_create_effect(output_handler()); + assert(sox_add_effect(chain, e, &in->signal, &in->signal) == SOX_SUCCESS); + free(e); + + /* Flow samples through the effects processing chain until EOF is reached */ + sox_flow_effects(chain, NULL, NULL); + + /* All done; tidy up: */ + sox_delete_effects_chain(chain); + sox_close(out); + sox_close(in); + sox_quit(); + return 0; +}