sexta-feira, 28 de junho de 2013

Engenharia reversa no Arduino (2ª parte)

Outro dia eu postei como ler o conteúdo de um arquivo .hex compilado pelo Arduino IDE. Neste post vou mostrar como fazer o dump da memória do AVR de forma que possamos analisar seu conteúdo e descompilar as seções relacionadas ao programa.

domingo, 23 de junho de 2013

Estabilizando a imagem de um vídeo no Ubuntu

Hoje, após realizar uma pequena filmagem com o meu celular e constatar que a imagem ficou bastante tremida, resolvi procurar uma forma de estabilizar a imagem de forma automática e simples. Vou passar os passos que eu segui para conseguir um resultado bastante satisfatório.

O software utilizado para realizar essa tarefa foi o MELT, que possui um filtro muito bom para obter a informação sobre o deslocamento da imagem entre os frames chamado videostab2.

Para realizar essa tarefa, eu segui um tutorial muito bom, escrito por Nicolas Bernaerts, e fiz alguns ajustes.

As ferramentas necessárias são o FFmpeg 0.9+ e o MELT 0.7.6+. Para testar a versão atual (se estiverem instalados) use:
# ffmpeg -version
# melt -version

Caso não tenha algum desses software instalado ou se a versão disponível form menor que a esperada, utilize os seguintes comandos para instalar/atualizar:
# sudo add-apt-repository ppa:jon-severinsson/ffmpeg
# sudo apt-get update


Caso já tenha o ffmpeg instalado use:
# sudo apt-get upgrade

Caso não tenha, use:
# sudo apt-get install ffmpeg

Para o MELT, use:
# sudo add-apt-repository ppa:sunab/kdenlive-release
# sudo apt-get update


Caso já tenha o MELT instalado use:
# sudo apt-get upgrade

Caso não tenha, use:

# sudo apt-get install melt

Agora, com as ferramentas necessárias instaladas, vamos para o processo de estabilização do vídeo.

Este processo é dividido em duas etapas. A primeira etapa consiste na verificação do vídeo pelo filtro videostab2 que vai calcular o deslocamento dos quados e gerar um arquivo de configuração que será usado na segunda etapa, que desloca o vídeo para estabilizar a imagem final.

Para a primeira etapa utilizamos o seguinte comando:

# melt "${ORIGINAL}" -filter videostab2 "shakiness=4" -consumer xml:vectors.xml all=1 real_time=-1

Onde $ORIGINAL é o caminho para o video que será estabilizado.

Depois desse passo, será produzido um arquivo (nesse caso vectors.xml) que conterá os vetores de deslocamento.

Para o segundo passo utilizamos o seguinte comando:
# melt vectors.xml -audio-track "${ORIGINAL}" -consumer avformat:"${FILE_STAB}" vcodec=libx264 b=5000k acodec=libmp3lame ab=128k "tune=film preset=slow"

Esse comando vai gerar o arquivo $FILE_STAB, com o áudio original do arquivo $ORIGINAL. A saída será um vídeo h264 a 5Mbits com áudio AAC de 128Kbits.

Script para o Nautilus

Para quem usa o Gnome2, transformar esse tipo de operação em um script que pode ser utilizado pelo menu de contexto no Nautilus é uma excelente opção.

O autor do artigo original criou um script excelente, e eu quero ter a oportunidade de compartilhá-lo e fazer algumas observações.

Para instalá-lo, copie o texto para um arquivo em ~/.gnome2/nautilus-scripts/StabilizeVideo (o nome fica a seu critério) e dê permissão de execução (# chmod u+x ~/.gnome2/nautilus-scripts/StabilizeVideo).

#!/bin/sh
# --------------------------------------------
#  Video Shooting Stabilization
#  Command-line & Nautilus script
#  Depends on :
#   * mlt 0.7.6 minimum
#   * ffmpeg 0.9 minimum
#   * yad
#  Revision history :
#  04/03/2012 - Creation by N. Bernaerts
#  04/04/2012 - Add codecs as parameters
# -------------------------------------------

# ----------------------------------------------------
#  User variable section
#  Please, do not modify anything out of this section
# ----------------------------------------------------

# You can define default encoding codec and rates in kbits/s
VIDEO_CODEC="libx264"
VIDEO_RATE=5000
AUDIO_CODEC="libmp3lame"
AUDIO_RATE=128

# You can setup optional parameters for stabilization & h264 encoding
OPTION_STABILIZER="shakiness=4"
OPTION_ENCODER="tune=film preset=slow"

# ------------------------------------
#  check if script is called
#  as command-line or nautilus-script
# ------------------------------------
if [ -n "$1" ]
then
  # at least one parameter, called as command-line
  FILE_PATH="$1"
else
  # no parameter, called as a nautilus script
  FILE_PATH="${NAUTILUS_SCRIPT_SELECTED_FILE_PATHS}"
fi

# ----------------
#  Initialisation
# ----------------
STABILIZE="TRUE"
CANCELED="FALSE"

# go in the video file directory
cd $(dirname "${FILE_PATH}")

# generate the filenames
ORIGINAL=$(basename "${FILE_PATH}")
FILE_NAME=`echo ${ORIGINAL} | sed 's/^\(.*\)[.].*$/\1/g'`
FILE_STAB="${FILE_NAME}"-stab.mp4
FILE_LOG="${FILE_NAME}".log
FILE_MLT="${FILE_NAME}".mlt

echo "---" > "${FILE_LOG}"

# --------------------------------------------
#  function to follow progress of the process
# --------------------------------------------
MELT_PROGRESS()
{
# loop till the end of melt process
PERCENTAGE=0
while [ "$PERCENTAGE" != "100" ]
do   
  # wait for 1 second
  sleep 1

  # if process is still running
  RESULT=`ps aux | awk '{print $2}' | grep "$PID"`
  if [ "$RESULT" -eq "$PID" ]
  then
    # get percentage of completion
    PERCENTAGE=`cat "${FILE_LOG}" | tail -n 1 | sed 's/^.*percentage:[ ]*\([0-9]*\).*$/\1/g'`
  else
    # else, force percentage to 100
    PERCENTAGE="100"
  fi

  # display current percentage
  echo $PERCENTAGE
done | yad --width=400 --height=30 --progress --auto-close --title "$TITLE" --text "$TEXT"

# if encode has been canceled, kill the current process
CANCELED="FALSE"
RESULT=`ps aux | awk '{print $2 }' | grep $PID`
if [ "$RESULT" -eq "$PID" ]
then
  kill $PID
  CANCELED="TRUE"
fi
}

# -----------------------------------
#  Selection of encoding parameters
# -----------------------------------
TITLE="Stabilization of ${ORIGINAL}"
TEXT="\nFinal video file will use $VIDEO_CODEC video and $AUDIO_CODEC audio.\nPlease select the encoding parameters :\n"
CHOICE=`yad  --title "$TITLE" --text "$TEXT" --image "dialog-question" --form --field=Stabilize:CHK ${STABILIZE} --field="Video bitrate (kbits):NUM" ${VIDEO_RATE} --field="Audio bitrate (kbits):NUM" ${AUDIO_RATE}`

# extract the parameters
STABILIZE=`echo ${CHOICE}  | cut -d"|" -f1`
VIDEO_RATE=`echo ${CHOICE} | cut -d"|" -f2 | cut -d"," -f1 | cut -d"." -f1`
AUDIO_RATE=`echo ${CHOICE} | cut -d"|" -f3 | cut -d"," -f1 | cut -d"." -f1`

# -------------------------
#  Phase 1 : Stabilization
# -------------------------
if [ "$STABILIZE" = "TRUE" ]
then
  # set text & title of progress window
  TITLE="1 - Stabilization of ${ORIGINAL}"
  TEXT="This phase may take a long time ...\n"

  # start the stabilization phase with melt and videostab2 filter
  melt -progress "${ORIGINAL}" -filter videostab2 ${OPTION_STABILIZER} -consumer xml:"${FILE_MLT}" all=1 real_time=-1 2>> "${FILE_LOG}" &

  # get the process id
  PID=`ps -ef | grep melt | grep "${ORIGINAL}" | sed 's/^'$USER'[ ]*\([0-9]*\).*$/\1/g'`

  # follow the stabilization progress
  MELT_PROGRESS
fi

# if canceled, no encoding to be done
if [ "$CANCELED" = "TRUE" ]
then
  VIDEO_RATE=0
fi

# --------------------
#  Phase 2 : Encoding
# --------------------
if [ "$VIDEO_RATE" -gt "0" ]
then
   # set text & title of progress window
  TITLE="2 - Encoding of ${FILE_STAB}"
  TEXT="This phase may also take a long time ...\n"

  # start melt encoding process with stabilized video and original audio
  melt -progress "${FILE_MLT}" -audio-track "${ORIGINAL}" -consumer avformat:"${FILE_STAB}" vcodec=${VIDEO_CODEC} b=${VIDEO_RATE}k acodec=${AUDIO_CODEC} ab=${AUDIO_RATE}k ${OPTION_ENCODER} 2>> "${FILE_LOG}" &

  # get the process id
  PID=`ps -ef | grep melt | grep "${FILE_MLT}" | sed 's/^'$USER'[ ]*\([0-9]*\).*$/\1/g'`

  # follow the stabilization progress
  MELT_PROGRESS
fi

# ------------------------------------
#  cleaning-up of all temporary files
# ------------------------------------
rm "${FILE_LOG}"
rm "${FILE_MLT}"

exit 0


Esse script utiliza uma ferramenta chamada yad que permite a criação de interfaces gráficas da mesma forma que o Zenity, mas com muito mais opções (possivelmente à custa de estabilidade).

Para instalar o yad no Ubuntu, utilize:
# sudo add-apt-repository ppa:webupd8team/y-ppa-manager
# sudo apt-get update
# sudo apt-get install yad


Observação

Caso você tenha problemas ao executar o segundo passo, recebendo a informação que os codecs não estão disponíveis, instale o pacote libavcodec-extra-53:
#sudo apt-get install libavcodec-extra-53

Referências

sexta-feira, 21 de junho de 2013

Engenharia reversa no Arduino

Procurando uma forma de entender melhor o funcionamento do meu Arduino, procurei saber como fazer a engenharia reversa do código que está sendo enviado para ele. Espero tentar repassar o que eu consegui descobrir para vocês.