flac | Free Lossless Audio Codec | Compression library

FLAC__StreamMetadata is not a list of metadata, it's one metadata, and only one TYPE_VORBIS_COMMENT is filled.

https://github.com/xiph/flac/blob/27c615706cedd252a206dd77e3910dfa395dcc49/src/libFLAC/metadata_iterators.c#L217

I found code how to iterate over it, from https://isrc.iscas.ac.cn/gitlab/mirrors/github.com/musicplayerdaemon_mpd/-/blob/6419cc54ac200b217d99ee35d1e2d57dbfda3f55/src/decoder/flac_plugin.c :

alignof(__m128i) == 16. That cast happens before the __m128i* is passed as an argument to _mm_loadu_si128, which casts it again, not actually dereferencing the __m128i*.

As @chtz points out, you could maybe work around this for clang by casting instead to __m128i_u const *. GCC/clang define those types with __attribute__((may_alias,aligned(1),vector_size(16))), unlike the standard __m128i type which doesn't override the alignment-requirement. But I don't think MSVC defines a __m128i_u, so that wouldn't be portable.

You're right there is no actual problem, just an artifact of Intel's poor design for their intrinsics API where even the unaligned-load intrinsics take a pointer that wouldn't be safe to dereference on its own. (For AVX-512, the new intrinsics take void* instead, also avoiding the need for stupid casting, but they didn't retroactively change the old intrinsics to take void*.)

If clang's warning checker followed the chain of usages of that pointer value, it would see that it's not dereferenced. But it doesn't do that, instead it warns you on the spot about having created a pointer that might not be safe to deref. That's normally not something you want to do, but as I said you're forced to do it by Intel's clunky API.

Related: Is `reinterpret_cast`ing between hardware SIMD vector pointer and the corresponding type an undefined behavior? discusses the behaviour that compilers must define as part of supporting the intrinsics API, including creating misaligned pointers. It's ISO C UB to simple create a misaligned int * even without dereferencing, but obviously the intrinsics API requires you to create misaligned __m128i* pointers to use loadu / storeu. (And potentially misaligned float* to use _mm_loadu_ps on bytes that weren't a valid aligned float object, but the intrinsic doesn't deref the float*, instead it casts to __m128_u*)

You can use geom_boxplot() with stat = "identity" and fill in the five boxplot numbers as aesthetics.

The forfiles command is a nasty beast, because there are several caveats:

• it is slow (particularly because it cannot run internal commands of the hosting command prompt);
• it handles wildcards differently than most other commands, hence /M *.* does not match all files but only such with an extension; to really match all files, use /M * or skip it since it is the default anyway;
• it applies backslash-escaping, which is particularly annoying with paths ending in \, like the root directory of a drive /P "D:\", which causes a syntax error since the closing quotation mark is considered as escaped; to work around that, preferably append a . like /P "D:\.", or remove the quotation marks like /P D:\, though this exposes potential whitespaces or special characters to the parser;
• all of the special @-variables that return the path and/or name of iterated items provide the values in quoted manner, which is particularly frustrating when it comes to concatenation;
• it iterates over both files and directories that match the given mask; to distinguish between them you could use the special @isdir variable, but you will need an if statement for this (like if @isdir==FALSE or if @isdir==TRUE), which is an internal cmd.exe command, requiring its explicit instantiation even when you would not need it else;
• handling of the command behind /C and its arguments is terribly implemented, leading to the problem that directly running external commands (so without cmd /C) may fail, unless you are aware of the mostly working fix by stating the command name twice (like /C "command.exe command.exe --parameter argument");
• even its basically nice /D option (which is the only reason why forfiles might suit better than for) to filter for the relative last modification date (but not time) is badly implemented when a positive number (like /D +1) is used, because this uselessly points to the future;

All of these issues lead me to the point that I suggest not to use forfiles and to use a standard for loop instead, like this (note also the changed mask *.flac):

• In a batch-file:

Change to Python 3, dude.

As much as I wanted there to be an answer that stayed on Python 2.7, I tried Python 3 and it didn't disappoint. I did have to go back through the obscure steps I found to generate a file that will run a COM/DLL in Python, and I had to remove all the str.decode and encode calls throughout my script. After only one import change, I hit run and it ran as expected.

Indeed Jortega I've based my image on the selenium image : https://hub.docker.com/r/selenium/standalone-firefox

Here is my Dockerfile

MDN Says:

For example, for any MIME type whose main type is text, you can add the optional charset parameter to specify the character set used for the characters in the data. If no charset is specified, the default is ASCII (US-ASCII) unless overridden by the user agent's settings. To specify a UTF-8 text file, the MIME type text/plain;charset=UTF-8 is used.

So, for anything based on text/... you can optionally add the charset.

https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types#structure_of_a_mime_type

The following update to contentType() function demonstrates one solution.

As you can see in strace, the execve command executes as: execve("/bin//nc", ["/bin//nc", "/bin//nc-e //bin/bash -nvlp 4455"], NULL) = 0 It seems to be taking the whole /bin//nc-e //bin/bash -nvlp 4455 as a single argument and thus thinks it's a hostname. In order to get around that, the three argv[] needed for execve() is pushed seperately. argv[]=["/bin/nc", "-e/bin/bash", "-nvlp4455"] These arguments are each pushed into edx, ecx, and ebx. since ebx needs to be /bin/nc, which was already done in the original code. we just needed to push 2nd and 3rd argv[] into ecx and edx and push it into stack. After that we just copy the whole stack into ecx, and then xor edx,edx to set edx as NULL.

Here is the correct solution:

You'll need to write the file directly when BusBoy emits the file event.

It seems there is a race condition if you rely on BusBoy that prevents the file load from being completed. If you load it in the file event handler then it works fine.