@scrypted/libav 1.0.172 → 1.0.173

package/src/frame.h

@@ -1,55 +0,0 @@
-#pragma once
-
-#include <napi.h>
-extern "C"
-{
-#include <libavutil/frame.h>
-#include <libavutil/pixdesc.h>
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libavformat/avformat.h>
-#include <libavutil/hwcontext.h>
-#include <libavutil/frame.h>
-#include <libavfilter/buffersink.h>
-#include <libavfilter/buffersrc.h>
-#include <libavfilter/avfilter.h>
-#include <libavutil/opt.h>
-#include <libavutil/imgutils.h>
-}
-
-class AVFrameObject : public Napi::ObjectWrap<AVFrameObject>
-{
-public:
-    static Napi::Object Init(Napi::Env env, Napi::Object exports);
-    AVFrameObject(const Napi::CallbackInfo &info);
-    ~AVFrameObject(); // Explicitly declare the destructor
-
-    // Factory method to create an instance from C++
-    static Napi::Object NewInstance(Napi::Env env, AVFrame *frame);
-    AVFrame *frame_;
-
-private:
-    static Napi::FunctionReference constructor;
-    Napi::Value GetWidth(const Napi::CallbackInfo &info);
-    Napi::Value GetHeight(const Napi::CallbackInfo &info);
-    Napi::Value GetPixelFormat(const Napi::CallbackInfo &info);
-    Napi::Value GetTimeBaseNum(const Napi::CallbackInfo &info);
-    Napi::Value GetTimeBaseDen(const Napi::CallbackInfo &info);
-    void SetTimeBaseNum(const Napi::CallbackInfo &info, const Napi::Value &value);
-    void SetTimeBaseDen(const Napi::CallbackInfo &info, const Napi::Value &value);
-    Napi::Value GetPTS(const Napi::CallbackInfo &info);
-    void SetPTS(const Napi::CallbackInfo &info, const Napi::Value &value);
-    Napi::Value GetDTS(const Napi::CallbackInfo &info);
-    void SetDTS(const Napi::CallbackInfo &info, const Napi::Value &value);
-    Napi::Value GetHardware(const Napi::CallbackInfo &info);
-    Napi::Value GetSoftware(const Napi::CallbackInfo &info);
-    Napi::Value GetFlags(const Napi::CallbackInfo &info);
-    void SetFlags(const Napi::CallbackInfo &info, const Napi::Value &value);
-    Napi::Value GetPictType(const Napi::CallbackInfo &info);
-    void SetPictType(const Napi::CallbackInfo &info, const Napi::Value &value);
-
-    Napi::Value Destroy(const Napi::CallbackInfo &info);
-    Napi::Value CreateEncoder(const Napi::CallbackInfo &info);
-    Napi::Value ToBuffer(const Napi::CallbackInfo &info);
-    Napi::Value FromBuffer(const Napi::CallbackInfo &info);
-};

package/src/index.ts

@@ -1,356 +0,0 @@
-import detectLibc from 'detect-libc';
-import { once } from 'events';
-import { https } from 'follow-redirects';
-import fs from 'fs';
-import { IncomingMessage } from 'http';
-import path from 'path';
-import { x as tarx } from 'tar';
-import packageJson from '../package.json';
-import { AVPictureType } from './flags';
-export * from './flags';
-export * as Profile from './profiles';
-
-let addon: any;
-
-export function isLoaded() {
-    return !!addon;
-}
-
-function getReleasePath(installPath: string) {
-    return path.join(installPath, 'build/Release');
-}
-
-const packagePath = path.join(__dirname, '..');
-export function getAddonPath(installPath = packagePath) {
-    return path.join(getReleasePath(installPath), 'addon.node');
-}
-
-export function getFFmpegPath(installPath = packagePath) {
-    return path.join(getReleasePath(installPath), process.platform === 'win32' ? 'ffmpeg.exe' : 'ffmpeg');
-}
-
-export function loadAddon(addonPath = getAddonPath(), nr: NodeRequire = require) {
-    if (isLoaded())
-        return addon;
-    addon = nr(addonPath);
-    return addon;
-}
-
-let installing: Promise<void> | undefined;
-export async function install(installPath = packagePath, nr: NodeRequire | null = require) {
-    const addonPath = getAddonPath(installPath);
-    if (!nr) {
-        if (fs.existsSync(addonPath))
-            return;
-    }
-    else {
-        if (isLoaded())
-            return;
-
-        if (installing)
-            return installing;
-
-        try {
-            loadAddon(addonPath, nr);
-            return;
-        }
-        catch (e) {
-        }
-    }
-
-    installing = (async () => {
-        await downloadAddon(installPath);
-        if (!nr)
-            return;
-        loadAddon(addonPath, nr);
-    })()
-        .finally(() => {
-            installing = undefined;
-        });
-
-    return installing;
-}
-
-export async function downloadAddon(installPath?: string) {
-    const cwd = installPath || process.cwd();
-    await fs.promises.mkdir(cwd, { recursive: true });
-    const buildPath = path.join(cwd, 'build');
-    const extractPath = path.join(cwd, '.extract');
-    try {
-        await fs.promises.rm(extractPath, { recursive: true, force: true });
-    }
-    catch (e) {
-        const oldExtractPath = path.join(cwd, '.extract-old');
-        fs.promises.rm(oldExtractPath, { recursive: true, force: true });
-        await fs.promises.rename(extractPath, oldExtractPath);
-    }
-    await fs.promises.mkdir(extractPath, { recursive: true });
-    await fs.promises.rm(buildPath, { recursive: true, force: true });
-    const binaryUrl = getBinaryUrl();
-    const r = https.get(binaryUrl, {
-        family: 4,
-    });
-    const [response] = await once(r, 'response') as [IncomingMessage];
-    if (!response.statusCode || (response.statusCode < 200 && response.statusCode >= 300))
-        throw new Error(`Failed to download libav binary: ${response.statusCode}`);
-    const t = response.pipe(tarx({
-        cwd: extractPath,
-    }));
-    await once(t, 'end');
-    await fs.promises.rename(path.join(extractPath, 'build'), buildPath);
-}
-
-export interface AVFrame extends AVTimeBase {
-    readonly width: number;
-    readonly height: number;
-    readonly pixelFormat: string;
-    readonly hardwareDeviceType: string;
-    readonly softwareFormat: string;
-    pictType: AVPictureType;
-
-    flags: number;
-    timeBaseNum: number;
-    timeBaseDen: number;
-    pts: number;
-    dts: number;
-
-    [Symbol.dispose](): void;
-    destroy(): void;
-    toBuffer(): Buffer;
-    fromBuffer(buffer: Buffer): void;
-    createEncoder(options: {
-        encoder: string,
-        bitrate: number,
-        minRate?: number;
-        maxRate?: number,
-        bufSize?: number,
-        timeBase: AVTimeBase,
-        framerate?: AVTimeBase,
-        flags?: number,
-        opts?: {
-            [key: string]: string | number,
-        },
-        profile?: number;
-        gopSize?: number;
-        keyIntMin?: number;
-    }): AVCodecContext;
-}
-
-export interface AVFilter {
-    [Symbol.dispose](): void;
-    destroy(): void;
-    sendCommand(target: string, command: string, arg: string): void;
-    addFrame(frame: AVFrame, index?: number): void;
-    getFrame(index?: number): AVFrame;
-}
-
-export interface AVBitstreamFilter {
-    [Symbol.dispose](): void;
-    destroy(): void;
-    setOption(name: string, value: string): void;
-    sendPacket(packet: AVPacket): void;
-    receivePacket(): AVPacket;
-    copyParameters(formatContext: AVFormatContext, streamIndex: number): void;
-}
-
-export interface AVPacket {
-    readonly streamIndex: number;
-    flags: number;
-    readonly size: number;
-    pts: number;
-    dts: number;
-    readonly duration: number;
-
-    [Symbol.dispose](): void;
-    getData(): Buffer;
-    destroy(): void;
-}
-
-export interface AVCodecContext extends AVTimeBase {
-    readonly hardwareDevice: string;
-    /**
-     * The pixel format of the output frames.
-     * May not be available until the first frame is read.
-     */
-    readonly pixelFormat: string;
-    readonly hardwarePixelFormat: string;
-    readonly vendorInfo: Record<string, any>;
-    keyIntMin: number;
-    gopSize: number;
-
-    [Symbol.dispose](): void;
-    destroy(): void;
-    sendPacket(packet: AVPacket): Promise<boolean>;
-    receiveFrame(): Promise<AVFrame>;
-    sendFrame(packet: AVFrame): Promise<boolean>;
-    receivePacket(): Promise<AVPacket>;
-}
-
-export interface AVStream extends AVTimeBase {
-    readonly index: number;
-    readonly codec: string;
-    readonly type: string;
-}
-
-export interface AVTimeBase {
-    readonly timeBaseNum: number,
-    readonly timeBaseDen: number,
-}
-
-export interface AVFormatContext {
-    readonly metadata: any;
-    readonly streams: AVStream[];
-
-    [Symbol.dispose](): void;
-    open(input: string): void;
-    createDecoder(streamIndex: number, hardwareDevice?: string, decoder?: string, deviceName?: string): AVCodecContext;
-    readFrame(): Promise<AVPacket>;
-    receiveFrame(streamIndex: number, codecContext: AVCodecContext): Promise<AVFrame|AVPacket>;
-    create(format: string, callback: (buffer: Buffer) => void): void;
-    newStream(options: {
-        codecContext?: AVCodecContext,
-        formatContext?: AVFormatContext,
-        streamIndex?: number,
-    }): number;
-    writeFrame(streamIndex: number, packet: AVPacket): void;
-    createSDP(): string;
-    close(): void;
-}
-
-export function setAVLogLevel(level: 'quiet' | 'panic' | 'fatal' | 'error' | 'warning' | 'info' | 'verbose' | 'debug' | 'trace') {
-    loadAddon().setLogLevel(level);
-}
-
-export function createAVFormatContext(): AVFormatContext {
-    return new (loadAddon().AVFormatContext)();
-}
-
-export function createAVFilter(options: {
-    filter: string,
-    frames: {
-        frame: AVFrame,
-        timeBase: AVTimeBase,
-    }[],
-    threadCount?: number,
-    hardwareDevice?: string,
-    hardwareDeviceName?: string,
-    hardwareDeviceFrame?: AVFrame;
-    // outCount defaults to 1
-    outCount?: number,
-}): AVFilter {
-    return new (loadAddon().AVFilter)(options);
-}
-
-export function createAVFrame(
-    width: number,
-    height: number,
-    pixelFormat: string,
-    fillBlack = true,
-): AVFrame {
-    return new (loadAddon().AVFrame)(width, height, pixelFormat, fillBlack);
-}
-
-export function createAVBitstreamFilter(filter: string): AVBitstreamFilter {
-    return new (loadAddon().AVBitstreamFilter)(filter);
-}
-
-export function getBinaryUrl() {
-    const libc = process.env.LIBC || process.env.npm_config_libc ||
-        (detectLibc.isNonGlibcLinuxSync() && detectLibc.familySync()) || ''
-
-    const { name, version } = packageJson;
-    const binaryName = name.replace(/^@[a-zA-Z0-9_\-.~]+\//, '')
-
-    const abi = process.versions.modules;
-    const runtime = process.env.npm_config_runtime || 'node';
-    const { platform, arch } = process;
-    const packageName = `${binaryName}-v${version}-${runtime}-v${abi}-${platform}${libc}-${arch}.tar.gz`;
-
-    const url = `https://github.com/scryptedapp/libav/releases/download/v${version}/${packageName}`;
-
-    return url;
-}
-
-async function encodeJpeg(softwareFrame: AVFrame, quality: number) {
-    using encoder = softwareFrame.createEncoder({
-        encoder: 'mjpeg',
-        bitrate: 2000000,
-        timeBase: {
-            timeBaseNum: 1,
-            timeBaseDen: 25,
-        },
-        opts: {
-            quality,
-            qmin: quality,
-            qmax: quality,
-        },
-    });
-
-    const sent = await encoder.sendFrame(softwareFrame);
-    if (!sent)
-        throw new Error('sendFrame failed');
-
-    using transcodePacket = await encoder.receivePacket();
-    if (!transcodePacket)
-        throw new Error('receivePacket needs more frames');
-
-    return transcodePacket.getData();
-}
-
-export function createSdp(formatContexts: AVFormatContext[]): string {
-    return loadAddon().createSdp(formatContexts);
-}
-
-export async function toJpeg(frame: AVFrame, quality: number) {
-    if (frame.pixelFormat === 'yuvj420p')
-        return await encodeJpeg(frame, quality);
-
-    let filterString = `scale,format=yuvj420p`;
-    if (frame.hardwareDeviceType)
-        filterString = `hwdownload,format=${frame.softwareFormat},${filterString}`;
-
-    using filter = createAVFilter({
-        filter: filterString,
-        frames: [
-            {
-                frame,
-                timeBase: {
-                    timeBaseNum: 1,
-                    timeBaseDen: 25,
-                },
-            }
-        ],
-    });
-
-    filter.addFrame(frame);
-    using softwareFrame = filter.getFrame();
-    softwareFrame.pts = 0;
-    softwareFrame.dts = 0;
-
-    return await encodeJpeg(softwareFrame, quality);
-}
-
-export async function toBuffer(frame: AVFrame) {
-    if (!frame.hardwareDeviceType)
-        return frame.toBuffer();
-
-    const filterString = `hwdownload,format=${frame.softwareFormat}`;
-    using filter = createAVFilter({
-        filter: filterString,
-        frames: [
-            {
-                frame,
-                timeBase: {
-                    timeBaseNum: 1,
-                    timeBaseDen: 25,
-                },
-            }
-        ],
-    });
-
-    filter.addFrame(frame);
-    using softwareFrame = filter.getFrame();
-    return softwareFrame.toBuffer();
-}
-
-export const version: string = packageJson.version;

package/src/packet.cpp

@@ -1,182 +0,0 @@
-#include <napi.h>
-extern "C"
-{
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libavutil/hwcontext.h>
-#include <libavutil/frame.h>
-#include <libavfilter/buffersink.h>
-#include <libavfilter/buffersrc.h>
-#include <libavfilter/avfilter.h>
-#include <libavutil/opt.h>
-}
-
-#include <thread>
-#include <v8.h>
-
-#include "packet.h"
-
-Napi::FunctionReference AVPacketObject::constructor;
-
-Napi::Object AVPacketObject::Init(Napi::Env env, Napi::Object exports)
-{
-    Napi::HandleScope scope(env);
-
-    Napi::Function func = DefineClass(env, "AVPacketObject", {
-                                                                 AVPacketObject::InstanceAccessor("flags", &AVPacketObject::GetFlags, &AVPacketObject::SetFlags),
-                                                                 AVPacketObject::InstanceAccessor("pts", &AVPacketObject::GetPTS, &AVPacketObject::SetPTS),
-                                                                 AVPacketObject::InstanceAccessor("dts", &AVPacketObject::GetDTS, &AVPacketObject::SetDTS),
-                                                                 AVPacketObject::InstanceAccessor("duration", &AVPacketObject::GetDuration, nullptr),
-                                                                 AVPacketObject::InstanceAccessor("size", &AVPacketObject::GetSize, nullptr),
-                                                                 AVPacketObject::InstanceAccessor("streamIndex", &AVPacketObject::GetStreamIndex, nullptr),
-                                                                 InstanceMethod(Napi::Symbol::WellKnown(env, "dispose"), &AVPacketObject::Destroy),
-                                                                 InstanceMethod("clone", &AVPacketObject::Clone),
-                                                                 InstanceMethod("destroy", &AVPacketObject::Destroy),
-                                                                 InstanceMethod("getData", &AVPacketObject::GetData),
-                                                             });
-
-    constructor = Napi::Persistent(func);
-    constructor.SuppressDestruct();
-    return exports;
-}
-
-Napi::Object AVPacketObject::NewInstance(Napi::Env env, AVPacket *packet)
-{
-    Napi::Object obj = constructor.New({});
-    AVPacketObject *avPacketObject = Napi::ObjectWrap<AVPacketObject>::Unwrap(obj);
-    avPacketObject->packet = packet;
-    return obj;
-}
-
-AVPacketObject::AVPacketObject(const Napi::CallbackInfo &info)
-    : Napi::ObjectWrap<AVPacketObject>(info)
-{
-    packet = nullptr;
-}
-
-AVPacketObject::~AVPacketObject()
-{
-}
-
-Napi::Value AVPacketObject::Clone(const Napi::CallbackInfo &info)
-{
-    if (!packet)
-    {
-        return info.Env().Undefined();
-    }
-
-    AVPacket *newPacket = av_packet_alloc();
-    if (!newPacket)
-    {
-        Napi::TypeError::New(info.Env(), "Failed to allocate new AVPacket").ThrowAsJavaScriptException();
-        return info.Env().Undefined();
-    }
-
-    int ret = av_packet_ref(newPacket, packet);
-    if (ret < 0)
-    {
-        av_packet_free(&newPacket);
-        Napi::TypeError::New(info.Env(), "Failed to reference AVPacket").ThrowAsJavaScriptException();
-        return info.Env().Undefined();
-    }
-
-    return NewInstance(info.Env(), newPacket);
-}
-
-Napi::Value AVPacketObject::Destroy(const Napi::CallbackInfo &info)
-{
-    if (packet)
-    {
-        av_packet_free(&packet);
-        packet = nullptr;
-    }
-
-    return info.Env().Undefined();
-}
-Napi::Value AVPacketObject::GetFlags(const Napi::CallbackInfo &info)
-{
-    return Napi::Number::New(info.Env(), packet ? packet->flags : 0);
-}
-
-void AVPacketObject::SetFlags(const Napi::CallbackInfo &info, const Napi::Value &value)
-{
-    if (!packet)
-    {
-        return;
-    }
-
-    if (!value.IsNumber())
-    {
-        Napi::TypeError::New(info.Env(), "Number expected for flags").ThrowAsJavaScriptException();
-        return;
-    }
-
-    packet->flags = value.As<Napi::Number>().Int32Value();
-}
-
-Napi::Value AVPacketObject::GetPTS(const Napi::CallbackInfo &info)
-{
-    return Napi::Number::New(info.Env(), packet ? packet->pts : 0);
-}
-
-void AVPacketObject::SetPTS(const Napi::CallbackInfo &info, const Napi::Value &value)
-{
-    if (!packet)
-    {
-        return;
-    }
-
-    if (!value.IsNumber())
-    {
-        Napi::TypeError::New(info.Env(), "Number expected for pts").ThrowAsJavaScriptException();
-        return;
-    }
-
-    packet->pts = value.As<Napi::Number>().Int64Value();
-}
-
-Napi::Value AVPacketObject::GetDTS(const Napi::CallbackInfo &info)
-{
-    return Napi::Number::New(info.Env(), packet ? packet->dts : 0);
-}
-
-void AVPacketObject::SetDTS(const Napi::CallbackInfo &info, const Napi::Value &value)
-{
-    if (!packet)
-    {
-        return;
-    }
-
-    if (!value.IsNumber())
-    {
-        Napi::TypeError::New(info.Env(), "Number expected for dts").ThrowAsJavaScriptException();
-        return;
-    }
-
-    packet->dts = value.As<Napi::Number>().Int64Value();
-}
-Napi::Value AVPacketObject::GetDuration(const Napi::CallbackInfo &info)
-{
-    return Napi::Number::New(info.Env(), packet ? packet->duration : 0);
-}
-
-Napi::Value AVPacketObject::GetSize(const Napi::CallbackInfo &info)
-{
-    return Napi::Number::New(info.Env(), packet ? packet->size : 0);
-}
-
-Napi::Value AVPacketObject::GetData(const Napi::CallbackInfo &info)
-{
-    if (!packet || !packet->data)
-    {
-        return info.Env().Undefined();
-    }
-
-    Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::Copy(info.Env(), packet->data, packet->size);
-    return buffer;
-}
-
-Napi::Value AVPacketObject::GetStreamIndex(const Napi::CallbackInfo &info)
-{
-    return Napi::Number::New(info.Env(), packet ? packet->stream_index : -1);
-}

package/src/packet.h

@@ -1,42 +0,0 @@
-#pragma once
-
-#include <napi.h>
-extern "C"
-{
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libavutil/hwcontext.h>
-#include <libavutil/frame.h>
-#include <libavfilter/buffersink.h>
-#include <libavfilter/buffersrc.h>
-#include <libavfilter/avfilter.h>
-#include <libavutil/opt.h>
-}
-
-#include <thread>
-#include <v8.h>
-
-class AVPacketObject : public Napi::ObjectWrap<AVPacketObject>
-{
-public:
-    static Napi::FunctionReference constructor;
-    static Napi::Object Init(Napi::Env env, Napi::Object exports);
-    static Napi::Object NewInstance(Napi::Env env, AVPacket *packet);
-
-    AVPacketObject(const Napi::CallbackInfo &info);
-    ~AVPacketObject();
-    Napi::Value Clone(const Napi::CallbackInfo &info);
-    Napi::Value Destroy(const Napi::CallbackInfo &info);
-    Napi::Value GetFlags(const Napi::CallbackInfo &info);
-    void SetFlags(const Napi::CallbackInfo &info, const Napi::Value &value);
-    Napi::Value GetPTS(const Napi::CallbackInfo &info);
-    void SetPTS(const Napi::CallbackInfo &info, const Napi::Value &value);
-    Napi::Value GetDTS(const Napi::CallbackInfo &info);
-    void SetDTS(const Napi::CallbackInfo &info, const Napi::Value &value);
-    Napi::Value GetDuration(const Napi::CallbackInfo &info);
-    Napi::Value GetSize(const Napi::CallbackInfo &info);
-    Napi::Value GetData(const Napi::CallbackInfo &info);
-    Napi::Value GetStreamIndex(const Napi::CallbackInfo &info);
-
-    AVPacket *packet;
-};

package/src/pkgconfig/glslang.pc

@@ -1,10 +0,0 @@
-prefix=/c/VulkanSDK/1.3.280.0
-includedir=${prefix}/Include
-libdir=${prefix}/Lib
-
-Name: ffnvcodec
-Description: Vulkan
-Version: 1.3.280
-Cflags: -I${includedir}
-Libs: -L${libdir} -lglslang -lMachineIndependent -lOSDependent -lGenericCodeGen -lSPVRemapper -lSPIRV -lSPIRV-Tools-opt -lSPIRV-Tools -lstdc++ -lmsvcrt
-Libs.private: