/*
* On an alsa capable system, plays an audio file starting 10 seconds in.
* Copes with sample-rate and channel change if necessary since its
* common for audio drivers to support a subset of rates and channel
* counts.
* E.g. example3 song2.ogg
*
* Can easily be changed to work with other audio device drivers supported
* by libSoX; e.g. "oss", "ao", "coreaudio", etc.
* See the soxformat(7) manual page.
*/
int main(int argc, char * argv[])
{
static sox_format_t * in, * out; /* input and output files */
sox_effects_chain_t * chain;
sox_effect_t * e;
sox_signalinfo_t interm_signal;
char * args[10];
assert(argc == 2);
sox_globals.output_message_handler = output_message;
sox_globals.verbosity = 1;
assert(sox_init() == SOX_SUCCESS);
assert(in = sox_open_read(argv[1], NULL, NULL, NULL));
/* Change "alsa" in this line to use an alternative audio device driver: */
assert(out= sox_open_write("default", &in->signal, NULL, "alsa", NULL, NULL));
chain = sox_create_effects_chain(&in->encoding, &out->encoding);
interm_signal = in->signal; /* NB: deep copy */
e = sox_create_effect(sox_find_effect("input"));
args[0] = (char *)in, assert(sox_effect_options(e, 1, args) == SOX_SUCCESS);
assert(sox_add_effect(chain, e, &interm_signal, &in->signal) == SOX_SUCCESS);
free(e);
e = sox_create_effect(sox_find_effect("trim"));
args[0] = "10", assert(sox_effect_options(e, 1, args) == SOX_SUCCESS);
assert(sox_add_effect(chain, e, &interm_signal, &in->signal) == SOX_SUCCESS);
free(e);
if (in->signal.rate != out->signal.rate) {
e = sox_create_effect(sox_find_effect("rate"));
assert(sox_effect_options(e, 0, NULL) == SOX_SUCCESS);
assert(sox_add_effect(chain, e, &interm_signal, &out->signal) == SOX_SUCCESS);
free(e);
}
if (in->signal.channels != out->signal.channels) {
e = sox_create_effect(sox_find_effect("channels"));
assert(sox_effect_options(e, 0, NULL) == SOX_SUCCESS);
assert(sox_add_effect(chain, e, &interm_signal, &out->signal) == SOX_SUCCESS);
free(e);
}
e = sox_create_effect(sox_find_effect("output"));
args[0] = (char *)out, assert(sox_effect_options(e, 1, args) == SOX_SUCCESS);
assert(sox_add_effect(chain, e, &interm_signal, &out->signal) == SOX_SUCCESS);
free(e);
sox_flow_effects(chain, NULL, NULL);
sox_delete_effects_chain(chain);
sox_close(out);
sox_close(in);
sox_quit();
return 0;
}
static THTensor * libsox_(read_audio_file)(const char *file_name)
{
// Create sox objects and read into int32_t buffer
sox_format_t *fd;
fd = sox_open_read(file_name, NULL, NULL, NULL);
if (fd == NULL)
abort_("[read_audio_file] Failure to read file");
int nchannels = fd->signal.channels;
long buffer_size = fd->signal.length;
int32_t *buffer = (int32_t *)malloc(sizeof(int32_t) * buffer_size);
size_t samples_read = sox_read(fd, buffer, buffer_size);
if (samples_read == 0)
abort_("[read_audio_file] Empty file or read failed in sox_read");
// alloc tensor
THTensor *tensor = THTensor_(newWithSize2d)(nchannels, samples_read / nchannels );
tensor = THTensor_(newContiguous)(tensor);
real *tensor_data = THTensor_(data)(tensor);
// convert audio to dest tensor
int x,k;
for (k=0; k<nchannels; k++) {
for (x=0; x<samples_read/nchannels; x++) {
*tensor_data++ = (real)buffer[x*nchannels+k];
}
}
// free buffer and sox structures
sox_close(fd);
free(buffer);
THTensor_(free)(tensor);
// return tensor
return tensor;
}
int main(int argc, char** argv) {
if (argc != 1) {
fprintf(stderr, "usage: %s < input_file\n", argv[0]);
exit(1);
}
const int in_channels = 2, in_samples = 512, sample_rate = 44100;
if (sox_init() != SOX_SUCCESS) {
oops("sox_init()");
}
sox_signalinfo_t out_si = {};
out_si.rate = sample_rate;
out_si.channels = in_channels;
out_si.precision = SOX_SAMPLE_PRECISION;
sox_format_t* output
= sox_open_write("default", &out_si, NULL, "alsa", NULL, NULL);
if (!output) {
oops("sox_open_read()");
}
sox_sample_t samples[in_samples * in_channels];
float input[in_samples * in_channels];
size_t clips = 0; SOX_SAMPLE_LOCALS;
for (;;) {
ssize_t sz = read(STDIN_FILENO, input, sizeof(input));
if (sz < 0) {
oops("read(stdin)");
}
if (sz == 0) {
break;
}
const size_t n_samples = sz / sizeof(float);
for (size_t n = 0; n < n_samples; n++) {
samples[n] = SOX_FLOAT_32BIT_TO_SAMPLE(input[n], clips);
}
if (sox_write(output, samples, n_samples) != n_samples) {
oops("sox_write()");
}
}
if (sox_close(output) != SOX_SUCCESS) {
oops("sox_close()");
}
if (sox_quit() != SOX_SUCCESS) {
oops("sox_quit()");
}
return 0;
}
int rfc1035_open_tcp(struct rfc1035_res *res, const RFC1035_ADDR *addr)
{
RFC1035_NETADDR addrbuf;
int af;
const struct sockaddr *addrptr;
int addrptrlen;
int fd=rfc1035_mksocket(SOCK_STREAM, 0, &af);
if (fd < 0) return (-1);
if (rfc1035_mkaddress(af, &addrbuf,
addr, htons(53),
&addrptr, &addrptrlen))
{
close(fd);
return (-1);
}
if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NDELAY) < 0)
{
sox_close(fd);
return (-1);
}
if (sox_connect(fd, addrptr, addrptrlen) == 0)
return (fd);
if (errno == EINPROGRESS || errno == EAGAIN)
{
unsigned w=res->rfc1035_timeout_initial;
if (!w) w=DEFAULT_INITIAL_TIMEOUT;
if (rfc1035_wait_query(fd, w) == 0 &&
(sox_connect(fd, addrptr, addrptrlen) == 0
|| errno == EISCONN))
{
return (fd);
}
}
sox_close(fd);
return (-1);
}
struct rfc1035_reply *rfc1035_resolve_multiple(
struct rfc1035_res *res,
int opcode, int options,
const struct rfc1035_query *queries,
unsigned nqueries)
{
struct querybuf qbuf;
int udpfd;
int attempt;
const RFC1035_ADDR *ns;
unsigned nscount;
unsigned current_timeout, timeout_backoff;
unsigned nbackoff, backoff_num;
int af;
static const char fakereply[]={0, 0, 0, RFC1035_RCODE_SERVFAIL,
0, 0,
0, 0,
0, 0,
0, 0};
nscount=rfc1035_init_nscount(res);
ns=rfc1035_init_nsget(res);
if (res->rfc1035_good_ns >= nscount)
res->rfc1035_good_ns=0;
qbuf.qbuflen=0;
if ( rfc1035_mkquery(res,
opcode, options, queries, nqueries, &putqbuf, &qbuf))
{
errno=EINVAL;
return (0);
}
/* Prepare the UDP socket */
if ((udpfd=rfc1035_open_udp(&af)) < 0) return (0);
/* Keep trying until we get an answer from a nameserver */
current_timeout=res->rfc1035_timeout_initial;
nbackoff=res->rfc1035_timeout_backoff;
if (!current_timeout) current_timeout=DEFAULT_INITIAL_TIMEOUT;
if (!nbackoff) nbackoff=DEFAULT_MAXIMUM_BACKOFF;
timeout_backoff=current_timeout;
for (backoff_num=0; backoff_num < nbackoff; backoff_num++,
current_timeout *= timeout_backoff)
for ( attempt=0; attempt < nscount; ++attempt)
{
int nbytes;
char *reply;
struct rfc1035_reply *rfcreply=0;
const RFC1035_ADDR *sin=&ns[(res->rfc1035_good_ns+attempt) % nscount];
int sin_len=sizeof(*sin);
int dotcp=0, isaxfr=0;
unsigned i;
for (i=0; i<nqueries; i++)
if (queries[i].qtype == RFC1035_TYPE_AXFR)
{
dotcp=1;
isaxfr=1;
break;
}
if (isaxfr && nqueries > 1)
return (rfc1035_replyparse(fakereply,
sizeof(fakereply)));
if (!dotcp)
{
/* Send the query via UDP */
RFC1035_NETADDR addrbuf;
const struct sockaddr *addrptr;
int addrptrlen;
if (rfc1035_mkaddress(af, &addrbuf,
sin, htons(53),
&addrptr, &addrptrlen))
continue;
if ((reply=rfc1035_query_udp(res, udpfd, addrptr,
addrptrlen, qbuf.qbuf, qbuf.qbuflen, &nbytes,
current_timeout)) == 0)
continue;
res->rfc1035_good_ns= (res->rfc1035_good_ns + attempt) %
nscount;
/* Parse the reply */
rfcreply=rfc1035_replyparse(reply, nbytes);
if (!rfcreply)
{
free(reply);
if (errno == ENOMEM) break;
continue;
/* Bad response from the server, try the next one. */
}
rfcreply->mallocedbuf=reply;
/*
** If the reply came back with the truncated bit set,
** retry the query via TCP.
*/
if (rfcreply->tc)
{
dotcp=1;
rfc1035_replyfree(rfcreply);
}
}
if (dotcp)
{
int tcpfd;
struct rfc1035_reply *firstreply=0, *lastreply=0;
if ((tcpfd=rfc1035_open_tcp(res, sin)) < 0)
continue; /*
** Can't connect via TCP,
** try the next server.
*/
reply=rfc1035_query_tcp(res, tcpfd, qbuf.qbuf,
qbuf.qbuflen, &nbytes, current_timeout);
if (!reply)
{
sox_close(tcpfd);
continue;
}
res->rfc1035_good_ns= (res->rfc1035_good_ns
+ attempt) % nscount;
rfcreply=rfc1035_replyparse(reply, nbytes);
if (!rfcreply)
{
free(reply);
sox_close(tcpfd);
continue;
}
rfcreply->mallocedbuf=reply;
firstreply=lastreply=rfcreply;
while (isaxfr && rfcreply->rcode == 0)
{
if ((reply=rfc1035_recv_tcp(res,
tcpfd, &nbytes, current_timeout))==0)
break;
rfcreply=rfc1035_replyparse(reply, nbytes);
if (!rfcreply)
{
free(reply);
rfc1035_replyfree(firstreply);
firstreply=0;
break;
}
rfcreply->mallocedbuf=reply;
lastreply->next=rfcreply;
lastreply=rfcreply;
if ( rfcreply->ancount &&
rfcreply->anptr[0].rrtype ==
RFC1035_TYPE_SOA)
break;
}
sox_close(tcpfd);
if (!firstreply)
return (0);
rfcreply=firstreply;
}
memcpy(&rfcreply->server_addr, sin, sin_len);
sox_close(udpfd);
return (rfcreply);
}
/*
** Return a fake server failure reply, when we couldn't contact
** any name server.
*/
sox_close(udpfd);
return (rfc1035_replyparse(fakereply, sizeof(fakereply)));
}
const char *tcpremoteinfo(const RFC1035_ADDR *laddr, int lport,
const RFC1035_ADDR *raddr, int rport, const char **ostype)
{
int fd;
time_t current_time, max_time;
fd_set fds;
struct timeval tv;
static char buf[512];
char *bufptr;
int bufleft, n;
char *p;
char *q;
RFC1035_NETADDR sin;
const struct sockaddr *addr;
int addrlen;
fd=rfc1035_mksocket(SOCK_STREAM, 0, &n);
if (fd < 0) return (0);
if (rfc1035_mkaddress(n, &sin, laddr, 0, &addr, &addrlen) < 0)
{
close(fd);
return (0);
}
if (sox_bind(fd, addr, addrlen) < 0)
{
sox_close(fd);
return (0);
}
time (¤t_time);
max_time=current_time+30;
if (rfc1035_mkaddress(n, &sin, raddr, htons(113), &addr, &addrlen) < 0)
{
sox_close(fd);
return (0);
}
if (s_connect(fd, addr, addrlen, max_time - current_time) < 0)
{
sox_close(fd);
return (0);
}
sprintf(buf, "%d,%d\r\n", ntohs(rport), ntohs(lport));
bufptr=buf;
bufleft=strlen(buf);
while (bufleft)
{
time(¤t_time);
if (current_time >= max_time)
{
sox_close(fd);
return (0);
}
FD_ZERO(&fds);
FD_SET(fd, &fds);
tv.tv_sec=max_time-current_time;
tv.tv_usec=0;
if (sox_select(fd+1, 0, &fds, 0, &tv) != 1 ||
!FD_ISSET(fd, &fds))
{
sox_close(fd);
return (0);
}
n=sox_write(fd, bufptr, bufleft);
if (n <= 0)
{
sox_close(fd);
return (0);
}
bufptr += n;
bufleft -= n;
}
bufptr=buf;
bufleft=sizeof(buf);
do
{
if (bufleft == 0)
{
sox_close(fd);
return (0);
}
time(¤t_time);
if (current_time >= max_time)
{
sox_close(fd);
return (0);
}
FD_ZERO(&fds);
FD_SET(fd, &fds);
tv.tv_sec=max_time-current_time;
tv.tv_usec=0;
if (sox_select(fd+1, &fds, 0, 0, &tv) != 1 ||
!FD_ISSET(fd, &fds))
{
sox_close(fd);
return (0);
}
n=sox_read(fd, bufptr, bufleft);
if (n <= 0)
{
sox_close(fd);
return (0);
}
bufptr += n;
bufleft -= n;
} while (bufptr[-1] != '\n');
sox_close(fd);
bufptr[-1]=0;
--bufptr;
if (bufptr > buf && bufptr[-1] == '\r')
bufptr[-1]=0;
if ((p=strchr(buf, ':')) == 0)
return (0);
q=++p;
if ((p=strchr(p, ':')) == 0)
return (0);
*p++=0;
q=strtok(q, " \t");
if (!q || strcmp(q, "USERID")) return (0);
if (ostype) *ostype=p;
if ((p=strchr(p, ':')) == 0)
return (0);
*p++=0;
while (*p && (*p == ' ' || *p == '\t')) p++;
return (p);
}
/*
* Reads input file and displays a few seconds of wave-form, starting from
* a given time through the audio. E.g. example2 song2.au 30.75 1
*/
int main(int argc, char * argv[])
{
sox_format_t * in;
sox_sample_t * buf;
size_t blocks, block_size;
/* Period of audio over which we will measure its volume in order to
* display the wave-form: */
static const double block_period = 0.025; /* seconds */
double start_secs = 0, period = 2;
char dummy;
uint64_t seek;
/* All libSoX applications must start by initialising the SoX library */
assert(sox_init() == SOX_SUCCESS);
assert(argc > 1);
++argv, --argc; /* Move to 1st parameter */
/* Open the input file (with default parameters) */
assert(in = sox_open_read(*argv, NULL, NULL, NULL));
++argv, --argc; /* Move past this parameter */
if (argc) { /* If given, read the start time: */
assert(sscanf(*argv, "%lf%c", &start_secs, &dummy) == 1);
++argv, --argc; /* Move past this parameter */
}
if (argc) { /* If given, read the period of time to display: */
assert(sscanf(*argv, "%lf%c", &period, &dummy) == 1);
++argv, --argc; /* Move past this parameter */
}
/* Calculate the start position in number of samples: */
seek = start_secs * in->signal.rate * in->signal.channels + .5;
/* Make sure that this is at a `wide sample' boundary: */
seek -= seek % in->signal.channels;
/* Move the file pointer to the desired starting position */
assert(sox_seek(in, seek, SOX_SEEK_SET) == SOX_SUCCESS);
/* Convert block size (in seconds) to a number of samples: */
block_size = block_period * in->signal.rate * in->signal.channels + .5;
/* Make sure that this is at a `wide sample' boundary: */
block_size -= block_size % in->signal.channels;
/* Allocate a block of memory to store the block of audio samples: */
assert(buf = malloc(sizeof(sox_sample_t) * block_size));
/* This example program requires that the audio has precisely 2 channels: */
assert(in->signal.channels == 2);
/* Read and process blocks of audio for the selected period or until EOF: */
for (blocks = 0; sox_read(in, buf, block_size) == block_size && blocks * block_period < period; ++blocks) {
double left = 0, right = 0;
size_t i;
static const char line[] = "===================================";
int l, r;
for (i = 0; i < block_size; ++i) {
SOX_SAMPLE_LOCALS;
/* convert the sample from SoX's internal format to a `double' for
* processing in this application: */
double sample = SOX_SAMPLE_TO_FLOAT_64BIT(buf[i],);
/* The samples for each channel are interleaved; in this example
* we allow only stereo audio, so the left channel audio can be found in
* even-numbered samples, and the right channel audio in odd-numbered
* samples: */
if (i & 1)
right = max(right, fabs(sample)); /* Find the peak volume in the block */
else
left = max(left, fabs(sample)); /* Find the peak volume in the block */
}
/* Build up the wave form by displaying the left & right channel
* volume as a line length: */
l = (1 - left) * 35 + .5;
r = (1 - right) * 35 + .5;
printf("%8.3f%36s|%s\n", start_secs + blocks * block_period, line + l, line + r);
}
/* All done; tidy up: */
free(buf);
sox_close(in);
sox_quit();
return 0;
}
int main(int argc, char** argv) {
if (argc != 2) {
fprintf(stderr, "usage: %s input_file > output_file\n", argv[0]);
exit(1);
}
const int out_channels = 2, sample_rate = 44100;
if (sox_init() != SOX_SUCCESS) {
oops("sox_init()");
}
sox_format_t* input = sox_open_read(argv[1], NULL, NULL, NULL);
if (!input) {
oops("sox_open_read()");
}
sox_signalinfo_t out_si = {};
out_si.rate = sample_rate;
out_si.channels = out_channels;
out_si.precision = SOX_SAMPLE_PRECISION;
sox_effect_handler_t out_handler = {
"stdout", NULL, SOX_EFF_MCHAN, NULL, NULL, stdout_writer, NULL, NULL, NULL, 0
};
sox_effects_chain_t* chain
= sox_create_effects_chain(&input->encoding, NULL);
if (!chain) {
oops("sox_create_effects_chain()");
}
{
sox_effect_t* effect = sox_create_effect(sox_find_effect("input"));
if (!effect) {
oops("sox_create_effect(input)");
}
char* args[1] = { (char*)input };
if (sox_effect_options(effect, 1, args) != SOX_SUCCESS) {
oops("sox_effect_options(input)");
}
if (sox_add_effect(
chain, effect, &input->signal, &out_si) != SOX_SUCCESS) {
oops("sox_add_effect(input)");
}
free(effect);
}
if (input->signal.rate != out_si.rate) {
{
sox_effect_t* effect = sox_create_effect(sox_find_effect("gain"));
if (!effect) {
oops("sox_create_effect(gain)");
}
const char* args[] = { "-h" };
if (sox_effect_options(effect, 1, (char**)args) != SOX_SUCCESS) {
oops("sox_effect_options(gain)");
}
if (sox_add_effect(
chain, effect, &input->signal, &out_si) != SOX_SUCCESS) {
oops("sox_add_effect(gain)");
}
free(effect);
}
{
sox_effect_t* effect = sox_create_effect(sox_find_effect("rate"));
if (!effect) {
oops("sox_create_effect(rate)");
}
const char* args[] = { "-Q", "7", "-b", "99.7" };
if (sox_effect_options(effect, 4, (char**)args) != SOX_SUCCESS) {
oops("sox_effect_options(rate)");
}
if (sox_add_effect(
chain, effect, &input->signal, &out_si) != SOX_SUCCESS) {
oops("sox_add_effect(rate)");
}
free(effect);
}
}
if (input->signal.channels != out_si.channels) {
sox_effect_t* effect = sox_create_effect(sox_find_effect("channels"));
if (!effect) {
oops("sox_create_effect(channels)");
}
if (sox_effect_options(effect, 0, NULL) != SOX_SUCCESS) {
oops("sox_effect_options(channels)");
}
if (sox_add_effect(
chain, effect, &input->signal, &out_si) != SOX_SUCCESS) {
oops("sox_add_effect(channels)");
}
free(effect);
}
{
sox_effect_t* effect = sox_create_effect(&out_handler);
if (!effect) {
oops("sox_create_effect(output)");
}
if (sox_add_effect(
chain, effect, &input->signal, &out_si) != SOX_SUCCESS) {
oops("sox_add_effect(output)");
}
free(effect);
}
sox_flow_effects(chain, NULL, NULL);
sox_delete_effects_chain(chain);
if (sox_close(input) != SOX_SUCCESS) {
oops("sox_close()");
}
if (sox_quit() != SOX_SUCCESS) {
oops("sox_quit()");
}
return 0;
}
/*
* Reads input file, applies vol & flanger effects, stores in output file.
* E.g. example1 monkey.au monkey.aiff
*/
int main(int argc, char * argv[]){
static sox_format_t * in, * out; /* input and output files */
sox_effects_chain_t * chain;
sox_effect_t * e;
char * args[10];
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 use the built-in handler that inputs
* data from an audio file */
e = sox_create_effect(sox_find_effect("input"));
args[0] = (char *)in, assert(sox_effect_options(e, 1, args) == SOX_SUCCESS);
/* This becomes the first `effect' in the chain */
assert(sox_add_effect(chain, e, &in->signal, &in->signal) == SOX_SUCCESS);
/* Create the `vol' effect, and initialise it with the desired parameters: */
e = sox_create_effect(sox_find_effect("vol"));
args[0] = "3dB", assert(sox_effect_options(e, 1, args) == 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);
/* 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);
/* The last effect in the effect chain must be something that only consumes
* samples; in this case, we use the built-in handler that outputs
* data to an audio file */
e = sox_create_effect(sox_find_effect("output"));
args[0] = (char *)out, assert(sox_effect_options(e, 1, args) == SOX_SUCCESS);
assert(sox_add_effect(chain, e, &in->signal, &in->signal) == SOX_SUCCESS);
/* 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;
}
int main(int argc, char* argv[])
{
static sox_format_t *in_file, *out_file;
sox_sample_t *buffer;
size_t read;
size_t sample_count;
unsigned int sample_order[SONG_LENGTH_S];
if(argc != 3) {
usage();
exit(EXIT_FAILURE);
}
if (sox_init() != SOX_SUCCESS) {
fprintf(stderr, "error: could not initialize Sox\n");
exit(EXIT_FAILURE);
}
if((in_file = sox_open_read(argv[1], NULL, NULL, NULL)) == NULL) {
fprintf(stderr, "error could not read input file\n");
exit(EXIT_FAILURE);
}
if((out_file = sox_open_write(argv[2], &in_file->signal,
NULL, "wav", NULL, NULL)) == NULL) {
fprintf(stderr, "error could not open output file\n");
exit(EXIT_FAILURE);
}
sample_count = SONG_LENGTH_S * in_file->signal.rate * in_file->signal.channels;
buffer = (sox_sample_t *) malloc(sizeof(sox_sample_t) * sample_count);
randomize_byte_order(sample_order);
if (sox_read(in_file, buffer, sample_count) != sample_count) {
fprintf(stderr, "Incorrect number of samples read");
}
unsigned int i=0;
for(i=0;i<SONG_LENGTH_S;i++) {
sox_write(out_file, buffer + (sample_order[i] * (((unsigned int)(in_file->signal.rate)
* in_file->signal.channels))),
in_file->signal.rate * in_file->signal.channels);
}
free(buffer);
sox_close(in_file);
sox_close(out_file);
sox_quit();
return 0;
}
