コード例 #1
0
TErrors SalsaStream::read(llaAudioPipe& buffer) {
	if(pcm_state_ == CLOSED) {
		LOGGER().warning(E_READ_STREAM, "Attempt to write to a closed stream.");
		return E_READ_STREAM;
	}

	TErrors err;
	if( (err = updateSettings(buffer)) != E_OK) return err;


	char *iraw, **niraw;
	int rc;
	getRawInputBuffers(buffer, &iraw, &niraw);

	if(organization_ == SND_PCM_ACCESS_RW_NONINTERLEAVED) {
		rc = snd_pcm_readn(pcm_, (void**)niraw, buffer.getBufferLength());

	}
	else {
		rc = snd_pcm_readi(pcm_, (void*)iraw, buffer.getBufferLength());
	}

	setBufferLastWrite(buffer, rc);
	if (rc == -EPIPE) {
	  /* EPIPE means underrun */
	  snd_pcm_prepare(pcm_);
	} else if (rc < 0) {
		LOGGER().warning(E_READ_STREAM, snd_strerror(rc));
		snd_pcm_recover(pcm_, rc, 0);
	}


	return E_OK;
}
コード例 #2
0
    bool readFromInputDevice (AudioBuffer<float>& inputChannelBuffer, const int numSamples)
    {
        jassert (numChannelsRunning <= inputChannelBuffer.getNumChannels());
        float* const* const data = inputChannelBuffer.getArrayOfWritePointers();

        if (isInterleaved)
        {
            scratch.ensureSize ((size_t) ((int) sizeof (float) * numSamples * numChannelsRunning), false);
            scratch.fillWith (0); // (not clearing this data causes warnings in valgrind)

            auto num = snd_pcm_readi (handle, scratch.getData(), (snd_pcm_uframes_t) numSamples);

            if (num < 0)
            {
                if (num == -(EPIPE))
                    overrunCount++;

                if (JUCE_ALSA_FAILED (snd_pcm_recover (handle, (int) num, 1 /* silent */)))
                    return false;
            }


            if (num < numSamples)
                JUCE_ALSA_LOG ("Did not read all samples: num: " << num << ", numSamples: " << numSamples);

            for (int i = 0; i < numChannelsRunning; ++i)
                converter->convertSamples (data[i], 0, scratch.getData(), i, numSamples);
        }
        else
        {
            auto num = snd_pcm_readn (handle, (void**) data, (snd_pcm_uframes_t) numSamples);

            if (num < 0)
            {
                if (num == -(EPIPE))
                    overrunCount++;

                if (JUCE_ALSA_FAILED (snd_pcm_recover (handle, (int) num, 1 /* silent */)))
                    return false;
            }

            if (num < numSamples)
                JUCE_ALSA_LOG ("Did not read all samples: num: " << num << ", numSamples: " << numSamples);

            for (int i = 0; i < numChannelsRunning; ++i)
                converter->convertSamples (data[i], data[i], numSamples);
        }

        return true;
    }
コード例 #3
0
static snd_pcm_sframes_t snd_pcm_file_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size)
{
	snd_pcm_file_t *file = pcm->private_data;
	snd_pcm_channel_area_t areas[pcm->channels];
	snd_pcm_sframes_t n;

	if (file->ifd >= 0) {
		SNDERR("DEBUG: Noninterleaved read not yet implemented.\n");
		return 0;	/* TODO: Noninterleaved read */
	}

	n = snd_pcm_readn(file->gen.slave, bufs, size);
	if (n > 0) {
		snd_pcm_areas_from_bufs(pcm, areas, bufs);
		snd_pcm_file_add_frames(pcm, areas, 0, n);
	}
	return n;
}
コード例 #4
0
    bool readFromInputDevice (AudioSampleBuffer& inputChannelBuffer, const int numSamples)
    {
        jassert (numChannelsRunning <= inputChannelBuffer.getNumChannels());
        float** const data = inputChannelBuffer.getArrayOfChannels();

        if (isInterleaved)
        {
            scratch.ensureSize (sizeof (float) * numSamples * numChannelsRunning, false);
            scratch.fillWith (0); // (not clearing this data causes warnings in valgrind)

            snd_pcm_sframes_t num = snd_pcm_readi (handle, scratch.getData(), numSamples);

            if (failed (num))
            {
                if (num == -EPIPE)
                {
                    if (failed (snd_pcm_prepare (handle)))
                        return false;
                }
                else if (num != -ESTRPIPE)
                    return false;
            }

            for (int i = 0; i < numChannelsRunning; ++i)
                converter->convertSamples (data[i], 0, scratch.getData(), i, numSamples);
        }
        else
        {
            snd_pcm_sframes_t num = snd_pcm_readn (handle, (void**) data, numSamples);

            if (failed (num) && num != -EPIPE && num != -ESTRPIPE)
                return false;

            for (int i = 0; i < numChannelsRunning; ++i)
                converter->convertSamples (data[i], data[i], numSamples);
        }

        return true;
    }
コード例 #5
0
snd_pcm_sframes_t snd_pcm_generic_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size)
{
    snd_pcm_generic_t *generic = pcm->private_data;
    return snd_pcm_readn(generic->slave, bufs, size);
}
コード例 #6
0
TErrors SalsaStream::connect( llaOutputStream* output, llaAudioPipe& buffer) {



	TErrors ret = _open(SND_PCM_NONBLOCK);
	// Update pcm settings
	if( ret != E_OK || (ret = updateSettings(buffer)) != E_OK ) return ret;

	if( (ret = output->open()) != E_OK ) {
		close();
		return ret;
	}

	int err = 0;

	snd_pcm_uframes_t avail_min = 0;
	if(buffer.getBufferLength() < period_size_) {
		close();
		output->close();
		LOGGER().error(E_STREAM_CONFIG, "Buffer length must be higher");
		return E_STREAM_CONFIG;
	}
	else if(buffer.getBufferLength() / period_size_ < 3 ) avail_min = period_size_;
	else avail_min = ((buffer.getBufferLength()/period_size_)-2)*period_size_;



	// Set up the input stream for polling /////////////////////////////////////
	// This is the same process as for the output.

	err = snd_pcm_sw_params_malloc(&sw_config_);
	err = snd_pcm_sw_params_current(pcm_, sw_config_);
	CHECK_SNDERROR(err, E_STREAM_CONFIG);

//	err = snd_pcm_sw_params_set_start_threshold (pcm_, sw_config_, 0U );
//	CHECK_SNDERROR(err, E_STREAM_CONFIG);

	err = snd_pcm_sw_params_set_avail_min(pcm_, sw_config_, avail_min  );
	CHECK_SNDERROR(err, E_STREAM_CONFIG);

	err = snd_pcm_sw_params(pcm_, sw_config_);
	CHECK_SNDERROR(err, E_STREAM_CONFIG);

	snd_pcm_prepare(pcm_);

	snd_pcm_uframes_t frames;

	char *iraw, **niraw;

	while(!buffer.stop() && !buffer.fail()) {
		snd_pcm_start(pcm_);
		if ((err = snd_pcm_wait (pcm_, -1)) < 0) {
			if (err == -EPIPE) {
			  /* EPIPE means xrun */
			  snd_pcm_prepare(pcm_);
			} else if (err < 0) {
				LOGGER().error(E_READ_STREAM, snd_strerror(err));
				snd_pcm_sw_params_free(sw_config_);
				close();
				output->close();
				return E_READ_STREAM;
			}
		}

		frames = snd_pcm_avail_update(pcm_);
		if(frames < 0) {
			LOGGER().error(E_READ_STREAM, snd_strerror(err));
			snd_pcm_sw_params_free(sw_config_);
			close();
			output->close();
			return E_READ_STREAM;
		}

		if(frames > buffer.getBufferLength()) frames = buffer.getBufferLength();

		int rc;
		getRawInputBuffers( buffer, &iraw, &niraw);

		// read from the stream
		if(organization_ == SND_PCM_ACCESS_RW_NONINTERLEAVED) {
			rc = snd_pcm_readn(pcm_, (void**)niraw, frames);
		}
		else {
			rc = snd_pcm_readi(pcm_, (void*)iraw, frames);
		}

		// save the number of frames read
		TSize lastwrite = ((TSize)rc <= buffer.getBufferLength())?
				rc : buffer.getBufferLength();

		setBufferLastWrite(buffer, lastwrite);

		// detect errors
		if (rc == -EPIPE) {
		  /* EPIPE means underrun */
		  snd_pcm_prepare(pcm_);
		} else if (rc < 0) {
			LOGGER().warning(E_READ_STREAM, snd_strerror(rc));
			snd_pcm_sw_params_free(sw_config_);
			close();
			output->close();
			return E_READ_STREAM;
		}

		TErrors reterr;
		if( (reterr=output->write(buffer)) != E_OK ) {
			snd_pcm_sw_params_free(sw_config_);
			close();
			output->close();
		}

	}

	snd_pcm_sw_params_free(sw_config_);
	close();
	output->close();

	return E_OK;
}