vlc | VLC media player - All pull requests | Video Utils library

Keep track of the video playing in another while loop and reload before starting again.
Here's your code (adjusted as I don't have your kit)

From the official documentation of Register-ObjectEvent (notes section)

Events, event subscriptions, and the event queue exist only in the current session. If you close the current session, the event queue is discarded and the event subscription is canceled.

Everything above belong to your session, which is terminated when the process exit. Even if it was somewhere else, your .net FileSystemWatcher is part of that process and is terminated as soon your session exit.

Now, when you debug through VSCode / ISE, your session is created beforehand and does not terminate after you exit the script, which allow you to evaluate variable of the last execution. It also mean your subscriptions and event callbacks and the associated .net objects remain in memory and active at this time.

That being said, your debugger also detached at the moment your script exited. It also mean that if you were not debugging and just running the script, your session would exit immediately after the script execution and thus, your listener, events callback and everything else would immediately exit without a chance to process anything.

To keep the debugger attached, be able to debug and also to have the script working in a normal context at all, you need to somewhat keep the process alive.

The usual way to ensure that is to add a loop at the end of the script.

I have found this: https://www.olivieraubert.net/vlc/python-ctypes/doc/vlc.MediaPlayer-class.html#is_playing

Basically, there is a method for checking if the player is already playing (player.is_playing()). So you just have to preserve the reference to the vlc.MediaPlayer somewhere in the code and then check if it is playing before starting the player again.

I have found the solution. This is the new main loop:

There are several implementation issues:

• As far "output.mp4v" is not a valid mp4 file extension in the current context.
  Change the file name to "output.mp4"
• "MP4V" is case sensitive and suppposed to be "mp4v".
• As gerda commented, the frame size may not be 1920x1080.
• The else:, break at the end of the loop may break the loop after one frame.
• cv2.waitKey is not working without using cv2.imshow (without an open windows).
  The loop is not terminated when q is pressed.
  The code may never reach to out.release().

Based on the following post, I tried to create a portable code that waits for Esc key, without root privilege in Linux.
The solution I found (waiting for Esc) seem a bit complicated... You may try other solutions.

Code sample:

Try using pygame.mixer.init()

For example:

Vlc.DotNet is archived, and you're expected to use LibVLCSharp instead.

Recording "on-the-fly" is not yet possible with libvlc (and thus not with LibVLCSharp nor Vlc.DotNet). It is a feature that is only possible with VLC, but you can start a second stream and pass it the same recording options as the CLI.

Have a look at the "How do I?" section

To view the "seek bar", you have to implement it yourself, you have properties that give you the time, duration and position plus events that lets you know when Time/Position changed.

I think you're confused about Live Streaming and Video Chat, which are both very important but different video platforms and use scenarios, and their architecture is totally different.

I think TIKTOK is an mobile app with:

• Most of it is VoD file and social connections.
• Some part is Live Streaming, like twitch.tv or YouTube live streaming.
• Few of Video Chat ability, only when two user are talking in a RTC room.

For VoD, it's something like HTTP(S) files, deliver by CDN or Nginx if you want to build it.

About the Live Streaming and Video Chat, please read detail from here.

After some research, I stumbled onto this Apple documentation page (which wasn't found after my hours of google searching when I posted this question)

https://developer.apple.com/documentation/uikit/view_controllers/providing_access_to_directories

Navigate to the Save the URL as a Bookmark part of the article.

Utilizing a SwiftUI fileImporter gives one-time read/write access to the user-selected directory. To persist this read/write access, I had to make a bookmark and store it somewhere to access later.

Since I only needed one bookmark for the user's downloads directory, I saved it in UserDefaults (a bookmark is very small in terms of size).

When saving a bookmark, the app is added into the Files and folders in the user's settings, so the user can revoke file permissions for the app immediately (hence all the guard statements in my code snippet).

Here's the code snippet which I used and with testing, downloading does persist across app launches and multiple downloads.