slow | Linux network device to lower speeds | Networking library

You're supposed to free memory right after the last time it will be used. In your program, after the while loop in recursion, Energy isn't used again, so you should free it right after that (i.e., right before return event_counter;).

You are looking for table partitioning:

An option with tidyverse

1. Get the objects in a named list (dplyr::lst)
2. Convert the named list to a tibble - enframe
3. unnest the list column
4. Extract the substring from the 'name', convert it to upper case
5. Do a join (right_join) with the 'chars' converted to a tibble
6. arrange the rows after replacing the NA with 'Unique'
7. pull the column as a vector

Use sum and count with list comprehension

Basically, the problem at hand is that rodio::Decoder::new consumes the value which it reads from (well, actually it is already consumed by BufReader::new). So, if you have a loop or a closure that can be called multiple times, you have to come up with a fresh value each time. This what File::open does in your first code snipped.

In your second code snipped, you only create a File once, and then try to consume it multiple times, which Rust's ownership concept prevents you from doing.

Also notice, that using reference is sadly not really an option with rodio since the decoders must be 'static (see for instance the Sink::append trait bound on S).

If you think your file system is a bit slow, and you want to optimize this, then you might actually want to read the entire file up-front (which File::open doesn't do). Doing this should also provide you with a buffer (e.g. a Vec) that you can clone, and thus allows to repeatedly create fresh values that can be consumed by the Decoder. Here is an example doing this:

Try removing the last line in which the cursor location is changed and see if this is the cause for slow performance. If so, try executing this part after a small delay:

In general instead of using Texture2D.SetPixel on individual pixels rather use Texture2D.GetPixels and Texture2D.SetPixels on the entire image (or the section you changed).

This is already way more efficient!

Then using Texture2D.GetPixels32 and Texture2D.SetPixels32 which do use raw byte color format (0 to 255 instead of 0f to 1f) is even faster!

Seems to be a prime case for fancy indexing (advanced indexing).

Something like this should do the trick, though I didn't verify it on an actual image. I've added a section to reconstruct the image in the beginning, because it is easier to work with the array as a whole than broken into parts. Likely, you can refactor this and avoid splitting it to begin with.

I wanted to change the pitch of all audio

If you want to change the pitch of any song at runtime you can simply use the source of type AudioSource that is saved in the sound class and edit it's values directly.

If you then do this as a foreach loop, in your soundManager class, with each song in your array, you can pitch down all of them.

Change All Pitch Values: