Go4vl is Go library for working with the Video for Linux API (V4L2) natively, without any C bindings.

Related tags

Video go4vl
Overview

go4vl

A Go library for working with the Video for Linux user API (V4L2).


Gov4l hides all the complexities of working with V4L2 and exposes idiomatic Go types, like channels, to consume captured frame.

Features

  • Capture and control video data from your Go programs
  • Idiomatic Go API
Comments
  • Cannot retrieve pixel format info from device [Error While Encoding v4l2 command via ioctl]

    Cannot retrieve pixel format info from device [Error While Encoding v4l2 command via ioctl]

    Error

    device.GetPixFormat() always fails with error device: pix format failed: unsupported error if we do a system call trace i get following

    ioctl(3, _IOC(_IOC_READ|_IOC_WRITE, 0x56, 0x4, 0xcc), 0xc000076ca8) = -1 ENOTTY (Inappropriate ioctl for device)
    write(1, "failed to get pix format\n", 25failed to get pix format
    

    It looks like encoded command is not VIDIOC_G_FMT and is not recognized by kernel.

    package main
    
    import (
    	"fmt"
    
    	"github.com/vladimirvivien/go4vl/v4l2"
    )
    
    func main() {
    	device, err := v4l2.Open("/dev/video0")
    	if err != nil {
    		panic(err)
    	}
    
    	_, err = device.GetPixFormat()
    	if err != nil {
    		fmt.Println("failed to get pix format")
    		panic(err)
    	}
    }
    
    

    My kernel is

    Linux endless 5.14.14-arch1-1 #1 SMP PREEMPT Wed, 20 Oct 2021 21:35:18 +0000 x86_64 GNU/Linux
    

    Cause

    I don't think this problem is caused by kernel. I can use <linux/videodev2.h> and it does not cause this error

    With the C API I get

    ioctl(3, VIDIOC_G_FMT, {type=V4L2_BUF_TYPE_VIDEO_CAPTURE, fmt.pix={width=1280, height=720, pixelformat=v4l2_fourcc('M', 'J', 'P', 'G') /* V4L2_PIX_FMT_MJPEG */, field=V4L2_FIELD_NONE, bytesperline=0, sizeimage=1843200, colorspace=V4L2_COLORSPACE_SRGB}}) = 0
    

    It looks like the problem is caused in ioctl encoding functions. I rechecked the ioct.go but could not find the problem

    opened by tarunKoyalwar 22
  • Missing constants from linux/videodev2.h

    Missing constants from linux/videodev2.h

    Hi, I'm getting the following errors building the package,

    /home/dev/go/pkg/mod/github.com/vladimirvivien/[email protected]/v4l2/capability.go:48:33: could not determine kind of name for C.V4L2_CAP_IO_MC
    /home/dev/go/pkg/mod/github.com/vladimirvivien/[email protected]/v4l2/format_desc.go:25:55: could not determine kind of name for C.V4L2_FMT_FLAG_CSC_COLORSPACE
    /home/dev/go/pkg/mod/github.com/vladimirvivien/[email protected]/v4l2/format_desc.go:28:55: could not determine kind of name for C.V4L2_FMT_FLAG_CSC_HSV_ENC
    /home/dev/go/pkg/mod/github.com/vladimirvivien/[email protected]/v4l2/format_desc.go:29:55: could not determine kind of name for C.V4L2_FMT_FLAG_CSC_QUANTIZATION
    /home/dev/go/pkg/mod/github.com/vladimirvivien/[email protected]/v4l2/format_desc.go:26:55: could not determine kind of name for C.V4L2_FMT_FLAG_CSC_XFER_FUNC
    /home/dev/go/pkg/mod/github.com/vladimirvivien/[email protected]/v4l2/format_desc.go:27:55: could not determine kind of name for C.V4L2_FMT_FLAG_CSC_YCBCR_ENC
    /home/dev/go/pkg/mod/github.com/vladimirvivien/[email protected]/v4l2/format_desc.go:24:55: could not determine kind of name for C.V4L2_FMT_FLAG_ENC_CAP_FRAME_INTERVAL
    

    When I open /usr/include/linux/videodev2.h I see these constants are not present. This is on ubuntu 20.04.3 with package linux-libc-dev version 5.4.0-94.106 (after update and upgrade). There may be other such constants, it stops showing errors at a certain point.

    On my other popos install I see linux-libc-dev is at version 5.15.5 and looks like the constants are present.

    It looks like some of those constants are relatively new, like V4L2_CAP_IO_MC might just be from 2020.

    Do I need to find a way to get the newer package? or should this library try to accommodate? Thanks

    opened by millerlogic 5
  • Buffer dequeue error

    Buffer dequeue error

    Hi,

    I'm testing out the mjpeg saving example in the README (making the sole change of width to 1280 and height to 720 - which the camera DOES support) and half of the time the example runs smoothly and then sometimes when I run it I get the following error:

    Done.
    panic: device: capture: buffer dequeue: system error
    
    goroutine 34 [running]:
    github.com/vladimirvivien/go4vl/v4l2.(*Device).Capture.func1(0xd06000, 0x3, 0xcb0850, {0x104658, 0xd02000}, 0x1fca055)
    	/home/pi/go/pkg/mod/github.com/vladimirvivien/[email protected]/v4l2/device.go:245 +0x3c0
    created by github.com/vladimirvivien/go4vl/v4l2.(*Device).Capture
    	/home/pi/go/pkg/mod/github.com/vladimirvivien/[email protected]/v4l2/device.go:230 +0xd0
    exit status 2
    
    

    Have you seen that before or have any idea why it might be happening seemingly randomly?

    Thanks for the library btw!

    opened by IanPhilips 4
  • Unable to set any frame size other than the default 640x480

    Unable to set any frame size other than the default 640x480

    Hi, I seem to have a problem setting the image size correctly and it keeps defaulting to the default 640x480, even when using your webcam.go example and changing the with and height to 1280x720 still resolves in a 640x480 picture. the capture card is able to provide an MJPEG of 720p as well as 1080p and this also works via this pkg: https://github.com/blackjack/webcam but I cant get the same to work here, even though I like the rest of the implementation here a bit better.

    Would you mind giving an example of a working webcam.go or capture.go with a different image size just as a reference to look at.

    opened by McHauge 4
  • v4l2/capability.go:48:33: could not determine kind of name for C.V4L2_CAP_IO_MC

    v4l2/capability.go:48:33: could not determine kind of name for C.V4L2_CAP_IO_MC

    uname -r
    5.11.0-1022-aws
    
    sudo find / -name videodev2.h
    /usr/include/linux/videodev2.h
    
    go version
    go version go1.17.8 linux/amd64
    
    
    
    

    GCC

    gcc -v
    Using built-in specs.
    COLLECT_GCC=gcc
    COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper
    OFFLOAD_TARGET_NAMES=nvptx-none:hsa
    OFFLOAD_TARGET_DEFAULT=1
    Target: x86_64-linux-gnu
    Thread model: posix
    gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04)
    
     make
    CGO_ENABLED=1 GO111MODULE=on go build -ldflags "-X github.com/edgexfoundry/device-usb-camera.Version=0.0.0" -o cmd/device-usb-camera ./cmd
    # github.com/vladimirvivien/go4vl/v4l2
    ../go/pkg/mod/github.com/vladimirvivien/[email protected]/v4l2/capability.go:48:33: could not determine kind of name for C.V4L2_CAP_IO_MC
    make: *** [Makefile:21: cmd/device-usb-camera] Error 2
    
    opened by wubigo 3
  • Generating camera image

    Generating camera image

    The examples seem to focus on capturing camera images.

    Would this library also be fit to "generate" camera input, to be consumed by e.g. OBS Studio or Zoom? I've been able to output OBS Studio to v4l2 to be consumed by Zoom, so I'd assume v4l2 in general somehow supports it.

    The IsVideoOutputSupported function seems to indicate something like that is possible.

    Are there any pointers you can give, where one would get started on doing so?

    func writeFrame(frame *image.RGBA) {
        // My custom logic to write this frame
    }
    
    func main() {
    	devName := "/dev/video10"
    	device, err := v4l2.Open(devName)
    	if err != nil {
    		log.Fatalln("unable to open virtual webcam:", err)
    	}
    
    	defer device.Close()
    
    	caps, err := device.GetCapability()
    	if err != nil {
    		log.Println("failed to get device capabilities:", err)
    	}
    	log.Printf("device [%s] opened\n", devName)
    	log.Printf("device info: %s", caps.String())
    
    	if !caps.IsVideoOutputSupported() {
    		log.Fatalln("virtual webcam does not support video output")
    	}
    
    	// Something should go here, to prepare everything for "write mode"
    	pxFmt, err := GetPixFormatOutput(device.fd)
    	if err != nil {
    		log.Fatalln("unable to get pix format:", err) // It crashes here due to https://github.com/vladimirvivien/go4vl/issues/7 but that's OK
    	}
    
    	// And at some point, whenever a frame should be written, the `writeFrame` above can be called, and those bytes could
    	// then be written into the buffer allocated for v4l2
    }
    
    func GetPixFormatOutput(fd uintptr) (PixFormat, error) {
    	format := v4l2Format{StreamType: BufTypeVideoOutput}
    	if err := Send(fd, VidiocGetFormat, uintptr(unsafe.Pointer(&format))); err != nil {
    		return PixFormat{}, fmt.Errorf("pix format failed: %w", err)
    	}
    
    	return format.getPixFormat(), nil
    }
    

    I'm using the code for obs-v4l2sink as a guidance, because I know that code works.

    opened by EtienneBruines 3
  • capture video and audio at same time possible ?

    capture video and audio at same time possible ?

    I wanna capture both video and audio from a HDMI to USB Capture Card , and keep video and audio in sync , is that possible using this library ? if possible , could you show me an example ? Thanks

    opened by c1ngular 2
  • default fps when capture

    default fps when capture

    nice job . i see the default/base fps is set to 10 from here : https://github.com/vladimirvivien/go4vl/blob/40b41ba86c5c8d169bae1bcce5ec16605db44e6f/v4l2/device/device.go#L231, is there any way to detect and set a default fps value(rather than 10) supported by opened device ?
    thanks

    enhancement 
    opened by c1ngular 2
  • Refactoring stream capture pipeline

    Refactoring stream capture pipeline

    This patch refactors some capture data plane for go4vl including:

    • Buggy behavior introduced by using Go stdlib's os.OpenFile
    • Add more aggressive ioctl error handling for v4l2 calls
    • Testing using Raspberry Pi's camera modules directly
    opened by vladimirvivien 0
  • Fix for memory leak in stream loop

    Fix for memory leak in stream loop

    This PR fixes a memory leak reported when running the webcam example. After profiling, the leak was identified in the loop for streaming captured from from the device. Specifically, the fix simply moved the v4l2.WaitForRead function call out of the loop.

    Fix

    Prior to the fix, the webcam process would be killed, after about an hour of running, by the OS to prevent an OOM situation. After the fix, the followings were observed:

    • Webcam process only used 1% of memory after 5 hours of running
    • Webcam process never crashed or killed
    • After opening 8 concurrent browser tabs, receiving 30 frames of HD video per second, the memory profile stayed the same

    Fixes #22

    opened by vladimirvivien 0
  • User device control support

    User device control support

    This patch adds supports for user device controls API wiht the followings:

    • v4l2 control types, values, and enums
    • Low level Go functions to query, get, and set controls
    • New methods added to the Device type to work with the Control API
    • Examples to show how to use the Control API

    Additionally:

    • Added Canonical Multipass setup file to help with local build/development
    • Update to existing documentations
    opened by vladimirvivien 0
  • Exploring ways to integrate/automate C header files in porject

    Exploring ways to integrate/automate C header files in porject

    In #20, @ajcasagrande contributed code changes that copied the Kernel v4l2 header files from a specific commit. This provides for a more stable build experience because the code does not depend on the local machine to provide the header files. This is very useful, however @farshidtz pointed out, in the closed PR, that there could be some unforeseen additional issues.

    I am opening this issue provide a place to continue discussions on this and also propose additional ways of approaching this problem. There are some valid issues brought forth in the discussion above. I am doing some research to see how other Go projects handle this. What I have seen so far

    • Project that includes the headers, as is done here
    • Project that automatically pull a specific version at commit, via submodules

    I think there is a middle ground solutions that can be adopted, while avoiding any additional burden for users of this library.

    Possible solutions

    • Manually update header files and pinned to a specific version (as done now)
    • Creating a simple code gen (Makefile/script) to automates pulling header files for a specified Kernel version.
    • Will add more proposals as I continue to explore
    opened by vladimirvivien 0
  • Review/refactor datapath to avoid unnecessary allocations and resource leakage

    Review/refactor datapath to avoid unnecessary allocations and resource leakage

    Now that the control portion of the API seems to be stable. It is time to go back into the datapath API to do some remodeling. This started with #22 . It appears that some early decisions in that portion of the code needs some refactoring to ensure better stability and avoid resource leakage.

    opened by vladimirvivien 0
  • Use types in Go's image package

    Use types in Go's image package

    The Go's image package has some surprisingly great type overlaps with this project. It would be great to leverage these types in the future

    • Bound
    • Rect
    • YCbCr
    • RGB
    • Gray
    • JPG
    • MPEG
    • Etc
    opened by vladimirvivien 0
  • Add support for YUYV

    Add support for YUYV

    Currently only MJPEG is supported but it would be great if there was support for the YUYV format. Showing:

    2021/07/31 15:35:43 setting format to 640x480 YUYV
    2021/07/31 15:35:43 device or resource busy
    exit status 1
    

    Sample camera settings:

    	Driver name      : ov534
    	Card type        : USB Camera-B4.09.24.1
    	Bus info         : usb-3f980000.usb-1.5
    	Driver version   : 5.10.17
    	Capabilities     : 0x85200001
    		Video Capture
    		Read/Write
    		Streaming
    		Extended Pix Format
    		Device Capabilities
    	Device Caps      : 0x05200001
    		Video Capture
    		Read/Write
    		Streaming
    		Extended Pix Format
    Priority: 2
    Video input : 0 (ov534: ok)
    Format Video Capture:
    	Width/Height      : 640/480
    	Pixel Format      : 'YUYV' (YUYV 4:2:2)
    	Field             : None
    	Bytes per Line    : 1280
    	Size Image        : 614400
    	Colorspace        : sRGB
    	Transfer Function : Default (maps to sRGB)
    	YCbCr/HSV Encoding: Default (maps to ITU-R 601)
    	Quantization      : Default (maps to Limited Range)
    	Flags             :
    Streaming Parameters Video Capture:
    	Capabilities     : timeperframe
    	Frames per second: 30.000 (30/1)
    	Read buffers     : 2````
    opened by julian59189 1
Releases(v0.0.4)
  • v0.0.4(Sep 18, 2022)

    This release introduced crucial bug fixes and other features including:

    • Support for extended controls (i.e. querying, value get/set, enumerating)
    • Capture sequence refactor to fix device-open bug
    • Memory leak identified when running video capture programs for long period

    Support for extended video controls

    This release introduces support for V4L2 extended controls.

    • Use existing control types, values for V4L2 extended control features
    • Addition of low level Go functions to query, get, and set control values
    • Ability to enumerate extended controls and their values.

    The following example shows how to retrieve all available extended controls from the driver.

    func main() {
    	device, err := dev.Open("/dev/video0")
    	if err != nil {
    		log.Fatalf("failed to open device: %s", err)
    	}
    	defer device.Close()
    
    	ctrls, err := v4l2.QueryAllExtControls(device.Fd())
    	if err != nil {
    		log.Fatalf("failed to get ext controls: %s", err)
    	}
    	if len(ctrls) == 0 {
    		log.Println("Device does not have extended controls")
    		os.Exit(0)
    	}
    	for _, ctrl := range ctrls {
    		printControl(ctrl)
    	}
           
           func printControl(ctrl v4l2.Contro) { ... }
    }
    

    See full example here

    Capture sequence refactor

    Since the inception of the project, it was known there were some bugs that needed to be revisited. We found out that some of the examples were failing when running on a Raspberry PI and capturing from a Raspberry Pi HD camera module. The code's use of the Go's standard library os.OpenFile was causing the device to report busy (when compared to similar programs in C).

    So this called for an overhaul of the entire capture sequence which delivered the followings

    • Fix device open failure by providing a simpler device operation that make system calls directly
    • Successful test using the Raspberry Pi's HD camera module connected as a capture device
    • Add more aggressive system call error handling for v4l2 calls including open, ioctl VIDIOC_QBUF, VIDIOC_DQBUFF, etc. This causes to run smoother, remove internal flickers that would happen sometimes

    Memory leak fix

    User @oyarzun reported a memory leak when running the webcam example (see issue #22). After a few hours of Go program profiling, it was found that the internal stream loop was leaking Go channel resources (by reinitialize the channel in the loop). After a simple fix (moving the channel initialization outside of the loop), the leak went away. After running the webcam program for over 25 hours on a RPi 3, it was observed that the memory consumption did not go over 1%. That was an awesome find.

    Source code(tar.gz)
    Source code(zip)
  • v0.0.3(Sep 3, 2022)

    VL2 user control support

    The main theme for this release is the introduction of the Control API with initial support of the V4L2 user controls. This release adds the followings:

    • Control types, values, and functions
    • Addition of low level Go functions, in the v4l2 package, to query, get, and set control values
    • Update to the Device type to add new methods to work with the control API
    func main() {
            device, err := dev.Open(devName)
    	if err != nil {
    		log.Fatalf("failed to open device: %s", err)
    	}
    	defer device.Close()
    
            // set single device control value
            val := 12
            device.SetControlValue(v4l2.CtrlBrightness, v4l2.CtrlValue(val))
    
            // retrieve Control
            ctrl, _ := device.GetControl(ctrlID)
    
           fmt.Printf("Control id (%d) name: %s\t[min: %d; max: %d; step: %d; default: %d current_val: %d]\n",
    		ctrl.ID, ctrl.Name, ctrl.Minimum, ctrl.Maximum, ctrl.Step, ctrl.Default, ctrl.Value)
    }
    

    For more detail, see the example

    V4L2 header files added

    Another improvement contributed by the community (thanks @ajcasagrande) is the inclusion of V4L2 header files as part of the project. This will provide consistent builds without relying on user's local header files (which can sometimes be outdated).

    See the include directory for detail.

    Local development

    To ease local development for non-Linux environment, this release comes with a script that can launch a Canonical Ubuntu VM managed by Multipass. This provides a VM along with a fake V4L2 driver (V4L2Loopback) to help run and test the project without the need of an environment with a real video camera attached.

    See the multipass directory for detail.

    Source code(tar.gz)
    Source code(zip)
  • v0.0.2(May 21, 2022)

    This release introduces major refactor that simplifies the way the API works. Unfortunately, these changes are not backward compatible with the previous version. Meaning, if you adopt this release, you will have to modify your existing code a bit.

    The new device package

    This release introduces a new device package to create and access device functionalities.

    Creating a device with the device package

    The device API creates a device without having to use the v4l2 directly.

    import  "github.com/vladimirvivien/go4vl/device"
    
    func main() {
        device, err := device.Open("/dev/video0")
        ...
    }
    

    function device.Open supports variable length arguments that can be used to specify the configuration of the device as it is being created:

    func main() {
        device, err := device.Open("/dev/video0",
            device.WithIOType(v4l2.IOTypeMMAP),
            device.WithPixFormat(v4l2.PixFormat{PixelFormat: getFormatType(format), Width: uint32(width), Height: uint32(height)}),
            device.WithFPS(uint32(frameRate)),
        )
    }
    

    Starting a device

    Once a device is created, it can be started with a context as shown below

    func main() {
        device, err := device.Open("/dev/video0")
        ctx, stop := context.WithCancel(context.TODO())
        if err := device.Start(ctx); err != nil {
            log.Fatalf("failed to start stream: %s", err)
        }
    }
    

    Streaming device output

    After a device has started, it's stream can be accessed as shown

    func main() {
        device, err := device.Open("/dev/video0")
        ctx, stop := context.WithCancel(context.TODO())
        if err := device.Start(ctx); err != nil {
            log.Fatalf("failed to start stream: %s", err)
        }
    
        for frame := range device.GetOutput() {
        ....
        }
    }
    

    Other enhancements

    This release introduces access to more device information via additional types.

    • Ability to enumerate all attached v4l2 devices
    • Enhanced device capability information (including capability description)
    • Access to media info (including bus info, driver, card, model, etc)
    • Driver version information
    • Video input information (i.e. video input status)
    • Enhanced pixel format description (including format sizes)
    • Enhanced crop capability (with default crop bounds)
    • Access to stream parameters (including both capture and output capabilities and capture modes)

    See the device info example for detail.

    Source code(tar.gz)
    Source code(zip)
  • v0.0.1(Nov 14, 2021)

    This release comes after an internal rewrite to use cgo-generated types and values (instead of hand-crafted types) to deal with type alignment issues. Since the project targets the Linux OS, there is no need to be concerned with portability or cross-platform supportability.

    The API is the same from the previous release. However, there are some changes that will cause code breakage (if you are using the previously tagged version) in how some types expose their values.

    Features

    • Capture and control video data from your Go programs
    • Idiomatic Go API for device access and video capture
    • Use cgo-generated types for correct data representation in Go
    • Use familiar types such as channels to stream video data
    • Exposes device enumeration and information
    • Provides device capture control
    • Access to video format information
    • Streaming support using memory map (other methods coming later)

    Examples

    The ./examples directory contains additional examples including:

    • device_info - queries and prints devince information
    • webcam - uses the v4l2 package to create a simple webcam that streams images from an attached camera accessible via a web page.
    Source code(tar.gz)
    Source code(zip)
Owner
Vladimir Vivien
Software Engineer, VMware
Vladimir Vivien
Go-video-preview-ffmpeg-wrapper - A simple helper wrapper to generate small webm video previews using ffmpeg, useful for web previews.

Go-video-preview-ffmpeg-wrapper A simple helper wrapper to generate small webm video previews using ffmpeg, useful for web previews. Getting Started u

Robert van Alphen 0 Jan 5, 2022
A simple library to extract video and audio frames from media containers (based on libav).

Reisen A simple library to extract video and audio frames from media containers (based on libav, i.e. ffmpeg). Dependencies The library requires libav

NightGhost 59 Sep 20, 2022
lmmp3 is a little golang library that download a video from youtube, and convert it to a mp3 file using ffmpeg

lmmp3 lmmp3 is a function that download a video from youtube, and convert it to a mp3 file using ffmpeg You need to have installed ffmpeg in your syst

pai 8 Aug 12, 2022
Personal video streaming server.

tube This is a Golang project to build a self hosted "tube"-style video player for watching your own video collection over HTTP or hosting your own ch

davy wybiral 230 Sep 21, 2022
Short video direct link acquisition 短视频直连获取工具

Glink 短视频去水印一键解析应用 Short video direct link acquisition 短视频直连获取工具 Glink是一款基于go语言开发的短视频解析应用,前端使用vue+argon主题,后端使用go-fiber框架,支持web在线模式、客户端模式。

佰阅 145 Sep 21, 2022
Quik.do is a video conferencing tool.

Quik.do is a video conferencing tool.

Bora Tanrıkulu 115 Aug 18, 2022
Take control over your live stream video by running it yourself. Streaming + chat out of the box.

Take control over your content and stream it yourself. Explore the docs » View Demo · Use Our Server for Testing · FAQ · Report Bug Table of Contents

Owncast 6.4k Sep 18, 2022
live video streaming server in golang

中文 Simple and efficient live broadcast server: Very simple to install and use; Pure Golang, high performance, and cross-platform; Supports commonly us

浩麟 8.3k Sep 27, 2022
LiveKit - Open source, distributed video/audio rooms over WebRTC

LiveKit is an open source project that provides scalable, multi-user conferencing over WebRTC. It's designed to give you everything you need to build real time video/audio capabilities in your applications.

LiveKit 3.9k Sep 24, 2022
Stream video from ffmpeg to webrtc

ffmpeg-to-webrtc demonstrates how to send video from ffmpeg to your browser using pion.

Artur Shellunts 867 Sep 8, 2022
Project to get Youtube video descriptions and search those videos as required

FamPayProject Project to get Youtube video descriptions and search those videos as required Prerequisities Postgres DB for persisting data Youtube Dat

null 0 Nov 5, 2021
Synthetic media is a realistic transformation of audio and video using artificial intelligence.

Synthetic media is a realistic transformation of audio and video using artificial intelligence.

null 1 Nov 20, 2021
Video converter with golang

Requirements Debian-like system (ubuntu, mint, etc...) with apt package manager Golang >1.15 Command tool make (use sudo apt install make -y to instal

Anaxita 2 Sep 10, 2022
golang function that download a video from youtube, and convert it to a mp3 file using ffmpeg

echedwnmp3 echedwnmp3 is a function that download a video from youtube, and convert it to a mp3 file using ffmpeg example package main import(echedwn

pai 4 Dec 7, 2021
ffcommander - An easy frontend to FFmpeg and Imagemagick to automatically process video and manipulate subtitles.

% FFCOMMANDER(1) ffcommander 2.39 % Mikael Hartzell (C) 2018 % 2021 Name ffcommander - An easy frontend to FFmpeg and Imagemagick to automatically pro

Mikael Hartzell 2 May 9, 2022
A go program that relies on back-end ffmpeg to process video-related content

Video Compress A go program that relies on back-end ffmpeg to process video-related content Installation v-go You can download the corresponding v-go

JokerHeyra 0 Dec 22, 2021
👾 Annie is a fast, simple and clean video downloader built with Go.

?? Annie is a fast, simple and clean video downloader built with Go. Installation Prerequisites Install via go install Homebrew (macOS only) Arch Linu

Rohan 1 Jun 1, 2022
SlideXtract - A tool to help extract slides from a video file.

SlideXtract A tool to help extract slides from a video file. Slides are output in the out folder. Features I didn't find any other piece of code that

Soumitra Shewale 2 Jul 3, 2022
📽 MovieGo - Video Editing in Golang

?? MovieGo - Video Editing in Golang MovieGo is a Golang library for video editing. The library is designed for fast processing of routine tasks relat

Student B. 128 Sep 17, 2022