Given an audio stream, find when a door slams (sound pressure level calculation?)

There is a lot of relevant literature on this problem in the radar world (it's called detection theory).

You might have a look at "cell averaging CFAR" (constant false alarm rate) detection. Wikipedia has a little bit here. Your idea is very similar to this, and it should work! :)

Good luck!

I would start by looking at the spectral. I did this on the two audio files you gave, and there does seem to be some similarity you could use. For example the main difference between the two seems to be around 40-50Hz. My .02.

UPDATE

I had another idea after posting this. If you can, add an accelerometer onto the device. Then correlate the vibrational and acoustic signals. This should help with cross vehicle door detection. I'm thinking it should be well correlated since the sound is vibrationally driven, wheres the stereo for example, is not. I've had a device that was able to detect my engine rpm with a windshield mount (suction cup), so the sensitivity might be there. (I make no promises this works!)

_{(source: charlesrcook.com)}

%% Test Script (Matlab)
clear
hold all %keep plots open
dt=.001

%% Van driver door
data = wavread('van_driver_door_closing.wav');

%Frequency analysis
NFFT = 2^nextpow2(length(data));
Y = fft(data(:,2), NFFT)/length(data);
freq = (1/dt)/2*linspace(0,1,NFFT/2);
spectral = [freq'  2*abs(Y(1:NFFT/2))];

plot(spectral(:,1),spectral(:,2))

%% Repeat for van sliding door
data = wavread('van_driverdoorclosing.wav');

%Frequency analysis
NFFT = 2^nextpow2(length(data));
Y = fft(data(:,2), NFFT)/length(data);
freq = (1/dt)/2*linspace(0,1,NFFT/2);
spectral = [freq'  2*abs(Y(1:NFFT/2))];

plot(spectral(:,1),spectral(:,2))

You should tap in to the door close switches in the car. Trying to do this with sound analysis is overengineering.

There are a lot of suggestions about different signal processing approaches to take, but really, by the time you learn about detection theory, build an embedded signal processing board, learn the processing architecture for the chip you chose, attempt an algorithm, debug it, and then tune it for the car you want to use it on (and then re-tune and re-debug it for every other car), you will be wishing you just stickey taped a reed switch inside the car and hotglued a magnet to the door.

Not that it's not an interesting problem to solve for the dsp experts, but from the way you're asking this question, it's clear that sound processing isn't the route you want to take. It will just be such a nightmare to make it work right.

Also, the clapper is just an high pass filter fed into a threshold detector. (plus a timer to make sure 2 claps quickly enough together)

Looking at the screenshots of the source audio files, one simple way to detect a change in sound level would be to do a numerical integration of the samples to find out the "energy" of the wave at a specific time.

A rough algorithm would be:

1. Divide the samples up into sections
2. Calculate the energy of each section
3. Take the ratio of the energies between the previous window and the current window
4. If the ratio exceeds some threshold, determine that there was a sudden loud noise.

Pseudocode

samples = load_audio_samples()     // Array containing audio samples
WINDOW_SIZE = 1000                 // Sample window of 1000 samples (example)

for (i = 0; i < samples.length; i += WINDOW_SIZE):
    // Perform a numerical integration of the current window using simple
    // addition of current sample to a sum.
    for (j = 0; j < WINDOW_SIZE; j++):
        energy += samples[i+j]

    // Take ratio of energies of last window and current window, and see
    // if there is a big difference in the energies. If so, there is a
    // sudden loud noise.
    if (energy / last_energy > THRESHOLD):
        sudden_sound_detected()

    last_energy = energy
    energy = 0;

I should add a disclaimer that I haven't tried this.

This way should be possible to be performed without having the samples all recorded first. As long as there is buffer of some length (WINDOW_SIZE in the example), a numerical integration can be performed to calculate the energy of the section of sound. This does mean however, that there will be a delay in the processing, dependent on the length of the WINDOW_SIZE. Determining a good length for a section of sound is another concern.

How to Split into Sections

In the first audio file, it appears that the duration of the sound of the door closing is 0.25 seconds, so the window used for numerical integration should probably be at most half of that, or even more like　a tenth, so the difference between the silence and sudden sound can be noticed, even if the window is overlapping between the silent section and the noise section.

For example, if the integration window was 0.5 seconds, and the first window was covering the 0.25 seconds of silence and 0.25 seconds of door closing, and the second window was covering 0.25 seconds of door closing and 0.25 seconds of silence, it may appear that the two sections of sound has the same level of noise, therefore, not triggering the sound detection. I imagine having a short window would alleviate this problem somewhat.

However, having a window that is too short will mean that the rise in the sound may not fully fit into one window, and it may apppear that there is little difference in energy between the adjacent sections, which can cause the sound to be missed.

I believe the WINDOW_SIZE and THRESHOLD are both going to have to be determined empirically for the sound which is going to be detected.

For the sake of determining how many samples that this algorithm will need to keep in memory, let's say, the WINDOW_SIZE is 1/10 of the sound of the door closing, which is about 0.025 second. At a sampling rate of 4 kHz, that is 100 samples. That seems to be not too much of a memory requirement. Using 16-bit samples that's 200 bytes.

Advantages / Disadvantages

The advantage of this method is that processing can be performed with simple integer arithmetic if the source audio is fed in as integers. The catch is, as mentioned already, that real-time processing will have a delay, depending on the size of the section that is integrated.

There are a couple of problems that I can think of to this approach:

1. If the background noise is too loud, the difference in energy between the background noise and the door closing will not be easily distinguished, and it may not be able to detect the door closing.
2. Any abrupt noise, such as a clap, could be regarded as the door is closing.

Perhaps, combining the suggestions in the other answers, such as trying to analyze the frequency signature of the door closing using Fourier analysis, which would require more processing but would make it less prone to error.

It's probably going to take some experimentation before finding a way to solve this problem.