MEncoder - Criando Programa Gráfico Para Conversão

m4iir1c10

Você gosta do MEncoder? Porém, acha um problema ter que memorizar os comandos? Não seria melhor ter um Script que,
com dois ou três cliques, faz o trabalho para você? Aqui vamos fazer um Script e transformá-lo em um programa, com
direito a ícone e tudo mais... Meu alvo principal é um Script que converta vídeos e que sejam compatíveis com o sistema
do PS3.

[ Hits: 30.750 ]

Por: M4iir1c10 em 05/03/2012 | Blog: https://github.com/mauricioph

0 0

Denuncie Favoritos Indicar Impressora

Ajustes Finais

Bom, agora estamos chegando na parte mais incrementada do artigo. Fazer Script, muita gente que usa Linux faz, agora vamos torná-los 'programas', dando uma cara mais profissional. Tudo bem que algumas pessoas não ligam muito para este detalhe.

Um dia desses, eu entrei em uma loja da Vodafone e vi um cara arrumando um Ubuntu, e bem na área de trabalho eu vi um Script que fazia a ligação da rede interna. Se ele tem um ícone na área de trabalho invés de um Script, dá um ar mais profissional, vocês não acham?

Começando com o Script no local certo, para quem não conhece o Linux, existem pastas específicas onde os programas rodam, embora o Linux dê a liberdade de mudar isto também, você pode colocar qualquer pasta como pasta de programas e o sistema vai aceitar.

Claro que se exagerarmos, vamos fazer do nosso sistema uma bagunça, por isso, eu prefiro colocar o meus Scripts em locais padrão.

Para conhecer os locais padrão do seu sistema, digite no terminal:

echo $PATH

Para mim, retornou isso:

/usr/bin:/bin:/usr/local/bin:/usr/X11R6/bin/:/usr/games:/usr/lib/kde4/libexec:sbin:/usr/sbin:/usr/lib/qt4/bin:/usr/bin:/usr/sbin:/usr/lib/kde4/libex ec:/bin:/sbin:/usr/X11R6/bin:/usr/games:/usr/local/bin:/usr/local/sbin:/home/mauricio/bin:/usr/bin:/usr/sbin:/usr/lib/kde4/libexec:/bin:/sbin:/usr/ X11R6/bin:/usr/games:/usr/local/bin:/usr/local/sbin

Quer dizer, os dois pontos são separações entre uma pasta e outra, por exemplo: “/usr/bin:/bin”, quer dizer que tanto na pasta “/usr/bin” quanto na “/bin”, eu posso colocar o meu Script e ao digitar o nome do meu Script, ele vai rodar como se fosse um programa.

Para ver de uma forma mais organizada, vamos complicar nosso comando:

echo $PATH | awk 'BEGIN{FS=":"}{print $1}'

Entre todas pastas que eu tenho para os programas, eu prefiro usar a “/usr/local/bin” por um motivo, como esta pasta já é separada para o uso dos Scripts dos usuários locais, é muito difícil encontrar um programa usando esta pasta, provavelmente no seu sistema, esta pasta vai estar vazia.

Caso você queira mudar algo no Script, é mais fácil para encontrar o seus Scripts, invés de colocar em “/usr/bin” e se perder junto com uma pancada de programas e Scripts.

Eu dei o nome ao meu Script de: Ps3.sh, então, vou digitar no terminal:

sudo mv ~/Ps3.sh /usr/local/bin/

Vamos checar a permissão com o comando:

ls -lh /usr/local/bin/Ps3.sh

O retorno deve ser algo assim:

-rwxr-xr-x 1 root root 5.4K Feb 13 13:23 /usr/local/bin/Ps3.sh

Caso você não queira ver aqueles 'X' no começo da linha, digite:

sudo chmod 755 /usr/local/bin/Ps3.sh

Agora, só para testar, digite:

Ps3.sh

. . .E veja se o Script executa automaticamente, caso execute, vamos criar o ícone para ele.

Você pode, tanto criar um ícone do zero com o Gimp (em formato PNG nos tamanhos 256x256, 128x128, 64x64, 32x32 e 16x16 e colocar em uma pasta) ou escolher um do sistema mesmo.

Vamos criar um com o Gimp, porque depois de feito isto, para colocar o ícone que eu vou escolher ou o do sistema, seria o mesmo passo escrever o nome no arquivo com extensão “.desktop”.

Eu criei este ícone com a mistura dos ícones do PS3 e do DviX como XviD e DivX ao contrário, eu fiz o mesmo com o símbolo. :)

Agora, vamos criar uma pasta para o nosso programa.

Assim como um programa tem uma pasta para a execução, eles também tem pastas para configuração, geralmente em “/usr/share/programa” ou “/opt/programa”.

Minha opção é “/opt/programa”, então eu digito:

sudo mkdir -p /opt/Ps3/icons
$ sudo mv /home/mauricio/Ps3-icon.png /opt/Ps3/icons/

Mude o meu nome, pelo seu nome de usuário “/home/usuario/”.

Não coloque “~/...” ou “$HOME”, porque você está executando este comando como Root. Se você colocar um dos dois, o comando vai procurar em “/root/...”

Agora, usando o seu editor de texto preferido, crie um arquivo de desktop. Digite:

kwrite PS3.desktop

E escreva dentro do arquivo:

[Desktop Entry]
Exec=Ps3.sh
Icon=/opt/Ps3/icons/Ps3-icon.png
MimeType=video/x-theora+ogg;video/x-sgi-movie;video/x-quicktime;video/x-ogm+ogg;video/x-msvideo;video/x-ms-wvx;video/x-ms-wmv;video/x- ms-wmp;video/x-ms-wm;video/x-ms-asf;video/x-mpeg2;video/x-mpeg;video/x-matroska;video/x-flv;video/x-flic;video/vnd.rn- realvideo;video/vnd.divx;video/vivo;video/quicktime;video/ogg;video/msvideo;video/mpeg;video/mp4;video/dv;video/divx;video/3gpp;
Name=PS3-Video
Terminal=false
Type=Application
Version=1.0

* “Exec” é o nome do Script, “Icon” é a localização do arquivo PNG que você criou, “MimeType” é o tipo de arquivo que este programa vai lidar. As demais opções, eu creio que você já tira de letra (o que é certo?).

Pronto, agora salve o arquivo em sua área de trabalho e você vai ver o ícone do seu 'Programa'.

Agora, como Root, coloque uma cópia do seu arquivo “PS3.desktop” para a pasta “/usr/share/applications”, assim você vai fazer outros gerenciadores de janelas reconhecer sua aplicação:

sudo cp -f /home/mauricio/PS3.desktop /usr/share/applications/

Você pode deixar o arquivo “PS3.desktop” na área de trabalho, para que ao clicar no ícone, o programa já abra automaticamente.

Pronto. Agora, no próximo passo, vamos fazer o nosso pacote para a distribuição em massa da nossa aplicação.

Página anterior Próxima página

Páginas do artigo

   1. Introdução
   2. Configuração do sistema
   3. Problemas comuns ao rodar vídeos no PS3
   4. O Código do Script
   5. Ajustes Finais
   6. Construindo o Pacote RPM
   7. Criando um Pacote DEB
   8. Teste Final

Outros artigos deste autor

Proteção de tela ou vídeo como papel de parede

Codificação e decodificação entre ASCII, hexadecimal e unicode

Aprendendo a melhorar os seus scripts

Máquina Enigma e encriptação em XOR

Servidor de Mídia com 128 MB de RAM

Leitura recomendada

Curiosidades e mitos sobre Slackware

Instalando e Usando a Versão Mais Recente do BleachBit no Linux

IBQUOTA - Gerenciador de Impressão por Usuário

Traduzindo mensagens no Linux

Compilando e instalando o XFCE 4.2 no SuSE através dos fontes

Comentários

[1] Comentário enviado por itamarnet em 06/03/2012 - 15:29h

Artigo muito interessante, e bem detalhado. Extrapolou inclusive a proposta inicial ao criar os pacotes e detalhar os problemas que encontrou.
Não vou tecer críticas pois o artigo é bem detalhado, mas gostaria de contribuir com algumas sugestões, que podem facilitar ou serem alternativas.
Já tive problemas com o mplayer e mencoder, assim como você, na questão de reconhecimento das dependências, especialmente com o Ubuntu.
O que pode fazer também é usar o ffmpeg no lugar do mencoder para as conversões, mas confesso não lembrar se tem todas as opções disponíveis do seu "Programa".
Outa opção é usar o flite ( http://www.speech.cs.cmu.edu/flite ) em substituição a tríade text2wave, lame e play, o que poderia ser feito nesse formato flite -t "Texto".

De resto está perfeito, Parabéns!!

0 0

[2] Comentário enviado por m4iir1c10 em 06/03/2012 - 18:16h

So para corrigir no codigo do programa houve alguns erros durante o processo da publicacao, alguem colocou quebra de linhas onde nao existem quebras ou seja deveria ser uma linha so, se voce seguir o raciocinio que eu vou explicar voce pode consertar ou voce pode esperar eu publicar o codigo :)

Linhas 9 e 10 e uma unica linha, assim linha 11 vira linha 10 por tanto siga passo a passo as instrucoes para voce conscertar o codigo, preste atencao porque a maioria das vezes em que voce fizer isso antes de apertar delete no final da linha voce deve apertar espaco depois delete mais algumas vezes voce nao deve fazer isso por exemplo awk -vRS nao pode ser awk - vRS

Linhas 9 e 10
Linhas 11 e 12
Linhas 19 e 10
Linhas 44, 45 e 46
Linhas 47, 48 e 49
Linhas 50, 51 e 52
Linhas 56, 57, 58, 59 e 60
Linhas 70, 71, 72, 73 e 74
Linhas 91, 92 e 93

Eu vou publicar o codigo para os novatos que nao querem arriscar destriuir o codigo :)

Deixa eu fazer um teste agora vamos ver se no comantario o codigo sai direito:

#!/bin/bash
#Os programas que serão usados e onde eles se encontram

MENCODER="$(builtin type -P mencoder)"
ZEN="$(builtin type -P zenity)"
LAME="$(builtin type -P lame)"
PLY="$(builtin type -P play)"

# A resolução ou o tamanho do vídeo, embora eu coloquei algumas opções para vídeos em HD lembre se que no PS3 você
# vai ter problemas para rodar qualquer vídeo com resolução superior a 720x576.

RESOLU="$(${ZEN} --list --text "Selecione a resolução do vídeo final" --column "Resolução" --radiolist --column size A "640x480" B "640x360" C "720x404" D "720x416" E "954x544" F "1280x720" G "1920x1080" | tr x :)"

# Agora vamos basear o bitrate do video de acordo com o tamanho do video
BITRATE="$(echo $RESOLU | sed 's/:/ /g' | awk '{print $1}')"

# Vamos selecionar o vídeo a ser convertido
INFILE="$(${ZEN} --file-selection)"

# Só para ter certeza que o usuário sabe oque esta escolhendo e não clicou sem querer em um arquivo que não é um vídeo,
# vamos olhar que tipo de arquivo foi selecionado se não for um vídeo damos uma bronca nele.

ENTRADA=$(file -bi "$INFILE" | awk '{print $1}'| grep video | awk 'BEGIN{FS="/"}{print $1}')
echo $ENTRADA
function intro(){
while [ "$ENTRADA" != "video" ]
do ${ZEN} --error --text "Voce não escolheu um arquivo de vídeo válido"
INFILE="$(${ZEN} --file-selection)"
ENTRADA=$(file -bi "$INFILE" | awk '{print $1}'| grep video | awk 'BEGIN{FS="/"}{print $1}')

echo $ENTRADA
done
}
intro

# agora que estamos certos que é um vídeo vamos definir o nome dele como a variável de entrada
ENTRADA="$(echo $INFILE)"

LOC=$(basename "${ENTRADA}")

#vamos criar uma pasta temporária para colocar todos os logs e arquivo usados durante a conversão, definindo os nomes para os mesmos
TEMPO="$(mktemp -d /tmp/mauricio.XXXXXXXXX)"
SAIDA="$(echo ${LOC} | sed 's/ /_/g')"
LOGI="$(echo ${TEMPO}/${SAIDA}.log)"

#Primeira função de conversão, colocamos os atributos necessários para o mencoder e jogamos a saída de dados para o zenity
# com o awk filtramos as informações do mencoder e criamos uma função que da um refresh no zenity para que o mesmo
# possa indicar a porcentagem da conversão junto com as demais informações.

function primeiropasso(){
${MENCODER} "${ENTRADA}" -ovc lavc -lavcopts vcodec=mpeg4:vpass=1:vbitrate=${BITRATE} -oac mp3lame -lameopts cbr:br=128:mode=0 -vf scale=${RESOLU},harddup -ffourcc XVID -o "$HOME/${SAIDA}.PS3.avi" -passlogfile ${LOGI} 2>&1 | awk -vRS="\r" '$1 ~ /Pos/ {gsub(/Pos:/," ");gsub(/%\)/," ");gsub(/ \(/," ");print $3"\n#Convertendo o vídeo para pasta do usuário \\nPosição :\\t"$1"\\nQuadros :\\t"$2"\\nPorcentagem :\\t"$3"%\\nMédia de Quadros :\\t"$4"\\nTempo Restante :\\t"$6; fflush();}' | ${ZEN} --progress --title "Convertendo ${LOC} 1 passo" --text "Convertendo ${LOC}" --auto-close
}

# fazemos a mesma coisa para o segundo passo, o motivo pelo qual estou colocando os passos em funções separadas é porque
# se algum dia você perdeu um usb com o vídeo convertido e quer converter do original para outro vídeo para o PS3 o programa
# vai identificar que você já converteu esse vídeo uma vez e vai lembrar dele fazendo assim só uma vez o segundo passo,
# quer dizer não precisa assistir o vídeo que ele já assistiu.

function segundopasso() {
echo "Second Stage" | text2wave -o ${TEMPO}/audio.wav
lame -V3 -b 192 ${TEMPO}/audio.wav ${TEMPO}/audio.mp3
play ${TEMPO}/audio.mp3
${MENCODER} "${ENTRADA}" -ovc lavc -lavcopts vcodec=mpeg4:vpass=2:vbitrate=${BITRATE} -oac mp3lame -lameopts cbr:br=128:mode=0 -vf scale=${RESOLU},harddup -ffourcc XVID -o "$HOME/${SAIDA}.PS3.avi" -passlogfile ${LOGI} 2>&1 | awk -vRS="\r" '$1 ~ /Pos/ {gsub(/Pos:/," ");gsub(/%\)/," ");gsub(/ $/," ");print $3"\n#Convertendo o vídeo para pasta do usuário \\nPosicao :\\t"$1"\\nQuadros :\\t"$2"\\nPorcentagem :\\t"$3"%\\nMedia de Quadros :\\t"$4"\\nTempo Restante :\\t"$6; fflush();}' | ${ZEN} --progress --title "converting ${LOC} 2 passo" --text "converting ${LOC}" --auto-close
echo "The file is ${SAIDA}.PS3.avi, You will find it on your home folder" | text2wave -o ${TEMPO}/audio.wav
lame -V3 -b 192 ${TEMPO}/audio.wav ${TEMPO}/audio.mp3
play ${TEMPO}/audio.mp3
}

# vamos lembrar do vídeo que foi convertido criando nossa pasta de "memória"

if [ ! -d $HOME/.videologs ]
then mkdir $HOME/.videologs
fi
LOGTWO=$(basename "${LOGI}")

function usedsecondpass() {
${MENCODER} "${ENTRADA}" -ovc lavc -lavcopts vcodec=mpeg4:vpass=2:vbitrate=${BITRATE} -oac mp3lame -lameopts cbr:br=128:mode=0 -vf scale=${RESOLU},harddup -ffourcc XVID -o "$HOME/${SAIDA}.PS3.avi" -passlogfile "${HOME}/.videologs/${LOGTWO}" 2>&1 | awk -vRS="\r" '$1 ~ /Pos/ {gsub(/Pos:/," ");gsub(/%$/," ");gsub(/ \(/," ");print $3"\n#Convertendo o vídeo para pasta do usuário \\nPosição :\\t"$1"\\nQuadros :\\t"$2"\\nPorcentagem :\\t"$3"%\\nMédia de Quadros :\\t"$4"\\nTempo Restante :\\t"$6; fflush();}' | ${ZEN} --progress --title "converting ${LOC} 2 passo" --text "converting ${LOC}" --auto-close
echo "Mission Acomplished, your file is at the Desktop. The name is ${SAIDA}.PS3.avi" | text2wave -o ${TEMPO}/audio.wav
lame -V3 -b 192 ${TEMPO}/audio.wav ${TEMPO}/audio.mp3
play ${TEMPO}/audio.mp3
}

# Lembra desse vídeo? então pula para o segundo passo.

if [ -f ${HOME}/.videologs/${LOGTWO} ]
then echo "I remember this, lets do it again." | text2wave -o ${TEMPO}/audio.wav
lame -V3 -b 192 ${TEMPO}/audio.wav ${TEMPO}/audio.mp3
play ${TEMPO}/audio.mp3
usedsecondpass
else primeiropasso
segundopasso
fi

# vamos limpar a bagunça que essa conversão fez
rm -f ${TEMPO}/audio.wav
rm -f ${TEMPO}/audio.mp3

# mais não vamos apagar tudo, esse programa tem que se lembrar desse vídeo para a próxima vez que for necessário
# caso você decidir limpar o seu sistema um dia para economizar espaço, essa pasta ~/.videologs deve ser um das que você
# definitivamente deve dar uma olhada, em uma semana ou um mês não acumula muito mais depois de uns 6 meses pode
# ultrapassar a marca dos GB de arquivos.

for i in $(ls ${TEMPO}/*.log | xargs )
do mv $i $HOME/.videologs/
done

#agora acabamos com todo o lixo.
cd ~/
rm -fr ${TEMPO}

Pessoal desculpe a falta de ascentos meu teclado e britanico :)

0 0