iodata | Python library for reading writing

There is no mistake in my Player code that is written up there. But the main reason for playing audio in fast mode was that while inserting my data into the player, I was giving stereo data but treated it as mono(As I was filling only half the number of frames). I multiplied the number of frames with the number of channels while allocating the memory and it did the trick.

You might not want to start playing until there's more in the circular buffer than the amount needed to cover the maximum time jitter in the incoming data rate. Try waiting until there's half a second of audio in the circular buffer before starting to play it. Then experiment with the amount of padding.

Answering my own question...

I'm not sure exactly why this works, but it does. Apparently I didn't need to use ring buffers either which is strange. I also added a switch for when mNumberBuffers only has one buffer.

Background mode will often cause the callback interval or buffer size to increase by 4X, likely to save on battery power (longer intervals allows the OS to do audio hardware DMA less often, or wake up your app from sleep/nap mode less often).

Turning Siri voice recognition on or off may affect how long it takes to power up the microphone chips and related audio input circuitry. Whether any other app also has an audio session configured may also affect start-up time. The audio circuitry is different in different models of iOS devices.

In the C++ code, the signature int getResults(..., float* oResults) isn't able to communicate the allocated pointer back to the caller. The line

I'll try to attack the main issues. My understanding of your actual problem is quite limited as I don't know what your code actually does.

This doesn't work as pygame is built on SDL2 which states "You should not expect to be able to create a window, render, or receive events on any thread other than the main one."

Same as above, the display only work in the main thread.

You could pickle the methods using something like dill, but it fells (to me) wrong to copy full on python object between processes. I'd go for another solution.

You need to use to serialize Python objects in order to send them between processes.

I don't understand what this mean.

It seems to me that the problem could be solved with better separation of data and visualization. The training should have no knowledge about any visualization, as it's not dependent on how you want to display it. So there should not be any reason to share the pygame display.

Once this is done, it shouldn't be too much problem (multi-threading always causes problems) to do what you're trying to do. Regarding the pickle issue; I'd try to avoid pickling Python objects and functions, and instead just pass basic primitives between threads and processes. It seems like you should be able to assign self.fitnessFromArray with a simple int instead and based on its value do the min/avg/max calculation in the thread/process instead.

If you want to do threading, then the main thread will take care of the rendering. It'll also spawn threads for the training. When the threads are completed they'll return their result (or put it in a thread safe storage) and the main thread will poll the data and display the result. If the work done by the training takes longer than one frame, then divide up the work so each thread only partially train and can continue where it left off the next frame.

The principal is the same if you instead want separate processes. The main process starts up several training processes and connect to them via sockets. From the sockets, you'd poll information about the state of the program and display it. It would basically be a client-server architecture (albeit on localhost) where the training scripts are servers and the main process is a client.

Apparently, when a function name is indicated, it might mean that the stack of that function overflowed. I added the static keyword to some arrays inside vcode_synth_frame_rate, and that SIGSEGV error disappeared.

I still did not understand this very well, if anyone has more detailed information please add an answer and I'll mark it as the accepted answer.

It seems like you programmed yourself a race-condition there. So your jQuery is executed whenever the page is loaded, regardless if the robots object is there or not. But the generation of the object is related to connections and network timing too. So your script only runs fine, if the generation is faster as your page loading.

And now you might ask why it would not work, if you copy the code below the generation itself. That is a race-condition too. Code inside a jQuery ready state will only be executed after page load. If you paste the code inside another script, like the object generation, the ready state may be registered at a time, where the page was already loaded. So it will never be executed, because you registered it to late.

So what you need to do, is to ensure that the code is only executed after the generation is finished. Maybe by using a callback, an event or something else. But for now, you have two related scripts what run whenever they want and nobody waits for each other. ;)

By the way, just a hint: Using $(document).ready(() => {}) is not best practice and out-dated too. There is a shorthand for that. And you should use jQuery instead of $ for calling it, so your scripts will work in noConflict mode too. So insted use jQuery(($) => {}).

The problem might be that you are setting two inputs to your IO node (remote or voice processing), and no inputs to your audio graph.