Czy jest coś lepszego niż Cheese do przechwytywania wideo?

Muszę nagrać trochę wideo z mojej kamery internetowej, a podczas gdy Cheese działa, brakuje ustawień i wysyła tylko format webm, który jest pełen jąkania itp.

Nie mogę znaleźć żadnej alternatywy ...

Guvcview ma na celu zapewnienie prostego interfejsu GTK do przechwytywania i przeglądania wideo z urządzeń obsługiwanych przez sterownik Linux UVC, chociaż powinien on również współpracować z dowolnym urządzeniem kompatybilnym z v4l2.

Projekt opiera się na luvcview do renderowania wideo, ale wszystkie formanty są budowane przy użyciu interfejsu GTK2.

Guvcview (od wersji 0.9.9) ma okno tylko kontroli, (z konsoli guvcview --control_only:), pozwala to kontrolować obraz w innych aplikacjach, takich jak ekiga, ser, mplayer, skype ...

Audio.

Obsługa dźwięku Guvcview oparta jest na bibliotece portaudio, do wersji 0.9.3 do przechwytywania dźwięku używano API blokującego, ponieważ zamiast wersji 0.9.4 stosowana jest metoda wywołania zwrotnego, co zapewnia lepszą wydajność, jest to również preferowana metoda portaudio API.

Wszystkie interfejsy (ALSA, OSD, JACK, ...) obsługiwane przez portaudio powinny być dostępne w guvcview. Upewnij się tylko, że portaudio zostało skompilowane z włączonymi żądanymi interfejsami.

Kontrola dynamiczna UVC.

Sterownik Linux UVC ma implementację dla kontrolek rozszerzeń (są to kontrolki specyficzne dla producenta i są obsługiwane w specyfikacji UVC), nazywane są kontrolkami dynamicznymi, ponieważ muszą być dynamicznie ładowane do sterownika.

Do dzisiaj tylko firma Logitech dostarczyła specyfikacje dla swoich kontrolek rozszerzających kamerę internetową UVC, są one obsługiwane przez guvcview.

W nowych wersjach sterowników potrzebne są uprawnienia administratora w celu dodania tych elementów sterujących do sterownika, więc istnieją zasadniczo dwa rozwiązania:

1. uruchom guvcview jako root (używając sudo) co najmniej raz na sesję, ponieważ w wersji 1.2.0 możesz to zrobić z opcją --add_ctrlsunikania konieczności pełnego uruchamiania guvcview

2. zainstaluj libwebcam to oprogramowanie ma skrypt udev, który powinien dodać niezbędne elementy sterujące do kamery Logitech.

Zainstaluj Guvcview na Ubuntu 12.04 za pośrednictwem ppa

sudo add-apt-repository ppa:pj-assis/ppa
sudo apt-get update
sudo apt-get install guvcview

Jeśli potrzebujesz nowej aplikacji, guvcview jest dobry.

https://launchpad.net/guvcview

Części tego pytania pochodzą z odpowiedzi na to pytanie: Nagraj z taśm VHS .

Musimy upewnić się, że oprogramowanie zbiera odpowiednie dane z właściwego urządzenia. Upuśćmy zapytanie w terminalu, które pozwoli nam zobaczyć, ile urządzeń jest podłączonych do twojego komputera, których można użyć do gromadzenia obrazów, użyj tego polecenia w terminalu:

ls -l /dev/video*

Wyniki powinny być takie:

geppettvs@DYLAN:~$ ls -l /dev/video*
crw-rw----+ 1 root video 81, 0 2012-04-17 19:53 /dev/video0
crw-rw----+ 1 root video 81, 1 2012-04-17 19:53 /dev/video1
crw-rw----+ 1 root video 81, 2 2012-04-18 17:54 /dev/video2
geppettvs@DYLAN:~$ 

W moim przypadku mam 3 urządzenia wideo, z których jednym jest tuner telewizyjny USB, którego używam do oglądania / nagrywania programów telewizyjnych na żywo / konwertera VTR / VCR / RF-DVD / Video i innych sygnałów RF.

Pozostałe urządzenia to kamera internetowa USB podłączona do gniazd USB w komputerze.

Jeśli kamera internetowa jest wyposażona w mikrofon, zarówno dźwięk, jak i wideo można nagrywać za pomocą skryptu tvcap autorstwa Andreasa Schalk , którego kod umieszczam tutaj dla Twojej wygody:

#!/bin/bash
#
#  tvcap-script by Andreas Schalk, easycap.blogspot.com (Dec. 2011)
#  This script is based an a template TV-script from Jose Catre-Vandis (Jan 2006).
#  The ascii artwork is based on a template i found here: http://www.retrojunkie.com/asciiart/electron/tv.txt
#  Contact: [email protected]
#-----------------------------------------------------------------------------
#
#  FUNCTION: This script provides Zenity menues for viewing an capturing video with a tv-card on Linux.
#
#  Supported programs: MPlayer, MEncoder, VLC, Tvtime, Cheese und Sox
# 
#-----------------------------------------------------------------------------
#  
#  Basic options:
#
#  Change the following parameters for viewing/ capturing according to your needs
#
#-----------------------------------------------------------------------------
VERBOSE=1   # if '0', this script does not show messages window and does not ask for norm and input number anymore
NORM="PAL"  # preselect tv norm 'PAL' or 'NTSC'
INPUT_NR=0      # preselect input number of your easycap where video source is plugged in
input_width=720     # preselect width an height of video source (mplayer, vlc, mencoder)
input_height=576    # other possible combinations: 640/480; 320/240 
ASPECT=169          # '169' (16:9) or '43' (4:3); this value affects video playback with mplayer or vlc only!
FREQ="48000"        # on soundproblems reduce audio frequency (44100 oder 32000 oder 8000)
TV_INPUT="no"       # if 'yes' the analogue antenna input of the tv-card will be used (mplayer only)
CHAN="chanlist=europe-west:channel=60"      # channel setting (nur mplayer/ mencoder) the analogue antenna input of the tv-card is used
NORM="PAL"          # preselect TV-norm 'PAL' oder 'NTSC'
INPUT_NR=1          # preselct the Input on the TV-card, where the videosource is plugged in ('0' normally is the antenna, '1' the first CVBS ...
#-----------------------------------------------------------------------------

MESSAGE=()
R_MESSAGE=()
EXITCODE=0

#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
#   test videodevices
##-----------------------------------------------------------------------------

declare -a VIDEO_DEV

VIDEO_DEV=( TRUE    none
            FALSE   none
            FALSE   none
            FALSE   none
            ) 
i1=0;
i2=0;
while `test -e "/dev/video${i1}"`; do
  VIDEO_DEV[$i2+1]="/dev/video${i1}"; 
  i1=$[$i1+1];
  i2=$[$i2+2];
done
if [ "xnone" = "x${VIDEO_DEV[1]}" ]; then 
  zenity  --error --timeout=5 --text "Cannot find /dev/video0!\n Script ends in 5 seconds" --title "No videodevice!";
  exit 1;
fi

if [ "x${VIDEO_DEV[$i2+1]}" = "xnone" ];  then
    VIDEO_DEV[$i2]="" && VIDEO_DEV[$i2+1]="" && VIDEO_DEV[$i2+2]="" && VIDEO_DEV[$i2+3]="" && VIDEO_DEV[$i2+4]="" && VIDEO_DEV[$i2+5]="";
fi

DEV_VIDEO=$(zenity --list --text "Select videodevice" --radiolist --column "Choice" --column "Device" ${VIDEO_DEV[@]}) || exit 0 

if [ ${VERBOSE} = 1 ]; then
#-----------------------------------------------------------------------------
#  select TV norm
#-----------------------------------------------------------------------------
title="Select tv norm"
NORM=`zenity --title="$title" --list --radiolist --column="Choice" \
    --column="Norm" --column="Description" \
    TRUE "PAL" "PAL Norm" \
    FALSE "NTSC" "NTSC Norm" \
    ` || exit 0 
fi
#-----------------------------------------------------------------------------
#  select Input number
#-----------------------------------------------------------------------------
title="Select Input NR"
INPUT_NR=`zenity --title="$title" --list --radiolist --column="Choice" \
    --column="Input NR" --column="Description" \
    TRUE "0" "Input 1 (TV)" \
    FALSE "1" "Input 2" \
    FALSE "2" "Input 3" \
    FALSE "3" "Input 4" \
    FALSE "4" "Input 5" \
    FALSE "5" "Input 6"
    ` || exit 0 
#-----------------------------------------------------------------------------


#-----------------------------------------------------------------------------
#  Check if snd_usb_audio module is loaded
#-----------------------------------------------------------------------------
SND_USB=`lsmod | grep snd_usb_audio | wc -l`
if  [ "${SND_USB}" -ge "1" ]; then
#  MESSAGE=("${MESSAGE[@]}" "\nNOTE: snd_usb_audio module was loaded and may conflict with your USB capture device")
   zenity  --info --text "NOTE: The snd_usb_audio module was loaded\nand may conflict with your USB capture device.\n \nIf sound problems appear,\nplug out your USB capturedevice and run\n rmmod snd_usb_audio \nas root in the terminal!" --title "Snd_usb_audio module loaded!"
fi

#-----------------------------------------------------------------------------
# test and select soundcard
#-----------------------------------------------------------------------------

if `test ! -e /dev/dsp` && [ -z "`ls -1 /proc/asound`" ]; then
    if_audio="no";
    echo "No soundcard detected";
    MESSAGE=("${MESSAGE[@]}" "Note: No soundcard can be found!\nSound is not supported.\n");
else
if_audio="yes"
declare -a SOUND_DEV

SOUND_DEV=( FALSE   /dev/dsp    OSS
            FALSE   card1   ALSA    
            TRUE    card2   ALSA
            FALSE   card3   ALSA
            ) 

test ! -e /dev/dsp && echo "No dsp" && SOUND_DEV[0]="" && SOUND_DEV[1]="" && SOUND_DEV[2]=""

ALSA_CARD=$(cat /proc/asound/cards | cut -d":" -f1 -s)
declare -a ALSA_CARDS
ALSA_CARDS=(${ALSA_CARD})

i5=1
for P in ${ALSA_CARDS[@]}; do
    ALSA_NAME=$(echo ${ALSA_CARDS[$i5]} | tr -d [=[=] );
    SOUND_DEV[$i5+3]=$ALSA_NAME
    if [ "x${ALSA_NAME}" = "x" ];  then
    SOUND_DEV[$i5+2]="" && SOUND_DEV[$i5+3]="" && SOUND_DEV[$i5+4]=""
    fi
    i5=$[$i5+3];
done
fi

DEV_AUDIO=$(zenity --list --text "Select soundcard" --radiolist --column "Choice" --column "Device" --column "Type" ${SOUND_DEV[@]}) || exit 0 

if [ $DEV_AUDIO = "/dev/dsp" ]; then 
    AUDIO_TYPE="oss"
    else
    AUDIO_TYPE="alsa"
fi
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
#   test, if devicenodes are read- and writable for unprivileged users
#-----------------------------------------------------------------------------

if [ -r ${DEV_VIDEO} ] && [ -w ${DEV_VIDEO} ]; then
MESSAGE=("${MESSAGE[@]}" "\nSUCCESS! ${DEV_VIDEO} is read- and writable!\n")
elif [ -e ${DEV_VIDEO} ]; then
zenity --info --text "Cannot access ${DEV_VIDEO}!\nRun 'sudo chmod a+rw ${DEV_VIDEO}'\nin the terminal!" --title "Message"
EXITCODE=1
fi

    if [ -r ${DEV_AUDIO} ] && [ -w ${DEV_AUDIO} ]; then
    MESSAGE=("${MESSAGE[@]}" "\nSUCCESS! ${DEV_AUDIO} is read- and writable!")
    elif [ -e ${DEV_AUDIO} ]; then
    zenity --info --text "\nCannot access ${DEV_AUDIO}!\nRun 'sudo chmod a+rw ${DEV_AUDIO}'\nin the terminal!" --title "Message"
    MESSAGE=("${MESSAGE[@]}" "\n\nCannot access ${DEV_AUDIO}!\nRun 'sudo chmod a+rw ${DEV_AUDIO}'\nin the terminal!!")
    if_audio="no"
    fi
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
#  find executable programs
#-----------------------------------------------------------------------------
PROG_LIST=( TRUE    vlc     #
            FALSE   mplayer     #
            FALSE   cheese      #
            FALSE   tvtime      #
            FALSE   mencoder    #
            FALSE   sox         #
            ) 

PROGS=(vlc mplayer cheese tvtime mencoder sox)
i4=0
for P in ${PROGS[@]}; do
            PROG=`which $P`
            if [ "x" = "x${PROG}" ] || [ ! -x ${PROG} ]; then
            echo "Cannot find or execute $P. Is t installed?"
            MESSAGE=("${MESSAGE[@]}" "\nCannot find or execute $P. Is it installed?")
            PROG_LIST[$i4]=""
            PROG_LIST[$i4+1]=""
                if [ "${PROG_LIST[11]}" = "" ]; then
                echo "Sox is needed for sound with tvtime!"
                MESSAGE=("${MESSAGE[@]}" "\nSox is needed for sound with tvtime!")
                fi          
            fi
            i4=$i4+2
done
PROG_LIST[10]=""        # Sox does not show up on list
PROG_LIST[11]=""        #
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
#  messages are displayed and script ends
#-----------------------------------------------------------------------------
if [ ${EXITCODE} = 1 ]; then
    MESSAGE=("${MESSAGE[@]}" "\nScript ends")
fi
echo ${MESSAGE[*]}
#########################
if [ ${VERBOSE} = 1 ]; then
zenity --height="50" --info --text "${MESSAGE[*]}" --title "Messages"
fi

if [ ${EXITCODE} = 1 ]; then
    exit 1
fi
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
#  create logfile
#-----------------------------------------------------------------------------
LOGFILE="./test`echo "${DEV_VIDEO}" | sed -e "s,/dev/,," - `.log"

# echo "Log file is:  ${LOGFILE}"
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
#  zenity list - program choice
#-----------------------------------------------------------------------------

view_cap=$(zenity --list --width=250 --height=400 --text "  ___________\n |  .----------.  o|\n | |   Easy  | o|\n | |   CAP_  | o|\n |_\`-----------´ _|\n   ´\`          ´\`\\nTv-norm: $NORM  Input-Nr:$INPUT_NR\nVideodevice: $DEV_VIDEO $input_width x $input_height \nAudiodevice: $AUDIO_TYPE $DEV_AUDIO $FREQ Hz\nIs audio on? $if_audio\nLogfile: $LOGFILE " --radiolist --column "Choice" --column "program" ${PROG_LIST[@]}) || exit 0

#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
#  mplayer command
#-----------------------------------------------------------------------------
if [ "alsa" = "${AUDIO_TYPE}" ]; then
M_AUDIO="buffersize=16:alsa:amode=1:forcechan=2:audiorate=${FREQ}:adevice=plughw.${DEV_AUDIO}"
elif [ "oss" = "${AUDIO_TYPE}" ]; then
M_AUDIO="adevice=${DEV_AUDIO}"
fi

if [ "$NORM" = "PAL" ]; then
    fps_count=25
else 
    fps_count=30
fi

if [ "$ASPECT" = 169 ]; then
    M_ASPECT="-aspect 1.78"
#   elif [ "$ASPECT" = 43 ]; then
#   M_ASPECT="-aspect 1"
    else
    M_ASPECT=""
    fi

if [ "yes" = "${TV_INPUT}" ]; then
M_VIDEO="${CHAN}"
elif [ "no" = "${TV_INPUT}" ]; then
M_VIDEO="norm=${NORM}:width=${input_width}:height=${input_height}:outfmt=uyvy:device=${DEV_VIDEO}:input=${INPUT_NR}:fps=${fps_count}"
fi

#echo $M_VIDEO
#echo $M_AUDIO
#echo $view_cap

if [ "mplayer" = "${view_cap}" ]; then


if [ "$if_audio" = "yes" ]; then    
1>${LOGFILE} 2>&1 \
mplayer tv:// -tv driver=v4l2:${M_VIDEO}:${M_AUDIO}:forceaudio:immediatemode=0 -hardframedrop ${M_ASPECT} -ao sdl, ${AUDIO_TYPE} -msglevel all=9

elif [ "$if_audio" = "no" ]; then
1>${LOGFILE} 2>&1 \
mplayer tv:// -tv driver=v4l2:${M_VIDEO} -hardframedrop ${M_ASPECT} -msglevel all=9 -nosound
fi
fi
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
#  vlc command
#-----------------------------------------------------------------------------
if [ "vlc" = "${view_cap}" ]; then

    if [ "alsa" = "${AUDIO_TYPE}" ]; then
    V_AUDIO="//plughw:${DEV_AUDIO}"
    elif [ "oss" = "${AUDIO_TYPE}" ]; then
    V_AUDIO="//${DEV_AUDIO}"
    fi

    if [ "$NORM" = "PAL" ]; then
    V_NORM="pal"
    elif [ "$NORM" = "NTSC" ]; then
    V_NORM="ntsc"
    fi

    if [ "$ASPECT" = 169 ]; then
    V_ASPECT="--aspect-ratio=16:9"
    elif [ "$ASPECT" = 43 ]; then
    V_ASPECT="--aspect-ratio=4:3"
    else
    V_ASPECT=""
    fi

1>${LOGFILE} 2>&1 \
vlc -vvv v4l2://${DEV_VIDEO}:input=${INPUT_NR}:width=$input_width:height=$input_height:norm=${V_NORM} ${V_ASPECT} :input-slave=${AUDIO_TYPE}:${V_AUDIO} --demux rawvideo 
fi
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
#  tvtime command
#-----------------------------------------------------------------------------
if [ "tvtime" = "${view_cap}" ]; then
    if [ "alsa" = "${AUDIO_TYPE}" ]; then
    T_AUDIO="-t alsa plughw:${DEV_AUDIO} -s2 -c 2 -r ${FREQ} -s2 -t alsa default"
    elif [ "oss" = "${AUDIO_TYPE}" ]; then
    T_AUDIO="-t raw -s2 ${DEV_AUDIO} -c 2 -r ${FREQ} -s2 -t ossdsp /dev/dsp"
    fi
echo $T_AUDIO
1>${LOGFILE} 2>&1 \
>./tvtime.err
(tvtime -d ${DEV_VIDEO} -i 0 -n "${NORM}" 1>/dev/null 2>>./tvtime.err) &
rc=1
while [ 0 -ne ${rc} ];
do
  tvtime-command run_command "(sox -c 2 -r ${FREQ} ${T_AUDIO} 1>/dev/null 2>>./tvtime.err)" 1>/dev/null 2>>./tvtime.err
  rc=$?
  if [ 0 -eq ${rc} ]; then break; fi
  sleep 0.5
done
fi
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
#  cheese command
#-----------------------------------------------------------------------------
if [ "cheese" = "${view_cap}" ]; then
1>${LOGFILE} 2>&1 \
cheese
fi
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
#  mencoder command - recording section
#-----------------------------------------------------------------------------

if [ "mencoder" = "${view_cap}" ]; then

#Auswahl des Seitenverhältnisses der Aufnahme?
title="Chose aspect of your target file!"
aspect_type=`zenity  --width="400" --height="220" --title="$title" --list --radiolist --column="Click Here" \
    --column="choice" --column="source >> target" \
    TRUE "1" "4:3 > 4:3"\
    FALSE "2" "4:3 > scale=16:9" \
    FALSE "3" "4:3 > crop borders=16:9" \
    ` || exit 0 

if [ "$aspect_type" = "1" ]; then
    crop_scale="scale=640:480"
elif [ "$aspect_type" = "2" ]; then
    crop_scale="scale=720:406"
elif [ "$aspect_type" = "3" ]; then
    crop_scale="crop=720:406:0:72"
fi  

#################################################################################
#Quality?
title="What quality do you want to record at ?"
qual_type=`zenity  --width="380" --height="380" --title="$title" --list --radiolist --column="Click Here" \
    --column="Record Time" --column="Description" \
    FALSE "500" "Passable Quality"\
    FALSE "900" "OK Quality"\
    FALSE "1100" "VHS Quality"\
    TRUE "1300" "SVHS Quality"\
    FALSE "1500" "VCD Quality"\
    FALSE "1800" "SVCD Quality" \
    FALSE "2000" "Very Good Quality"\
    FALSE "2500" "High Quality" \
    FALSE "3000" "Excellent Quality"\
    ` || exit 0

##################################################################################
#How Long?
title="How long do you want to record for ?"
time_type=`zenity  --width="380" --height="500" --title="$title" --list --radiolist --column="Click Here" \
    --column="Record Time" --column="Description" \
    FALSE "00:00:00" "unlimited"\
    TRUE "00:00:30" "30 seconds for testing"\
    FALSE "00:10:00" "0.2 hours"\
    FALSE "00:30:00" "0.5 hours"\
    FALSE "00:45:00" "0.75 hours"\
    FALSE "01:00:00" "1 hour"\
    FALSE "01:15:00" "1.25 hours"\
    FALSE "01:30:00" "1.5 hours" \
    FALSE "01:45:00" "1.75 hours"\
    FALSE "02:00:00" "2 hours" \
    FALSE "02:15:00" "2.25 hours"\
    FALSE "02:30:00" "2.5 hours" \
    FALSE "02:45:00" "2.75 hours"\
    FALSE "03:00:00" "3 hours" \
    FALSE "03:15:00" "3.25 hours" \
    FALSE "03:30:00" "3.5 hours" \
    ` || exit 0

#M_TIME="-endpos $time_type"

#################################################################################
#user must enter a filename
filedate=$(date +%F_%H:%M-%S)
title="Please enter a filename for your recording, no spaces"
file_name=`zenity  --width="480" --height="150" --title="$title" --file-selection --save --confirm-overwrite --filename="tvcap_$filedate"` || exit 0

###########################################################################################
# summary
R_MESSAGE=("${R_MESSAGE[@]}" "\nRecording options:")
R_MESSAGE=("${R_MESSAGE[@]}" "\nRecording audio: $if_audio")
R_MESSAGE=("${R_MESSAGE[@]}" "\nRecording from Input $INPUT_NR - Norm: $NORM $fps_count fps")
R_MESSAGE=("${R_MESSAGE[@]}" "\nCrop and scale options: $crop_scale")
R_MESSAGE=("${R_MESSAGE[@]}" "\nEncoding quality: $qual_type kb/s")
R_MESSAGE=("${R_MESSAGE[@]}" "\nRecording time:$time_type hours")
R_MESSAGE=("${R_MESSAGE[@]}" "\nFile name: $file_name.avi ")

echo ${R_MESSAGE[*]}

if [ ${VERBOSE} = 1 ]; then
zenity --info --text "${R_MESSAGE[*]}" --title "Recording options"
fi
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
#  mencoder line
#-----------------------------------------------------------------------------
if [ "$if_audio" = "yes" ]; then

zenity --info --title="Start recording with audio" --text="Press OK to start."

mencoder tv:// -tv driver=v4l2:norm=$NORM:width=$input_width:height=$input_height:outfmt=uyvy:device=${DEV_VIDEO}:input=${INPUT_NR}:fps=$fps_count:${M_AUDIO}:forceaudio:immediatemode=0 -msglevel all=9 -ovc lavc -ffourcc DX50 -lavcopts vcodec=mpeg4:mbd=2:turbo:vbitrate=$qual_type:keyint=15 -vf pp=lb,$crop_scale -oac mp3lame -endpos $time_type -o $file_name.avi | tee ${LOGFILE} | zenity --progress --pulsate --auto-close --auto-kill --text="Processing Video - length: $time_type H:M:S" 

zenity --info --title="Job complete" --text="The recording is now complete."


elif [ "$if_audio" = "no" ]; then

zenity --info --title="Start recording without audio" --text="Press ok to start recording"
1>${LOGFILE} 2>&1 \
mencoder tv:// -tv driver=v4l2:norm=$NORM:width=$input_width:height=$input_height:outfmt=uyvy:device=${DEV_VIDEO}:input=${INPUT_NR}:fps=$fps_count -msglevel all=9 -nosound -ovc lavc -ffourcc DX50 -lavcopts vcodec=mpeg4:mbd=2:turbo:vbitrate=$qual_type:keyint=15 -vf pp=lb,$crop_scale -endpos $time_type -o $file_name.avi | tee ${LOGFILE} | zenity --progress --pulsate --auto-close --auto-kill --text="Processing Video - length: $time_type H:M:S" 

zenity --info --title="Job complete" --text="The recording is now complete."

fi

fi
exit 1

Po prostu skopiuj / wklej cały ten kod do pliku o nazwie tvcap-script.sh, daj uprawnienia do wykonywania i uruchom go w terminalu. Proces jest dość łatwy i zamierzam wyjaśnić w następujący sposób:

1. - Po naciśnięciu Enter zostaniesz poproszony o źródło przechwytywania i zależnie od lokalizacji urządzenia (przetestowane wcześniej), możesz mieć - jak w moim przypadku - kilka źródeł wideo, używam do tego / dev / video2 przykład, który odnosi się do mojego tunera TV USB. Zwróć uwagę, że ten zrzut ekranu nie otrzymał dekoratora okien, ale opcje i przycisk „OK” można zobaczyć właśnie tam.

2.- Teraz musimy zdefiniować normę, w Meksyku używamy NTSC i chyba, że ​​chcesz uchwycić swój film przy użyciu innej normy o kwadratowym współczynniku proporcji, nie powinieneś używać PAL, co może trochę zaszkodzić jakości twojego wideo. To zależy również od tego, gdzie mieszkasz i od normy twojego kraju.

3.- Mój tuner telewizyjny ma kilka wejść, twój może mieć inną liczbę wejść, sprawdź go i uruchom tyle testów, ile potrzebujesz, aby ustalić, który z nich jest najlepszy do przechwytywania. Użyję tego, który odnosi się do telewizji. (Wejście 1 (TV))

4.- Następnie możesz (lub nie) zostać ostrzeżony i zaoferować rozwiązanie, jeśli coś pójdzie nie tak podczas przechwytywania dźwięku (zarówno dźwięk, jak i wideo zostaną przechwycone jednocześnie, ale jeśli moduł snd_usb_audio został już załadowany, może się zawiesić przechwytywanie audio, a tym samym samo przechwytywanie wideo)

5.- Mój tuner telewizyjny obsługuje kilka wejść audio, w tym integrację z wbudowanym urządzeniem dźwiękowym w mojej płycie głównej (poprzez podłączenie kabla do linii Aux i kontrolowanego przez mikser dźwięku), sprawdzasz, które z nich jest najlepsze dla i pamiętaj, że wartości domyślne są zwykle oznaczone jako „najlepsze dla Ciebie”.

6.- Jeśli wszystko pójdzie dobrze, zobaczysz małe okno z komunikatem, który brzmi mniej więcej tak:

„SUKCES! / Dev / video2 jest dostępny do odczytu i zapisu!”

kliknij „OK”, aby kontynuować.

7.- Następnie możesz wybrać z listy opcji nagrywania dostępnych w systemie. Zainstalowałem to, co widać na następnym zrzucie ekranu. Każdy jest ważny, a jakość nie odzwierciedla istotnych zmian, ale ja osobiście wolę mencoder . Jeśli nie masz zainstalowanego żadnego z nich, zainstaluj go, aby uruchomić testy.

8.- Po wybraniu preferencji oprogramowania do kodowania (w poprzednim kroku) zostaniesz poproszony o podanie współczynnika kształtu. Jeśli nie masz doświadczenia w tym zakresie, po prostu zostaw to tak, jak jest. Zwykle jest to ustawienie domyślne, które lepiej pasuje do sygnału tunera telewizyjnego.

9.- W zależności od twojego wyboru związanego ze współczynnikiem proporcji, będziesz miał kilka opcji jakości wideo, również na podstawie szybkości transmisji, opis w następnym oknie jest bardzo konkretny. Pamiętaj: im wyższy bitrate (najlepsza jakość), rozmiar pliku wideo może stać się ogromną ilością.

10.- Następnie musimy wybrać, jak długo będzie trwać przechwytywanie wideo. Istnieje kilka ustawień wstępnych, w tym przykładzie wybrałem „30 sekund na testowanie”, ale możesz wybrać dowolną, a nawet „nieograniczoną”, aby zdecydować, kiedy zatrzymać nagrywanie.

11.- Następnie zostaniesz poproszony o podanie nazwy pliku, podając domyślnie jedną, którą możesz zmienić na tym ekranie.

12.- Zostaniesz poproszony o sprawdzenie „Opcje nagrywania” na następnym ekranie, po prostu kliknij „OK”.

13.- Jeszcze jedno kliknięcie, aby rozpocząć.

14.- Podczas nagrywania terminal może pokazywać pewną aktywność i małe okno takie jak to:

15.- Pod koniec procesu pojawi się okno potwierdzenia.

I to wszystko...

Możesz anulować nagrywanie lub sam proces, naciskając klawisz ESC w dowolnym momencie, nie będzie żadnych zmian.

Pod koniec nagrania wideo będzie znajdować się w miejscu wybranym w kroku 11, towarzyszącym plikowi dziennika o nazwie takiej jak: „testvideo0.log” lub coś w tym rodzaju.

Jest to najprostszy sposób na kodowanie z tunerów telewizyjnych RF Signal, gromadząc zarówno audio, jak i wideo w tym samym pliku.

Mam inny proces, który jest realizowany za pomocą procesu python, który zawiera GUI, w którym możesz obsłużyć kilka przydatnych rzeczy, takich jak zmiana kanału, uruchomienie testów przed nagraniem, a nawet nagrywanie, ale czasami powoduje to awarie. Jeśli chcesz, daj mi znać, jak mogę się z tobą skontaktować. Nie chcę pisać pergaminów ani biblii ... LOL!

Jeśli ta procedura nie działa w Twoim przypadku, poinformuj mnie o wynikach, aby zapewnić wsparcie przed usunięciem tej odpowiedzi. Dziękuję Ci I...

Powodzenia!

Musisz wypróbować „QtCAM” - bezpłatne oprogramowanie kamery internetowej Linux typu open source z ponad 10 ustawieniami kontroli obrazu.

Ustawienia przechwytywania obrazu QtCAM

To jest najprostsze polecenie:

ffmpeg -i /dev/video0 output.mp4

Radziłbym vokoscreen dla Ubuntu 18.04. Możesz go zainstalować za pomocą „sudo apt install vokoscreen”. Zobacz także https://github.com/vkohaupt/vokoscreen .