On 02/03/2016 02:54 PM, Fokke de Jong wrote: watching this with interest, keep us posted about your results and longer-term experience with this card! best, jörn -- Jörn Nettingsmeier Lortzingstr. 11, 45128 Essen, Tel. +49 177 7937487 Meister für Veranstaltungstechnik (Bühne/Studio) Tonmeister VDT http://stackingdwarves.net

On Wed, Feb 03, 2016 at 10:41:06PM +0100, Markus Seeber wrote: No. Takashi had some feedback, and I had neither the time nor hardware to work on it. I can do the cosmetics, but rewriting the MIDI code to abandon tasklets is nothing I have the bandwidth for. It's pretty much "take it or leave it" by now due to lack of time. Cheers -- mail: adi(a)thur.de http://adi.thur.de PGP/GPG: key via keyserver

It turns out I am doing something very wrong, and i *can* get much lower latency’s even with the large buffersize. I could not get jack_delay itself to work (it wouldn’t connect to any ports no matter what i tried), but i did use jack rather than my own alsa implementation and with a period size of 32 samples @ 48KHz I measured a roundtrip delay of around 169 samples (3.5 ms), which is very reasonable. The method I used was perhaps a bit crude, so it could be off by a few samples. But it seems accurate enough. (I used another soundcard on a different machine, and plugged one output straight back in, and the other went through the converter /madi fx / jack and then back in. The difference in timing should be the rtd). So now i am a but confused how to get the same kind of latency in my own code (using alsa directly rather than through jack) Basically what happens is when i have a buffersize of 8192 and a period of 32 is that snd_pcm_avail_update(capture_handle), will keep returning 0 until i have played back the full 8192 samples. After that I will start receiving input samples, but obviously the latency is now more than 8182 samples… How can i make alsa not wait until the entire buffer is full? best, Fokke

I tried the alsa_loopback example: alsa_loopback hw:0,0 hw:0,0 48000 32 256 Can't open ALSA device which is weird, because i can open the device just fine, and so can jack…

That, helped thanks. Unfortunately I’m still getting the same huge latency as before.. cheers, Fokke

On Sat, Feb 06, 2016 at 04:12:39PM +0000, Fons Adriaensen wrote: Not impossible, but I fail to see how. Here is the relevant driver side: .channels_min = 1, .channels_max = 196, .buffer_bytes_max = OUTPUT_DMA_BUFFER_SIZE, .period_bytes_min = (32 * 4), .period_bytes_max = OUTPUT_DMA_BUFFER_SIZE, .periods_min = 2, .periods_max = 1024, and according to some doc on the internet: --- cut --- buffer_bytes_max defines the maximum buffer size in bytes. There is no buffer_bytes_min field, since it can be calculated from the minimum period size and the minimum number of periods. Meanwhile, period_bytes_min and define the minimum and maximum size of the period in bytes. periods_max and periods_min define the maximum and minimum number of periods in the buffer. The “period” is a term that corresponds to a fragment in the OSS world. The period defines the size at which a PCM interrupt is generated. This size strongly depends on the hardware. Generally, the smaller period size will give you more interrupts, that is, more controls. In the case of capture, this size defines the input latency. On the other hand, the whole buffer size defines the output latency for the playback direction. --- cut --- 1ch*2periods*32samples. Fokke, do you mind running the attached program? Cheers -- mail: adi(a)thur.de http://adi.thur.de PGP/GPG: key via keyserver

On Sat, Feb 06, 2016 at 06:30:16PM +0100, Fokke de Jong wrote: You probably mean nperiods = 2 ??? (otherwise the mystery becomes even more mysterious...) I'll look into why z-a-pcmi doesn't give you the same result as Jack --- it should. Ciao, -- FA A world of exhaustive, reliable metadata would be an utopia. It's also a pipe-dream, founded on self-delusion, nerd hubris and hysterically inflated market opportunities. (Cory Doctorow)

If anyone knows how to get the roundtrip latency down, i would highly appreciate it! Ive pasted my full code below (the important stuff is in AlsaDevice::setParam and AlsaDevice::run_thread). The problem is that I only start getting input samples after o have already played an entire buffer full of samples. Which results in a latency of more ore less 1 whole buffer rather than (just) 2 periods. I have looked at alsa_driver.c from jack but I can’t really see what exactly they do different in that regard. I hope the alsa-experts here, it will be immediately obvious what i’m missing :-) fokke ////////////////////////////////////// AlsaDevice.h #ifndef AlsaDevice_H #define AlsaDevice_H #include <alsa/asoundlib.h> #include <iostream> #include <stdexcept> #include <sstream> #include <vector> #include <cmath> typedef std::vector<std::vector<float>> ChannelBuffers; class AudioEngine { public: virtual void process(const ChannelBuffers& inputs, ChannelBuffers& outputs) = 0; }; class AlsaError: public std::runtime_error { std::string _file, _function; int _line; public: AlsaError(int err ) :std::runtime_error(snd_strerror(err)) {} AlsaError(int err, const std::string& file, const std::string& function, int line ) :std::runtime_error(snd_strerror(err)) ,_file(file) ,_function(function) ,_line(line) { std::cerr << "throw: " << snd_strerror(err) << "\n";; } std::string where() { std::stringstream w; w << " function: '" << _function << "' file: '" << _file << "' line: " << _line; return w.str(); } }; #define THROW_ALSA_ERROR(e) throw AlsaError(e, __FILE__, __FUNCTION__, __LINE__ ) class AlsaDevice { private: unsigned int numInChannels = 0; unsigned int numOutChannels = 0; unsigned int samplerate = 48000; snd_pcm_uframes_t buffer_size = 0; snd_pcm_uframes_t period_size = 0; // snd_pcm_t* pcm_in_handle = nullptr; snd_pcm_t* pcm_out_handle = nullptr; const snd_pcm_format_t format = SND_PCM_FORMAT_FLOAT_LE; ChannelBuffers inBuffers; ChannelBuffers outBuffers; // de-interleaved float buffers; int numXruns = 0; static int xrun_recovery(snd_pcm_t *handle, int err) { if (err == -EPIPE) { /* under-run */ err = snd_pcm_prepare(handle); if (err < 0) printf("Can't recovery from underrun, prepare failed: %s\n", snd_strerror(err)); return 0; } else if (err == -ESTRPIPE) { while ((err = snd_pcm_resume(handle)) == -EAGAIN) sleep(1); /* wait until the suspend flag is released */ if (err < 0) { err = snd_pcm_prepare(handle); if (err < 0) printf("Can't recovery from suspend, prepare failed: %s\n", snd_strerror(err)); } return 0; } return err; } int run_thread(AudioEngine*); void setParams(snd_pcm_t* handle, int requestBuffersize, unsigned int &requestNumChannels, int mode); public: AlsaDevice(){} void process(float **outs, int n); void print() { std::cout << "samplerate: " << samplerate << "Hz\n"; std::cout << "in channels: " << numInChannels << "\n"; std::cout << "out channels: " << numOutChannels << "\n"; std::cout << "buffersize: " << buffer_size<< "\n"; std::cout << "period_size: " << period_size << "\n"; } void open(const std::string& deviceName, int requestPeriodSize, unsigned int requestNumInChannels=0, unsigned int requestNumOutChannels=0); int run(AudioEngine*); void stop(); int getNumXRuns() const { return numXruns; } ~AlsaDevice(); }; #endif ////////////////////////////////AlsaDevice.cpp #include "AlsaDevice.h" #include <thread> #include <strings.h> #include <iomanip> #include <fstream> #define THROW_ALSA_ERROR(e) throw AlsaError(e, __FILE__, __FUNCTION__, __LINE__ ) void AlsaDevice::open(const std::string& deviceName, int requestPeriodSize, unsigned int requestNumInChannels, unsigned int requestNumOutChannels) { int err = 0; if (requestNumInChannels > 0) { err = snd_pcm_open (&pcm_in_handle, deviceName.c_str(), SND_PCM_STREAM_CAPTURE, 0); if (err < 0) { pcm_in_handle = nullptr; THROW_ALSA_ERROR(err); } std::cout << "opened capture device '" << deviceName << "'\n"; unsigned int numHWChannels=0; setParams(pcm_in_handle, requestPeriodSize, numHWChannels, SND_PCM_STREAM_CAPTURE); if(numHWChannels < requestNumInChannels) { throw std::runtime_error("num hw out channels too small"); } numInChannels = numHWChannels; inBuffers.resize(requestNumInChannels); for (int i=0;i<requestNumInChannels;i++) { inBuffers[i].resize(period_size); } } else { numInChannels = 0; } if (requestNumOutChannels > 0) { err = snd_pcm_open (&pcm_out_handle, deviceName.c_str(), SND_PCM_STREAM_PLAYBACK, 0); if (err < 0) { pcm_out_handle = nullptr; THROW_ALSA_ERROR(err); } std::cout << "opened playback device '" << deviceName << "'\n"; unsigned int numHWChannels=0; setParams(pcm_out_handle, requestPeriodSize, numHWChannels, SND_PCM_STREAM_PLAYBACK); if(numHWChannels < requestNumOutChannels) { throw std::runtime_error("num hw out channels too small"); } numOutChannels = numHWChannels; outBuffers.resize(requestNumOutChannels); for (int i=0;i<requestNumOutChannels;i++) { outBuffers[i].resize(period_size); for (int j=0;j<period_size;j++) { outBuffers[i][j] = 0.0f; } } } else { numOutChannels = 0; } } void AlsaDevice::setParams(snd_pcm_t* pcm_handle, int requestPeriodSize, unsigned int& numChannels, int dir) { snd_pcm_hw_params_t *params = nullptr; snd_pcm_hw_params_alloca(&params); int err = 0; err = snd_pcm_hw_params_any(pcm_handle, params); if (err != 0 ) THROW_ALSA_ERROR(err); err = snd_pcm_hw_params_set_access(pcm_handle, params, SND_PCM_ACCESS_MMAP_COMPLEX); if (err != 0 ) { std::cerr << snd_strerror(err) << "\n"; THROW_ALSA_ERROR(err); } err = snd_pcm_hw_params_set_format(pcm_handle, params, format); if (err != 0 ) THROW_ALSA_ERROR(err); unsigned int maxChannels = 0; err = snd_pcm_hw_params_get_channels_max(params, &maxChannels); if (err != 0 ) THROW_ALSA_ERROR(err); numChannels = maxChannels; err = snd_pcm_hw_params_set_channels(pcm_handle, params, numChannels); if (err != 0 ) THROW_ALSA_ERROR(err); unsigned int realNumChannels = 0; err = snd_pcm_hw_params_get_channels(params, &realNumChannels); if (err != 0 ) THROW_ALSA_ERROR(err); numChannels = realNumChannels; err = snd_pcm_hw_params_set_rate_near(pcm_handle, params, &samplerate, 0); if (err != 0 ) THROW_ALSA_ERROR(err); snd_pcm_uframes_t min_bufsize=0; err = snd_pcm_hw_params_get_buffer_size_min(params, &min_bufsize); if (err < 0) THROW_ALSA_ERROR(err); buffer_size = min_bufsize; err = snd_pcm_hw_params_set_buffer_size(pcm_handle, params, buffer_size); if (err < 0) THROW_ALSA_ERROR(err); err = snd_pcm_hw_params_set_period_size(pcm_handle, params, requestPeriodSize, 0); if (err < 0) THROW_ALSA_ERROR(err); err = snd_pcm_hw_params_get_period_size(params, &period_size, 0); if (err < 0) THROW_ALSA_ERROR(err); err = snd_pcm_hw_params(pcm_handle, params); if (err != 0 ) THROW_ALSA_ERROR(err); snd_pcm_sw_params_t *sw_params = nullptr; snd_pcm_sw_params_alloca(&sw_params); err = snd_pcm_sw_params_current(pcm_handle, sw_params); if (err != 0 ) THROW_ALSA_ERROR(err); err = snd_pcm_sw_params_set_start_threshold(pcm_handle, sw_params, period_size); if (err != 0 ) THROW_ALSA_ERROR(err); err = snd_pcm_sw_params_set_avail_min(pcm_handle, sw_params, period_size); if (err != 0 ) THROW_ALSA_ERROR(err); err = snd_pcm_sw_params(pcm_handle, sw_params); if (err != 0 ) THROW_ALSA_ERROR(err); } std::thread audioThred; int AlsaDevice::run(AudioEngine* engine) { audioThred = std::thread([this, engine]() { try { // ProcessThread::setCPUCore(0); // ProcessThread::setThreadRealtime(32/ 48000.); run_thread(engine); } catch (AlsaError& e) { std::cerr <<"ERROR: " << e.what() << " in " << e.where() << "\n"; } }); return 0; } int AlsaDevice::run_thread(AudioEngine* engine) { pthread_setname_np(pthread_self(), "audio thread"); snd_pcm_link(pcm_in_handle, pcm_out_handle); int err, first = 1; bool firstCapture = true; while (1) { snd_pcm_state_t state = snd_pcm_state(pcm_out_handle); if (state == SND_PCM_STATE_XRUN) { numXruns++; err = xrun_recovery(pcm_out_handle, -EPIPE); if (err < 0) { THROW_ALSA_ERROR(err); return err; } first = 1; } else if (state == SND_PCM_STATE_SUSPENDED) { err = xrun_recovery(pcm_out_handle, -ESTRPIPE); if (err < 0) { printf("SUSPEND recovery failed: %s\n", snd_strerror(err)); return err; } } snd_pcm_sframes_t availCapture = snd_pcm_avail_update(pcm_in_handle); snd_pcm_sframes_t availPlayback = snd_pcm_avail_update(pcm_out_handle); if (availPlayback < 0) { err = xrun_recovery(pcm_out_handle, availPlayback); if (err < 0) { err = xrun_recovery(pcm_out_handle, -EPIPE); if (err < 0) { printf("XRUN recovery failed: %s\n", snd_strerror(err)); return err; } first = 1; } { printf("avail update failed: %s\n", snd_strerror(err)); return err; } first = 1; continue; } if (availPlayback < period_size) { if (first) { first = 0; err = snd_pcm_start(pcm_out_handle); if (err < 0) { printf("Start error: %s\n", snd_strerror(err)); exit(EXIT_FAILURE); } } else { err = snd_pcm_wait(pcm_out_handle, -1); if (err < 0) { if ((err = xrun_recovery(pcm_out_handle, err)) < 0) { printf("snd_pcm_wait error: %s\n", snd_strerror(err)); exit(EXIT_FAILURE); } first = 1; } } continue; } if (availCapture > 0) { const snd_pcm_channel_area_t *capt_areas = nullptr; snd_pcm_uframes_t offset=0, frames=period_size; err = snd_pcm_mmap_begin(pcm_in_handle, &capt_areas, &offset, &frames); if (err < 0) { exit(EXIT_FAILURE); //first = 1; } for (int chnl=0;chnl<inBuffers.size();chnl++) { float *ptr = (float*)capt_areas[chnl].addr; unsigned first = capt_areas[chnl].first / 32; unsigned step = capt_areas[chnl].step / 32; ptr += first; for (int i=0;i<frames;i++) { inBuffers[chnl][i] = ptr[(i+offset)*step]; } } snd_pcm_sframes_t commitres = snd_pcm_mmap_commit(pcm_in_handle, offset, frames); if (commitres < 0 || (snd_pcm_uframes_t)commitres != frames) { //if ((err = xrun_recovery(pcm_out_handle, commitres >= 0 ? -EPIPE : commitres)) < 0) { //printf("MMAP commit error: %s\n", snd_strerror(err)); exit(EXIT_FAILURE); } //first = 1; } } snd_pcm_uframes_t size = period_size; while (size > 0) { snd_pcm_uframes_t offset, frames; const snd_pcm_channel_area_t *play_areas = nullptr; // frames = size; err = snd_pcm_mmap_begin(pcm_out_handle, &play_areas, &offset, &frames); if (err < 0) { if ((err = xrun_recovery(pcm_out_handle, err)) < 0) { printf("MMAP begin avail error: %s\n", snd_strerror(err)); exit(EXIT_FAILURE); } first = 1; } { engine->process(inBuffers, outBuffers); static const float kScale = float(1<<31); // copy outBuffers for (int chnl=0;chnl<outBuffers.size();chnl++) { float *ptr = (float*)play_areas[chnl].addr; unsigned first = play_areas[chnl].first / 32; unsigned step = play_areas[chnl].step / 32; ptr += first; for (int i=0;i<frames;i++) { ptr[(i+offset)*step] = outBuffers[chnl][i]; } } // zero remaining buffers for (int chnl=outBuffers.size();chnl<numOutChannels;chnl++) { float *ptr = (float*)play_areas[chnl].addr; unsigned first = play_areas[chnl].first / 32; unsigned step = play_areas[chnl].step / 32; ptr += first; for (int i=0;i<frames;i++) { ptr[(i+offset)*step] = 0.0f; // } } } snd_pcm_sframes_t commitres = snd_pcm_mmap_commit(pcm_out_handle, offset, frames); if (commitres < 0 || (snd_pcm_uframes_t)commitres != frames) { if ((err = xrun_recovery(pcm_out_handle, commitres >= 0 ? -EPIPE : commitres)) < 0) { printf("MMAP commit error: %s\n", snd_strerror(err)); exit(EXIT_FAILURE); } first = 1; } size -= frames; assert(size == 0); } } } void AlsaDevice::stop() { snd_pcm_drain(pcm_out_handle); snd_pcm_drop(pcm_out_handle); } AlsaDevice::~AlsaDevice() { if (pcm_out_handle) { snd_pcm_close (pcm_out_handle); std::cout << "closed device\n"; } } class TestAudioEngine: public AudioEngine { // just copy in to out for now: void process(const ChannelBuffers& inputs, ChannelBuffers& outputs) override { const int numInChannels = inputs.size(); const int numOutChannels = outputs.size(); int n = outputs[0].size(); assert(numInChannels <= numOutChannels); for ( int j=0;j<numOutChannels;j++) { for (int i=0;i<n;i++) { outputs[j][i] = inputs[j][i]; } } } }; int main () { try { std::cout << "alsa test..\n"; AlsaDevice device; device.open("hw:0,0", 32, 32, 32); device.print(); TestAudioEngine engine; std::cout << "starting device.\n"; device.run(&engine); std::cout << "running..\n"; while (1) { sleep(1); } std::cout << "done.\n"; } catch (AlsaError& e) { std::cerr << "ERROR: " << e.what() << " in " << e.where() << "\n"; } catch (...) { std::cerr << "uncaught exception!!..\n"; } return 0; }