How to generate a pair of golay codes:
        [Posted by John Stewart]
/*
        a and b must have 2^order*sizeof(short)
        bytes allocated.
        -32767 <= sf <= 32767
*/

void short_fill_golay(short *a, short *b, long order, short sf)
{
long tlen;
long blk_sz;
long k;
long i;

    /* Start with 0th order golay code */
    a[0]=sf;
    b[0]=sf;

    for(k=0;k<order;k++)
    {
        tlen=1<<k;
        blk_sz=tlen*sizeof(a[0]);

        /* concatenate B to A*/
        memcpy(&a[tlen],b,(size_t)blk_sz);

        /* Copy first half of A to first half of B */
        memcpy(b,a,(size_t)blk_sz);

        /* Copy second half of A to second half of B with negation*/
        for(i=tlen;i<(tlen<<1);i++)
        {
            b[i]= -a[i];
        }
    }
}
        How to get the impulse response using a pair of golay codes:

        #define GOLAY_ORDER 6
        #define RING_LEN 1024 
        /* RING_LEN is how many samples to keep
           recording after the golay codes have
           been played.  It should be enough
           for the room to ring down to 0.
        */
        
        #define GOLAY_LEN 64
        /* since golay order is 6 arrays need to be
           at least 2^6 or 64 elements long */
        #define RECORD_LEN 64+RING_LEN

        short a[GOLAY_LEN]; /* space for output a */
        short b[GOLAY_LEN]; /* space for output b */
        short ar[RECORD_LEN]; /* space for a response */
        short br[RECORD_LEN]; /* space for b response */

        /*
        3277 worked out to about 1 volt peak on the hardware
        I was using in the past
        */
        short_fill_golay(&a, &b, GOLAY_ORDER, 3277);

        /*
        play_rec would play the first buffer until end
        while recording the second buffer until end
        */
        play_rec(&a, GOLAY_LEN, &ar, RECORD_LEN);
        play_rec(&b, GOLAY_LEN, &br, RECORD_LEN);

        /*
        xcorr is cross correlation which could be implemented
        in either the time or frequency domain, I generally
        use the frequency domain since I have tons of memory
        available(a PC) and often want it to go faster.
        */
        impulse_response=xcorr(a,ar)+xcorr(b,br);
        /*
        you'll need to scale impulse_response back down by
        1/(2*GOLAY_ORDER) or some such I don't remember
        the exact details, though I've figured it out a few times
        now ;)
        */