---

/* XXX Now we support either only input of ouput streams, bot not both at the same time */
PaError Pa_OpenStream(PaStream** stream,
		const PaStreamParameters *inputParameters,
		const PaStreamParameters *outputParameters,
		double sampleRate, unsigned int framesPerBuffer,
		PaStreamFlags streamFlags, PaStreamCallback *streamCallback,
		void *userData)
{
	struct pa_strm *pa_stream;
	struct audio_dev *audio_dev;
	int prev_rate, ret;
	int rate = (int) sampleRate;

	if(stream == NULL || streamCallback == NULL)
	{
		printf("Pa_OpenStream: failed stream=%p streamCallback=%p\n",stream,streamCallback);
		return paInternalError;
	}
	printf("stream %p input %p output %p rate %f"
			" framesPerBuffer %lu flags %lu callback %p user_data %p\n",
			stream, inputParameters, outputParameters, sampleRate,
			framesPerBuffer, streamFlags, streamCallback, userData);

	pa_stream = pa_str_alloc();
	if (!pa_stream) {
		printf("Cannot allocate pa_strm\n");
		return paInternalError;
	}

	if (outputParameters != NULL) {
		pa_stream->active          = 1;
		pa_stream->number_of_chan  = outputParameters->channelCount;
		pa_stream->devid           = outputParameters->device;
		pa_stream->sample_format   = outputParameters->sampleFormat;
	} else {
		pa_stream->active          = 0;
		pa_stream->number_of_chan  = inputParameters->channelCount;
		pa_stream->devid           = inputParameters->device;
		pa_stream->sample_format   = inputParameters->sampleFormat;
	}

	pa_stream->callback       = streamCallback;
	pa_stream->user_data      = userData;

	pthread_cond_init(&pa_stream->pa_cond, 0);
	ret = pa_mutex_init(pa_stream);
	if(ret != 0) {
		return paInternalError;
	}
	*stream = pa_stream;

	audio_dev = audio_dev_get_by_idx(pa_stream->devid);
	if (audio_dev == NULL)
		return paInvalidDevice;

	if(!audio_dev->ad_ops || !audio_dev->ad_ops->ad_ops_ioctl || !audio_dev->ad_ops->ad_ops_start)
	{
		printf("Pa_OpenStream failed: audio_dev=%p\n",audio_dev);
		return paInvalidDevice;
	}
	prev_rate = audio_dev->ad_ops->ad_ops_ioctl(audio_dev,
		ADIOCTL_GET_RATE, NULL);
	if ((prev_rate != -1) && (prev_rate != rate)) {
		audio_dev->ad_ops->ad_ops_ioctl(audio_dev, ADIOCTL_SET_RATE, &rate);
	}
	pa_stream->rate = rate;
	audio_dev->dir == AUDIO_DEV_OUTPUT
		? audio_dev_open_out_stream(audio_dev, pa_stream)
		: audio_dev_open_in_stream(audio_dev, pa_stream);
	pa_stream->state = PA_STREAM_RUNNING;
	pthread_attr_init(&pa_stream->threadAttr);
	pthread_attr_setstacksize(&pa_stream->threadAttr, 2048);
	ret = pthread_create(&pa_stream->pa_thread, &pa_stream->threadAttr, outputParameters ? pa_thread_hnd_out : pa_thread_hnd_in, pa_stream);
	if (ret != 0) {
		printf("pthread_create failed ret=%d\n",ret);
		ret = paInternalError;
	}
	else
		ret = paNoError;

	pthread_setschedprio(pa_stream->pa_thread, PA_THREAD_PRIORITY);
	if(outputParameters)
		pthread_setname_np(pa_stream->pa_thread, "pa_thread_hnd_out");
	else
		pthread_setname_np(pa_stream->pa_thread, "pa_thread_hnd_in");
	return ret;
}

static void pa_thread_wakeup(struct pa_strm *strm,
		enum pa_state state) {
	if(!strm)
		return;
	strm->state = state;
	strm->active = 1;
	pa_cond_signal(strm);
}

PaError Pa_IsStreamStopped(PaStream *stream) {
	struct pa_strm *strm = (struct pa_strm *)stream;
	return strm->state == PA_STREAM_STOPPED;
}

PaError Pa_CloseStream(PaStream *stream) {
	struct pa_strm *pa_stream = stream;

	if (!Pa_IsStreamStopped(stream)) {
		pa_thread_wakeup(pa_stream, PA_STREAM_CLOSED);
		/* Wait until thread finished and only after that free the stream */
		pthread_join(pa_stream->pa_thread, NULL);
	}
	pthread_cond_destroy(&pa_stream->pa_cond);
	pa_mutex_destroy(pa_stream);
	pthread_attr_destroy(&pa_stream->threadAttr);
	pa_str_free(pa_stream);
	return paNoError;
}

PaError Pa_StartStream(PaStream *stream) {
	pa_thread_wakeup((struct pa_strm *) stream, PA_STREAM_RUNNING);
	return paNoError;
}

PaError Pa_StopStream(PaStream *stream) {
	struct pa_strm *strm;
	struct audio_dev *audio_dev;

	if(stream == NULL)
		return paInternalError;
	strm = (struct pa_strm *)stream;

	audio_dev = audio_dev_get_by_idx(strm->devid);
	if(!audio_dev || !audio_dev->ad_ops)
		return paInternalError;

	if (audio_dev->ad_ops->ad_ops_pause)
		audio_dev->ad_ops->ad_ops_pause(audio_dev);
	else
		printf("Stream pause not supported!\n");

	if (audio_dev->ad_ops->ad_ops_stop)
		audio_dev->ad_ops->ad_ops_stop(audio_dev);
	else
		printf("Stream stop not supported!\n");

	pa_thread_wakeup(strm, PA_STREAM_STOPPED);
	/* Wait until thread finished and only after that free the stream */
	pthread_join(strm->pa_thread, NULL);

	return paNoError;
}

void Pa_Sleep(int msec) {
	usleep(msec * 1000);
}
это весь код