Recovering crashes manually

From Audacity Wiki
Revision as of 05:36, 9 July 2007 by Galeandrews (talk | contribs) (Aud_Recover command-line recovery utility: convert plain text link)
Jump to: navigation, search

How to recover unsaved data

If Audacity is not able to shut down properly (e.g. because the program crashes, or the computer loses power suddenly), then unsaved data may be left in Audacity's temporary files folder. These instructions can help you recover that unsaved data.

Note: This can be very difficult for long recordings. The Audacity developers are planning to add auto-recovery features to future versions of Audacity.

When you first launch Audacity after a crash, a dialog will appear warning you that there are still files in the temporary folder. It will ask if you want to delete the files. Say "no." (If you were editing an existing project, then the files may be in the project_data folder instead of the temp folder.)

Audacity breaks tracks into "block files", each with about one megabyte of data. This allows Audacity to perform many editing tasks very quickly and efficiently. Without a saved project file, Audacity does not know how to assemble the blockfiles into tracks. You will need to assemble them manually.

NOTE: As of 20060409, none of the information here works for Audacity 1.3x. For one thing, the temporary files are not numbered decimal sequentially. If the files are sorted by the date they were created, and then renamed in that order as if they came from 1.2.x, then they should recover OK. The next release of audacity will automate this process.


Check the "Directories" section of the Audacity preferences to find out where temporary files are stored.

(Mac users: The temporary folder is usually hidden in the Finder. To access it, use the "Go To Folder" command in the Finder, or type "open /tmp/INSERT_FOLDER_NAME_HERE" in the Terminal.)

Use the "Import Audio" command in the Project to open all of the .au files in Audacity's temp folder. Use shift-click or control-click to select multiple files. The files will be in approximately 10-second chunks. Files from stereo tracks will alternate between left and right channels. You can use copy/paste to re-assemble the original tracks.

Audacity Recovery Utility

The following program was written by an Audacity developer to help with crash recovery. It still needs more testing, so please write to [email protected] to let us know whether it works for you:

Aud_Recover command-line recovery utility

NOTE: At the time of writing all the links below to this utility are dead. UPDATE: As of July 7, 2007 a Windows binary of version 1.1.1 is available here.

This is a portable command line program by Tyler Knott which does much the same as the Audacity Recovery Utility but is not written in python/ wxpython, so does not need those libraries in order to compile it.

I recently was editing a file I recorded with Audacity and it crashed before I had saved it. Since I didn't want to re-record the file I wrote a reasonably-portable* C program to recover the file. This program worked extremely well so I polished it up (I added tons of file I/O error checking and rewrote some parts of it) as well as a companion utility (auinfo) to get the file info (required for the Import Raw Data dialog). This program is different from others in that it gets the header length from the .au file, instead of guessing it or ignoring that there is a header, and that it requires no other external programs/interpreters to run (once it's compiled). This program will also work with files that have the wrong type of endianness for the platform it's run on.

The programs are too long to post here (over 300 lines total), so I'm hosting them on my webspace at (26k) They are both licensed under the GNU GLP. The zip file includes the source code, Win32 executables, and a copy of the GNU GPL. I might get a chance to compile these programs for Mac OS X next week. If I do I'll post the binaries then.

To recover files using this program:

  1. Figure out which file is the first file that is your recording by listening to the files in the temp directory
  2. Place the aud_recover program in your Audacity temp directory
  3. Run aud_recover and answer all the prompts
  4. You should get one or two files (depending on whether the file is stereo or mono), you need to import these into Audacity using the Import Raw Data option. This option will ask you a series of questions about the data you're importing. The tool auinfo can examine your temporary files to tell you this information. To use it, call auinfo from the command line and provide as an argument the file that you figured out in the first step. For example, C:\audacity_1_2_temp>auinfo.exe
  5. For stereo files set the left channel to left, the right channel to right, then select "Make Stereo Track" from the track popdown menu

The resulting file should be exactly what was recorded before Audacity crashed/was unexpectedly terminated.

(*By reasonably portable I mean that it should compile on at least everything that Audacity compiles on, for Macs you'll need to modify the source file for auinfo slightly (see the file for instructions).)

I recently received an e-mail from Richard Ash (richardash1981 at yahoo dot co dot uk) who made some small improvements to the source so it works better in *nix environments, as well as including a makefile. The changes do not affect Windows envirionments. You can get the improved version (without Windows binaries) at (17k)

I recently received a few bug reports (thanks Robert Piche and Martin Kirst!) and had a bit of free time so I've updated aud_recover and auinfo to version 1.1.0 (and I started versioning them :D). Here are the changes:

  • aud_recover and auinfo now take command line options. See their -? or --usage for options for usage info.
  • aud_recover now supports up to 16 channels.
    • (For those interested in the source code: As a result I also simplified the main processing loop in main())
  • Fixed bug in aud_recover involving channel selection.
  • Includes previous contributions from Richard Ash

The new version (including the source code, *nix makefiles, and Windows binaries) can be found here: (42k)

If you have any questions, comments, or bug reports please don't hesitate to e-mail me at tknott *at* gmail *dot* com

A new version of aud_recover (1.1.1) is available that fixes a serious programming error in the previous release. Windows binares are available here: and Linux binaries (compiled on Slackware 10.2 for x86) with sourcecode are available here:

All aud_recover users using version 1.1.0 are strongly encouraged to upgrade to 1.1.

Other Tools

This freeware tool can automatically join large numbers of files. (Note: One Audacity user reported an audible noise at the places where the files were joined.)

  • tail and cat (On Linux/UNIX systems)
   - I found that 123 AV Merger gave me exactly what I would get with cat.
   I  was able to get around this with the following procedure:
   1. I had to throw out all odd-numbered files (1,3,5...)
   2. Using tail's byte-count switch "-c" I copied each remaining .au to a new .au.tmp file
   3. Using cat I  ran all the .au.tmp files into on long .au
   4. Imported the final .au with "Import RAW Data"
   5. Exported the track as wav
   I played around with exactly how many bytes to tail until there was no longer any sharp noises at each joint. I don't have that number with me right now - I'll try to get it later.

This could be theoretically written into a script. I'll try to add more details later.

<a href="">sox</a> can concatenate the files together.

Usage: sox file1 .. filen outfile

(Sox can handle up to 32 files at a time.)

e.g. for a mono recording:

  % sox b0000*.au b0001*.au b0002*.au

After I'm done, I have just several au files to import (a lot fewer than before).

I found it easier to write the following Python script that I used under Mac OS X to recover 1.2GB of data. It was easier than the above solutions.

% cat

# python script to recover audacity recording after crash

import os

directory = raw_input('Enter directory where temp data files are: ')

rawfiles = os.listdir(directory)  # grab directory listing

files = []           # only interested in .au files and
for i in rawfiles:   # prepend each with the directory name
   if i[-3:] == '.au': files.append(directory+'/'+i)

files.sort()  # sort files so the result will be in proper sequence

# open the output file for the recovery
fp = open('','wb')

# write the whole first file because it has the header
dd = open(files[0],'rb').read()

# for every other file, write from the data offset on
for i in files[1:]:
   dd = open(i, 'rb').read()[12380:]

# close recovered sound file

I had problems using the above script. I found that it didn't really write every other file, so if you try to recovery stereo recordings you get a nasty echo effect since every other file is the left or right channel.

The problem with the script above is that you coded the slice wrong:

>>> x=(1,2,3,4,5,6,7,8,9,10)  # sample data
>>> x[1:]                     # doesn't do what you wanted
(2, 3, 4, 5, 6, 7, 8, 9, 10)
>>> x[::2]                    # this gets the odd-numbered items
(1, 3, 5, 7, 9)
>>> x[1::2]                   # this gets the even-numbered ones
(2, 4, 6, 8, 10)

So, you just need to change the line "for i in files[1:]:" to either "for i in files[::2]:" (for the first channel), or "for i in files[1::2]:" (for the other).

I wrote this modified version of the script to try to put the two tracks into two recovery files. Unfortunately, just importing the recovered files doesn't seem to give you perfect stereo again because of sync issues, possibly due to missing files in the recovery set. Give it a shot, it might work for you.

# python script to recover audacity recording after crash

import os

directory = raw_input('Enter directory where temp data files are: ')

rawfiles = os.listdir(directory)  # grab directory listing

files = []           # only interested in .au files and
for i in rawfiles:   # prepend each with the directory name
   if i[-3:] == '.au': files.append(directory+'/'+i)

files.sort()  # sort files so the result will be in proper sequence

# open the output file for the recovery
fp = open('','wb')

# write the whole first file because it has the header
dd = open(files[0],'rb').read()

#this is intented for recoverying stereo and the second file should be the
# first part of the second track, so write the whole file.

fpp = open('','wb')
# write the whole second file because it has the header for track 2
dd = open(files[1],'rb').read()

#it's stereo, so the .au files should alternate left & right channels, so files
#should be written to our two recovery files alternately starting with the 3rd file in our list

#count serves as a quick hack to let us alternate recovery files
count = 1
#this is just to give a quick count so you can see if the two recovery files got the same number of files added to them
track_one_files = 1
track_two_files = 1
# for every other file, write from the data offset on
for i in files[2:]:
   	if count == 1:
		#write to first recovery file
   		dd = open(i, 'rb').read()[12380:]
   		count = 0
		track_one_files = track_one_files + 1
		#write to second recovery file
		dd = open(i, 'rb').read()[12380:]
		count = 1
		track_two_files = track_two_files + 1

print "Files recovered for track 1:"
print track_one_files
print "Files recovered for track 2:"
print track_two_files
# close recovered sound files

I was unable to get sox to work as the above tip instructed. Sox always complained about a missing operation or misinterpreted the filename of one of the Audacity temp files as a filter to perform on the other files.

So, I used sox in a different way. I was trying to rescue an hour-long mono recording on a Unix-like system (a Fedora Core 3 GNU/Linux system). First, I made a copy of the temp directory and its files:

$ cp -r /tmp/audacity1.2-jbn ~/rescue

Then I used sox to convert the AU temp files into raw files (headerless files). Since Audacity had already numbered the files with leading zeroes (and perhaps because I didn't have that many of them to work on), I could use an ordinary shell wildcard to do the work:

$ for f in b*.au ; do sox ${f} -t raw ${f}.raw ; done

I concatenated the raw files together to make one hour-long mono raw file. I had to use raw files to do this, concatenating the AU files together (each with its own header) would have produced a periodic noise (because Audacity was trying to interpret the AU header data as sound data).

$ cat *.raw > bigfile.raw

And then I imported the raw file into Audacity specifying the appropriate number and signedness of the samples (16-bit signed PCM, in my case), endianness (Big-endian, in my case), channels (1 channel for mono), and sample rate (44,100 samples per second, in my case). I wanted to import the whole file (100%) starting from the beginning (0 byte offset).

I was left with a file I could export to WAV, play, and edit normally. 1

I recently have to kill audacity and as a result I lost the aup project file for my recording of 3000+ au files. What exactly should I do to restore the aup project file from the thousands au files?

i tried to add the .au files to a winamp playlist ordered by date (ascending) then save the output as a wav file this solved my problem. i hope it will help yours. (My project was a recording project so the order of files were easily understood)

I also had success with the winamp method using the write to disk output utility. Didn't work for me until I first converted each individual .au into .wav files then converted all the .wav files into a single .wav file.