source: downloads/openal-0.0.8/src/extensions/al_ext_capture.c @ 17

/* -*- mode: C; tab-width:8; c-basic-offset:8 -*-
 * vi:set ts=8:
 *
 * al_ext_capture.c
 *
 * audio recording extension
 *
 */
#include "al_siteconfig.h"

#include <AL/al.h>
#include <AL/alc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "al_ext_needed.h"
#include "al_ext_capture.h"

#include "al_buffer.h"
#include "al_error.h"
#include "al_debug.h"
#include "al_mixer.h"
#include "al_source.h"
#include "alc/alc_device.h"
#include "alc/alc_context.h"
#include "al_types.h"

#include "audioconvert/audioconvert.h"

#include "backends/alc_backend.h"
#include "al_mutexlib.h"

#ifdef OPENAL_EXTENSION

/*
 * we are not being build into the library, therefore define the
 * table that informs openal how to register the extensions upon
 * dlopen.
 */
struct { ALubyte *name; void *addr; } alExtension_03222001 [] = {
        AL_EXT_PAIR(alCaptureInit_EXT),
        AL_EXT_PAIR(alCaptureStart_EXT),
        AL_EXT_PAIR(alCaptureStop_EXT),
        AL_EXT_PAIR(alCaptureGetData_EXT),
        AL_EXT_PAIR(alCaptureDestroy_EXT),
        { NULL, NULL }
};

/*
 *  We don't need init or fini functions, but we might as well
 *  keep them in place if, in some distant future, they turn out
 *  to be useful.
 */
void alExtInit_03282000(void) {
        fprintf(stderr, "alExtInit_03282000 STUB\n");
        return;
}

void alExtFini_03282000(void) {
        fprintf(stderr, "alExtFini_03282000 STUB\n");
        return;
}
#endif /* OPENAL_EXTENSION */

void alInitCapture(void) {
        return;
}

void alFiniCapture(void) {
        return;
}

ALboolean alCaptureInit_EXT( UNUSED(ALenum format),
                             UNUSED(ALuint rate),
                             UNUSED(ALsizei bufferSize) )
{
        ALuint cid;
        AL_context *cc;
        AL_device *capture_device;

        /* get the current context */
        capture_device = NULL;
        cid = _alcCCId;
        _alcLockContext( cid );
        cc = _alcGetContext(cid);
        if ( cc != NULL ) {
                capture_device = cc->read_device;
                if ( capture_device == NULL ) {
                        char spec[1024];
                        const char *fmt="'( (direction \"read\") (sampling-rate %d))";

                        snprintf(spec, sizeof(spec), fmt, rate);
                        capture_device = alcOpenDevice((ALchar *)spec);
                        if ( capture_device ) {
                                _alcSetContext(NULL, cid, capture_device);
                                _alcDeviceSet(capture_device);
                        }
                }
        }
        _alcUnlockContext( cid );

        return (capture_device != NULL);
}

ALboolean alCaptureDestroy_EXT( void )
{
        ALuint cid;
        AL_context *cc;

        /* get the current context */
        cid = _alcCCId;
        _alcLockContext( cid );
        cc = _alcGetContext(cid);
        if ( cc == NULL ) {
                _alcUnlockContext( cid );
                return AL_FALSE;
        }

        if ( cc->read_device ) {
                /* Only close it if we opened it originally */
                if (cc->write_device && (cc->read_device != cc->write_device)) {
                        alcCloseDevice(cc->read_device);
                        cc->read_device = NULL;
                }
        }
        _alcUnlockContext( cid );

        return AL_TRUE;
}

ALboolean alCaptureStart_EXT( void )
{
        return AL_FALSE;
}

ALboolean alCaptureStop_EXT( void )
{
        return AL_FALSE;
}

ALsizei alCaptureGetData_EXT( UNUSED(ALvoid* data),
                              ALsizei n,
                              UNUSED(ALenum format),
                              UNUSED(ALuint rate) )
{
        AL_device *dev;
        ALuint size;
        ALuint cid;
        AL_context *cc;

        /* get the read device */
        cid = _alcCCId;
        cc = _alcGetContext(cid);
        if ( cc == NULL ) {
                return 0;
        }
        dev = cc->read_device;

        if ( (dev->format == format) && (dev->speed == rate) ) {
                size = _alcDeviceRead(cid, data, (ALuint)n);
        } else {
                ALuint samples;
                void *temp;

                samples = n / (_alGetBitsFromFormat(format) / 8);

                /* Set size to the bytes of raw audio data we need */
                size = _al_PCMRatioify(rate, dev->speed,
                                       format, dev->format, samples);
                size *= (_alGetBitsFromFormat(dev->format) / 8);

                if ( n > (ALsizei)size )
                        temp = malloc( (size_t)n );
                else
                        temp = malloc( (size_t)size );

                if ( size > 0 ) {
                        size = _alcDeviceRead(cid, temp, size);

                        temp = (void *)_alBufferCanonizeData(dev->format,
                                                     temp,
                                                     size,
                                                     dev->speed,
                                                     format,
                                                     rate,
                                                     &size,
                                                     AL_TRUE);
                } else {
                        /* Hmm, zero size in record.. */
                        memset(temp, 0, (size_t)n);
                        size = n;
                }
                if(temp == NULL) {
                        fprintf(stderr, "could not canonize data\n");
                        return 0;
                }

                memcpy(data, temp, size);

                free( temp );
        }
        return size;
}