ffpyplayer 4.5.2__cp313-cp313-win_amd64.whl

ffpyplayer/__init__.py

@@ -0,0 +1,53 @@
+'''
+FFPyPlayer library
+==================
+'''
+import sys
+import site
+import os
+from os.path import join
+import platform
+
+__all__ = ('dep_bins', )
+
+__version__ = '4.5.2'
+version = __version__
+
+# the ffmpeg src git version tested and upto date with,
+# and including this commit
+_ffmpeg_git = 'c926140558c60786dc577b121df6b3c6b430bd98'
+# excludes commits bdf9ed41fe4bdf4e254615b7333ab0feb1977e98,
+# 1be3d8a0cb77f8d34c1f39b47bf5328fe10c82d7,
+# f1907faab4023517af7d10d746b5684cccc5cfcc, and
+# 0995e1f1b31f6e937a1b527407ed3e850f138098 because they require ffmpeg 5.1/5.2
+# which is too new as of now
+
+# also skipped all show modes and subtitle display related functionality commits
+
+# TODO:
+# * Implement CONFIG_SDL to be able to compile without needing SDL at all.
+# * Currently, it only supports text subtitles - bitmap subtitles are ignored.
+#   Unless one uses a filter to overlay the subtitle.
+# * We can not yet visualize audio to video. Provide a filter chain link between
+#   audio to video filters to acomplish this.
+
+dep_bins = []
+'''A list of paths to the binaries used by the library. It can be used during
+packaging for including required binaries.
+
+It is read only.
+'''
+
+for d in [sys.prefix, site.USER_BASE]:
+    if d is None:
+        continue
+    for lib in ('ffmpeg', 'sdl'):
+        p = join(d, 'share', 'ffpyplayer', lib, 'bin')
+        if os.path.isdir(p):
+            os.environ["PATH"] = p + os.pathsep + os.environ["PATH"]
+            if hasattr(os, 'add_dll_directory'):
+                os.add_dll_directory(p)
+            dep_bins.append(p)
+
+if 'SDL_AUDIODRIVER' not in os.environ and platform.system() == 'Windows':
+    os.environ['SDL_AUDIODRIVER'] = 'DirectSound'

ffpyplayer/clib/misc.c

@@ -0,0 +1,186 @@
+
+#include "misc.h"
+
+#define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
+void print_all_libs_info(int flags, int level)
+{
+#if CONFIG_AVUTIL
+    PRINT_LIB_INFO(avutil,   AVUTIL,   flags, level);
+#endif
+#if CONFIG_AVCODEC
+    PRINT_LIB_INFO(avcodec,  AVCODEC,  flags, level);
+#endif
+#if CONFIG_AVFORMAT
+    PRINT_LIB_INFO(avformat, AVFORMAT, flags, level);
+#endif
+#if CONFIG_AVDEVICE
+    PRINT_LIB_INFO(avdevice, AVDEVICE, flags, level);
+#endif
+#if CONFIG_AVFILTER
+    PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
+#endif
+#if CONFIG_SWSCALE
+    PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);
+#endif
+#if CONFIG_SWRESAMPLE
+    PRINT_LIB_INFO(swresample,SWRESAMPLE,  flags, level);
+#endif
+#if CONFIG_POSTPROC
+    PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
+#endif
+}
+
+const AVOption *opt_find(const void * obj, const char *name, const char *unit,
+    int opt_flags, int search_flags)
+{
+    const AVOption *o = av_opt_find(obj, name, unit, opt_flags, search_flags);
+    if(o && !o->flags)
+        return NULL;
+    return o;
+}
+
+#define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
+int opt_default(const char *opt, const char *arg,
+    struct SwsContext *sws_opts, AVDictionary **sws_dict, AVDictionary **swr_opts,
+    AVDictionary **resample_opts, AVDictionary **format_opts, AVDictionary **codec_opts)
+{
+    const AVOption *o;
+    int consumed = 0;
+    char opt_stripped[128];
+    const char *p;
+    const AVClass *cc = avcodec_get_class();
+    const AVClass *fc = avformat_get_class();
+#if CONFIG_AVRESAMPLE
+    const AVClass *rc = avresample_get_class();
+#endif
+#if CONFIG_SWRESAMPLE
+    struct SwrContext *swr;
+#endif
+    const AVClass *sc;
+    const AVClass *swr_class;
+    int ret;
+#if CONFIG_SWSCALE
+    struct SwsContext *sws;
+#endif
+
+
+    if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug"))
+        av_log_set_level(AV_LOG_DEBUG);
+
+    if (!(p = strchr(opt, ':')))
+        p = opt + strlen(opt);
+    av_strlcpy(opt_stripped, opt, FFMIN(sizeof(opt_stripped), p - opt + 1));
+
+    if ((o = opt_find(&cc, opt_stripped, NULL, 0,
+                         AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
+        ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
+         (o = opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) {
+        av_dict_set(codec_opts, opt, arg, FLAGS);
+        consumed = 1;
+    }
+    if ((o = opt_find(&fc, opt, NULL, 0,
+                         AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
+        av_dict_set(format_opts, opt, arg, FLAGS);
+        if (consumed)
+            av_log(NULL, AV_LOG_VERBOSE, "Routing option %s to both codec and muxer layer\n", opt);
+        consumed = 1;
+    }
+#if CONFIG_SWSCALE
+    sc = sws_get_class();
+    if (sws_dict && !consumed && (o = opt_find(&sc, opt, NULL, 0,
+                         AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
+        sws = sws_alloc_context();
+        ret = av_opt_set(sws, opt, arg, 0);
+        sws_freeContext(sws);
+        if (ret < 0) {
+            av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
+            return ret;
+        }
+        if (sws_opts){
+            ret = av_opt_set(sws_opts, opt, arg, 0);
+            if (ret < 0) {
+                av_log(NULL, AV_LOG_ERROR, "Error setting option %s for sws_opts.\n", opt);
+                return ret;
+            }
+        }
+
+        av_dict_set(sws_dict, opt, arg, FLAGS);
+
+        consumed = 1;
+    }
+#else
+    if (!consumed && !strcmp(opt, "sws_flags")) {
+        av_log(NULL, AV_LOG_WARNING, "Ignoring %s %s, due to disabled swscale\n", opt, arg);
+        consumed = 1;
+    }
+#endif
+#if CONFIG_SWRESAMPLE
+    swr_class = swr_get_class();
+    if (swr_opts && !consumed && (o=opt_find(&swr_class, opt, NULL, 0,
+                                    AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
+        swr = swr_alloc();
+        ret = av_opt_set(swr, opt, arg, 0);
+        swr_free(&swr);
+        if (ret < 0) {
+            av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
+            return ret;
+        }
+        av_dict_set(swr_opts, opt, arg, FLAGS);
+        consumed = 1;
+    }
+#endif
+#if CONFIG_AVRESAMPLE
+    if (resample_opts && (o=opt_find(&rc, opt, NULL, 0,
+                       AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
+        av_dict_set(resample_opts, opt, arg, FLAGS);
+        consumed = 1;
+    }
+#endif
+
+    if (consumed)
+        return 0;
+    return AVERROR_OPTION_NOT_FOUND;
+}
+
+int get_plane_sizes(int size[4], int required_plane[4], enum AVPixelFormat pix_fmt,
+    int height, const int linesizes[4])
+{
+    int i, total_size;
+    memset(required_plane, 0, sizeof(required_plane[0])*4);
+
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+    memset(size, 0, sizeof(size[0])*4);
+
+    if (!height)
+        return AVERROR(EINVAL);
+
+    if (!desc || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
+        return AVERROR(EINVAL);
+
+    if (linesizes[0] > (INT_MAX - 1024) / height)
+        return AVERROR(EINVAL);
+    size[0] = linesizes[0] * height;
+
+    if (desc->flags & AV_PIX_FMT_FLAG_PAL) {
+        size[1] = 256 * 4;
+        required_plane[0] = 1;
+        return size[0] + size[1];
+    }
+
+    for (i = 0; i < 4; i++)
+        required_plane[desc->comp[i].plane] = 1;
+
+    total_size = size[0];
+    for (i = 1; i < 4 && required_plane[i]; i++) {
+        int h, s = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
+        h = (height + (1 << s) - 1) >> s;
+        if (linesizes[i] > INT_MAX / h)
+            return AVERROR(EINVAL);
+        size[i] = h * linesizes[i];
+        if (total_size > INT_MAX - size[i])
+            return AVERROR(EINVAL);
+        total_size += size[i];
+    }
+
+    return total_size;
+}

ffpyplayer/clib/misc.h

@@ -0,0 +1,62 @@
+
+#ifndef _FFINFO_H
+#define _FFINFO_H
+
+#include "../includes/ffconfig.h"
+#include "libavcodec/avcodec.h"
+#include "libavfilter/avfilter.h"
+#include "libavformat/avformat.h"
+#include "libavdevice/avdevice.h"
+#include "libswscale/swscale.h"
+#include "libswresample/swresample.h"
+#include "libavutil/opt.h"
+#include "libavutil/avstring.h"
+#include "libavutil/pixdesc.h"
+
+
+#if CONFIG_POSTPROC
+#include "libpostproc/postprocess.h"
+#endif
+
+#ifndef AV_LOG_TRACE
+#define AV_LOG_TRACE    56
+#endif
+
+
+#define INDENT        1
+#define SHOW_VERSION  2
+#define SHOW_CONFIG   4
+
+#define PRINT_LIB_INFO(libname, LIBNAME, flags, level)                  \
+    if (CONFIG_##LIBNAME) {                                             \
+        const char *indent = flags & INDENT? "  " : "";                 \
+        if (flags & SHOW_VERSION) {                                     \
+            unsigned int version = libname##_version();                 \
+            av_log(NULL, level,                                         \
+                   "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",            \
+                   indent, #libname,                                    \
+                   LIB##LIBNAME##_VERSION_MAJOR,                        \
+                   LIB##LIBNAME##_VERSION_MINOR,                        \
+                   LIB##LIBNAME##_VERSION_MICRO,                        \
+                   version >> 16, version >> 8 & 0xff, version & 0xff); \
+        }                                                               \
+        if (flags & SHOW_CONFIG) {                                      \
+            const char *cfg = libname##_configuration();                \
+            av_log(NULL, level, "%s%-11s configuration: %s\n",   	   	\
+                    indent, #libname, cfg);                         	\
+        }                                                               \
+    }
+
+void print_all_libs_info(int flags, int level);
+
+const AVOption *opt_find(const void * obj, const char *name, const char *unit,
+                            int opt_flags, int search_flags);
+
+int opt_default(const char *opt, const char *arg,
+    struct SwsContext *sws_opts, AVDictionary **sws_dict, AVDictionary **swr_opts,
+    AVDictionary **resample_opts, AVDictionary **format_opts, AVDictionary **codec_opts);
+
+int get_plane_sizes(int size[4], int required_plane[4], enum AVPixelFormat pix_fmt,
+    int height, const int linesizes[4]);
+
+#endif

ffpyplayer/includes/ff_consts.pxi

@@ -0,0 +1,51 @@
+include "ffconfig.pxi"
+
+
+''' Minimum SDL audio buffer size, in samples.. '''
+DEF SDL_AUDIO_MIN_BUFFER_SIZE = 512
+DEF AUDIO_MIN_BUFFER_SIZE = SDL_AUDIO_MIN_BUFFER_SIZE
+' Calculate actual buffer size keeping in mind not cause too frequent audio callbacks. '
+DEF AUDIO_MAX_CALLBACKS_PER_SEC = 30
+
+DEF MAX_QUEUE_SIZE = (15 * 1024 * 1024)
+DEF MIN_FRAMES = 25
+DEF EXTERNAL_CLOCK_MIN_FRAMES = 2
+DEF EXTERNAL_CLOCK_MAX_FRAMES = 10
+
+'no AV sync correction is done if below the minimum AV sync threshold '
+DEF AV_SYNC_THRESHOLD_MIN = 0.04
+'AV sync correction is done if above the maximum AV sync threshold '
+DEF AV_SYNC_THRESHOLD_MAX = 0.1
+'If a frame duration is longer than this, it will not be duplicated to compensate AV sync'
+DEF AV_SYNC_FRAMEDUP_THRESHOLD = 0.1
+'no AV correction is done if too big error'
+DEF AV_NOSYNC_THRESHOLD = 10.0
+
+'maximum audio speed change to get correct sync'
+DEF SAMPLE_CORRECTION_PERCENT_MAX = 10
+
+'external clock speed adjustment constants for realtime sources based on buffer fullness'
+DEF EXTERNAL_CLOCK_SPEED_MIN = 0.900
+DEF EXTERNAL_CLOCK_SPEED_MAX = 1.010
+DEF EXTERNAL_CLOCK_SPEED_STEP = 0.001
+
+'we use about AUDIO_DIFF_AVG_NB A-V differences to make the average'
+DEF AUDIO_DIFF_AVG_NB = 20
+
+'polls for possible required screen refresh at least this often, should be less than 1/fps'
+DEF REFRESH_RATE = 0.0167
+
+'''NOTE: the size must be big enough to compensate the hardware audio buffersize size
+TODO: We assume that a decoded and resampled frame fits into this buffer'''
+DEF SAMPLE_ARRAY_SIZE = (8 * 65536)
+
+DEF VIDEO_PICTURE_QUEUE_SIZE = 3
+DEF SUBPICTURE_QUEUE_SIZE = 16
+DEF SAMPLE_QUEUE_SIZE = 9
+DEF FRAME_QUEUE_SIZE = max(SAMPLE_QUEUE_SIZE, max(VIDEO_PICTURE_QUEUE_SIZE, SUBPICTURE_QUEUE_SIZE))
+
+
+DEF FF_LOCK_CREATE = 0
+DEF FF_LOCK_OBTAIN = 1
+DEF FF_LOCK_RELEASE = 2
+DEF FF_LOCK_DESTROY = 3

ffpyplayer/includes/ffconfig.h

@@ -0,0 +1,40 @@
+
+#ifndef _FFCONFIG_H
+#define _FFCONFIG_H
+
+#include "SDL_version.h"
+#define SDL_VERSIONNUM(X, Y, Z) ((X)*1000 + (Y)*100 + (Z))
+#define SDL_VERSION_ATLEAST(X, Y, Z) (SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z))
+#if defined(__APPLE__) && SDL_VERSION_ATLEAST(1, 2, 14)
+#define MAC_REALLOC 1
+#else
+#define MAC_REALLOC 0
+#endif
+
+#if !defined(_WIN32) && !defined(__APPLE__)
+#define NOT_WIN_MAC 1
+#else
+#define NOT_WIN_MAC 0
+#endif
+
+#if defined(_WIN32)
+#define WIN_IS_DEFINED 1
+#else
+#define WIN_IS_DEFINED 0
+#endif
+
+#define CONFIG_AVFILTER 1
+#define CONFIG_AVDEVICE 1
+#define CONFIG_SWSCALE 1
+#define CONFIG_RTSP_DEMUXER 1
+#define CONFIG_MMSH_PROTOCOL 1
+#define CONFIG_POSTPROC 0
+#define CONFIG_SDL 1
+#define HAS_SDL2 1
+#define USE_SDL2_MIXER 1
+#define CONFIG_AVUTIL 1
+#define CONFIG_AVCODEC 1
+#define CONFIG_AVFORMAT 1
+#define CONFIG_SWRESAMPLE 1
+
+#endif

ffpyplayer/includes/ffconfig.pxi

@@ -0,0 +1,13 @@
+DEF CONFIG_AVFILTER = 1
+DEF CONFIG_AVDEVICE = 1
+DEF CONFIG_SWSCALE = 1
+DEF CONFIG_RTSP_DEMUXER = 1
+DEF CONFIG_MMSH_PROTOCOL = 1
+DEF CONFIG_POSTPROC = 0
+DEF CONFIG_SDL = 1
+DEF HAS_SDL2 = 1
+DEF USE_SDL2_MIXER = 1
+DEF CONFIG_AVUTIL = 1
+DEF CONFIG_AVCODEC = 1
+DEF CONFIG_AVFORMAT = 1
+DEF CONFIG_SWRESAMPLE = 1