The best — though least helpful — way to do this is not to use MP3 files as your source files. WAV, FLAC or M4A files don't have this problem.

MP3s aren't made up of fixed-rate samples, so cropping out a section of an arbitrary length will not work as you expect. Unless the encoder was smart (like lame), there will often be a gap at the start or end of the MP3 file's audio. I did a test with a sample 0.98s long (which is precisely 73½ CDDA frames, and many MP3 encoders use frames for minimum sample lengths). I then encoded the sample with three different MP3 encoders (lame, sox, and the ancient shine), then decoded those files with three decoders (lame, sox, and madplay). Here's how the sample lengths compare to the original:

 Enc.→Dec.          Length     Samples  CDDA Frames
 -----------------  ---------  -------  -----------
 shine→lame         0.95"      42095    71.5901
 shine→madplay      0.97"      42624    72.4898
 shine→sox          0.97"      42624    72.4898
 lame→lame          0.98"      43218    73.5000
*Original           0.98"      43218    73.5000
 sox→sox            0.99"      43776    74.4490
 sox→lame           1.01"      44399    75.5085
 lame→madplay       1.02"      44928    76.4082
 lame→sox           1.02"      44928    76.4082
 sox→madplay        1.02"      44928    76.4082

Only the file encoded and decoded by lame ended up the same length (mostly because lame inserts a length tag to correct for these too-short samples, and knows how to decode it). Everything encoded by sox ended up with a tiny gap, no matter what decoder I used. So joining the files will result in tiny clicks.

Your browser is likely mixing and overlapping the source files very slightly so you don't hear the clicks. Gapless playback is hard to do correctly.

just change -M with -m

-M = merge
-m = mix

You should be able to do something like:

sox short.ogg -p pad 0 6|sox - long.ogg output.ogg

-p option to sox is used for piping - basically, it tells sox to use stdout as the output. Using - as the input to the second sox is actually saying input is stdin (which happens to be the stdout of the previous sox, as we are piping with |). pad 0 6 tells pad 0 seconds at the beginning and 6 seconds at the end.

Hope this helps.

You can do it with one invocation of sox like this:

sox -m in1.mp3 in2.mp3 in3.mp3 out.mp3

If you want to combine this with the pad effect you need to be clearer about what you want.

You're almost there. The -v option can be applied to each input file, and for any of the combine methods. Set the scale factor in front of the file you want it applied to.

sox -n -r 44100 -b 16 s660.wav synth 20 sine 660 # a pure A
sox -n -r 44100 -b 16 s440.wav synth 20 sine 440 # a pure E

sox -m -v 0.4 s440.wav -v 0.9 s660.wav mix4-9.wav # an A5 with weight on the prime
sox -m -v 0.9 s440.wav -v 0.4 s660.wav mix9-4.wav # an A5 with weight on the fifth

I have gotten most of the way there with

sox --combine concatenate *.wav _merge.wav splice -q 3,1

The splice effect at the end places the beginning of the cross-fade at 3 seconds into the first file, and uses 1 second as cross-fade duration (half second at beginning and end of two files). This method is a temporary fix as I can choose to include only ~3 second files in my output (using other methods). A better answer would figure out how to grab duration of current file and substitute that in place of the 3.

sox --combine concatenate *.wav _merge.wav splice -q $(soxi −D {}),1

If the {} here selected the current item (as in find), that would do it. But that doesn't seem to work.

3gp is a multimedia container and not supported by sox.

You can extract the audio with ffmpeg and further process it with sox although ffmpeg can also do a lot of audio processing.

Here's one way to convert the data to wav, concatenate and convert back to 3gp:

ffmpeg -i 1.3gp 1.wav
ffmpeg -i 2.3gp 2.wav
ffmpeg -i 3.3gp 3.wav

Concatenate, maybe other things with sox (sequence is default so no need to specify):

sox 1.wav 2.wav 3.wav long.wav

Convert back to 3gp:

ffmpeg -i long.wav newaudio.3gp

I don't know if you are aware of the crossfade_cat.sh script offered by sox. You could just use it successively:

./crossfade_cat.sh 1 440.wav 660.wav auto auto && ./crossfade_cat.sh 1 mix.wav 880.wav auto auto

Or if you want to crossfade a high number of wav files, to use all files in a directory you could use a shell loop, something like this:

crossfade_dur=1
i=0

for file in *.wav
do

    i=$((i+1))

    if [ $i -eq 1 ]
    then
        cp $file mix.wav
    else
        crossfade_cat.sh $crossfade_dur mix.wav $file auto auto
    fi

done

You can try using find

find . -type d -exec bash -O nullglob -c 'cd "$0" && files=(*.wav) && ((${#files[@]})) && echo sox "${files[@]}" "${0##*/}_combined.wav"' {} \;

• That will not do anything but print the output to stdout.

• Remove the echo if you think the output is ok, so it will actually convert the files.

A brief explanation.

• -type d means find will look for directory only.

• -exec is use so we can call/invoke a shell to do a shell tasks.

• bash -O nullglob Just in case there are no files the glob *.wav will not expand. ( no files will be added to the array files )

• -c Execute a shell commands

• cd "$0" && go inside on each directory && run the next command if the command before it succeeded.

• files=(*.wav) && Create an array of *.wav files

• ((${#files[@]})) If array is not empty ( there are *.wav files )

• sox "${files[@]}" "${0##*/}_combined.wav Run sox on all the *.wav files, the "${0##*/} strips the filename from the path name.

I think there's an issue with ". Try

sox -m drums.wav '|sox beats.wav -p pad 1.5' out.wav

After hours and hours of trying finaly i find a way to do this:

this is the anwser:

sox -m "|sox 1.wav 2.wav -p" noise.wav output.wav 

where 1.wav, 2.wav and noise.wav are file localy stored and output.wav is the output generated by SOX.

I hope this save others time. I serch over the internet for this answer for days and no luck.

You could concatenate both files, then remove the part that you don't need:

sox A B O trim 0 17 43

In a bash shell, this can be fully automated like so:

sox A B O trim 0 $(( $(soxi -s A) - $(soxi -s B) ))s $(soxi -s B)s

Here, soxi -s file is used to determine the file length in samples. Another possibility, using a second sox instance in a pipe special input file:

sox "| sox A -p trim 0 -$(soxi -s B)s" B O

I found that the simplest solution is to write the command as such:

sox infile outfile start =end

The audio is not sent to the output stream until the start location is reached and specifying an end location can be done by using the "=" sign with the end time.

So the code would now be, for instance:

sox forth.wav 10.wav trim 303.463 =353.790

1. Link to the docs http://manpages.ubuntu.com/manpages/precise/man1/sox.1.html
2. Relevant excerpt:

trim start [length|=end] The optional length parameter gives the length of audio to output after the start sample and is thus used to trim off the end of the audio. Alternatively, an absolute end location can be given by preceding it with an equals sign. Using a value of 0 for the start parameter will allow trimming off the end only.