I have very long audio with thousands of “stutters” in it. That is, some small parts got repeated twice. Those duplicates should be cut out. I’ve looked for DSP software that does such processing, but couldn’t find any. It’s certainly not a hard algorithmic problem, but I’m not good enough in DSP to write my own code for it.
It’s a huge set of very old recordings. I don’t have access to better sources. The cutting could be made easily by hand, but there are lots and lots of hours of work to be processed, with really huge number of cuts to be made.
It isn’t a very difficult problem to solve automatically (unlike echo cancellation, which nevertheless is also being attempted). I was sure I could find some software already providing such feature, but I couldn’t find so far.
Thanks a lot for responding, in any case. It seems I should keep looking.
I’m trying to build this job in my head. What kind of show can you have a slight stutter and be able to remove it surgically by hand if you had enough time? A series of needle getting stuck and somebody smacking it?
Let me clarify again: it is not echo. It’s with the same volume, not quieter.
I have no idea how the recording was made; it’s almost ancient recording. But some chunks of audio are just played twice. Like, if digits here represent unique chunks of the right sequence of audio:
, then what I have looks like this:
0112345567889 ---------------> I need to cut out the bold chunks of the audio.
In other words, at irregular places in time, with irregular length, some parts of the tape are being repeated twice. The redundant parts are just very confusing for the human ear, because they break the speech at random places. But the audio data itself is not lost, it just contains redundancy.
Over simple numeric data, this problem is solvable with linear algorithms. To do it over audio data, one needs to have algorithms to compare chunks. Probably by applying some vector measure which calls the chunks “equal”, if their difference within said measure is below some threshold. Unfortunately I really don’t know enough about DSP programming to do it all by myself.
From the information given so far there is no way to do that automatically in Audacity (and I know of no other program that can do it automatically either).
However, with a short sample for to play with, it’s possible that we may spot some peculiarity that will enable to repeats to be detected easily without having to listen to the whole of the recording - thus enabling a “semi-automatic” method of fixing (which has to be better than totally manual).
If the original is tape then the repetition is possibly “bleed through” : where the magnetized pattern on the tape is transferred between adjacent layers in the spool.
You could try googling “bleed through”, “audio”, “tape”, but I don’t think there a cure as the amount of bleed through and the interval between original and repetition is variable, (the former is random).
It would be unfortunate if no software supports this, because it’s certainly doable algorithmically.
No, it’s not print-through from the tape - in that case it would run OVER itself. It doesn’t run over itself. Rather, it may be from some kind of disk, or vinyl record, which got to occasionally slip back, and replay the same chunk one more time. Unfortunately, this has happened at random times, and the length of the repeated chunks is also random (if it’s from a disk, maybe not the whole cycle got repeated). I have no access to more original source.
We could simplify the whole problem to the following:
— Recognize where one chunk of audio is repeated twice. Delete the redundancy. The output of the needed operation would be shorter than the input.
The recording isn’t of some music with beat, so it doesn’t have other repetitive patterns of this kind, and with the right threshold an algorithm could identify exactly the chunks I need, and simply erase those segments from the audio. Thanks everyone for the input. I’ll look around some more.
Hm. Maybe, even if that sounds a little stupid, I could use echo removal tools (which exist, even if imperfect), and get them to treat the repetitions as “echo”, which they suppress. As a result, the repeated chunks would contain low-volume noise, close to silence (right?), because the “echo” in my case does not run over another part of the audio. Then, the silenced chunks could be identified with another tool (like gate) and erased automatically.
The stupidity of such approach is that we shoot ducks with bazooka, because my particular problem is much easier and more clear than echo removal, which is a very hard algorithmic challenge.