pylibvpx 1.0__tar.gz

pylibvpx-1.0/.cmake-format.yaml

@@ -0,0 +1,10 @@
+additional_commands:
+bullet_char: '*'
+dangle_parens: false
+enum_char: .
+line_ending: unix
+line_width: 120
+max_pargs_hwrap: 3
+separate_ctrl_name_with_space: false
+separate_fn_name_with_space: false
+tab_size: 2

pylibvpx-1.0/CMakeLists.txt

@@ -0,0 +1,70 @@
+cmake_minimum_required(VERSION 3.16)
+project(pylibvpx LANGUAGES CXX VERSION "1.0")
+
+# Default to Release build type
+if (NOT CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "")
+  set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" FORCE)
+endif()
+
+# Fetch conan.cmake
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_BINARY_DIR})
+list(APPEND CMAKE_PREFIX_PATH ${CMAKE_BINARY_DIR})
+if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
+  message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
+  file(DOWNLOAD "https://raw.githubusercontent.com/conan-io/cmake-conan/0.18.1/conan.cmake"
+       "${CMAKE_BINARY_DIR}/conan.cmake" TLS_VERIFY ON)
+endif()
+include(${CMAKE_BINARY_DIR}/conan.cmake)
+
+# Get pybind11 and libvpx from conan
+conan_cmake_configure(
+  REQUIRES pybind11/2.10.4 libvpx/1.11.0
+  GENERATORS cmake_find_package
+)
+conan_cmake_autodetect(settings)
+if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+  # MSVC 2022 can't build libvpx -> donwload binary for MSVC 2019
+  list(APPEND settings "libvpx:compiler.version=16")
+endif()
+conan_cmake_install(
+  PATH_OR_REFERENCE .
+  BUILD missing
+  REMOTE conancenter
+  SETTINGS ${settings}
+)
+
+# Create libvpx python library
+find_package(pybind11 REQUIRED)
+find_package(libvpx REQUIRED)
+pybind11_add_module(${PROJECT_NAME} "pylibvpx.cpp" "vpxcommon.hpp" "vpxcommon_impl.hpp")
+  set_target_properties(${PROJECT_NAME} PROPERTIES
+  CXX_STANDARD 20
+  CXX_STANDARD_REQUIRED ON
+)
+target_link_libraries(${PROJECT_NAME} PRIVATE libvpx::libvpx)
+target_compile_definitions(${PROJECT_NAME} PRIVATE
+  MODULE_NAME=${PROJECT_NAME}
+  MODULE_VERSION=${PROJECT_VERSION}
+)
+
+option(WITH_VPX_ENCODER "With vpx encoder" ON)
+if(WITH_VPX_ENCODER)
+  message(STATUS "With VPX encoder")
+  target_sources(${PROJECT_NAME} PRIVATE "vpxencoder.hpp" "vpxencoder.cpp")
+  target_compile_definitions(${PROJECT_NAME} PRIVATE WITH_VPX_ENCODER=1)
+endif()
+
+option(WITH_VPX_DECODER "With vpx decoder" ON)
+if(WITH_VPX_DECODER)
+  message(STATUS "With VPX decoder")
+  target_sources(${PROJECT_NAME} PRIVATE "vpxdecoder.hpp" "vpxdecoder.cpp")
+  target_compile_definitions(${PROJECT_NAME} PRIVATE WITH_VPX_DECODER=1)
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+  target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Wextra -Wpedantic)
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+  target_compile_options(${PROJECT_NAME} PUBLIC "/Zc:__cplusplus")
+endif()
+
+install(TARGETS ${PROJECT_NAME} DESTINATION ".")

pylibvpx-1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Peter Würtz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pylibvpx-1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: pylibvpx
+Version: 1.0
+Summary: Python bindings for libvpx
+Home-page: https://github.com/pwuertz/libvpx-bindings
+Author: Peter Würtz
+Author-email: pwuertz@gmail.com
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Python `libvpx` bindings
+Python bindings for VPX encoding/decoding library

pylibvpx-1.0/README.md

@@ -0,0 +1,2 @@
+# Python `libvpx` bindings
+Python bindings for VPX encoding/decoding library

pylibvpx-1.0/pylibvpx.cpp

@@ -0,0 +1,97 @@
+#include <Python.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/pytypes.h>
+#include <pybind11/numpy.h>
+#include "vpxcommon.hpp"
+#ifdef WITH_VPX_ENCODER
+#include "vpxencoder.hpp"
+#endif
+#ifdef WITH_VPX_DECODER
+#include "vpxdecoder.hpp"
+#endif
+
+#include <string_view>
+#include <iostream>
+
+namespace py = pybind11;
+
+constexpr std::string_view VERSION_STR = PYBIND11_TOSTRING(MODULE_VERSION);
+
+#ifdef WITH_VPX_ENCODER
+void py_vpxe_encode(Vpx::Encoder& encoder, const py::object& fn)
+{
+    const auto packetHandler = [&](const uint8_t* packet, const size_t size) {
+        fn(py::memoryview::from_memory(packet, size));
+    };
+    encoder.encode(packetHandler);
+}
+py::array_t<uint8_t, py::array::c_style> py_vpxe_yplane(Vpx::Encoder& encoder)
+{
+    const Vpx::Plane plane = encoder.yPlane();
+    return py::array_t<uint8_t, py::array::c_style>(
+        std::vector<Py_ssize_t>{plane.height, plane.width},
+        std::vector<Py_ssize_t>{plane.stride, 1},
+        plane.data
+    );
+}
+void py_vpxe_copygray(Vpx::Encoder& encoder, const py::array& image)
+{
+    const auto* imageData = static_cast<const uint8_t*>(image.data());
+    encoder.copyFromGray(imageData);
+}
+#endif
+
+#ifdef WITH_VPX_DECODER
+void py_vpxd_decode(Vpx::Decoder& decoder, const py::bytes& packet, const py::object& fn)
+{
+    uint8_t* data; Py_ssize_t size;
+    PyBytes_AsStringAndSize(packet.ptr(), reinterpret_cast<char**>(&data), &size);
+    const auto frameHandler = [&](const Vpx::Plane& plane) {
+        py::array_t<uint8_t, py::array::c_style> img(
+            std::vector<Py_ssize_t>{plane.height, plane.width},
+            std::vector<Py_ssize_t>{plane.stride, 1},
+            plane.data
+        );
+        fn(img);
+    };
+    decoder.decode(data, static_cast<size_t>(size), frameHandler);
+}
+#endif
+
+
+PYBIND11_MODULE(MODULE_NAME, m) {
+    m.attr("__version__") = py::str(VERSION_STR.data(), VERSION_STR.size());
+
+    py::enum_<Vpx::Gen>(m, "VpxGen")
+    .value("Vp8", Vpx::Gen::Vp8)
+    .value("Vp9", Vpx::Gen::Vp9);
+
+#ifdef WITH_VPX_ENCODER
+    py::class_<Vpx::Encoder> vpxencCls(m, "VpxEncoder");
+    vpxencCls.def(py::init<const Vpx::Encoder::Config&>())
+    .def(py::init([](const unsigned int width, const unsigned int height) {
+        return new Vpx::Encoder({.width = width, .height = height});
+    }))
+    .def("encode", py_vpxe_encode)
+    .def("yPlane", py_vpxe_yplane)
+    .def("copyGray", py_vpxe_copygray);
+
+    py::class_<Vpx::Encoder::Config>(vpxencCls, "Config")
+    .def(py::init([](const unsigned int width, const unsigned int height) {
+        return new Vpx::Encoder::Config { .width=width, .height=height };
+    }))
+    .def_readwrite("width", &Vpx::Encoder::Config::width)
+    .def_readwrite("height", &Vpx::Encoder::Config::height)
+    .def_readwrite("fps", &Vpx::Encoder::Config::fps)
+    .def_readwrite("bitrate", &Vpx::Encoder::Config::bitrate)
+    .def_readwrite("threads", &Vpx::Encoder::Config::threads)
+    .def_readwrite("cpu_used", &Vpx::Encoder::Config::cpu_used)
+    .def_readwrite("gen", &Vpx::Encoder::Config::gen);
+#endif
+
+#ifdef WITH_VPX_DECODER
+    py::class_<Vpx::Decoder> vpxdecCls(m, "VpxDecoder");
+    vpxdecCls.def(py::init<Vpx::Gen>())
+    .def("decode", py_vpxd_decode);
+#endif
+}

pylibvpx-1.0/pylibvpx.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: pylibvpx
+Version: 1.0
+Summary: Python bindings for libvpx
+Home-page: https://github.com/pwuertz/libvpx-bindings
+Author: Peter Würtz
+Author-email: pwuertz@gmail.com
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Python `libvpx` bindings
+Python bindings for VPX encoding/decoding library

pylibvpx-1.0/pylibvpx.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+.cmake-format.yaml
+CMakeLists.txt
+LICENSE
+README.md
+pylibvpx.cpp
+pyproject.toml
+setup.py
+vpxcommon.hpp
+vpxcommon_impl.hpp
+vpxdecoder.cpp
+vpxdecoder.hpp
+vpxencoder.cpp
+vpxencoder.hpp
+pylibvpx.egg-info/PKG-INFO
+pylibvpx.egg-info/SOURCES.txt
+pylibvpx.egg-info/dependency_links.txt
+pylibvpx.egg-info/top_level.txt

pylibvpx-1.0/pylibvpx.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pylibvpx-1.0/pylibvpx.egg-info/top_level.txt

@@ -0,0 +1 @@
+pylibvpx

pylibvpx-1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=56.0", "cmake_build_extension", "wheel", "conan~=1.50"]
+build-backend = "setuptools.build_meta"

pylibvpx-1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pylibvpx-1.0/setup.py

@@ -0,0 +1,24 @@
+import pathlib
+from setuptools import setup
+from cmake_build_extension import BuildExtension, CMakeExtension
+
+this_directory = pathlib.Path(__file__).parent
+long_description = (this_directory / "README.md").read_text()
+long_description_content_type="text/markdown"
+
+setup(
+    name="pylibvpx",
+    version="1.0",
+    author="Peter Würtz",
+    author_email="pwuertz@gmail.com",
+    url="https://github.com/pwuertz/libvpx-bindings",
+    description="Python bindings for libvpx",
+    long_description=long_description,
+    long_description_content_type=long_description_content_type,
+    ext_modules=[CMakeExtension(
+        name="pylibvpx",
+        source_dir=".",
+        install_prefix=".",
+    )],
+    cmdclass=dict(build_ext=BuildExtension),
+)

pylibvpx-1.0/vpxcommon.hpp

@@ -0,0 +1,18 @@
+#pragma once
+#include <cstdint>
+
+namespace Vpx {
+
+enum class Gen {
+    Vp8,
+    Vp9,
+};
+
+struct Plane {
+    uint8_t* data;
+    const unsigned int height;
+    const unsigned int width;
+    const int stride;
+};
+
+}  // namespace Vpx

pylibvpx-1.0/vpxcommon_impl.hpp

@@ -0,0 +1,57 @@
+#pragma once
+#include <algorithm>
+#include <stdexcept>
+#include <vpx/vpx_image.h>
+#include "vpxcommon.hpp"
+
+namespace Vpx {
+
+struct Image
+{
+    Image(const unsigned int width, const unsigned int height)
+    {
+        if (vpx_img_alloc(&m_img, VPX_IMG_FMT_I420, width, height, 1) == nullptr) {
+            throw std::runtime_error("Failed to allocate image");
+        }
+        fillBlack();
+    }
+
+    Image(const Image&) = delete;
+    void operator=(const Image&) = delete;
+
+    ~Image() noexcept { vpx_img_free(&m_img); }
+
+    constexpr operator vpx_image_t*() noexcept { return &m_img; }
+    constexpr operator const vpx_image_t*() const noexcept { return &m_img; }
+
+    void fillBlack() noexcept
+    {
+        std::fill_n(m_img.planes[VPX_PLANE_Y], m_img.w * m_img.h, 0);
+        std::fill_n(m_img.planes[VPX_PLANE_U], m_img.w * m_img.h / 4, 128);
+        std::fill_n(m_img.planes[VPX_PLANE_V], m_img.w * m_img.h / 4, 128);
+    }
+
+    constexpr Plane yPlane() const noexcept
+    {
+        return {
+            .data = m_img.planes[VPX_PLANE_Y],
+            .height = m_img.d_h, .width = m_img.d_w,
+            .stride = m_img.stride[0]
+        };
+    }
+
+    void copyFromGrayscale(const uint8_t* src)
+    {
+        const auto yPlane = this->yPlane();
+        for (unsigned int row = 0; row < yPlane.height; ++row) {
+            const auto* srcRow = src + row * yPlane.width;
+            auto* dstRow = yPlane.data + row * yPlane.stride;
+            std::copy_n(srcRow, yPlane.width, dstRow);
+        }
+    }
+
+private:
+    vpx_image_t m_img;
+};
+
+}  // namespace Vpx

pylibvpx-1.0/vpxdecoder.cpp

@@ -0,0 +1,75 @@
+#include "vpxdecoder.hpp"
+#include "vpxcommon_impl.hpp"
+#include <algorithm>
+#include <stdexcept>
+#include <vpx/vpx_decoder.h>
+#include <vpx/vp8dx.h>
+
+using namespace Vpx;
+
+namespace {
+
+constexpr vpx_codec_iface_t* decoder_vp8 = &vpx_codec_vp8_dx_algo;
+constexpr vpx_codec_iface_t* decoder_vp9 = &vpx_codec_vp9_dx_algo;
+
+struct DecCtx
+{
+    DecCtx(const Gen gen)
+    {
+        // Create decoder context
+        const auto* decoder_iface = (gen == Gen::Vp8) ? decoder_vp8 : decoder_vp9;
+        if (vpx_codec_dec_init(&m_ctx, decoder_iface, nullptr, 0) != VPX_CODEC_OK) {
+            throw std::runtime_error("Failed to create decoding context");
+        }
+    }
+
+    DecCtx(const DecCtx&) = delete;
+    void operator=(const DecCtx&) = delete;
+
+    ~DecCtx() noexcept { vpx_codec_destroy(&m_ctx); }
+
+    constexpr operator vpx_codec_ctx_t*() noexcept { return &m_ctx; }
+    constexpr operator const vpx_codec_ctx_t*() const noexcept { return &m_ctx; }
+
+private:
+    vpx_codec_ctx_t m_ctx;
+};
+
+}  // private namespace
+
+
+struct Decoder::Ctx {
+    Ctx(const Gen gen) : m_ctx(gen) { }
+
+    template<typename Fn> void decode(const uint8_t* data, const size_t size, Fn&& fn)
+    {
+        constexpr auto VPX_DL_REALTIME = 1;
+        if (vpx_codec_decode(m_ctx, data, size, nullptr, VPX_DL_REALTIME) != VPX_CODEC_OK) {
+            throw std::runtime_error("Failed to decode packet");
+        }
+
+        vpx_codec_iter_t iter = nullptr;
+        vpx_image* img = nullptr;
+        while ((img = vpx_codec_get_frame(m_ctx, &iter)) != nullptr) {
+            fn(Plane {
+                .data = img->planes[VPX_PLANE_Y],
+                .height = img->d_h, .width = img->d_w,
+                .stride = img->stride[0]
+            });
+        }
+    }
+
+private:
+    DecCtx m_ctx;
+};
+
+Decoder::Decoder(const Gen gen)
+    : ctx(std::make_unique<Ctx>(gen))
+{ }
+
+Decoder::~Decoder() = default;
+
+void Decoder::decode(const uint8_t* packet, size_t size, const frame_handler_t& fn)
+{
+    ctx->decode(packet, size, fn);
+}

pylibvpx-1.0/vpxdecoder.hpp

@@ -0,0 +1,25 @@
+#pragma once
+#include <memory>
+#include <cstdint>
+#include <functional>
+#include "vpxcommon.hpp"
+
+namespace Vpx {
+
+struct Decoder
+{
+private:
+    struct Ctx;
+
+public:
+    Decoder(Gen gen = Gen::Vp8);
+    ~Decoder();
+
+    using frame_handler_t = std::function<void(const Plane&)>;
+    void decode(const uint8_t* packet, size_t size, const frame_handler_t& fn);
+
+private:
+    std::unique_ptr<Ctx> ctx;
+};
+
+}  // namespace Vpx

pylibvpx-1.0/vpxencoder.cpp

@@ -0,0 +1,116 @@
+#include "vpxencoder.hpp"
+#include "vpxcommon_impl.hpp"
+#include <algorithm>
+#include <vpx/vpx_encoder.h>
+#include <vpx/vp8cx.h>
+#include <iostream>
+
+using namespace Vpx;
+
+namespace {
+
+constexpr vpx_codec_iface_t* encoder_vp8 = &vpx_codec_vp8_cx_algo;
+constexpr vpx_codec_iface_t* encoder_vp9 = &vpx_codec_vp9_cx_algo;
+
+struct EncCtx
+{
+    EncCtx(const Encoder::Config& config)
+    {
+        // Encoder config from defaults + provided settings
+        vpx_codec_enc_cfg_t cfg;
+        const auto* encoder_iface = (config.gen == Gen::Vp8) ? encoder_vp8 : encoder_vp9;
+        if (vpx_codec_enc_config_default(encoder_iface, &cfg, 0) != VPX_CODEC_OK) {
+            throw std::runtime_error("Failed to get default codec config");
+        }
+        cfg.g_w = config.width;
+        cfg.g_h = config.height;
+        cfg.g_timebase.num = 1;
+        cfg.g_timebase.den = config.fps;
+        cfg.rc_target_bitrate = config.bitrate;
+        cfg.g_error_resilient = 0;
+        cfg.g_threads = config.threads;
+        // Create encoder context
+        constexpr auto use_flags = 0;
+        if (vpx_codec_enc_init(&m_ctx, encoder_iface, &cfg, use_flags) != VPX_CODEC_OK) {
+            throw std::runtime_error("Failed to create encoding context");
+        }
+        // Set codec parameters (destroy ctx on fail)
+        try {
+            if (vpx_codec_control(&m_ctx, VP8E_SET_CPUUSED, config.cpu_used) != VPX_CODEC_OK) {
+                throw std::runtime_error("Failed to set CPUUSED parameter");
+            }
+        }
+        catch(...) {
+            vpx_codec_destroy(&m_ctx);
+            throw;
+        }
+    }
+
+    EncCtx(const EncCtx&) = delete;
+    void operator=(const EncCtx&) = delete;
+
+    ~EncCtx() noexcept { vpx_codec_destroy(&m_ctx); }
+
+    constexpr operator vpx_codec_ctx_t*() noexcept { return &m_ctx; }
+    constexpr operator const vpx_codec_ctx_t*() const noexcept { return &m_ctx; }
+
+private:
+    vpx_codec_ctx_t m_ctx;
+};
+
+}  // private namespace
+
+
+struct Encoder::Ctx {
+    Ctx(const Encoder::Config& config)
+        : m_img(config.width, config.height)
+        , m_ctx(config)
+    { }
+
+    constexpr Vpx::Image& frame() noexcept { return m_img; }
+    constexpr const Vpx::Image& frame() const noexcept { return m_img; }
+
+    constexpr const auto frameIdx() const noexcept { return m_frameIdx; }
+
+    template<typename Fn> void encode(Fn&& fn)
+    {
+        constexpr vpx_enc_frame_flags_t flags = 0;
+        if (vpx_codec_encode(m_ctx, m_img, ++m_frameIdx, 1, flags, VPX_DL_REALTIME) != VPX_CODEC_OK) {
+            throw std::runtime_error("Failed to encode frame");
+        }
+
+        vpx_codec_iter_t iter = nullptr;
+        const vpx_codec_cx_pkt_t *pkt = nullptr;
+        while ((pkt = vpx_codec_get_cx_data(m_ctx, &iter)) != nullptr) {
+            if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
+                fn(static_cast<const uint8_t*>(pkt->data.raw.buf), pkt->data.raw.sz);
+            }
+        }
+    }
+
+private:
+    unsigned int m_frameIdx = 0;
+    Vpx::Image m_img;
+    EncCtx m_ctx;
+};
+
+Encoder::Encoder(const Config& config)
+    : ctx(std::make_unique<Ctx>(config))
+{ }
+
+Encoder::~Encoder() = default;
+
+void Encoder::encode(const packet_handler_t& fn)
+{
+    ctx->encode(fn);
+}
+
+Plane Encoder::yPlane() const noexcept
+{
+    return ctx->frame().yPlane();
+}
+
+void Encoder::copyFromGray(const uint8_t* data)
+{
+    ctx->frame().copyFromGrayscale(data);
+}

pylibvpx-1.0/vpxencoder.hpp

@@ -0,0 +1,39 @@
+#pragma once
+#include <memory>
+#include <cstdint>
+#include <functional>
+#include "vpxcommon.hpp"
+
+namespace Vpx {
+
+struct Encoder
+{
+private:
+    struct Ctx;
+
+public:
+    struct Config {
+        unsigned int width;
+        unsigned int height;
+        unsigned int fps = 30;
+        unsigned int bitrate = 3000;
+        unsigned int threads = 0;
+        int cpu_used = 16;
+        Gen gen = Gen::Vp8;
+    };
+
+    Encoder(const Config& config);
+    ~Encoder();
+
+    Plane yPlane() const noexcept;
+
+    void copyFromGray(const uint8_t* data);
+
+    using packet_handler_t = std::function<void(const uint8_t*, size_t)>;
+    void encode(const packet_handler_t& fn);
+
+private:
+    std::unique_ptr<Ctx> ctx;
+};
+
+}  // namespace Vpx