Attachment #25813 for bug #41978

View | Details | Raw Unified | Return to bug 41978
Collapse All | Expand All

Lines 993-997 Link Here

(-)src/al_ext.c (+4 lines)
993	return ALC_TRUE;	993	return ALC_TRUE;
994	}	994	}
995		995
		996	if(ustrcmp("ALC_CAPTURE_SAMPLES", ename) == 0) {
		997	return 0x312;
		998	}
		999
996	return 0;	1000	return 0;
997	}	1001	}

Lines 133-138 Link Here

(-)src/al_main.c (+1 lines)
133		133
134	#ifdef CAPTURE_SUPPORT	134	#ifdef CAPTURE_SUPPORT
135	_alRegisterExtensionGroup( (const ALubyte*) "AL_EXT_capture" );	135	_alRegisterExtensionGroup( (const ALubyte*) "AL_EXT_capture" );
		136	_alRegisterExtensionGroup( (const ALubyte*) "ALC_EXT_capture" );
136	#endif /* CAPTURE_SUPPORT */	137	#endif /* CAPTURE_SUPPORT */
137		138
138	#endif /* BUILTIN_EXT_LOKI */	139	#endif /* BUILTIN_EXT_LOKI */

Lines 51-56 Link Here

(-)src/al_queue.c (+5 lines)
51	return;	51	return;
52	}	52	}
53		53
		54	_alcDCLockContext();
		55
54	SOURCELOCK();	56	SOURCELOCK();
55		57
56	src = _alDCGetSource( sid );	58	src = _alDCGetSource( sid );
Lines 60-65 Link Here
60	_alDebug(ALD_SOURCE, __FILE__, __LINE__,	62	_alDebug(ALD_SOURCE, __FILE__, __LINE__,
61	"alSourceQueueBuffers: invalid sid %d\n", sid );	63	"alSourceQueueBuffers: invalid sid %d\n", sid );
62		64
		65	_alcDCUnlockContext();
63	SOURCEUNLOCK();	66	SOURCEUNLOCK();
64		67
65	return;	68	return;
Lines 79-84 Link Here
79		82
80	_alDCSetError( AL_INVALID_NAME );	83	_alDCSetError( AL_INVALID_NAME );
81		84
		85	_alcDCUnlockContext();
82	SOURCEUNLOCK();	86	SOURCEUNLOCK();
83		87
84	return;	88	return;
Lines 100-105 Link Here
100	/* we're done */	104	/* we're done */
101		105
102	_alUnlockBuffer();	106	_alUnlockBuffer();
		107	_alcDCUnlockContext();
103	SOURCEUNLOCK();	108	SOURCEUNLOCK();
104		109
105	return;	110	return;




			"alSourcefv: %d is an invalid source id", sid );

		_alDCSetError( AL_INVALID_NAME );

		SOURCEUNLOCK();

		return;
	}


		  }
		  break;
		case AL_VELOCITY:
break;
		  source->velocity.isset = AL_TRUE;
		  memcpy( &source->velocity.data, fv1, SIZEOFVECTOR );


		  break;
		case AL_PITCH:
		  /* only set pitch if it differs from 1.0 */
break;
		  if(fv1[0] == 1.0) {
			source->pitch.isset = AL_FALSE;
			source->pitch.data  = 1.0;

Lines 1525-1530 Link Here

(-)src/alc/alc_context.c (+6 lines)
1525	return deviceHandle->cc;	1525	return deviceHandle->cc;
1526	}	1526	}
1527		1527
		1528
		1529	ALint __alcGetAvailableSamples(ALvoid);
		1530
1528	void alcGetIntegerv( ALCdevice *deviceHandle, ALenum token,	1531	void alcGetIntegerv( ALCdevice *deviceHandle, ALenum token,
1529	ALsizei size , ALint *dest )	1532	ALsizei size , ALint *dest )
1530	{	1533	{
Lines 1546-1551 Link Here
1546	time.	1549	time.
1547	Check size	1550	Check size
1548	*/	1551	*/
		1552	case 0x312: /ALC_CAPTURE_SAMPLES:/
		1553	*dest = __alcGetAvailableSamples();
		1554	break;
1549	case ALC_MAJOR_VERSION:	1555	case ALC_MAJOR_VERSION:
1550	*dest = 1;	1556	*dest = 1;
1551	break;	1557	break;




 * get either the default device name or something the
 * user specified
 */
static void get_in_device_name(char *retref, int retsize);
static void get_out_device_name(char *retref, int retsize);

struct alsa_info
{

	unsigned int periods;
	snd_pcm_uframes_t bufframesize;
	fd_set fd_set;
	int setup_read, setup_write;
};

void *release_alsa(void *handle)


void *grab_read_alsa( void )
{
	struct alsa_info *retval;
	snd_pcm_t *handle;
	char card_name[256];
	int err;

	get_in_device_name(card_name, 256);

	err = snd_pcm_open(&handle, card_name, SND_PCM_STREAM_CAPTURE, 0);
	if(err < 0)
	{
		const char *serr = snd_strerror(err);

		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"grab_alsa: init failed: %s\n", serr);

		return NULL;
	}

	retval = malloc(sizeof *retval);
	retval->handle      = handle;
	retval->format      = 0;
	retval->channels    = 0;
	retval->speed       = 0;
	retval->framesize   = 0;
	retval->bufframesize= 0;
	retval->periods     = 0;
	retval->setup_read	= 0;
	retval->setup_write	= 0;

	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
			"grab_alsa: init ok, using %s\n", card_name);

	return retval;
}

static void get_out_device_name(char *retref, int retsize)
{
	Rcvar rcv;

	assert(retref);

	if (!(rcv = rc_lookup("alsa-device")))
		rcv = rc_lookup("alsa-out-device");
	if (rcv != NULL)
	{
		if(rc_type(rcv) == ALRC_STRING)
		{
			rc_tostr0(rcv, retref, retsize);
                        return;

		}
	}

	assert((int) strlen(DEFAULT_DEVICE) < retsize);
	strcpy(retref, DEFAULT_DEVICE);

	return;
}

static void get_in_device_name(char *retref, int retsize)
{
	Rcvar rcv;

	assert(retref);

	if (!(rcv = rc_lookup("alsa-in-device")))
		rcv = rc_lookup("alsa-device");
	if(rcv != NULL)
	{
		if(rc_type(rcv) == ALRC_STRING)

	char card_name[256];
	int err;

	get_out_device_name(card_name, 256);

	err = snd_pcm_open(&handle, card_name, SND_PCM_STREAM_PLAYBACK, 0);
	if(err < 0)
	{
		const char *serr = snd_strerror(err);

	retval->speed       = 0;
	retval->framesize   = 0;
	retval->bufframesize= 0;
	retval->periods     = 0;
	retval->setup_read	= 0;
	retval->setup_write	= 0;

	_alBlitBuffer = alsa_blitbuffer;


	return retval;
}

ALboolean set_read_alsa( void *handle,
			 ALuint *bufsiz,
			 ALenum *fmt,
			 ALuint *speed)
{
	struct alsa_info *ai = handle;
	snd_pcm_hw_params_t *setup;
	snd_pcm_uframes_t buffer_size, period_size;
	snd_pcm_t *phandle = 0;
	int err, dir;
	snd_output_t *out;

	if( (ai == NULL) || (ai->handle == NULL) )
		return AL_FALSE;


	if (*fmt == AL_FORMAT_QUAD8_LOKI)
		*fmt = AL_FORMAT_STEREO8;
	if (*fmt == AL_FORMAT_QUAD16_LOKI)
		*fmt = AL_FORMAT_STEREO16;

	ai->channels    = (unsigned int) _al_ALCHANNELS(*fmt);
	ai->format      = (unsigned int) AL2ALSAFMT(*fmt);
	ai->speed       = (unsigned int) *speed;
	ai->framesize   = (unsigned int) FRAMESIZE(ai->format, ai->channels);
	ai->bufframesize= (snd_pcm_uframes_t) *bufsiz / ai->framesize * 4;
	ai->periods     = 2;

	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
			"alsa info (read):\n"\
			" channels: %u\n"\
			" format: %u\n"\
			" speed: %u\n"\
			" framesize: %u\n"\
			" bufframesize: %u\n"\
			" periods: %u",
			ai->channels, ai->format, ai->speed, ai->framesize, ai->bufframesize, ai->periods);

	phandle = ai->handle;
	snd_output_stdio_attach (&out, stderr, 0);

	snd_pcm_hw_params_alloca(&setup);
	err = snd_pcm_hw_params_any(phandle, setup);
	if(err < 0)
	{
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_read_alsa: Could not query parameters: %s",snd_strerror(err));

		return AL_FALSE;
	}

	/* set the interleaved read format */
	err = snd_pcm_hw_params_set_access(phandle, setup, SND_PCM_ACCESS_RW_INTERLEAVED);
	if (err < 0) {
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_read_alsa: Could not set access type: %s",snd_strerror(err));
		return AL_FALSE;
	}

	/* set format */
	err = snd_pcm_hw_params_set_format(phandle, setup, ai->format);
	if(err < 0)
	{
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_read_alsa: could not set format: %s",snd_strerror(err));

		return AL_FALSE;
	}


	/* channels */
	err = snd_pcm_hw_params_set_channels(phandle, setup, ai->channels);
	if(err < 0)
	{
#if (SND_LIB_MAJOR == 0)
		err = snd_pcm_hw_params_get_channels(setup);
#else
		snd_pcm_hw_params_get_channels(setup, &err);
#endif

		if (err != (int) (ai->channels)) {
			_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
					"set_read_alsa: could not set channels: %s",snd_strerror(err));

			return AL_FALSE;
		}
	}


	/* sampling rate */
	err = snd_pcm_hw_params_set_rate_near(phandle, setup, &ai->speed, NULL);
	if(err < 0)
	{
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_read_alsa: could not set speed: %s",snd_strerror(err));

		return AL_FALSE;
	} else if (err > 0) /* err is sampling rate if > 0 */
		ai->speed = (unsigned int) err;


	/* Set number of periods. Periods used to be called fragments. */
	err = snd_pcm_hw_params_set_periods(phandle, setup, ai->periods, 0);
	if (err < 0) {
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_read_alsa: %s\n", snd_strerror(err));
		return AL_FALSE;
	}

	snd_pcm_hw_params_dump (setup, out);
	err = snd_pcm_hw_params_set_buffer_size(phandle, setup, ai->bufframesize);
	snd_pcm_hw_params_dump (setup, out);
	if (err < 0) {
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_read_alsa: %s, size: %d, speed: %d\n",
				snd_strerror(err), ai->bufframesize, ai->speed);
		return AL_FALSE;
	}

#if (SND_LIB_MAJOR == 0)
	buffer_size = snd_pcm_hw_params_get_buffer_size(setup);
	period_size = snd_pcm_hw_params_get_period_size(setup, &dir);
#else
	snd_pcm_hw_params_get_buffer_size(setup, &buffer_size);
	snd_pcm_hw_params_get_period_size(setup, &period_size, &dir);
#endif

	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
			"set_read_alsa (info): Buffersize = %i (%i)",buffer_size, *bufsiz);
	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
			"set_read_alsa (info): Periodsize = %i", period_size);

	err = snd_pcm_hw_params(phandle, setup);
	if(err < 0)
	{
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_read_alsa: %s\n", snd_strerror(err));
		return AL_FALSE;
	}

	err = snd_pcm_prepare(phandle);
	if(err < 0)
	{
		_alDebug(ALD_MAXIMUS,  __FILE__, __LINE__,
				"set_read_alsa %s\n", snd_strerror(err));
		return AL_FALSE;
	}

	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
			"set_read_alsa: handle: %p, phandle: %p\n", handle, phandle);
	snd_output_close (out);
	ai->setup_read = 1;

	return AL_TRUE;
}

ALboolean set_write_alsa(void *handle,

	snd_pcm_uframes_t buffer_size, period_size;
	snd_pcm_t *phandle = 0;
	int err, dir;
	snd_output_t *out;

	if( (ai == NULL) || (ai->handle == NULL) )
		return AL_FALSE;


	ai->channels    = (unsigned int) _al_ALCHANNELS(*fmt);
	ai->format      = (unsigned int) AL2ALSAFMT(*fmt);
	ai->speed       = (unsigned int) *speed;
	ai->framesize   = (unsigned int) FRAMESIZE(ai->format, ai->channels);
	ai->bufframesize= (snd_pcm_uframes_t) *bufsiz / ai->framesize * 4;
	ai->periods     = 2;

	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
			"alsa info (write):\n"\
			" channels: %u\n"\
			" format: %u\n"\
			" speed: %u\n"\
			" framesize: %u\n"\
			" bufframesize: %u\n"\
			" periods: %u",
			ai->channels, ai->format, ai->speed, ai->framesize, ai->bufframesize, ai->periods);

	phandle = ai->handle;
	snd_output_stdio_attach (&out, stderr, 0);

	snd_pcm_hw_params_alloca(&setup);
	err = snd_pcm_hw_params_any(phandle, setup);
	if(err < 0)
	{
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_write_alsa: Could not query parameters: %s",snd_strerror(err));

		return AL_FALSE;
	}

	/* set the interleaved write format */
	err = snd_pcm_hw_params_set_access(phandle, setup, SND_PCM_ACCESS_RW_INTERLEAVED);
	if (err < 0) {
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_write_alsa: Could not set access type: %s",snd_strerror(err));
		return AL_FALSE;
	}

	/* set format */
	err = snd_pcm_hw_params_set_format(phandle, setup, ai->format);
	if(err < 0)
	{
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_write_alsa: could not set format: %s",snd_strerror(err));

		return AL_FALSE;
	}

	err = snd_pcm_hw_params_set_channels(phandle, setup, ai->channels);
	if(err < 0)
	{
#if (SND_LIB_MAJOR == 0)
		err = snd_pcm_hw_params_get_channels(setup);
#else
		snd_pcm_hw_params_get_channels(setup, &err);
#endif

		if (err!= (int) (ai->channels)) {
			err = snd_pcm_hw_params_get_channels(setup);
		#else
			snd_pcm_hw_params_get_channels(setup, &err);
		#endif

		if(err!= (int) (ai->channels)) {
			_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
					"set_write_alsa: could not set channels: %s",snd_strerror(err));

			return AL_FALSE;
		}



	/* sampling rate */
	err = snd_pcm_hw_params_set_rate_near(phandle, setup, &ai->speed, NULL);
	if(err < 0)
	{
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_write_alsa: could not set speed: %s",snd_strerror(err));

		return AL_FALSE;
	} else if (err > 0) /* err is sampling rate if > 0 */
		ai->speed = (unsigned int) err;
	ai->speed = (unsigned int) err;


	/* Set number of periods. Periods used to be called fragments. */
	err = snd_pcm_hw_params_set_periods(phandle, setup, ai->periods, 0);
	if (err < 0) {
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_write_alsa: %s\n", snd_strerror(err));
		return AL_FALSE;
	}

	snd_pcm_hw_params_dump (setup, out);
	err = snd_pcm_hw_params_set_buffer_size(phandle, setup, ai->bufframesize);
	snd_pcm_hw_params_dump (setup, out);
	if (err < 0) {
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_write_alsa: %s, size: %d, speed: %d\n",
				snd_strerror(err), ai->bufframesize, ai->speed);
		return AL_FALSE;
	}

#if (SND_LIB_MAJOR == 0)
	buffer_size = snd_pcm_hw_params_get_buffer_size(setup);
	period_size = snd_pcm_hw_params_get_period_size(setup, &dir);
#else
	snd_pcm_hw_params_get_buffer_size(setup, &buffer_size);
	snd_pcm_hw_params_get_period_size(setup, &period_size, &dir);
#endif

	#if (SND_LIB_MAJOR == 0)
		buffer_size = snd_pcm_hw_params_get_buffer_size(setup);
		period_size = snd_pcm_hw_params_get_period_size(setup, &dir);
	#else
        	snd_pcm_hw_params_get_buffer_size(setup, &buffer_size);
		snd_pcm_hw_params_get_period_size(setup, &period_size, &dir);
	#endif
	
	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
			"set_write_alsa (info): Buffersize = %i (%i)",buffer_size, *bufsiz);
	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
			"set_write_alsa (info): Periodsize = %i", period_size);

	err = snd_pcm_hw_params(phandle, setup);
	if(err < 0)
	{
		_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
				"set_alsa: %s\n", snd_strerror(err));
		return AL_FALSE;
	}


	if(err < 0)
	{
		_alDebug(ALD_MAXIMUS,  __FILE__, __LINE__,
				"set_alsa %s\n", snd_strerror(err));
		return AL_FALSE;
	}

	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
			"set_write_alsa: handle: %p, phandle: %p\n", handle, phandle);
	snd_output_close (out);
	ai->setup_write = 1;

	return AL_TRUE;
}


	int data_len = bytes;
	int channels = 0;
	int err;
	snd_pcm_uframes_t frames;

	if((ai == NULL) || (ai->handle == NULL) || (!ai->setup_write))
	{
		return;
	}

	phandle = ai->handle;
	channels= ai->channels;
	frames  = (snd_pcm_uframes_t) bytes / ai->framesize;

	while(data_len > 0)
	{


	return;
}

/* capture data from the audio device */
ALsizei capture_alsa(void *handle,
		void *capture_buffer,
		int bufsize)
{
	struct alsa_info *ai = handle;
	snd_pcm_t *phandle = 0;
	char *pdata = capture_buffer;
	int ret;
	snd_pcm_uframes_t frames;

	if ((ai == NULL) || (ai->handle == NULL) || (!ai->setup_read))
		return 0;

	phandle = ai->handle;
	frames = (snd_pcm_uframes_t) bufsize / ai->framesize;
grab:

	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
			"set_read_alsa: handle: %p, phandle: %p\n", handle, phandle);
	ret = snd_pcm_readi (phandle, pdata, frames);
	if (ret < 0) {
		fprintf(stderr, "Error, overrun: %d, trying to recover.\n", ret);
		ret = snd_pcm_prepare(phandle);
		if (ret < 0)
			fprintf(stderr, "Unable to recover: %d\n", ret);
		else
			goto grab;
		return 0;
	} else
		return ret * ai->framesize;
}


static int AL2ALSAFMT(ALenum format) {
	switch(format) {

Lines 17-21 Link Here

(-)src/arch/alsa/alsa.h (+3 lines)
17	ALuint *bufsiz,	17	ALuint *bufsiz,
18	ALenum *fmt,	18	ALenum *fmt,
19	ALuint *speed);	19	ALuint *speed);
		20	ALsizei capture_alsa(void *handle,
		21	void *capture_buffer,
		22	int bufsiz);
20		23
21	#endif /* ALSA_H_ */	24	#endif /* ALSA_H_ */

Lines 413-418 Link Here

(-)src/arch/interface/interface_sound.c (+2 lines)
413	bytes = capture_emu10k1(handle, capture_buffer, bufsiz);	413	bytes = capture_emu10k1(handle, capture_buffer, bufsiz);
414	break;	414	break;
415	case LA_ALSA:	415	case LA_ALSA:
		416	bytes = capture_alsa(handle, capture_buffer, bufsiz);
		417	break;
416	case LA_SDL:	418	case LA_SDL:
417	case LA_ARTS:	419	case LA_ARTS:
418	case LA_ESD:	420	case LA_ESD:

Lines 446-451 Link Here

(-)src/arch/linux/lin_dsp.c (-1 / +4 lines)
446	int retval;	446	int retval;
447		447
448	retval = read(read_fd, capture_buffer, bufsiz);	448	retval = read(read_fd, capture_buffer, bufsiz);
		449
		450	/if (retval < 0) printf("%s\n", strerror(errno));/
		451
449	return retval > 0 ? retval : 0;	452	return retval > 0 ? retval : 0;
450	}	453	}
451		454
Lines 633-639 Link Here
633	* This is for reading. Don't really use	636	* This is for reading. Don't really use
634	* the speed argument.	637	* the speed argument.
635	*/	638	*/
636	*speed = 8000;	639	*speed = 16000;
637		640
638	/* Try to set the speed (ignore value), then read it back */	641	/* Try to set the speed (ignore value), then read it back */
639	ioctl(dsp_fd, SNDCTL_DSP_SPEED, speed);	642	ioctl(dsp_fd, SNDCTL_DSP_SPEED, speed);




	AL_EXT_PAIR(alCaptureStop_EXT),
	AL_EXT_PAIR(alCaptureGetData_EXT),
	AL_EXT_PAIR(alCaptureDestroy_EXT),
	AL_EXT_PAIR(alcCaptureOpenDevice),
	AL_EXT_PAIR(alcCaptureCloseDevice),
	AL_EXT_PAIR(alcCaptureStart),
	AL_EXT_PAIR(alcCaptureStop),
	AL_EXT_PAIR(alcCaptureSamples),
	{ NULL, NULL }
};


		                       format, dev->format, samples);
		size *= (_al_formatbits(dev->format) / 8);

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

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

		if ( size > 0 ) {
			temp = _alBufferCanonizeData(dev->format,
						     temp,
						     size,

						     AL_TRUE);
		} else {
			/* Hmm, zero size in record.. */
			/*memset(temp, 0, n);*/
			size = 0;
		}
		if(temp == NULL) {
			fprintf(stderr, "could not canonize data\n");

	}
	return size;
}


/* Hacked in ALC_EXT_capture support.  --ryan. */
/* This doesn't support multiple devices, device enumeration, or capture */
/*  devices seperate from an existing context. How painful. */

/* ring buffer functionality... */

typedef struct
{
    ALubyte *buffer;
    ALsizei size;
    ALsizei write;
    ALsizei read;
    ALsizei used;
} __ALRingBuffer;

static ALboolean __alRingBufferInit(__ALRingBuffer *ring, ALsizei size);
static ALvoid __alRingBufferShutdown(__ALRingBuffer *ring);
static ALsizei __alRingBufferSize(__ALRingBuffer *ring);
static ALvoid __alRingBufferPut(__ALRingBuffer *ring, ALubyte *data, ALsizei size);
static ALsizei __alRingBufferGet(__ALRingBuffer *ring, ALubyte *data, ALsizei size);

static __ALRingBuffer captureRing;

static ALboolean __alRingBufferInit(__ALRingBuffer *ring, ALsizei size)
{
    ALubyte *ptr = (ALubyte *) realloc(ring->buffer, size);
    if (ptr == NULL)
        return(AL_FALSE);

    ring->buffer = ptr;
    ring->size = size;
    ring->write = 0;
    ring->read = 0;
    ring->used = 0;
    return(AL_TRUE);
} /* __alRingBufferInit */

static ALvoid __alRingBufferShutdown(__ALRingBuffer *ring)
{
    free(ring->buffer);
    ring->buffer = NULL;
} /* __alRingBufferShutdown */

static ALsizei __alRingBufferSize(__ALRingBuffer *ring)
{
    return(ring->used);
} /* __alRingBufferSize */

static ALvoid __alRingBufferPut(__ALRingBuffer *ring, ALubyte *data, ALsizei _size)
{
    register ALsizei size = _size;
    register ALsizei cpy;
    register ALsizei avail;

    if (!size)   /* just in case... */
        return;

    /* Putting more data than ring buffer holds in total? Replace it all. */
    if (size > ring->size)
    {
        ring->write = 0;
        ring->read = 0;
        ring->used = ring->size;
        memcpy(ring->buffer, data + (size - ring->size), ring->size);
        return;
    } /* if */

    /* Buffer overflow? Push read pointer to oldest sample not overwritten. */
    avail = ring->size - ring->used;
    if (size > avail)
    {
        ring->read += size - avail;
        if (ring->read > ring->size)
            ring->read -= ring->size;
    } /* if */

    /* Clip to end of buffer and copy first block... */
    cpy = ring->size - ring->write;
    if (size < cpy)
        cpy = size;
    if (cpy) memcpy(ring->buffer + ring->write, data, cpy);

    /* Wrap around to front of ring buffer and copy remaining data... */
    avail = size - cpy;
    if (avail) memcpy(ring->buffer, data + cpy, avail);

    /* Update write pointer... */
    ring->write += size;
    if (ring->write > ring->size)
        ring->write -= ring->size;

    ring->used += size;
    if (ring->used > ring->size)
        ring->used = ring->size;
} /* __alRingBufferPut */

static ALsizei __alRingBufferGet(__ALRingBuffer *ring, ALubyte *data, ALsizei _size)
{
    register ALsizei cpy;
    register ALsizei size = _size;
    register ALsizei avail = ring->used;

    /* Clamp amount to read to available data... */
    if (size > avail)
        size = avail;
    
    /* Clip to end of buffer and copy first block... */
    cpy = ring->size - ring->read;
    if (cpy > size) cpy = size;
    if (cpy) memcpy(data, ring->buffer + ring->read, cpy);
    
    /* Wrap around to front of ring buffer and copy remaining data... */
    avail = size - cpy;
    if (avail) memcpy(data + cpy, ring->buffer, avail);

    /* Update read pointer... */
    ring->read += size;
    if (ring->read > ring->size)
        ring->read -= ring->size;

    ring->used -= size;

    return(size);  /* may have been clamped if there wasn't enough data... */
} /* __alRingBufferGet */


static ALenum captureFmt = AL_NONE;
static ALuint captureFreq = 0;
static ALint captureFmtSize = 0;

ALCdevice *alcCaptureOpenDevice(const ALubyte *deviceName,
                                ALuint freq, ALenum fmt,
                                ALsizei bufsize)
{
    ALCdevice *retval;
	AL_context *cc;
	ALuint cid;

    if (deviceName != NULL)  /* !!! FIXME */
        return NULL;

    switch (fmt)  /* try to keep this sane for now... */
    {
        case AL_FORMAT_MONO8:
        case AL_FORMAT_MONO16:
        case AL_FORMAT_STEREO8:
        case AL_FORMAT_STEREO16:
            break;  /* okay format. */

        default:
            return(NULL);
    }

    captureFmt = fmt;
    captureFreq = freq;
    captureFmtSize = (_al_formatbits(fmt) / 8);
    if ((fmt == AL_FORMAT_STEREO8) || (fmt == AL_FORMAT_STEREO16))
        captureFmtSize *= 2;

    bufsize *= captureFmtSize;

    if (!__alRingBufferInit(&captureRing, bufsize))
        return NULL;

    if (!alCaptureInit_EXT(fmt, freq, bufsize))
        return NULL;

	cid = _alcCCId;
	_alcLockContext( cid );
	cc = _alcGetContext(cid);
    retval = cc->read_device;
	retval->cc = cc;
    _alcUnlockContext( cid );

    fprintf(stderr, "WARNING: ALC_EXT_capture is subject to change!\n");

    return(retval);
}

ALvoid alcCaptureCloseDevice(ALCdevice *dev)
{
    if (dev == NULL)
        return;

    alCaptureDestroy_EXT();
    __alRingBufferShutdown(&captureRing);
}

ALvoid alcCaptureStart(void)
{
    alCaptureStart_EXT();
}

ALvoid alcCaptureStop(void)
{
    alCaptureStop_EXT();
}

/* !!! FIXME: Not ideal; reads samples in ALC_CAPTURE_SAMPLES query */
/* !!! FIXME: should query hardware here and do read in alcCaptureSamples() */
ALint __alcGetAvailableSamples(ALvoid)
{
    static ALubyte buf[1024];
    ALsizei got = alCaptureGetData_EXT(buf, sizeof (buf),
                                       captureFmt, captureFreq);
    if (got > 0)
        __alRingBufferPut(&captureRing, buf, got);

    /*printf("got %d have %d\n", (int) got, (int) (__alRingBufferSize(&captureRing) / captureFmtSize));*/

    return(__alRingBufferSize(&captureRing) / captureFmtSize);
}


ALvoid alcCaptureSamples(ALCdevice *device, ALvoid *buf, ALsizei samps)
{
    if ((__alRingBufferSize(&captureRing) / captureFmtSize) < samps)
        return;  /* !!! FIXME: This is an error condition! */

    __alRingBufferGet(&captureRing, buf, samps * captureFmtSize);
}


Lines 13-18 Link Here

(-)src/extensions/al_ext_capture.h (-1 / +16 lines)
13		13
14	#include <AL/alext.h>	14	#include <AL/alext.h>
15		15
		16	ALCdevice alcCaptureOpenDevice(const ALubyte deviceName,
		17	ALuint freq, ALenum fmt,
		18	ALsizei bufsize);
		19	ALvoid alcCaptureCloseDevice(ALCdevice *dev);
		20	ALvoid alcCaptureStart(void);
		21	ALvoid alcCaptureStop(void);
		22	ALint __alcGetAvailableSamples(ALvoid);
		23	ALvoid alcCaptureSamples(ALCdevice device, ALvoid buf, ALsizei samps);
		24
		25
16	/*	26	/*
17	* alInitCapture( void )	27	* alInitCapture( void )
18	*	28	*
Lines 38-44 Link Here
38	AL_EXT_PAIR(alCaptureStart_EXT), \	48	AL_EXT_PAIR(alCaptureStart_EXT), \
39	AL_EXT_PAIR(alCaptureStop_EXT), \	49	AL_EXT_PAIR(alCaptureStop_EXT), \
40	AL_EXT_PAIR(alCaptureGetData_EXT), \	50	AL_EXT_PAIR(alCaptureGetData_EXT), \
41	AL_EXT_PAIR(alCaptureDestroy_EXT) \	51	AL_EXT_PAIR(alCaptureDestroy_EXT), \
		52	AL_EXT_PAIR(alcCaptureOpenDevice), \
		53	AL_EXT_PAIR(alcCaptureCloseDevice), \
		54	AL_EXT_PAIR(alcCaptureStart), \
		55	AL_EXT_PAIR(alcCaptureStop), \
		56	AL_EXT_PAIR(alcCaptureSamples) \
42		57
43	/* initialization and destruction functions */	58	/* initialization and destruction functions */
44		59

Return to bug 41978

Lines 595-603 Link Here

(-)src/al_source.c (-2 / +2 lines)
595	"alSourcefv: %d is an invalid source id", sid );	595	"alSourcefv: %d is an invalid source id", sid );
596		596
597	_alDCSetError( AL_INVALID_NAME );	597	_alDCSetError( AL_INVALID_NAME );
598
599	SOURCEUNLOCK();	598	SOURCEUNLOCK();
600
601	return;	599	return;
602	}	600	}
603		601
Lines 690-695 Link Here
690	}	688	}
691	break;	689	break;
692	case AL_VELOCITY:	690	case AL_VELOCITY:
		691	break;
693	source->velocity.isset = AL_TRUE;	692	source->velocity.isset = AL_TRUE;
694	memcpy( &source->velocity.data, fv1, SIZEOFVECTOR );	693	memcpy( &source->velocity.data, fv1, SIZEOFVECTOR );
695		694
Lines 723-728 Link Here
723	break;	722	break;
724	case AL_PITCH:	723	case AL_PITCH:
725	/* only set pitch if it differs from 1.0 */	724	/* only set pitch if it differs from 1.0 */
		725	break;
726	if(fv1[0] == 1.0) {	726	if(fv1[0] == 1.0) {
727	source->pitch.isset = AL_FALSE;	727	source->pitch.isset = AL_FALSE;
728	source->pitch.data = 1.0;	728	source->pitch.data = 1.0;

Lines 46-52 Link Here

(-)src/arch/alsa/alsa.c (-79 / +328 lines)
46	* get either the default device name or something the	46	* get either the default device name or something the
47	* user specified	47	* user specified
48	*/	48	*/
49	void get_device_name(char *retref, int retsize);	49	static void get_in_device_name(char *retref, int retsize);
		50	static void get_out_device_name(char *retref, int retsize);
50		51
51	struct alsa_info	52	struct alsa_info
52	{	53	{
Lines 58-63 Link Here
58	unsigned int periods;	59	unsigned int periods;
59	snd_pcm_uframes_t bufframesize;	60	snd_pcm_uframes_t bufframesize;
60	fd_set fd_set;	61	fd_set fd_set;
		62	int setup_read, setup_write;
61	};	63	};
62		64
63	void release_alsa(void handle)	65	void release_alsa(void handle)
Lines 76-92 Link Here
76		78
77	void *grab_read_alsa( void )	79	void *grab_read_alsa( void )
78	{	80	{
79	/* no capture support */	81	struct alsa_info *retval;
80	return NULL;	82	snd_pcm_t *handle;
		83	char card_name[256];
		84	int err;
		85
		86	get_in_device_name(card_name, 256);
		87
		88	err = snd_pcm_open(&handle, card_name, SND_PCM_STREAM_CAPTURE, 0);
		89	if(err < 0)
		90	{
		91	const char *serr = snd_strerror(err);
		92
		93	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
		94	"grab_alsa: init failed: %s\n", serr);
		95
		96	return NULL;
		97	}
		98
		99	retval = malloc(sizeof *retval);
		100	retval->handle = handle;
		101	retval->format = 0;
		102	retval->channels = 0;
		103	retval->speed = 0;
		104	retval->framesize = 0;
		105	retval->bufframesize= 0;
		106	retval->periods = 0;
		107	retval->setup_read = 0;
		108	retval->setup_write = 0;
		109
		110	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
		111	"grab_alsa: init ok, using %s\n", card_name);
		112
		113	return retval;
		114	}
		115
		116	static void get_out_device_name(char *retref, int retsize)
		117	{
		118	Rcvar rcv;
		119
		120	assert(retref);
		121
		122	if (!(rcv = rc_lookup("alsa-device")))
		123	rcv = rc_lookup("alsa-out-device");
		124	if (rcv != NULL)
		125	{
		126	if(rc_type(rcv) == ALRC_STRING)
		127	{
		128	rc_tostr0(rcv, retref, retsize);
		129	return;
		130
		131	}
		132	}
		133
		134	assert((int) strlen(DEFAULT_DEVICE) < retsize);
		135	strcpy(retref, DEFAULT_DEVICE);
		136
		137	return;
81	}	138	}
82		139
83	void get_device_name(char *retref, int retsize)	140	static void get_in_device_name(char *retref, int retsize)
84	{	141	{
85	Rcvar rcv;	142	Rcvar rcv;
86		143
87	assert(retref);	144	assert(retref);
88		145
89	rcv = rc_lookup("alsa-device");	146	if (!(rcv = rc_lookup("alsa-in-device")))
		147	rcv = rc_lookup("alsa-device");
90	if(rcv != NULL)	148	if(rcv != NULL)
91	{	149	{
92	if(rc_type(rcv) == ALRC_STRING)	150	if(rc_type(rcv) == ALRC_STRING)
Lines 110-118 Link Here
110	char card_name[256];	168	char card_name[256];
111	int err;	169	int err;
112		170
113	get_device_name(card_name, 256);	171	get_out_device_name(card_name, 256);
114		172
115	err = snd_pcm_open(&handle, card_name, 0, SND_PCM_STREAM_PLAYBACK);	173	err = snd_pcm_open(&handle, card_name, SND_PCM_STREAM_PLAYBACK, 0);
116	if(err < 0)	174	if(err < 0)
117	{	175	{
118	const char *serr = snd_strerror(err);	176	const char *serr = snd_strerror(err);
Lines 130-136 Link Here
130	retval->speed = 0;	188	retval->speed = 0;
131	retval->framesize = 0;	189	retval->framesize = 0;
132	retval->bufframesize= 0;	190	retval->bufframesize= 0;
133	retval->periods = 0;	191	retval->periods = 0;
		192	retval->setup_read = 0;
		193	retval->setup_write = 0;
134		194
135	_alBlitBuffer = alsa_blitbuffer;	195	_alBlitBuffer = alsa_blitbuffer;
136		196
Lines 140-152 Link Here
140	return retval;	200	return retval;
141	}	201	}
142		202
143	ALboolean set_read_alsa( UNUSED(void *handle),	203	ALboolean set_read_alsa( void *handle,
144	UNUSED(ALuint *bufsiz),	204	ALuint *bufsiz,
145	UNUSED(ALenum *fmt),	205	ALenum *fmt,
146	UNUSED(ALuint *speed))	206	ALuint *speed)
147	{	207	{
148	/* no capture support */	208	struct alsa_info *ai = handle;
149	return AL_FALSE;	209	snd_pcm_hw_params_t *setup;
		210	snd_pcm_uframes_t buffer_size, period_size;
		211	snd_pcm_t *phandle = 0;
		212	int err, dir;
		213	snd_output_t *out;
		214
		215	if( (ai == NULL) \|\| (ai->handle == NULL) )
		216	return AL_FALSE;
		217
		218
		219	if (*fmt == AL_FORMAT_QUAD8_LOKI)
		220	*fmt = AL_FORMAT_STEREO8;
		221	if (*fmt == AL_FORMAT_QUAD16_LOKI)
		222	*fmt = AL_FORMAT_STEREO16;
		223
		224	ai->channels = (unsigned int) _al_ALCHANNELS(*fmt);
		225	ai->format = (unsigned int) AL2ALSAFMT(*fmt);
		226	ai->speed = (unsigned int) *speed;
		227	ai->framesize = (unsigned int) FRAMESIZE(ai->format, ai->channels);
		228	ai->bufframesize= (snd_pcm_uframes_t) bufsiz / ai->framesize 4;
		229	ai->periods = 2;
		230
		231	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
		232	"alsa info (read):\n"\
		233	" channels: %u\n"\
		234	" format: %u\n"\
		235	" speed: %u\n"\
		236	" framesize: %u\n"\
		237	" bufframesize: %u\n"\
		238	" periods: %u",
		239	ai->channels, ai->format, ai->speed, ai->framesize, ai->bufframesize, ai->periods);
		240
		241	phandle = ai->handle;
		242	snd_output_stdio_attach (&out, stderr, 0);
		243
		244	snd_pcm_hw_params_alloca(&setup);
		245	err = snd_pcm_hw_params_any(phandle, setup);
		246	if(err < 0)
		247	{
		248	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
		249	"set_read_alsa: Could not query parameters: %s",snd_strerror(err));
		250
		251	return AL_FALSE;
		252	}
		253
		254	/* set the interleaved read format */
		255	err = snd_pcm_hw_params_set_access(phandle, setup, SND_PCM_ACCESS_RW_INTERLEAVED);
		256	if (err < 0) {
		257	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
		258	"set_read_alsa: Could not set access type: %s",snd_strerror(err));
		259	return AL_FALSE;
		260	}
		261
		262	/* set format */
		263	err = snd_pcm_hw_params_set_format(phandle, setup, ai->format);
		264	if(err < 0)
		265	{
		266	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
		267	"set_read_alsa: could not set format: %s",snd_strerror(err));
		268
		269	return AL_FALSE;
		270	}
		271
		272
		273	/* channels */
274	err = snd_pcm_hw_params_set_channels(phandle, setup, ai->channels);
275	if(err < 0)
276	{
277	#if (SND_LIB_MAJOR == 0)
278	err = snd_pcm_hw_params_get_channels(setup);
279	#else
280	snd_pcm_hw_params_get_channels(setup, &err);
281	#endif
282
283	if (err != (int) (ai->channels)) {
284	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
285	"set_read_alsa: could not set channels: %s",snd_strerror(err));
286
287	return AL_FALSE;
288	}
289	}
290
291
292	/* sampling rate */
293	err = snd_pcm_hw_params_set_rate_near(phandle, setup, &ai->speed, NULL);
294	if(err < 0)
295	{
296	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
297	"set_read_alsa: could not set speed: %s",snd_strerror(err));
298
299	return AL_FALSE;
300	} else if (err > 0) /* err is sampling rate if > 0 */
301	ai->speed = (unsigned int) err;
302
303
304	/* Set number of periods. Periods used to be called fragments. */
305	err = snd_pcm_hw_params_set_periods(phandle, setup, ai->periods, 0);
306	if (err < 0) {
307	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
308	"set_read_alsa: %s\n", snd_strerror(err));
309	return AL_FALSE;
310	}
311
312	snd_pcm_hw_params_dump (setup, out);
313	err = snd_pcm_hw_params_set_buffer_size(phandle, setup, ai->bufframesize);
314	snd_pcm_hw_params_dump (setup, out);
315	if (err < 0) {
316	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
317	"set_read_alsa: %s, size: %d, speed: %d\n",
318	snd_strerror(err), ai->bufframesize, ai->speed);
319	return AL_FALSE;
320	}
321
322	#if (SND_LIB_MAJOR == 0)
323	buffer_size = snd_pcm_hw_params_get_buffer_size(setup);
324	period_size = snd_pcm_hw_params_get_period_size(setup, &dir);
325	#else
326	snd_pcm_hw_params_get_buffer_size(setup, &buffer_size);
327	snd_pcm_hw_params_get_period_size(setup, &period_size, &dir);
328	#endif
329
330	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
331	"set_read_alsa (info): Buffersize = %i (%i)",buffer_size, *bufsiz);
332	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
333	"set_read_alsa (info): Periodsize = %i", period_size);
334
335	err = snd_pcm_hw_params(phandle, setup);
336	if(err < 0)
337	{
338	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
339	"set_read_alsa: %s\n", snd_strerror(err));
340	return AL_FALSE;
341	}
342
343	err = snd_pcm_prepare(phandle);
344	if(err < 0)
345	{
346	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
347	"set_read_alsa %s\n", snd_strerror(err));
348	return AL_FALSE;
349	}
350
351	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
352	"set_read_alsa: handle: %p, phandle: %p\n", handle, phandle);
353	snd_output_close (out);
354	ai->setup_read = 1;
355
356	return AL_TRUE;
150	}	357	}
151		358
152	ALboolean set_write_alsa(void *handle,	359	ALboolean set_write_alsa(void *handle,
Lines 159-212 Link Here
159	snd_pcm_uframes_t buffer_size, period_size;	366	snd_pcm_uframes_t buffer_size, period_size;
160	snd_pcm_t *phandle = 0;	367	snd_pcm_t *phandle = 0;
161	int err, dir;	368	int err, dir;
		369	snd_output_t *out;
162		370
163	if( (ai == NULL) \|\| (ai->handle == NULL) )	371	if( (ai == NULL) \|\| (ai->handle == NULL) )
164	return AL_FALSE;	372	return AL_FALSE;
165		373
166		374
167	ai->channels = (unsigned int) _al_ALCHANNELS(*fmt);	375	ai->channels = (unsigned int) _al_ALCHANNELS(*fmt);
168	ai->format = (unsigned int) AL2ALSAFMT(*fmt);	376	ai->format = (unsigned int) AL2ALSAFMT(*fmt);
169	ai->speed = (unsigned int) *speed;	377	ai->speed = (unsigned int) *speed;
170	ai->framesize = (unsigned int) FRAMESIZE(ai->format, ai->channels);	378	ai->framesize = (unsigned int) FRAMESIZE(ai->format, ai->channels);
171	ai->bufframesize= (snd_pcm_uframes_t) bufsiz / ai->framesize 4;	379	ai->bufframesize= (snd_pcm_uframes_t) bufsiz / ai->framesize 4;
172	ai->periods = 2;	380	ai->periods = 2;
173		381
174	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,	382	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
175	"alsa info:\n"\	383	"alsa info (write):\n"\
176	" channels: %u\n"\	384	" channels: %u\n"\
177	" format: %u\n"\	385	" format: %u\n"\
178	" speed: %u\n"\	386	" speed: %u\n"\
179	" framesize: %u\n"\	387	" framesize: %u\n"\
180	" bufframesize: %u\n"\	388	" bufframesize: %u\n"\
181	" periods: %u",	389	" periods: %u",
182	ai->channels, ai->format, ai->speed, ai->framesize, ai->bufframesize, ai->periods);	390	ai->channels, ai->format, ai->speed, ai->framesize, ai->bufframesize, ai->periods);
183		391
184	phandle = ai->handle;	392	phandle = ai->handle;
		393	snd_output_stdio_attach (&out, stderr, 0);
185		394
186	snd_pcm_hw_params_alloca(&setup);	395	snd_pcm_hw_params_alloca(&setup);
187	err = snd_pcm_hw_params_any(phandle, setup);	396	err = snd_pcm_hw_params_any(phandle, setup);
188	if(err < 0)	397	if(err < 0)
189	{	398	{
190	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,	399	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
191	"set_write_alsa: Could not query parameters: %s",snd_strerror(err));	400	"set_write_alsa: Could not query parameters: %s",snd_strerror(err));
192		401
193	return AL_FALSE;	402	return AL_FALSE;
194	}	403	}
195		404
196	/* set the interleaved read format */	405	/* set the interleaved write format */
197	err = snd_pcm_hw_params_set_access(phandle, setup, SND_PCM_ACCESS_RW_INTERLEAVED);	406	err = snd_pcm_hw_params_set_access(phandle, setup, SND_PCM_ACCESS_RW_INTERLEAVED);
198	if (err < 0) {	407	if (err < 0) {
199	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,	408	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
200	"set_write_alsa: Could not set access type: %s",snd_strerror(err));	409	"set_write_alsa: Could not set access type: %s",snd_strerror(err));
201	return AL_FALSE;	410	return AL_FALSE;
202	}	411	}
203		412
204	/* set format */	413	/* set format */
205	err = snd_pcm_hw_params_set_format(phandle, setup, ai->format);	414	err = snd_pcm_hw_params_set_format(phandle, setup, ai->format);
206	if(err < 0)	415	if(err < 0)
207	{	416	{
208	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,	417	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
209	"set_write_alsa: could not set format: %s",snd_strerror(err));	418	"set_write_alsa: could not set format: %s",snd_strerror(err));
210		419
211	return AL_FALSE;	420	return AL_FALSE;
212	}	421	}
Lines 216-231 Link Here
216	err = snd_pcm_hw_params_set_channels(phandle, setup, ai->channels);	425	err = snd_pcm_hw_params_set_channels(phandle, setup, ai->channels);
217	if(err < 0)	426	if(err < 0)
218	{	427	{
		428	#if (SND_LIB_MAJOR == 0)
		429	err = snd_pcm_hw_params_get_channels(setup);
		430	#else
		431	snd_pcm_hw_params_get_channels(setup, &err);
		432	#endif
219		433
220	#if (SND_LIB_MAJOR == 0)	434	if (err!= (int) (ai->channels)) {
221	err = snd_pcm_hw_params_get_channels(setup);
222	#else
223	snd_pcm_hw_params_get_channels(setup, &err);
224	#endif
225
226	if(err!= (int) (ai->channels)) {
227	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,	435	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
228	"set_write_alsa: could not set channels: %s",snd_strerror(err));	436	"set_write_alsa: could not set channels: %s",snd_strerror(err));
229		437
230	return AL_FALSE;	438	return AL_FALSE;
231	}	439	}
Lines 233-283 Link Here
233		441
234		442
235	/* sampling rate */	443	/* sampling rate */
236	err = snd_pcm_hw_params_set_rate_near(phandle, setup, ai->speed, NULL);	444	err = snd_pcm_hw_params_set_rate_near(phandle, setup, &ai->speed, NULL);
237	if(err < 0)	445	if(err < 0)
238	{	446	{
239	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,	447	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
240	"set_write_alsa: could not set speed: %s",snd_strerror(err));	448	"set_write_alsa: could not set speed: %s",snd_strerror(err));
241		449
242	return AL_FALSE;	450	return AL_FALSE;
243	}	451	} else if (err > 0) /* err is sampling rate if > 0 */
244	/* err is sampling rate if >= 0 */	452	ai->speed = (unsigned int) err;
245	ai->speed = (unsigned int) err;
246		453
247		454
248	/* Set number of periods. Periods used to be called fragments. */	455	/* Set number of periods. Periods used to be called fragments. */
249	err = snd_pcm_hw_params_set_periods(phandle, setup, ai->periods, 0);	456	err = snd_pcm_hw_params_set_periods(phandle, setup, ai->periods, 0);
250	if (err < 0) {	457	if (err < 0) {
251	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,	458	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
252	"set_write_alsa: %s\n", snd_strerror(err));	459	"set_write_alsa: %s\n", snd_strerror(err));
253	return AL_FALSE;	460	return AL_FALSE;
254	}	461	}
255		462
256	err = snd_pcm_hw_params_set_buffer_size(phandle, setup, ai->bufframesize);	463	snd_pcm_hw_params_dump (setup, out);
257	if (err < 0) {	464	err = snd_pcm_hw_params_set_buffer_size(phandle, setup, ai->bufframesize);
258	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,	465	snd_pcm_hw_params_dump (setup, out);
259	"set_write_alsa: %s\n", snd_strerror(err));	466	if (err < 0) {
		467	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
		468	"set_write_alsa: %s, size: %d, speed: %d\n",
		469	snd_strerror(err), ai->bufframesize, ai->speed);
260	return AL_FALSE;	470	return AL_FALSE;
261	}	471	}
		472
		473	#if (SND_LIB_MAJOR == 0)
		474	buffer_size = snd_pcm_hw_params_get_buffer_size(setup);
		475	period_size = snd_pcm_hw_params_get_period_size(setup, &dir);
		476	#else
		477	snd_pcm_hw_params_get_buffer_size(setup, &buffer_size);
		478	snd_pcm_hw_params_get_period_size(setup, &period_size, &dir);
		479	#endif
262		480
263	#if (SND_LIB_MAJOR == 0)
264	buffer_size = snd_pcm_hw_params_get_buffer_size(setup);
265	period_size = snd_pcm_hw_params_get_period_size(setup, &dir);
266	#else
267	snd_pcm_hw_params_get_buffer_size(setup, &buffer_size);
268	snd_pcm_hw_params_get_period_size(setup, &period_size, &dir);
269	#endif
270
271	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,	481	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
272	"set_write_alsa (info): Buffersize = %i (%i)",buffer_size, *bufsiz);	482	"set_write_alsa (info): Buffersize = %i (%i)",buffer_size, *bufsiz);
273	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,	483	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
274	"set_write_alsa (info): Periodsize = %i", period_size);	484	"set_write_alsa (info): Periodsize = %i", period_size);
275		485
276	err = snd_pcm_hw_params(phandle, setup);	486	err = snd_pcm_hw_params(phandle, setup);
277	if(err < 0)	487	if(err < 0)
278	{	488	{
279	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,	489	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
280	"set_alsa: %s\n", snd_strerror(err));	490	"set_alsa: %s\n", snd_strerror(err));
281	return AL_FALSE;	491	return AL_FALSE;
282	}	492	}
283		493
Lines 285-294 Link Here
285	if(err < 0)	495	if(err < 0)
286	{	496	{
287	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,	497	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
288	"set_alsa %s\n", snd_strerror(err));	498	"set_alsa %s\n", snd_strerror(err));
289	return AL_FALSE;	499	return AL_FALSE;
290	}	500	}
291		501
		502	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
		503	"set_write_alsa: handle: %p, phandle: %p\n", handle, phandle);
		504	snd_output_close (out);
		505	ai->setup_write = 1;
		506
292	return AL_TRUE;	507	return AL_TRUE;
293	}	508	}
294		509
Lines 300-315 Link Here
300	int data_len = bytes;	515	int data_len = bytes;
301	int channels = 0;	516	int channels = 0;
302	int err;	517	int err;
303	snd_pcm_uframes_t frames;	518	snd_pcm_uframes_t frames;
304		519
305	if((ai == NULL) \|\| (ai->handle == NULL))	520	if((ai == NULL) \|\| (ai->handle == NULL) \|\| (!ai->setup_write))
306	{	521	{
307	return;	522	return;
308	}	523	}
309		524
310	phandle = ai->handle;	525	phandle = ai->handle;
311	channels= ai->channels;	526	channels= ai->channels;
312	frames = (snd_pcm_uframes_t) bytes / ai->framesize;	527	frames = (snd_pcm_uframes_t) bytes / ai->framesize;
313		528
314	while(data_len > 0)	529	while(data_len > 0)
315	{	530	{
Lines 347-352 Link Here
347		562
348	return;	563	return;
349	}	564	}
		565
		566	/* capture data from the audio device */
		567	ALsizei capture_alsa(void *handle,
		568	void *capture_buffer,
		569	int bufsize)
		570	{
		571	struct alsa_info *ai = handle;
		572	snd_pcm_t *phandle = 0;
		573	char *pdata = capture_buffer;
		574	int ret;
		575	snd_pcm_uframes_t frames;
		576
		577	if ((ai == NULL) \|\| (ai->handle == NULL) \|\| (!ai->setup_read))
		578	return 0;
		579
		580	phandle = ai->handle;
		581	frames = (snd_pcm_uframes_t) bufsize / ai->framesize;
		582	grab:
		583
		584	_alDebug(ALD_MAXIMUS, __FILE__, __LINE__,
		585	"set_read_alsa: handle: %p, phandle: %p\n", handle, phandle);
		586	ret = snd_pcm_readi (phandle, pdata, frames);
		587	if (ret < 0) {
		588	fprintf(stderr, "Error, overrun: %d, trying to recover.\n", ret);
		589	ret = snd_pcm_prepare(phandle);
		590	if (ret < 0)
		591	fprintf(stderr, "Unable to recover: %d\n", ret);
		592	else
		593	goto grab;
		594	return 0;
		595	} else
		596	return ret * ai->framesize;
		597	}
		598
350		599
351	static int AL2ALSAFMT(ALenum format) {	600	static int AL2ALSAFMT(ALenum format) {
352	switch(format) {	601	switch(format) {

Lines 45-50 Link Here

(-)src/extensions/al_ext_capture.c (-3 / +234 lines)
45	AL_EXT_PAIR(alCaptureStop_EXT),	45	AL_EXT_PAIR(alCaptureStop_EXT),
46	AL_EXT_PAIR(alCaptureGetData_EXT),	46	AL_EXT_PAIR(alCaptureGetData_EXT),
47	AL_EXT_PAIR(alCaptureDestroy_EXT),	47	AL_EXT_PAIR(alCaptureDestroy_EXT),
		48	AL_EXT_PAIR(alcCaptureOpenDevice),
		49	AL_EXT_PAIR(alcCaptureCloseDevice),
		50	AL_EXT_PAIR(alcCaptureStart),
		51	AL_EXT_PAIR(alcCaptureStop),
		52	AL_EXT_PAIR(alcCaptureSamples),
48	{ NULL, NULL }	53	{ NULL, NULL }
49	};	54	};
50		55
Lines 171-184 Link Here
171	format, dev->format, samples);	176	format, dev->format, samples);
172	size *= (_al_formatbits(dev->format) / 8);	177	size *= (_al_formatbits(dev->format) / 8);
173		178
174	if ( n > (ALsizei)size )	179	if ( n > (ALsizei)size )
175	temp = malloc( n );	180	temp = malloc( n );
176	else	181	else
177	temp = malloc( size );	182	temp = malloc( size );
178		183
179	if ( size > 0 ) {	184	if ( size > 0 ) {
180	size = _alcDeviceRead(cid, temp, size);	185	size = _alcDeviceRead(cid, temp, size);
		186	}
181		187
		188	if ( size > 0 ) {
182	temp = _alBufferCanonizeData(dev->format,	189	temp = _alBufferCanonizeData(dev->format,
183	temp,	190	temp,
184	size,	191	size,
Lines 189-196 Link Here
189	AL_TRUE);	196	AL_TRUE);
190	} else {	197	} else {
191	/* Hmm, zero size in record.. */	198	/* Hmm, zero size in record.. */
192	memset(temp, 0, n);	199	/memset(temp, 0, n);/
193	size = n;	200	size = 0;
194	}	201	}
195	if(temp == NULL) {	202	if(temp == NULL) {
196	fprintf(stderr, "could not canonize data\n");	203	fprintf(stderr, "could not canonize data\n");
Lines 203-205 Link Here
203	}	210	}
204	return size;	211	return size;
205	}	212	}
		213
		214
		215	/* Hacked in ALC_EXT_capture support. --ryan. */
		216	/* This doesn't support multiple devices, device enumeration, or capture */
		217	/* devices seperate from an existing context. How painful. */
		218
		219	/* ring buffer functionality... */
		220
		221	typedef struct
		222	{
		223	ALubyte *buffer;
		224	ALsizei size;
		225	ALsizei write;
		226	ALsizei read;
		227	ALsizei used;
		228	} __ALRingBuffer;
		229
		230	static ALboolean __alRingBufferInit(__ALRingBuffer *ring, ALsizei size);
		231	static ALvoid __alRingBufferShutdown(__ALRingBuffer *ring);
		232	static ALsizei __alRingBufferSize(__ALRingBuffer *ring);
		233	static ALvoid __alRingBufferPut(__ALRingBuffer ring, ALubyte data, ALsizei size);
		234	static ALsizei __alRingBufferGet(__ALRingBuffer ring, ALubyte data, ALsizei size);
		235
		236	static __ALRingBuffer captureRing;
		237
		238	static ALboolean __alRingBufferInit(__ALRingBuffer *ring, ALsizei size)
		239	{
		240	ALubyte ptr = (ALubyte ) realloc(ring->buffer, size);
		241	if (ptr == NULL)
		242	return(AL_FALSE);
		243
		244	ring->buffer = ptr;
		245	ring->size = size;
		246	ring->write = 0;
		247	ring->read = 0;
		248	ring->used = 0;
		249	return(AL_TRUE);
		250	} /* __alRingBufferInit */
		251
		252	static ALvoid __alRingBufferShutdown(__ALRingBuffer *ring)
		253	{
		254	free(ring->buffer);
		255	ring->buffer = NULL;
		256	} /* __alRingBufferShutdown */
		257
		258	static ALsizei __alRingBufferSize(__ALRingBuffer *ring)
		259	{
		260	return(ring->used);
		261	} /* __alRingBufferSize */
		262
		263	static ALvoid __alRingBufferPut(__ALRingBuffer ring, ALubyte data, ALsizei _size)
		264	{
		265	register ALsizei size = _size;
		266	register ALsizei cpy;
		267	register ALsizei avail;
		268
		269	if (!size) /* just in case... */
		270	return;
		271
		272	/* Putting more data than ring buffer holds in total? Replace it all. */
		273	if (size > ring->size)
		274	{
		275	ring->write = 0;
		276	ring->read = 0;
277	ring->used = ring->size;
278	memcpy(ring->buffer, data + (size - ring->size), ring->size);
279	return;
280	} /* if */
281
282	/* Buffer overflow? Push read pointer to oldest sample not overwritten. */
283	avail = ring->size - ring->used;
284	if (size > avail)
285	{
286	ring->read += size - avail;
287	if (ring->read > ring->size)
288	ring->read -= ring->size;
289	} /* if */
290
291	/* Clip to end of buffer and copy first block... */
292	cpy = ring->size - ring->write;
293	if (size < cpy)
294	cpy = size;
295	if (cpy) memcpy(ring->buffer + ring->write, data, cpy);
296
297	/* Wrap around to front of ring buffer and copy remaining data... */
298	avail = size - cpy;
299	if (avail) memcpy(ring->buffer, data + cpy, avail);
300
301	/* Update write pointer... */
302	ring->write += size;
303	if (ring->write > ring->size)
304	ring->write -= ring->size;
305
306	ring->used += size;
307	if (ring->used > ring->size)
308	ring->used = ring->size;
309	} /* __alRingBufferPut */
310
311	static ALsizei __alRingBufferGet(__ALRingBuffer ring, ALubyte data, ALsizei _size)
312	{
313	register ALsizei cpy;
314	register ALsizei size = _size;
315	register ALsizei avail = ring->used;
316
317	/* Clamp amount to read to available data... */
318	if (size > avail)
319	size = avail;
320
321	/* Clip to end of buffer and copy first block... */
322	cpy = ring->size - ring->read;
323	if (cpy > size) cpy = size;
324	if (cpy) memcpy(data, ring->buffer + ring->read, cpy);
325
326	/* Wrap around to front of ring buffer and copy remaining data... */
327	avail = size - cpy;
328	if (avail) memcpy(data + cpy, ring->buffer, avail);
329
330	/* Update read pointer... */
331	ring->read += size;
332	if (ring->read > ring->size)
333	ring->read -= ring->size;
334
335	ring->used -= size;
336
337	return(size); /* may have been clamped if there wasn't enough data... */
338	} /* __alRingBufferGet */
339
340
341	static ALenum captureFmt = AL_NONE;
342	static ALuint captureFreq = 0;
343	static ALint captureFmtSize = 0;
344
345	ALCdevice alcCaptureOpenDevice(const ALubyte deviceName,
346	ALuint freq, ALenum fmt,
347	ALsizei bufsize)
348	{
349	ALCdevice *retval;
350	AL_context *cc;
351	ALuint cid;
352
353	if (deviceName != NULL) /* !!! FIXME */
354	return NULL;
355
356	switch (fmt) /* try to keep this sane for now... */
357	{
358	case AL_FORMAT_MONO8:
359	case AL_FORMAT_MONO16:
360	case AL_FORMAT_STEREO8:
361	case AL_FORMAT_STEREO16:
362	break; /* okay format. */
363
364	default:
365	return(NULL);
366	}
367
368	captureFmt = fmt;
369	captureFreq = freq;
370	captureFmtSize = (_al_formatbits(fmt) / 8);
371	if ((fmt == AL_FORMAT_STEREO8) \|\| (fmt == AL_FORMAT_STEREO16))
372	captureFmtSize *= 2;
373
374	bufsize *= captureFmtSize;
375
376	if (!__alRingBufferInit(&captureRing, bufsize))
377	return NULL;
378
379	if (!alCaptureInit_EXT(fmt, freq, bufsize))
380	return NULL;
381
382	cid = _alcCCId;
383	_alcLockContext( cid );
384	cc = _alcGetContext(cid);
385	retval = cc->read_device;
386	retval->cc = cc;
387	_alcUnlockContext( cid );
388
389	fprintf(stderr, "WARNING: ALC_EXT_capture is subject to change!\n");
390
391	return(retval);
392	}
393
394	ALvoid alcCaptureCloseDevice(ALCdevice *dev)
395	{
396	if (dev == NULL)
397	return;
398
399	alCaptureDestroy_EXT();
400	__alRingBufferShutdown(&captureRing);
401	}
402
403	ALvoid alcCaptureStart(void)
404	{
405	alCaptureStart_EXT();
406	}
407
408	ALvoid alcCaptureStop(void)
409	{
410	alCaptureStop_EXT();
411	}
412
413	/* !!! FIXME: Not ideal; reads samples in ALC_CAPTURE_SAMPLES query */
414	/* !!! FIXME: should query hardware here and do read in alcCaptureSamples() */
415	ALint __alcGetAvailableSamples(ALvoid)
416	{
417	static ALubyte buf[1024];
418	ALsizei got = alCaptureGetData_EXT(buf, sizeof (buf),
419	captureFmt, captureFreq);
420	if (got > 0)
421	__alRingBufferPut(&captureRing, buf, got);
422
423	/printf("got %d have %d\n", (int) got, (int) (__alRingBufferSize(&captureRing) / captureFmtSize));/
424
425	return(__alRingBufferSize(&captureRing) / captureFmtSize);
426	}
427
428
429	ALvoid alcCaptureSamples(ALCdevice device, ALvoid buf, ALsizei samps)
430	{
431	if ((__alRingBufferSize(&captureRing) / captureFmtSize) < samps)
432	return; /* !!! FIXME: This is an error condition! */
433
434	__alRingBufferGet(&captureRing, buf, samps * captureFmtSize);
435	}
436