examples: add a am7xxx-play example program
authorAntonio Ospite <ospite@studenti.unina.it>
Thu, 15 Mar 2012 14:30:28 +0000 (15:30 +0100)
committerAntonio Ospite <ospite@studenti.unina.it>
Thu, 15 Mar 2012 14:44:56 +0000 (15:44 +0100)
am7xxx-play is a simple player based on ffmpeg/libav which displays the
output on a am7xxx device. It can be used to capture the desktop screen,
or video from a v4l2 device, or from any other device supported by
libavdevice including video files.

However it is to note that am7xxx-play displays the output as fast as it
can so it is not reliable when used to display video files directly.

cmake_modules/FindFFmpeg.cmake [new file with mode: 0644]
cmake_modules/FindXCB.cmake [new file with mode: 0644]
examples/CMakeLists.txt
examples/am7xxx-play.c [new file with mode: 0644]

diff --git a/cmake_modules/FindFFmpeg.cmake b/cmake_modules/FindFFmpeg.cmake
new file mode 100644 (file)
index 0000000..eabe5a0
--- /dev/null
@@ -0,0 +1,126 @@
+# Locate ffmpeg
+# This module defines
+# FFMPEG_LIBRARIES
+# FFMPEG_FOUND, if false, do not try to link to ffmpeg
+# FFMPEG_INCLUDE_DIR, where to find the headers
+#
+# $FFMPEG_DIR is an environment variable that would
+# correspond to the ./configure --prefix=$FFMPEG_DIR
+#
+# Created by Robert Osfield.
+
+
+#In ffmpeg code, old version use "#include <header.h>" and newer use "#include <libname/header.h>"
+#In OSG ffmpeg plugin, we use "#include <header.h>" for compatibility with old version of ffmpeg
+
+#We have to search the path which contain the header.h (usefull for old version)
+#and search the path which contain the libname/header.h (usefull for new version)
+
+#Then we need to include ${FFMPEG_libname_INCLUDE_DIRS} (in old version case, use by ffmpeg header and osg plugin code)
+#                                                       (in new version case, use by ffmpeg header) 
+#and ${FFMPEG_libname_INCLUDE_DIRS/libname}             (in new version case, use by osg plugin code)
+
+
+# Macro to find header and lib directories
+# example: FFMPEG_FIND(AVFORMAT avformat avformat.h)
+MACRO(FFMPEG_FIND varname shortname headername)
+    # old version of ffmpeg put header in $prefix/include/[ffmpeg]
+    # so try to find header in include directory
+    FIND_PATH(FFMPEG_${varname}_INCLUDE_DIRS ${headername}
+        PATHS
+        ${FFMPEG_ROOT}/include
+        $ENV{FFMPEG_DIR}/include
+        $ENV{OSGDIR}/include
+        $ENV{OSG_ROOT}/include
+        ~/Library/Frameworks
+        /Library/Frameworks
+        /usr/local/include
+        /usr/include
+        /sw/include # Fink
+        /opt/local/include # DarwinPorts
+        /opt/csw/include # Blastwave
+        /opt/include
+        /usr/freeware/include
+        PATH_SUFFIXES ffmpeg
+        DOC "Location of FFMPEG Headers"
+    )
+
+    # newer version of ffmpeg put header in $prefix/include/[ffmpeg/]lib${shortname}
+    # so try to find lib${shortname}/header in include directory
+    IF(NOT FFMPEG_${varname}_INCLUDE_DIRS)
+        FIND_PATH(FFMPEG_${varname}_INCLUDE_DIRS lib${shortname}/${headername}
+            ${FFMPEG_ROOT}/include
+            $ENV{FFMPEG_DIR}/include
+            $ENV{OSGDIR}/include
+            $ENV{OSG_ROOT}/include
+            ~/Library/Frameworks
+            /Library/Frameworks
+            /usr/local/include
+            /usr/include/
+            /sw/include # Fink
+            /opt/local/include # DarwinPorts
+            /opt/csw/include # Blastwave
+            /opt/include
+            /usr/freeware/include
+            PATH_SUFFIXES ffmpeg
+            DOC "Location of FFMPEG Headers"
+        )
+    ENDIF(NOT FFMPEG_${varname}_INCLUDE_DIRS)
+
+    FIND_LIBRARY(FFMPEG_${varname}_LIBRARIES
+        NAMES ${shortname}
+        PATHS
+        ${FFMPEG_ROOT}/lib
+        $ENV{FFMPEG_DIR}/lib
+        $ENV{OSGDIR}/lib
+        $ENV{OSG_ROOT}/lib
+        ~/Library/Frameworks
+        /Library/Frameworks
+        /usr/local/lib
+        /usr/local/lib64
+        /usr/lib
+        /usr/lib64
+        /sw/lib
+        /opt/local/lib
+        /opt/csw/lib
+        /opt/lib
+        /usr/freeware/lib64
+        DOC "Location of FFMPEG Libraries"
+    )
+
+    IF (FFMPEG_${varname}_LIBRARIES AND FFMPEG_${varname}_INCLUDE_DIRS)
+        SET(FFMPEG_${varname}_FOUND 1)
+    ENDIF(FFMPEG_${varname}_LIBRARIES AND FFMPEG_${varname}_INCLUDE_DIRS)
+
+ENDMACRO(FFMPEG_FIND)
+
+SET(FFMPEG_ROOT "$ENV{FFMPEG_DIR}" CACHE PATH "Location of FFMPEG")
+
+FFMPEG_FIND(LIBAVFORMAT avformat avformat.h)
+FFMPEG_FIND(LIBAVDEVICE avdevice avdevice.h)
+FFMPEG_FIND(LIBAVCODEC  avcodec  avcodec.h)
+FFMPEG_FIND(LIBAVUTIL   avutil   avutil.h)
+FFMPEG_FIND(LIBSWSCALE  swscale  swscale.h)  # not sure about the header to look for here.
+
+SET(FFMPEG_FOUND "NO")
+# Note we don't check FFMPEG_LIBSWSCALE_FOUND here, it's optional.
+IF   (FFMPEG_LIBAVFORMAT_FOUND AND FFMPEG_LIBAVDEVICE_FOUND AND FFMPEG_LIBAVCODEC_FOUND AND FFMPEG_LIBAVUTIL_FOUND)
+
+    SET(FFMPEG_FOUND "YES")
+
+    SET(FFMPEG_INCLUDE_DIRS ${FFMPEG_LIBAVFORMAT_INCLUDE_DIRS})
+
+    SET(FFMPEG_LIBRARY_DIRS ${FFMPEG_LIBAVFORMAT_LIBRARY_DIRS})
+
+    # Note we don't add FFMPEG_LIBSWSCALE_LIBRARIES here, it will be added if found later.
+    SET(FFMPEG_LIBRARIES
+        ${FFMPEG_LIBAVFORMAT_LIBRARIES}
+        ${FFMPEG_LIBAVDEVICE_LIBRARIES}
+        ${FFMPEG_LIBAVCODEC_LIBRARIES}
+        ${FFMPEG_LIBAVUTIL_LIBRARIES})
+
+ELSE (FFMPEG_LIBAVFORMAT_FOUND AND FFMPEG_LIBAVDEVICE_FOUND AND FFMPEG_LIBAVCODEC_FOUND AND FFMPEG_LIBAVUTIL_FOUND)
+
+#    MESSAGE(STATUS "Could not find FFMPEG")
+
+ENDIF(FFMPEG_LIBAVFORMAT_FOUND AND FFMPEG_LIBAVDEVICE_FOUND AND FFMPEG_LIBAVCODEC_FOUND AND FFMPEG_LIBAVUTIL_FOUND)
diff --git a/cmake_modules/FindXCB.cmake b/cmake_modules/FindXCB.cmake
new file mode 100644 (file)
index 0000000..517ad26
--- /dev/null
@@ -0,0 +1,43 @@
+# - Try to find libxcb
+# Once done this will define
+#
+#  LIBXCB_FOUND - system has libxcb
+#  LIBXCB_LIBRARIES - Link these to use libxcb
+#  LIBXCB_INCLUDE_DIR - the libxcb include dir
+#  LIBXCB_DEFINITIONS - compiler switches required for using libxcb
+
+# Copyright (c) 2008 Helio Chissini de Castro, <helio@kde.org>
+# Copyright (c) 2007, Matthias Kretz, <kretz@kde.org>
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+
+
+IF (NOT WIN32)
+  IF (LIBXCB_INCLUDE_DIR AND LIBXCB_LIBRARIES)
+    # in cache already
+    SET(XCB_FIND_QUIETLY TRUE)
+  ENDIF (LIBXCB_INCLUDE_DIR AND LIBXCB_LIBRARIES)
+
+  # use pkg-config to get the directories and then use these values
+  # in the FIND_PATH() and FIND_LIBRARY() calls
+  FIND_PACKAGE(PkgConfig)
+  PKG_CHECK_MODULES(PKG_XCB xcb)
+
+  SET(LIBXCB_DEFINITIONS ${PKG_XCB_CFLAGS})
+
+  FIND_PATH(LIBXCB_INCLUDE_DIR xcb/xcb.h
+    ${PKG_XCB_INCLUDE_DIRS}
+    )
+
+  FIND_LIBRARY(LIBXCB_LIBRARIES NAMES xcb libxcb
+    PATHS
+    ${PKG_XCB_LIBRARY_DIRS}
+    )
+
+  include(FindPackageHandleStandardArgs)
+  FIND_PACKAGE_HANDLE_STANDARD_ARGS(XCB DEFAULT_MSG LIBXCB_INCLUDE_DIR LIBXCB_LIBRARIES )
+
+
+  MARK_AS_ADVANCED(LIBXCB_INCLUDE_DIR LIBXCB_LIBRARIES XCBPROC_EXECUTABLE)
+ENDIF (NOT WIN32)
index 0450e26..c70d121 100644 (file)
@@ -1,4 +1,6 @@
 add_definitions("-D_POSIX_C_SOURCE=2") # for getopt()
+add_definitions("-D_POSIX_SOURCE") # for sigaction
+add_definitions("-D_BSD_SOURCE") # for strdup
 
 include_directories(${CMAKE_SOURCE_DIR}/src/)
 
@@ -7,3 +9,27 @@ add_executable(picoproj picoproj.c)
 target_link_libraries(picoproj am7xxx)
 install(TARGETS picoproj
   DESTINATION "${CMAKE_INSTALL_PREFIX}/bin")
+
+# Build a more complete example
+find_package(FFmpeg REQUIRED)
+
+include_directories(${FFMPEG_LIBAVDEVICE_INCLUDE_DIRS})
+include_directories(${FFMPEG_LIBAVFORMAT_INCLUDE_DIRS})
+include_directories(${FFMPEG_LIBSWSCALE_INCLUDE_DIRS})
+
+# xcb is used to retrieve the full screen dimensions when using x11grab
+# as input format
+find_package(XCB)
+if (XCB_FOUND)
+  add_definitions("${LIBXCB_DEFINITIONS} -DHAVE_XCB")
+  include_directories(${LIBXCB_INCLUDE_DIRS})
+endif()
+
+add_executable(am7xxx-play am7xxx-play.c)
+
+target_link_libraries(am7xxx-play am7xxx
+  ${FFMPEG_LIBAVDEVICE_LIBRARIES}
+  ${FFMPEG_LIBSWSCALE_LIBRARIES}
+  ${LIBXCB_LIBRARIES})
+install(TARGETS am7xxx-play
+  DESTINATION "${CMAKE_INSTALL_PREFIX}/bin")
diff --git a/examples/am7xxx-play.c b/examples/am7xxx-play.c
new file mode 100644 (file)
index 0000000..f7e069a
--- /dev/null
@@ -0,0 +1,748 @@
+/*
+ * am7xxx-play - play stuff on an am7xxx device (e.g. Acer C110, PicoPix 1020)
+ *
+ * Copyright (C) 2012  Antonio Ospite <ospite@studenti.unina.it>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <signal.h>
+#include <getopt.h>
+
+#include <libavdevice/avdevice.h>
+#include <libavformat/avformat.h>
+#include <libswscale/swscale.h>
+
+#include <am7xxx.h>
+
+static unsigned int run = 1;
+
+struct video_input_ctx {
+       AVFormatContext *format_ctx;
+       AVCodecContext  *codec_ctx;
+       int video_stream_index;
+};
+
+static int video_input_init(struct video_input_ctx *input_ctx,
+                           const char *input_format_string,
+                           const char *input_path,
+                           AVDictionary **input_options)
+{
+       AVInputFormat *input_format = NULL;
+       AVFormatContext *input_format_ctx;
+       AVCodecContext *input_codec_ctx;
+       AVCodec *input_codec;
+       int video_index;
+       unsigned int i;
+       int ret;
+
+       avdevice_register_all();
+       avcodec_register_all();
+       av_register_all();
+
+       if (input_format_string) {
+               /* find the desired input format */
+               input_format = av_find_input_format(input_format_string);
+               if (input_format == NULL) {
+                       fprintf(stderr, "cannot find input format\n");
+                       ret = -ENODEV;
+                       goto out;
+               }
+       }
+
+       if (input_path == NULL) {
+               fprintf(stderr, "input_path must not be NULL!\n");
+               ret = -EINVAL;
+               goto out;
+       }
+
+       /* open the input format/device */
+       input_format_ctx = NULL;
+       ret = avformat_open_input(&input_format_ctx,
+                                 input_path,
+                                 input_format,
+                                 input_options);
+       if (ret < 0) {
+               fprintf(stderr, "cannot open input format/device\n");
+               goto out;
+       }
+
+       /* get information on the input stream (e.g. format, bitrate, framerate) */
+       ret = avformat_find_stream_info(input_format_ctx, NULL);
+       if (ret < 0) {
+               fprintf(stderr, "cannot get information on the stream");
+               goto cleanup;
+       }
+
+       /* dump what was found */
+       av_dump_format(input_format_ctx, 0, input_path, 0);
+
+       /* look for the first video_stream */
+       video_index = -1;
+       for (i = 0; i < input_format_ctx->nb_streams; i++)
+               if (input_format_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+                       video_index = i;
+                       break;
+               }
+       if (video_index == -1) {
+               fprintf(stderr, "cannot find any video streams\n");
+               ret = -ENOTSUP;
+               goto cleanup;
+       }
+
+       /* get a pointer to the codec context for the video stream */
+       input_codec_ctx = input_format_ctx->streams[video_index]->codec;
+       if (input_codec_ctx == NULL) {
+               fprintf(stderr, "input codec context is not valid\n");
+               ret = -ENOTSUP;
+               goto cleanup;
+       }
+
+       /* find the decoder for the video stream */
+       input_codec = avcodec_find_decoder(input_codec_ctx->codec_id);
+       if (input_codec == NULL) {
+               fprintf(stderr, "input_codec is NULL!");
+               ret = -ENOTSUP;
+               goto cleanup;
+       }
+
+       /* open the decoder */
+       ret = avcodec_open2(input_codec_ctx, input_codec, NULL);
+       if (ret < 0) {
+               fprintf(stderr, "cannot open input codec\n");
+               ret = -ENOTSUP;
+               goto cleanup;
+       }
+
+       input_ctx->format_ctx = input_format_ctx;
+       input_ctx->codec_ctx = input_codec_ctx;
+       input_ctx->video_stream_index = video_index;
+
+       ret = 0;
+       goto out;
+
+cleanup:
+       avformat_close_input(&input_format_ctx);
+out:
+       av_dict_free(input_options);
+       *input_options = NULL;
+       return ret;
+}
+
+
+struct video_output_ctx {
+       AVCodecContext  *codec_ctx;
+       int raw_output;
+};
+
+static int video_output_init(struct video_output_ctx *output_ctx,
+                            struct video_input_ctx *input_ctx,
+                            unsigned int upscale,
+                            unsigned int quality,
+                            am7xxx_image_format image_format,
+                            am7xxx_device *dev)
+{
+       AVCodecContext *output_codec_ctx;
+       AVCodec *output_codec;
+       unsigned int new_output_width;
+       unsigned int new_output_height;
+       int ret;
+
+       if (input_ctx == NULL) {
+               fprintf(stderr, "input_ctx must not be NULL!");
+               ret = -EINVAL;
+               goto out;
+       }
+
+       /* create the encoder context */
+       output_codec_ctx = avcodec_alloc_context3(NULL);
+       if (output_codec_ctx == NULL) {
+               fprintf(stderr, "cannot allocate output codec context!");
+               ret = -ENOMEM;
+               goto out;
+       }
+
+       /* Calculate the new output dimension so the original picture is shown
+        * in its entirety */
+       ret = am7xxx_calc_scaled_image_dimensions(dev,
+                                                 upscale,
+                                                 (input_ctx->codec_ctx)->width,
+                                                 (input_ctx->codec_ctx)->height,
+                                                 &new_output_width,
+                                                 &new_output_height);
+       if (ret < 0) {
+               fprintf(stderr, "cannot calculate output dimension\n");
+               goto cleanup;
+       }
+
+       /* put sample parameters */
+       output_codec_ctx->bit_rate   = (input_ctx->codec_ctx)->bit_rate;
+       output_codec_ctx->width      = new_output_width;
+       output_codec_ctx->height     = new_output_height;
+       output_codec_ctx->time_base.num  = (input_ctx->codec_ctx)->time_base.num;
+       output_codec_ctx->time_base.den  = (input_ctx->codec_ctx)->time_base.den;
+
+       /* When the raw format is requested we don't actually need to setup
+        * and open a decoder
+        */
+       if (image_format == AM7XXX_IMAGE_FORMAT_NV12) {
+               fprintf(stdout, "using raw output format\n");
+               output_codec_ctx->pix_fmt    = PIX_FMT_NV12;
+               output_ctx->codec_ctx = output_codec_ctx;
+               output_ctx->raw_output = 1;
+               ret = 0;
+               goto out;
+       }
+
+       output_codec_ctx->pix_fmt    = PIX_FMT_YUVJ420P;
+       output_codec_ctx->codec_id   = CODEC_ID_MJPEG;
+       output_codec_ctx->codec_type = AVMEDIA_TYPE_VIDEO;
+
+       /* Set quality and other VBR settings */
+
+       /* @note: 'quality' is expected to be between 1 and 100, but a value
+        * between 0 to 99 has to be passed when calculating qmin and qmax.
+        * This way qmin and qmax will cover the range 1-FF_QUALITY_SCALE, and
+        * in particular they won't be 0, this is needed because they are used
+        * as divisor somewhere in the encoding process */
+       output_codec_ctx->qmin       = output_codec_ctx->qmax = ((100 - (quality - 1)) * FF_QUALITY_SCALE) / 100;
+       output_codec_ctx->mb_lmin    = output_codec_ctx->lmin = output_codec_ctx->qmin * FF_QP2LAMBDA;
+       output_codec_ctx->mb_lmax    = output_codec_ctx->lmax = output_codec_ctx->qmax * FF_QP2LAMBDA;
+       output_codec_ctx->flags      |= CODEC_FLAG_QSCALE;
+       output_codec_ctx->global_quality = output_codec_ctx->qmin * FF_QP2LAMBDA;
+
+       /* find the encoder */
+       output_codec = avcodec_find_encoder(output_codec_ctx->codec_id);
+       if (output_codec == NULL) {
+               fprintf(stderr, "cannot find output codec!\n");
+               ret = -ENOTSUP;
+               goto cleanup;
+       }
+
+       /* open the codec */
+       ret = avcodec_open2(output_codec_ctx, output_codec, NULL);
+       if (ret < 0) {
+               fprintf(stderr, "could not open output codec!\n");
+               goto cleanup;
+       }
+
+       output_ctx->codec_ctx = output_codec_ctx;
+       output_ctx->raw_output = 0;
+
+       ret = 0;
+       goto out;
+
+cleanup:
+       avcodec_close(output_codec_ctx);
+       av_free(output_codec_ctx);
+out:
+       return ret;
+}
+
+
+static int am7xxx_play(const char *input_format_string,
+                      AVDictionary **input_options,
+                      const char *input_path,
+                      unsigned int rescale_method,
+                      unsigned int upscale,
+                      unsigned int quality,
+                      am7xxx_image_format image_format,
+                      am7xxx_device *dev)
+{
+       struct video_input_ctx input_ctx;
+       struct video_output_ctx output_ctx;
+       AVFrame *picture_raw;
+       AVFrame *picture_scaled;
+       int out_buf_size;
+       uint8_t *out_buf;
+       int out_picture_size;
+       struct SwsContext *sw_scale_ctx;
+       AVPacket packet;
+       int got_picture;
+       int ret = 0;
+
+       ret = video_input_init(&input_ctx, input_format_string, input_path, input_options);
+       if (ret < 0) {
+               fprintf(stderr, "cannot initialize input\n");
+               goto out;
+       }
+
+       ret = video_output_init(&output_ctx, &input_ctx, upscale, quality, image_format, dev);
+       if (ret < 0) {
+               fprintf(stderr, "cannot initialize input\n");
+               goto cleanup_input;
+       }
+
+       /* allocate an input frame */
+       picture_raw = avcodec_alloc_frame();
+       if (picture_raw == NULL) {
+               fprintf(stderr, "cannot allocate the raw picture frame!");
+               goto cleanup_output;
+       }
+
+       /* allocate output frame */
+       picture_scaled = avcodec_alloc_frame();
+       if (picture_scaled == NULL) {
+               fprintf(stderr, "cannot allocate the scaled picture!\n");
+               goto cleanup_picture_raw;
+       }
+
+       /* calculate the bytes needed for the output image and create buffer for the output image */
+       out_buf_size = avpicture_get_size((output_ctx.codec_ctx)->pix_fmt,
+                                         (output_ctx.codec_ctx)->width,
+                                         (output_ctx.codec_ctx)->height);
+       out_buf = av_malloc(out_buf_size * sizeof(uint8_t));
+       if (out_buf == NULL) {
+               fprintf(stderr, "cannot allocate output data buffer!\n");
+               goto cleanup_picture_scaled;
+       }
+
+       /* assign appropriate parts of buffer to image planes in picture_scaled */
+       avpicture_fill((AVPicture *)picture_scaled,
+                      out_buf,
+                      (output_ctx.codec_ctx)->pix_fmt,
+                      (output_ctx.codec_ctx)->width,
+                      (output_ctx.codec_ctx)->height);
+
+       sw_scale_ctx = sws_getCachedContext(NULL,
+                                           (input_ctx.codec_ctx)->width,
+                                           (input_ctx.codec_ctx)->height,
+                                           (input_ctx.codec_ctx)->pix_fmt,
+                                           (output_ctx.codec_ctx)->width,
+                                           (output_ctx.codec_ctx)->height,
+                                           (output_ctx.codec_ctx)->pix_fmt,
+                                           rescale_method,
+                                           NULL, NULL, NULL);
+       if (sw_scale_ctx == NULL) {
+               fprintf(stderr, "cannot set up the rescaling context!\n");
+               goto cleanup_out_buf;
+       }
+
+       while (run) {
+               /* read packet */
+               ret = av_read_frame(input_ctx.format_ctx, &packet);
+               if (ret < 0) {
+                       if (ret == (int)AVERROR_EOF || input_ctx.format_ctx->pb->eof_reached)
+                               ret = 0;
+                       else
+                               fprintf(stderr, "av_read_frame failed, EOF?\n");
+                       run = 0;
+                       goto end_while;
+               }
+
+               if (packet.stream_index != input_ctx.video_stream_index) {
+                       /* that is more or less a "continue", but there is
+                        * still the packet to free */
+                       goto end_while;
+               }
+
+               /* decode */
+               got_picture = 0;
+               ret = avcodec_decode_video2(input_ctx.codec_ctx, picture_raw, &got_picture, &packet);
+               if (ret < 0) {
+                       fprintf(stderr, "cannot decode video\n");
+                       run = 0;
+                       goto end_while;
+               }
+
+               /* if we get the complete frame */
+               if (got_picture) {
+                       /* convert it to YUV */
+                       sws_scale(sw_scale_ctx,
+                                 (const uint8_t * const*)picture_raw->data,
+                                 picture_raw->linesize,
+                                 0,
+                                 (input_ctx.codec_ctx)->height,
+                                 picture_scaled->data,
+                                 picture_scaled->linesize);
+
+                       if (output_ctx.raw_output) {
+                               out_picture_size = out_buf_size;
+                       } else {
+                               picture_scaled->quality = (output_ctx.codec_ctx)->global_quality;
+                               /* TODO: switch to avcodec_encode_video2() eventually */
+                               out_picture_size = avcodec_encode_video(output_ctx.codec_ctx,
+                                                                       out_buf,
+                                                                       out_buf_size,
+                                                                       picture_scaled);
+                               if (out_picture_size < 0) {
+                                       fprintf(stderr, "cannot encode video\n");
+                                       ret = out_picture_size;
+                                       run = 0;
+                                       goto end_while;
+                               }
+                       }
+
+#ifdef DEBUG
+                       char filename[NAME_MAX];
+                       FILE *file;
+                       if (!output_ctx.raw_output)
+                               snprintf(filename, NAME_MAX, "out_q%03d.jpg", quality);
+                       else
+                               snprintf(filename, NAME_MAX, "out.raw");
+                       file = fopen(filename, "wb");
+                       fwrite(out_buf, 1, out_picture_size, file);
+                       fclose(file);
+#endif
+
+                       ret = am7xxx_send_image(dev,
+                                               image_format,
+                                               (output_ctx.codec_ctx)->width,
+                                               (output_ctx.codec_ctx)->height,
+                                               out_buf,
+                                               out_picture_size);
+                       if (ret < 0) {
+                               perror("am7xxx_send_image");
+                               run = 0;
+                               goto end_while;
+                       }
+               }
+end_while:
+               av_free_packet(&packet);
+       }
+
+       sws_freeContext(sw_scale_ctx);
+cleanup_out_buf:
+       av_free(out_buf);
+cleanup_picture_scaled:
+       av_free(picture_scaled);
+cleanup_picture_raw:
+       av_free(picture_raw);
+
+cleanup_output:
+       /* av_free is needed as well,
+        * see http://libav.org/doxygen/master/avcodec_8h.html#a5d7440cd7ea195bd0b14f21a00ef36dd
+        */
+       avcodec_close(output_ctx.codec_ctx);
+       av_free(output_ctx.codec_ctx);
+
+cleanup_input:
+       avcodec_close(input_ctx.codec_ctx);
+       avformat_close_input(&(input_ctx.format_ctx));
+
+out:
+       return ret;
+}
+
+#ifdef HAVE_XCB
+#include <xcb/xcb.h>
+static int x_get_screen_dimensions(const char *displayname, int *width, int *height)
+{
+       int i, screen_number;
+       xcb_connection_t *connection;
+       const xcb_setup_t *setup;
+       xcb_screen_iterator_t iter;
+
+       connection = xcb_connect(displayname, &screen_number);
+       if (xcb_connection_has_error(connection)) {
+               fprintf(stderr, "Cannot open a connection to %s\n", displayname);
+               return -EINVAL;
+       }
+
+       setup = xcb_get_setup(connection);
+       if (setup == NULL) {
+               fprintf(stderr, "Cannot get setup for %s\n", displayname);
+               xcb_disconnect(connection);
+               return -EINVAL;
+       }
+
+       iter = xcb_setup_roots_iterator(setup);
+       for (i = 0; i < screen_number; ++i) {
+               xcb_screen_next(&iter);
+       }
+
+       xcb_screen_t *screen = iter.data;
+
+       *width = screen->width_in_pixels;
+       *height = screen->height_in_pixels;
+
+       xcb_disconnect(connection);
+
+       return 0;
+}
+
+static char *get_x_screen_size(const char *input_path)
+{
+       int len;
+       int width;
+       int height;
+       char *screen_size;
+       int ret;
+
+       ret = x_get_screen_dimensions(input_path, &width, &height);
+       if (ret < 0) {
+               fprintf(stderr, "Cannot get screen dimensions for %s\n", input_path);
+               return NULL;
+       }
+
+       len = snprintf(NULL, 0, "%dx%d", width, height);
+
+       screen_size = malloc((len + 1) * sizeof(char));
+       if (screen_size == NULL) {
+               perror("malloc");
+               return NULL;
+       }
+
+       len = snprintf(screen_size, len + 1, "%dx%d", width, height);
+       if (len < 0) {
+               free(screen_size);
+               screen_size = NULL;
+               return NULL;
+       }
+       return screen_size;
+}
+#else
+static char *get_x_screen_size(const char *input_path)
+{
+       (void) input_path;
+       fprintf(stderr, "%s: fallback implementation\n", __func__);
+       return strdup("vga");
+}
+#endif
+
+static void unset_run(int signo)
+{
+       (void) signo;
+       run = 0;
+}
+
+static int set_signal_handler(void (*signal_handler)(int))
+{
+       struct sigaction new_action;
+       struct sigaction old_action;
+       int ret = 0;
+
+       new_action.sa_handler = signal_handler;
+       sigemptyset(&new_action.sa_mask);
+       new_action.sa_flags = 0;
+
+       ret = sigaction(SIGINT, NULL, &old_action);
+       if (ret < 0) {
+               perror("sigaction on old_action");
+               goto out;
+       }
+
+       if (old_action.sa_handler != SIG_IGN) {
+               ret = sigaction(SIGINT, &new_action, NULL);
+               if (ret < 0) {
+                       perror("sigaction on new_action");
+                       goto out;
+               }
+       }
+
+out:
+       return ret;
+}
+
+static void usage(char *name)
+{
+       printf("usage: %s [OPTIONS]\n\n", name);
+       printf("OPTIONS:\n");
+       printf("\t-f <input format>\tthe input device format\n");
+       printf("\t-i <input path>\t\tthe input path\n");
+       printf("\t-o <options>\t\ta comma separated list of input format options\n");
+       printf("\t\t\t\tEXAMPLE:\n");
+       printf("\t\t\t\t\t-o draw_mouse=1,framerate=100,video_size=800x480\n");
+       printf("\t-s <input path>\t\tthe rescaling method (see swscale.h)\n");
+       printf("\t-u \t\t\tupscale the image if smaller than the display dimensions\n");
+       printf("\t-F <format>\t\tthe image format to use (default is JPEG)\n");
+       printf("\t\t\t\tSUPPORTED FORMATS:\n");
+       printf("\t\t\t\t\t1 - JPEG\n");
+       printf("\t\t\t\t\t2 - NV12\n");
+       printf("\t-q \t\t\tquality of jpeg sent to the device, between 1 and 100\n");
+       printf("\t-h \t\t\tthis help message\n");
+       printf("\n\nEXAMPLES OF USE:\n");
+       printf("\t%s -f x11grab -i :0.0 -o video_size=800x480\n", name);
+       printf("\t%s -f fbdev -i /dev/fb0\n", name);
+       printf("\t%s -f video4linux2 -i /dev/video0 -o video_size=320x240,frame_rate=100 -u -q 90\n", name);
+       printf("\t%s -i http://download.blender.org/peach/bigbuckbunny_movies/BigBuckBunny_640x360.m4v\n", name);
+}
+
+int main(int argc, char *argv[])
+{
+       int ret;
+       int opt;
+       char *subopts;
+       char *subopts_saved;
+       char *subopt;
+       char *input_format_string = NULL;
+       AVDictionary *options = NULL;
+       char *input_path = NULL;
+       unsigned int rescale_method = SWS_BICUBIC;
+       unsigned int upscale = 0;
+       unsigned int quality = 95;
+       int format = AM7XXX_IMAGE_FORMAT_JPEG;
+       am7xxx_context *ctx;
+       am7xxx_device *dev;
+
+       while ((opt = getopt(argc, argv, "f:i:o:s:uF:q:h")) != -1) {
+               switch (opt) {
+               case 'f':
+                       input_format_string = strdup(optarg);
+                       break;
+               case 'i':
+                       input_path = strdup(optarg);
+                       break;
+               case 'o':
+                       /*
+                        * parse suboptions, the expected format is something
+                        * like:
+                        *   draw_mouse=1,framerate=100,video_size=800x480
+                        */
+                       subopts = subopts_saved = strdup(optarg);
+                       while((subopt = strtok_r(subopts, ",", &subopts))) {
+                               char *subopt_name = strtok_r(subopt, "=", &subopt);
+                               char *subopt_value = strtok_r(NULL, "", &subopt);
+                               if (subopt_value == NULL) {
+                                       fprintf(stderr, "invalid suboption: %s\n", subopt_name);
+                                       continue;
+                               }
+                               av_dict_set(&options, subopt_name, subopt_value, 0);
+                       }
+                       free(subopts_saved);
+                       break;
+               case 's':
+                       rescale_method = atoi(optarg);
+                       switch(format) {
+                       case SWS_FAST_BILINEAR:
+                       case SWS_BILINEAR:
+                       case SWS_BICUBIC:
+                       case SWS_X:
+                       case SWS_POINT:
+                       case SWS_AREA:
+                       case SWS_BICUBLIN:
+                       case SWS_GAUSS:
+                       case SWS_SINC:
+                       case SWS_LANCZOS:
+                       case SWS_SPLINE:
+                               break;
+                       default:
+                               fprintf(stderr, "Unsupported rescale method\n");
+                               ret = -EINVAL;
+                               goto out;;
+                       }
+                       break;
+               case 'u':
+                       upscale = 1;
+                       break;
+               case 'F':
+                       format = atoi(optarg);
+                       switch(format) {
+                       case AM7XXX_IMAGE_FORMAT_JPEG:
+                               fprintf(stdout, "JPEG format\n");
+                               break;
+                       case AM7XXX_IMAGE_FORMAT_NV12:
+                               fprintf(stdout, "NV12 format\n");
+                               break;
+                       default:
+                               fprintf(stderr, "Unsupported format\n");
+                               ret = -EINVAL;
+                               goto out;;
+                       }
+                       break;
+               case 'q':
+                       quality = atoi(optarg);
+                       if (quality < 1 || quality > 100) {
+                               fprintf(stderr, "Invalid quality value, must be between 1 and 100\n");
+                               ret = -EINVAL;
+                               goto out;;
+                       }
+                       break;
+               case 'h':
+                       usage(argv[0]);
+                       ret = 0;
+                       goto out;
+                       break;
+               default: /* '?' */
+                       usage(argv[0]);
+                       ret = -EINVAL;
+                       goto out;
+               }
+       }
+
+       if (input_path == NULL) {
+               fprintf(stderr, "The -i option must always be passed\n");
+               ret = -EINVAL;
+               goto out;
+       }
+
+       /*
+        * When the input format is 'x11grab' set some useful fallback options
+        * if not supplied by the user, in particular grab full screen
+        */
+       if (input_format_string && strcmp(input_format_string, "x11grab") == 0) {
+               char *video_size;
+
+               video_size = get_x_screen_size(input_path);
+
+               if (!av_dict_get(options, "video_size", NULL, 0))
+                       av_dict_set(&options, "video_size", video_size, 0);
+
+               if (!av_dict_get(options, "framerate", NULL, 0))
+                       av_dict_set(&options, "framerate", "60", 0);
+
+               if (!av_dict_get(options, "draw_mouse", NULL, 0))
+                       av_dict_set(&options, "draw_mouse",  "1", 0);
+
+               free(video_size);
+       }
+
+       ret = set_signal_handler(unset_run);
+       if (ret < 0) {
+               perror("sigaction");
+               goto out;
+       }
+
+       ret = am7xxx_init(&ctx);
+       if (ret < 0) {
+               perror("am7xxx_init");
+               goto out;
+       }
+
+       ret = am7xxx_open_device(ctx, &dev, 0);
+       if (ret < 0) {
+               perror("am7xxx_open_device");
+               goto cleanup;
+       }
+
+       ret = am7xxx_set_power_mode(dev, AM7XXX_POWER_LOW);
+       if (ret < 0) {
+               perror("am7xxx_set_power_mode");
+               goto cleanup;
+       }
+
+       ret = am7xxx_play(input_format_string,
+                         &options,
+                         input_path,
+                         rescale_method,
+                         upscale,
+                         quality,
+                         format,
+                         dev);
+       if (ret < 0) {
+               fprintf(stderr, "am7xxx_play failed\n");
+               goto cleanup;
+       }
+
+cleanup:
+       am7xxx_shutdown(ctx);
+out:
+       av_dict_free(&options);
+       free(input_path);
+       free(input_format_string);
+       return ret;
+}