stitches | HTML5 Sprite Sheet Generator | Generator Utils library

There are many ways in which you could design a solution for that. They will vary depending on how often you get your videos, should it be scalable, fault tolerant, how many videos do you want to process in parallel and more. I will just provide one, on the assumption that the new videos are uploaded occasionally and no auto-scaling groups are needed for processing large number of videos at the same time.

On the above assumption, one way could be as follows:

1. Upload of a new video triggers a lambda function using S3 event notifications.
2. Lambda gets the video details (e.g. s3 path) from the S3 event, submits the video details to a SQS queue and starts your instance.
3. Your application on the instance, once started, pulls the SQS queue for details of the video file to process. This would require your application to be designed in a way that its starts a instance start, which can be done using modified user data, systemd unit files and more.

Its a very basic solution, and as I mentioned many other ways are possible, involving auto-scaling group, scaling policies based on sqs size, ssm run commands, and more.

As suggested by Thomas Lin Pedersen in the github issue you're linking, the solution would be to use the png(..., type = 'cairo') device on Windows machines. If you read the documentation at ?av::av_capture_graphics(), you'll see that the ... argument can be used to pass arguments to the png() function. Hence, I propose to do exactly that:

Try the following

The issue here was not the TensorFlow Serving setup or the Python code, but the way the networking between the two parts was configured. The TensorFlow Serving instances were orchestrated by Kubernetes, and then stitched together using a Kubernetes service. It was that service that the Python code called, and the poor configuration that was causing the timeout.

This post on the Kubernetes blog explains the details. In a nutshell, because gRPC depends on HTTP/2, it runs into some problems with the standard Kubernetes services due to the multiplexing that is otherwise one of the advantageous features of gRPC.

The solution, also in the same blog post, is to set up a more sophisticated network object to mediate connections to the TensorFlow Serving instances.

Here is an example that does what I think you want:

Your date you are trying to parse is not in the right format. The required format you give is yyyy-MM-dd'T'HH:mm:ssX.

This format expects a number for the timezone - even if the number is a zero ('0').

One workaround for this is to create a second SimpleDateFormat that uses a fallback format treating the 'Z' character as a literal and ignoring it. If your first attempt at parsing fails, catch the exception and try parsing with this format - yyyy-MM-dd'T'HH:mm:ss'Z'.

You will also need to override the timezone to force UTC.

Something like:

You don't have any gap in between your waveforms. You can see from this view of the result from Reaper that you have continuous sound:

What you have is a discontinuity in your waveform each time you start up a new note. This will be heard as clicks or pops each time the note changes. Since the waveforms for each note are being calculated against the underlying data structure, they will all have a zero crossing at 0s, and then quickly get out a phase with each other from there.

To fix this you could try either a proper gradual fade in/out of each sound, or make sure you are tracking the phase of your waveform and keeping it consistent as the notes change.

For a falloff function, you want something along the lines of (frames - each_sample_number) / frames)**n so that it will reach zero by the end. You can play around with this function to see how it affects the duration of the sound and the perceived clipping between notes.

Using arrays to store strings is dangerous because if you allocate 20 characters to store the label and the label happens to be 20 characters long, then there is no room to store a NUL (0) terminating character. Once the bytes are stored in the array there's nothing to tell functions that are expecting null-terminated strings (like cout) where the end of the string is.

Your label has 20 chars. That's enough to store the first 20 letters of the alphabet: ABCDEFGHIJKLMNOPQRST

But this is not a null-terminated string. This is just an array of characters. In fact, in memory, the byte right after the T will be the first byte of the next field, which happens to be your 11-character st array. Let's say those 11 characters are: abcdefghijk.

Now the bytes in memory look like this: ABCDEFGHIJKLMNOPQRSTabcdefghijk

There's no way to tell where label ends and st begins. When you pass a pointer to the first byte of the array that is intended to be interpreted as a null-terminated string by convention, the implementation will happily start scanning until it finds a null terminating character (0). Which, on subsequent reuses of the structure, it may not! There's a serious risk of overrunning the buffer (reading past the end of the buffer), and potentially even the end of your virtual memory block, ultimately causing an access violation / segmentation fault.

When your program first ran, the memory of the header structure was all zeros (because you initialized with {}) and so after reading the label field from disk, the bytes after the T were already zero, so your first cout worked correctly. There happened to be a terminating null character at st[0]. You then overwrite this when you read the st field from disk. When you come back to output label again, the terminator is gone, and some characters of st will get interpreted as belonging to the string.

To fix the problem you probably want to use a different, more practical data structure to store your strings that allows for convenient string functions. And use your raw header structure just to represent the file format.

You can still read the data from disk into memory using fixed sized buffers, this is just for staging purposes (to get it into memory) but then store the data into a different structure that uses std::string variables for convenience and later use by your program.

For this you'll want these two structures: