ffpyplayer | A cython implementation of an ffmpeg based player | Media Player library

There may be quite a few reasons for this. First of all, I don't see anything wrong with the code so there must be a problem with the target system. I suggest that you check whether any access (to speaker) is blocked by antivirus software.......This has happened repeatedly with me in the past, checking the app permissions is probably the only solution.

So I wasn't able to pass the needed parameters to the ffmpeg player used by Kivy, so instead I converted the videos with ffmpeg before passing them to kivy... Not a perfect solution, but hey, it works !

It seems you can't control when to play audio because it uses SDL to play it in separated thread but get_frame() gives tuple (frame, val) and frame is (image, time_when_to_display_image) and you should use this time_when_to_display_image to control when to display image.

And all this code doesn't need cv2.VideoCapture() to get frame.

I use cv2 only to display it but you can use any GUI to create window to display it.

I use current_time to get next frame without using time.sleep() because video wasn't smooth.

BTW: You can use player.set_size(720, 480) to resize frame.

The error fixed by configuring C:\Users\\.kivy\config.ini:

According to the documentation, partial

“freezes” some portion of a function’s arguments

So that your print function in the partial is just printing the value of self.video1.loaded as it was when the partial function was called.

Here is a version of your posted code that prints the current version of loaded every half second:

The problem is that QPixmap.loadFromData() expects actual image "files", while what ffpyplayer (as in ffmpeg) provides are actually raw images, which is the actual representation (rasterization) of the images as they will eventually appear.

For various reasons, QPixmap cannot directly deal with raw data, as it's intended for showing images on screen, while QImages can, as they also are hardware independent.

QImage can load raw image data (meaning that, for example, if the image is compressed, the raw data is the actual representation of an uncompressed image), but it needs to know something about the "image format" and, obviously the image width/height.
When you use QPixmap.loadFromData() what actually happens is that Qt "guesses" the image file format, decompresses it (if necessary) to get data about "each pixel", gets both graphical size and pixel format, then it builds an internal QImage with all that information and finally returns it as QPixmap.

In this case, you already have all that data provided by ffpyplayer, so you just skip the first "decoding" passage entirely and create a QImage, and then get a QPixmap from it.

So ok I found a wayyyy better solution to this. I tried using again the vlc module, I had trouble using it before but after I got through it I actually found a way to print the output from vlc to a frame with a canvas.

It's actually stupidly simple, I got rid of cv2 and ffpyplayer and used a simple VLC player

Note that in my case Screen is a Frame, so to make this work just use 'Frame'.winfo_id() to get the id of the tk frame where to output the video, the audio works as well. Then just use player .set_hwnd(ID) to set it to the vlc player.

OpenCV on PyPI (where pip downloads from) provides only binary wheels that are compiled for cpython, not pypy. Unfortunately there is no source for binary wheels for PyPy at this time. You dont' really have any good options at this point in time (Feb 2019):

• Try compiling from source with CMake, the OpenCV source code, and PyPy, but I wouldn't expect it to work out of the box.
• Use this CFFI alternative which has not been updated in quite a while
• Use cpython to interact with OpenCV and somehow pass the result to PyPy via something like pymetabiosis but that project seems unsupported

Have you profiled your code and determined that python is slowing you down? From the packages you named, I would imagine the problem is that you are just trying to do too much in each frame, or that you are not using double buffering to read a frame while processing the previous one.