Alguma coisa melhor que Cheese para captura de vídeo?

46

Eu preciso gravar alguns vídeos da minha webcam e, enquanto o Cheese funciona, ele não tem configurações e exibe apenas o formato webm cheio de falhas, etc.

Parece que não encontrou alternativa ...

    
por HDave 10.09.2012 / 03:50

4 respostas

49
O

Guvcview tem como objetivo fornecer uma interface GTK simples para capturar e visualizar vídeo de dispositivos suportados pelo driver Linux UVC, embora também deva funcionar com qualquer dispositivo compatível com v4l2.

O projeto é baseado no luvcview para renderização de vídeo, mas todos os controles são construídos usando uma interface GTK2.

O Guvcview (desde a versão 0.9.9) tem uma janela somente de controle, (do console: guvcview --control_only ), isso permite o controle da imagem em outros aplicativos, como ekiga, cheese, mplayer, skype ...

Áudio.

O suporte de áudio do Guvcview é baseado na biblioteca portaudio, até a versão 0.9.3 a API de bloqueio era usada para captura de áudio, desde a versão 0.9.4 é usado o método de retorno, isso fornece melhor desempenho, é também o preferido método para a API do portaudio.

Todas as interfaces (ALSA, OSD, JACK, ...) suportadas pelo portaudio devem estar disponíveis no guvcview. Apenas certifique-se de que o portaudio foi compilado com as interfaces desejadas ativadas.

Controles dinâmicos UVC.

O driver Linux UVC tem uma implementação para controles de extensão (são controles específicos de fornecedores e são suportados na especificação UVC.), eles são chamados de controles dinâmicos, pois devem ser carregados dinamicamente no driver.

Até hoje, apenas a Logitech forneceu especificações para seus controles de extensão de webcam UVC, que são suportados pelo guvcview.

Em novas revisões de driver, direitos de administrador são necessários para adicionar esses controles ao driver, portanto, existem basicamente duas soluções:

  1. inicie o guvcview como root (usando sudo ) pelo menos uma vez por sessão, desde a versão 1.2.0 você pode fazer isso com a opção --add_ctrls evitando a necessidade de lançar completamente o guvcview

  2. instale a libwebcam este software tem um script do udev que deve adicionar os controles necessários à sua câmera da logitech.

Instale o Guvcview no Ubuntu 12.04 via ppa

sudo add-apt-repository ppa:pj-assis/ppa
sudo apt-get update
sudo apt-get install guvcview
    
por ptheo 10.09.2012 / 09:59
14

Se você precisar de um novo aplicativo, guvcview é bom.

link

    
por JoeSteiger 10.09.2012 / 05:00
10

Partes desta pergunta vêm da resposta nesta pergunta: Grave de fitas VHS .

Precisamos garantir que o software esteja reunindo os dados corretos do dispositivo correto. Vamos soltar uma consulta no terminal que nos permitirá ver quantos dispositivos estão conectados ao seu computador, que podem ser usados para coletar imagens, usar este comando em um terminal:

ls -l /dev/video*

Os resultados devem ser assim:

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:~$ 

No meu caso, tenho 3 dispositivos de vídeo, sendo um deles o sintonizador de TV USB que uso para assistir / gravar programas de TV ao vivo / VTR / VCR / conversor de RF-DVD / Vídeo e outros sinais de RF. / p>

Os outros dispositivos são USB Webcam conectados a slots USB no computador.

Se a sua webcam estiver apresentando um microfone, o áudio e o vídeo podem ser gravados usando o script tvcap de Andreas Schalk , que código eu coloco aqui para sua conveniência:

#!/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: easycapdc60-blogspot@yahoo.de
#-----------------------------------------------------------------------------
#
#  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

Basta copiar / colar todo esse código em um arquivo chamado tvcap-script.sh, dar as permissões de execução e executá-lo em um terminal. O processo é bastante fácil e vou explicar da seguinte forma:

1 .- Depois de pressionar Enter, você será perguntado pela fonte de captura e dependendo da localização do dispositivo (testado antes), você pode ter, como no meu caso, várias fontes de vídeo, Eu estou usando o / dev / video2 para este exemplo, que se refere ao meu sintonizador de TV USB. Observe que esta captura de tela não obteve o decorador de janelas, mas as opções e o botão "OK" podem ser vistos ali.

2 .- Agora precisamos definir a norma, no México usamos NTSC e, a menos que você deseje capturar seu vídeo usando uma norma diferente com proporção de quadrado, você não deve usar PAL, que pode de fato prejudicar um pouco sua qualidade de vídeo. Depende também de onde você mora e da norma do seu país.

3 .- Meu sintonizador de TV está tendo várias entradas, o seu pode ter uma quantidade diferente de entradas, verificar e executar todos os testes necessários para determinar qual é o melhor para o seu capturar. Eu vou usar o que se refere à TV. (Entrada 1 (TV))

4 .- Em seguida, você pode (ou não) ser avisado e oferecido para uma solução se algo der errado durante a captura de som (áudio e vídeo serão capturados de uma só vez, mas se seu módulo snd_usb_audio já foi carregado, pode travar a captura de áudio e, portanto, a própria captura de vídeo)

5 .- Meu sintonizador de TV oferece suporte a várias entradas de áudio, o que inclui a integração com o dispositivo de som embutido na minha placa-mãe (conectando um cabo à linha auxiliar e controlado pelo mixer de som ), você verifica qual é o melhor para você e lembra que os padrões são geralmente marcados como "melhores para você".

6.- Se tudo estiver indo bem, você verá uma pequena janela com uma mensagem que diz algo assim:

  

"SUCESSO! / dev / video2 é lido e gravável!"

clique em "OK" para continuar.

7 .- Depois disso, você pode escolher na lista de opções de gravação disponíveis no seu sistema. Eu instalei o que você pode ver na próxima tela. Qualquer um é válido e a qualidade não reflete grandes mudanças, mas eu pessoalmente prefiro o mencoder . Se você não tiver nenhum desses instalados, deverá instalá-lo para executar seus testes.

8 .- Depois de escolher sua preferência de software de codificação (na etapa anterior), você será solicitado a obter a proporção. Se você não tem experiência nisso, apenas deixe como está. Normalmente, o padrão é o que melhor se ajusta ao sinal do sintonizador de TV.

9 .- Com base na sua escolha relacionada à proporção, você terá várias opções para a qualidade do vídeo, também com base na taxa de bits, a descrição na próxima janela é muito específica. Lembre-se: quanto maior a taxa de bits (melhor qualidade), o tamanho do arquivo de vídeo pode se tornar muito grande.

10 .- Depois disso, precisamos apenas escolher por quanto tempo nossa captura de vídeo será. Existem várias predefinições, eu escolhi "30 segundos para teste" neste exemplo, mas você pode escolher qualquer ou até mesmo escolher "ilimitado" para decidir quando parar a gravação.

11.- Em seguida, você será perguntado por um nome de arquivo, dando um por padrão, que você pode alterar nesta tela.

12 .- Você será solicitado a verificar suas "Opções de gravação" na próxima tela, basta clicar em "OK".

13 .- Apenas mais um clique para começar.

14 .- Ao gravar, o terminal pode mostrar alguma atividade e uma pequena janela como esta:

15.- No final do processo, você receberá uma janela de confirmação.

E ... é isso ...

Você pode cancelar a gravação ou o próprio processo pressionando ESC a qualquer momento, não haverá alterações.

No final da gravação, você terá o vídeo no lugar escolhido na etapa 11, acompanhando um arquivo de log com um nome como: "testvideo0.log" ou algo assim.

Esta é a maneira mais fácil de codificar os sintonizadores de TV de sinais de RF, reunindo áudio e vídeo no mesmo arquivo.

Eu tenho outro processo que é alcançado usando um processo python que possui uma GUI na qual você pode lidar com várias coisas úteis, como mudar o canal, executar testes de pré-gravação e até gravar, mas às vezes me falha. Se você quiser, por favor, deixe-me saber como posso chegar até você. Eu não quero escrever pergaminhos ou uma bíblia ... LOL!

Se este procedimento não funcionar no seu caso, informe-nos, incluindo seus resultados, para fornecer algum suporte antes de excluir esta resposta. Obrigado e ...

Boa sorte!

    
por Geppettvs D'Constanzo 10.09.2012 / 04:04
2

Você deve experimentar o "QtCAM" - um Software Webcamera Linux de código aberto gratuito com mais de 10 configurações de controle de imagem.

Configurações de captura de imagem do QtCAM

    
por venkatesh 10.12.2015 / 10:30