Webcam setup

Related articles
Libcamera
This is a guide to setting up your
webcam
. Most probably your webcam will work out of the box. Permissions to access video devices—e.g.
/dev/video0
—are handled by
udev
, there is no configuration necessary.
Loading
Most recent webcams are
USB video device class
(UVC) compliant and are supported by the generic
uvcvideo
kernel driver module. To check that your webcam is recognized, see the
journal
just after you plug the webcam in. You should see something like this:
kernel: sn9c102: V4L2 driver for SN9C10x PC Camera Controllers v1:1.24a
usb 1-1: SN9C10[12] PC Camera Controller detected (vid/pid 0x0C45/0x600D)
usb 1-1: PAS106B image sensor detected
usb 1-1: Initialization succeeded
usb 1-1: V4L2 device registered as /dev/video0
usb 1-1: Optional device control through 'sysfs' interface ready
usbcore: registered new driver sn9c102
Some pre-UVC webcams are also supported via the
gspca
kernel driver module. See the
gspca cards list
for a non-exhaustive list of supported devices under this framework.
Otherwise, if your webcam is not supported by the
kernel
drivers, an external driver is necessary:
The first step is to identify the name of the webcam, using for example
lsusb
.
Then you can check
Webcam devices
for information and resources about webcams.
Once you find a driver compatible with the webcam, you can
load the module at boot
.
Note
The Linux kernel to userspace API used to control webcams is named
Video4Linux
(V4L, or
V4L2
). All applications which support V4L2 will work with the kernel drivers.
Configuration
If you want to configure brightness, color and other webcam parameters (e.g. in the case when out-of-the-box colors are too bluish/reddish/greenish) you may use a variety of applications. Some specific webcams such as the Logitech Brio or the Razer Kiyo Pro might require a specific application for some of their specific options such as
HDR
. Changing any settings in an application that configures V4L settings will generally change those settings for all applications using those cameras unless they override those settings themselves.
Command line
v4l-utils
installs a command line tool,
v4l2-ctl
.
To list all video devices:
$ v4l2-ctl --list-devices
To list the configurable settings of a video device:
$ v4l2-ctl -d /dev/video0 --list-ctrls
You can change the settings of the video device by doing the following:
$ v4l2-ctl -c brightness=128
Alternatively, you can use
cameractrls
:
$ cameractrls -c brightness=128
Graphical
For generic graphical webcam configuration tools you can use either
qv4l2
from
v4l-utils
or
guvcview
. In addition to this,
cameractrls
contains
cameractrlsgtk4
which allows you to configure some camera-specific features for the Logitech Brio as well as the Razer Kiyo Pro on top of supporting all the other V4L options.
Persisting configuration changes
Configuration made via V4L2 does not persist after the webcam is disconnected and reconnected. It is possible to use
v4l2-ctl
with
udev
rules in order to set some configuration each time a particular camera is connected.
For example, to set a default zoom setting on a particular Logitech webcam each time it is connected, add a
udev rule
like this:
/etc/udev/rules.d/99-logitech-default-zoom.rules
SUBSYSTEM=="video4linux", KERNEL=="video[0-9]*", ATTR{index}=="0", ATTRS{idVendor}=="046d", ATTRS{idProduct}=="0892", RUN+="/usr/bin/v4l2-ctl -d $devnode --set-ctrl=zoom_absolute=170"
The above rule is valid for the Logitech C920 HD Pro Webcam - hardware ID 046d:0892.
The device's vendor id and product id can be found using
lsusb
. These are unique per product and do not change unless the product gets a new hardware revision.
To find udev attributes like the product name and serial, see
udev#List the attributes of a device
. It is also possible to
set a static name for a video device
).
Disable internal laptop webcam
Sometimes we might want to disable a laptop's internal webcam so that only the one attached via USB is showing. This can be done with a udev rule. First we will need the device's vendor id and the product id:
$ lsusb
Bus 001 Device 008: ID
1bcf:28c1
Sunplus Innovation Technology Inc. Integrated_Webcam_HD
Then we add new udev rule to remove the device as soon as it is detected:
/etc/udev/rules.d/40-disable-internal-webcam.rules
ACTION=="add", ATTR{idVendor}=="
1bcf
", ATTR{idProduct}=="
28c1
", RUN="/bin/sh -c 'echo 1 >/sys/\$devpath/remove'"
Disable webcam completely
To disable webcam completely, you can
blacklist
the
uvcvideo
kernel module. For example:
/etc/modprobe.d/nowebcam.conf
blacklist uvcvideo
Applications
See also
List of applications/Multimedia#Webcam
.
FFmpeg
See
v4l2loopback#Use cases
for various examples, where FFmpeg is used to output video to a v4l2 device, which can be used as a webcam.
For laptops without a webcam, an IP camera can be used as an alternative to droidcam which does not keep the extra webcam device hanging around. For android, something like
IP webcam
can be hosted on the phone, then use the IP camera as a video input for the laptop. First, install
linux-headers
and
v4l2loopback-dkms
, then connect to the video source as
/dev/video0
using
v4l2loopback
with
192.168.1.
xxx
being the IP address of the phone:
# modprobe v4l2loopback exclusive_caps=1
$ ffmpeg -i http://192.168.1.
xxx
:8080/video -vf format=yuv420p -f v4l2 /dev/video0
Note
exclusive_caps=1
helps solve the issue of the video input not usable on some Chrome/WebRTC applications
[1]
.
Firefox
Firefox
may use not the highest resolution possible by default, leading to 4:3 image being captured from a 16:9 capable webcam. You can force specific resolution in
about:config
via
media.navigator.video.default_height
and
media.navigator.video.default_width
settings.
For example, to force 1920x1080 captured output, set
media.navigator.video.default_width
to
1920
.
MPlayer
To use
MPlayer
to take snapshots from your webcam run this command from the terminal:
$ mplayer tv:// -tv driver=v4l2:width=640:height=480:device=/dev/video0 -fps 15 -vf screenshot
From here you have to press
s
to take the snapshot. The snapshot will be saved in the current folder as
shotXXXX.png
.
If you want to record video continuous:
$ mencoder tv:// -tv driver=v4l2:width=640:height=480:device=/dev/video0:forceaudio:adevice=/dev/dsp -ovc lavc -oac mp3lame -lameopts cbr:br=64:mode=3 -o
filename
.avi
Press
Ctrl+c
to end the recording.
To play video with
MPlayer
using MJPEG as the pixelformat instead of the default, which in most cases is YUYV, you can run the following:
$ mplayer tv:// -tv driver=v4l2:width=640:height=480:device=/dev/video0:outfmt=mjpeg -fps 15
mpv
To use
mpv
to take snapshots from your webcam, run this command from the terminal:
$ mpv av://v4l2:/dev/video0 --profile=low-latency --untimed
From here you have to press
s
to take the snapshot. The snapshot will be saved in your current folder as
mpv-shot
NNNN
.jpg
.
To use MJPEG as the pixelformat instead of the default, which in most cases is YUYV, you can run the following instead:
$ mpv --demuxer-lavf-format=video4linux2 --demuxer-lavf-o-set=input_format=mjpeg av://v4l2:/dev/video0
In some cases this can lead to drastic improvements in quality and performance (5FPS -> 30FPS for example).
To adjust webcam settings, including the resolution,
see the mpv documentation
.
VLC
VLC
can also be used to view and record your webcam. In VLC's
Media
menu, open the
Capture Device...
dialog and enter the video and audio device files. Or from the command line, for example:
$ vlc v4l2://:input-slave=alsa://:v4l-vdev="/dev/video0"
This will make VLC mirror your webcam.
To take stills, simply choose
Snapshot
in the
Video
menu.
To record the stream, add a
--sout
argument to the command line, e.g.
$ vlc v4l2://:v4l-vdev="/dev/video0":v4l-adev="/dev/audio2" --sout "#transcode{vcodec=mp1v,vb=1024,scale=1,acodec=mpga,ab=192,channels=2}:duplicate{dst=std{access=file,mux=mpeg1,dst=/tmp/test.mpg}}"
Note that by default this will not display the video. In order to see what you are recording, you need to add the display as a destination to the argument (which will slow down the operation):
... :duplicate{
dst=display
,dst=std{access= ....
Note
If VLC does not detect webcams, ensure that the packages
zvbi
and
vlc-plugin-zvbi
are installed.
xawtv
This is a basic
Video4Linux2
device viewer, and although it is intended for use with TV tuner cards, it works well with webcams. It will display what your webcam sees in a window.
Install
xawtv
AUR
and run it with:
$ xawtv -c /dev/video0
In case of error see
#xawtv with NVIDIA card
.
Troubleshooting
xawtv with NVIDIA card
If you are using an NVIDIA graphics card, and get an error like:
X Error of failed request:  XF86DGANoDirectVideoMode
 Major opcode of failed request:  139 (XFree86-DGA)
 Minor opcode of failed request:  1 (XF86DGAGetVideoLL)
 Serial number of failed request:  69
 Current serial number in output stream:  69
you should instead run it as
xawtv -nodga
.
Microsoft Lifecam Studio/Cinema
Under certain configurations, the Microsoft lifecam studio/cinema may request too much usb bandwidth and fail
see Uvcvideo FAQ
. In this case, change the buffering by loading the
uvcvideo
driver with
quirks=0x80
. Add it to
/etc/modprobe.d/uvcvideo.conf
:
/etc/modprobe.d/uvcvideo.conf
## fix bandwidth issue for lifecam studio/cinema
options uvcvideo quirks=0x80
Note
If delays are visible in the logs, or the camera works periodically, this workaround should apply generally. Bigger values such as
quirks=0x100
are possible.
Check bandwidth used by USB webcams
When running multiple webcams on a single USB bus, they may saturate the bandwidth of the USB bus and not work properly. You can diagnose this with the
usbtop
tool from the
usbtop
AUR
package.
Invert the video stream
If your video stream is inverted, you can make a new virtual video camera which inverts the inverted video. You need to
install
v4l-utils
and also
v4l2loopback-dkms
. Create the virtual video camera:
# modprobe v4l2loopback
Check the name of the newly created camera:
$ v4l2-ctl --list-devices
Dummy video device (0x0000) (platform:v4l2loopback-000):
   	/dev/video1
Then you can run
ffmpeg
to read from your actual webcam (here
/dev/video0
) and invert it and feed it to the virtual camera:
$ ffmpeg -f v4l2 -i /dev/video0 -vf "vflip" -f v4l2 /dev/video1
Here
vflip
inverts the video stream vertically. Use
hflip
to invert it horizontally.
Note that the format argument
yuv420p
might be needed to avoid an error, otherwise there might not be any video stream and a black screen will be shown
[2]
. In other words:
$ ffmpeg -f v4l2 -i /dev/video0 -vf "hflip,format=yuv420p" -f v4l2 /dev/video1
You can then use the "Dummy" camera in your applications instead of the "Integrated" camera.
Bad image quality
If you experience images being too bright, too dark, too exposed or any other, you can install
v4l2ucp
AUR
to tweak your image output.
Logitech Quickcam Pro 9000
Install
libwebcam-git
AUR
to enable autofocus control. After the installation, disconnect and reconnect your camera to trigger the newly added
udev rules
.
Creality Webcam
Creality webcam is based on the Fullhan FH8852 chip used in many cheap 2MP cameras (USB ID
1d6c:0103
), but its firmware requires a special sequence to enable it, otherwise you'll get a black screen. Trying to grab a frame using FFmpeg seems to properly initialize the device, making it work on other apps. You might have to try the following on both
/dev/video0
and
/dev/video2
, and see which one produces a correct
/tmp/test_img.jpg
image:
$ ffmpeg -i /dev/video0 /tmp/test_img.jpg
Once done, the camera should work on web browser, applications like Cheese, etc.