add coding unit size for interlaced decoding
[ffmpeg.git] / vhook / watermark.c
index 1d01540..a8f7d57 100644 (file)
@@ -1,51 +1,71 @@
 /*
- * Watermark Hook 
+ * Watermark Hook
  * Copyright (c) 2005 Marcus Engene myfirstname(at)mylastname.se
  *
- * The watermarkpicture works like this. (Assuming colorintencities 0..0xff)
+ * parameters for watermark:
+ *  -m nbr = nbr is 0..1. 0 is the default mode, see below.
+ *  -t nbr = nbr is six digit hex. Threshold.
+ *  -f file = file is the watermark image filename. You must specify this!
+ *
+ * MODE 0:
+ * The watermark picture works like this (assuming color intensities 0..0xff):
  * Per color do this:
- * If mask color is 0x80, no change to original frame.
- * If mask color is < 0x80 the abs difference is subtracted from frame. If
+ * If mask color is 0x80, no change to the original frame.
+ * If mask color is < 0x80 the abs difference is subtracted from the frame. If
  * result < 0, result = 0
- * If mask color is > 0x80 the abs difference is added to frame. If result
+ * If mask color is > 0x80 the abs difference is added to the frame. If result
  * > 0xff, result = 0xff
  *
+ * You can override the 0x80 level with the -t flag. E.g. if threshold is
+ * 000000 the color value of watermark is added to the destination.
+ *
  * This way a mask that is visible both in light pictures and in dark can be
- * made (fex by using a picture generated by gimp and the bump map tool). 
+ * made (fex by using a picture generated by Gimp and the bump map tool).
  *
  * An example watermark file is at
  * http://engene.se/ffmpeg_watermark.gif
  *
+ * MODE 1:
+ * Per color do this:
+ * If mask color > threshold color then the watermark pixel is used.
+ *
  * Example usage:
- *  ffmpeg -i infile -vhook '/path/watermark.so -f wm.gif' out.mov
+ *  ffmpeg -i infile -vhook '/path/watermark.so -f wm.gif' -an out.mov
+ *  ffmpeg -i infile -vhook '/path/watermark.so -f wm.gif -m 1 -t 222222' -an out.mov
  *
  * Note that the entire vhook argument is encapsulated in ''. This
- * way, arguments to the vhook won't be mixed up with those to ffmpeg.
+ * way, arguments to the vhook won't be mixed up with those for ffmpeg.
+ *
+ * This file is part of FFmpeg.
  *
- * This library is free software; you can redistribute it and/or
+ * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
  *
- * This library is distributed in the hope that it will be useful,
+ * FFmpeg 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-//#include <stdlib.h>
+#include <stdlib.h>
 //#include <fcntl.h>
 #include <unistd.h>
 #include <stdarg.h>
+
 #include "common.h"
 #include "avformat.h"
 
 #include "framehook.h"
+#include "cmdutils.h"
+#include "swscale.h"
+
+static int sws_flags = SWS_BICUBIC;
 
 typedef struct {
     char            filename[2000];
@@ -57,8 +77,8 @@ typedef struct {
     const char     *p_ext;
     int             videoStream;
     int             frameFinished;
-    AVCodecContext *pCodecCtx;    
-    AVCodec        *pCodec;    
+    AVCodecContext *pCodecCtx;
+    AVCodec        *pCodec;
     AVFrame        *pFrame;
     AVPacket        packet;
     int             numBytes;
@@ -66,85 +86,115 @@ typedef struct {
     int             i;
     AVInputFormat  *file_iformat;
     AVStream       *st;
-    int             is_done;    
+    int             is_done;
     AVFrame        *pFrameRGB;
+    int             thrR;
+    int             thrG;
+    int             thrB;
+    int             mode;
+
+    // This vhook first converts frame to RGB ...
+    struct SwsContext *toRGB_convert_ctx;
+    // ... then converts a watermark and applies it to the RGB frame ...
+    struct SwsContext *watermark_convert_ctx;
+    // ... and finally converts back frame from RGB to initial format
+    struct SwsContext *fromRGB_convert_ctx;
 } ContextInfo;
 
 int get_watermark_picture(ContextInfo *ci, int cleanup);
 
 
 /****************************************************************************
- * 
+ *
  ****************************************************************************/
 void Release(void *ctx)
 {
     ContextInfo *ci;
     ci = (ContextInfo *) ctx;
 
-    if (ci) get_watermark_picture(ci, 1);
-    
-    if (ctx)
-        av_free(ctx);
+    if (ci) {
+        get_watermark_picture(ci, 1);
+        sws_freeContext(ci->toRGB_convert_ctx);
+        sws_freeContext(ci->watermark_convert_ctx);
+        sws_freeContext(ci->fromRGB_convert_ctx);
+    }
+    av_free(ctx);
 }
 
 
 /****************************************************************************
- * 
+ *
  ****************************************************************************/
 int Configure(void **ctxp, int argc, char *argv[])
 {
     ContextInfo *ci;
     int c;
+    int tmp = 0;
 
     if (0 == (*ctxp = av_mallocz(sizeof(ContextInfo)))) return -1;
     ci = (ContextInfo *) *ctxp;
 
-    optind = 0;
-    
+    optind = 1;
+
     // Struct is mallocz:ed so no need to reset.
-        
-    while ((c = getopt(argc, argv, "f:")) > 0) {
+    ci->thrR = 0x80;
+    ci->thrG = 0x80;
+    ci->thrB = 0x80;
+
+    while ((c = getopt(argc, argv, "f:m:t:")) > 0) {
         switch (c) {
             case 'f':
                 strncpy(ci->filename, optarg, 1999);
                 ci->filename[1999] = 0;
                 break;
+            case 'm':
+                ci->mode = atoi(optarg);
+                break;
+            case 't':
+                if (1 != sscanf(optarg, "%x", &tmp)) {
+                    av_log(NULL, AV_LOG_ERROR, "Watermark: argument to -t must be a 6 digit hex number\n");
+                    return -1;
+                }
+                ci->thrR = (tmp >> 16) & 0xff;
+                ci->thrG = (tmp >> 8) & 0xff;
+                ci->thrB = (tmp >> 0) & 0xff;
+                break;
             default:
-                av_log(NULL, AV_LOG_DEBUG, "Unrecognized argument '%s'\n", argv[optind]);
+                av_log(NULL, AV_LOG_ERROR, "Watermark: Unrecognized argument '%s'\n", argv[optind]);
                 return -1;
         }
     }
-    
+
     //
-    if (0 == ci->filename[0]) return -1;
-        
+    if (0 == ci->filename[0]) {
+        av_log(NULL, AV_LOG_ERROR, "Watermark: There is no filename specified.\n");
+        return -1;
+    }
+
     av_register_all();
     return get_watermark_picture(ci, 0);
-
-    return 0;
 }
 
 
 /****************************************************************************
- * Why is this a void returning functions? I want to be able to go wrong!
+ * For mode 0 (the original one)
  ****************************************************************************/
-void Process(void *ctx, 
-             AVPicture *picture, 
-             enum PixelFormat pix_fmt, 
-             int src_width, 
-             int src_height, 
-             int64_t pts)
+static void Process0(void *ctx,
+              AVPicture *picture,
+              enum PixelFormat pix_fmt,
+              int src_width,
+              int src_height,
+              int64_t pts)
 {
     ContextInfo *ci = (ContextInfo *) ctx;
     char *buf = 0;
     AVPicture picture1;
     AVPicture *pict = picture;
-    
+
     AVFrame *pFrameRGB;
     int xm_size;
     int ym_size;
 
-//    int retval = -1;
     int x;
     int y;
     int offs, offsm;
@@ -153,39 +203,52 @@ void Process(void *ctx,
     uint32_t pixel_meck;
     uint32_t pixel;
     uint32_t pixelm;
-    int tmp;    
-    
-        
-//??    (void) ci;
+    int tmp;
+    int thrR = ci->thrR;
+    int thrG = ci->thrG;
+    int thrB = ci->thrB;
 
-    if (pix_fmt != PIX_FMT_RGBA32) {
+    if (pix_fmt != PIX_FMT_RGB32) {
         int size;
 
-        size = avpicture_get_size(PIX_FMT_RGBA32, src_width, src_height);
+        size = avpicture_get_size(PIX_FMT_RGB32, src_width, src_height);
         buf = av_malloc(size);
 
-        avpicture_fill(&picture1, buf, PIX_FMT_RGBA32, src_width, src_height);
-        if (img_convert(&picture1, PIX_FMT_RGBA32, 
-                        picture, pix_fmt, src_width, src_height) < 0) {
-            av_free(buf);
+        avpicture_fill(&picture1, buf, PIX_FMT_RGB32, src_width, src_height);
+
+        // if we already got a SWS context, let's realloc if is not re-useable
+        ci->toRGB_convert_ctx = sws_getCachedContext(ci->toRGB_convert_ctx,
+                                    src_width, src_height, pix_fmt,
+                                    src_width, src_height, PIX_FMT_RGB32,
+                                    sws_flags, NULL, NULL, NULL);
+        if (ci->toRGB_convert_ctx == NULL) {
+            av_log(NULL, AV_LOG_ERROR,
+                   "Cannot initialize the toRGB conversion context\n");
             return;
         }
+
+// img_convert parameters are          2 first destination, then 4 source
+// sws_scale   parameters are context, 4 first source,      then 2 destination
+        sws_scale(ci->toRGB_convert_ctx,
+                 picture->data, picture->linesize, 0, src_height,
+                 picture1.data, picture1.linesize);
+
         pict = &picture1;
     }
 
     /* Insert filter code here */ /* ok */
 
-    // Get me next frame    
+    // Get me next frame
     if (0 > get_watermark_picture(ci, 0)) {
         return;
-    }     
+    }
     // These are the three original static variables in the ffmpeg hack.
     pFrameRGB = ci->pFrameRGB;
     xm_size = ci->x_size;
     ym_size = ci->y_size;
-    
+
     // I'll do the *4 => <<2 crap later. Most compilers understand that anyway.
-    // According to avcodec.h PIX_FMT_RGBA32 is handled in endian specific manner.
+    // According to avcodec.h PIX_FMT_RGB32 is handled in endian specific manner.
     for (y=0; y<src_height; y++) {
         offs = y * (src_width * 4);
         offsm = (((y * ym_size) / src_height) * 4) * xm_size; // offsm first in maskline. byteoffs!
@@ -199,39 +262,50 @@ void Process(void *ctx,
             pixel_meck = pixel & 0xff000000;
 
             // R
-            tmp = (int)((pixel >> 16) & 0xff) + (int)((pixelm >> 16) & 0xff) - 0x80;
+            tmp = (int)((pixel >> 16) & 0xff) + (int)((pixelm >> 16) & 0xff) - thrR;
             if (tmp > 255) tmp = 255;
             if (tmp < 0) tmp = 0;
             pixel_meck |= (tmp << 16) & 0xff0000;
             // G
-            tmp = (int)((pixel >> 8) & 0xff) + (int)((pixelm >> 8) & 0xff) - 0x80;
+            tmp = (int)((pixel >> 8) & 0xff) + (int)((pixelm >> 8) & 0xff) - thrG;
             if (tmp > 255) tmp = 255;
             if (tmp < 0) tmp = 0;
             pixel_meck |= (tmp << 8) & 0xff00;
             // B
-            tmp = (int)((pixel >> 0) & 0xff) + (int)((pixelm >> 0) & 0xff) - 0x80;
+            tmp = (int)((pixel >> 0) & 0xff) + (int)((pixelm >> 0) & 0xff) - thrB;
             if (tmp > 255) tmp = 255;
             if (tmp < 0) tmp = 0;
             pixel_meck |= (tmp << 0) & 0xff;
-            
-            
+
+
             // test:
             //pixel_meck = pixel & 0xff000000;
             //pixel_meck |= (pixelm & 0x00ffffff);
 
             *p_pixel = pixel_meck;
 
-            offs += 4; 
+            offs += 4;
         } // foreach X
-    } // foreach Y    
-    
-    
-    
-
-    if (pix_fmt != PIX_FMT_RGBA32) {
-        if (img_convert(picture, pix_fmt, 
-                        &picture1, PIX_FMT_RGBA32, src_width, src_height) < 0) {
+    } // foreach Y
+
+
+
+
+    if (pix_fmt != PIX_FMT_RGB32) {
+        ci->fromRGB_convert_ctx = sws_getCachedContext(ci->fromRGB_convert_ctx,
+                                      src_width, src_height, PIX_FMT_RGB32,
+                                      src_width, src_height, pix_fmt,
+                                      sws_flags, NULL, NULL, NULL);
+        if (ci->fromRGB_convert_ctx == NULL) {
+            av_log(NULL, AV_LOG_ERROR,
+                   "Cannot initialize the fromRGB conversion context\n");
+            return;
         }
+// img_convert parameters are          2 first destination, then 4 source
+// sws_scale   parameters are context, 4 first source,      then 2 destination
+        sws_scale(ci->fromRGB_convert_ctx,
+                 picture1.data, picture1.linesize, 0, src_height,
+                 picture->data, picture->linesize);
     }
 
     av_free(buf);
@@ -239,10 +313,140 @@ void Process(void *ctx,
 
 
 /****************************************************************************
+ * For mode 1 (the original one)
+ ****************************************************************************/
+static void Process1(void *ctx,
+              AVPicture *picture,
+              enum PixelFormat pix_fmt,
+              int src_width,
+              int src_height,
+              int64_t pts)
+{
+    ContextInfo *ci = (ContextInfo *) ctx;
+    char *buf = 0;
+    AVPicture picture1;
+    AVPicture *pict = picture;
+
+    AVFrame *pFrameRGB;
+    int xm_size;
+    int ym_size;
+
+    int x;
+    int y;
+    int offs, offsm;
+    int mpoffs;
+    uint32_t *p_pixel = 0;
+    uint32_t pixel;
+    uint32_t pixelm;
+
+    if (pix_fmt != PIX_FMT_RGB32) {
+        int size;
+
+        size = avpicture_get_size(PIX_FMT_RGB32, src_width, src_height);
+        buf = av_malloc(size);
+
+        avpicture_fill(&picture1, buf, PIX_FMT_RGB32, src_width, src_height);
+
+        // if we already got a SWS context, let's realloc if is not re-useable
+        ci->toRGB_convert_ctx = sws_getCachedContext(ci->toRGB_convert_ctx,
+                                    src_width, src_height, pix_fmt,
+                                    src_width, src_height, PIX_FMT_RGB32,
+                                    sws_flags, NULL, NULL, NULL);
+        if (ci->toRGB_convert_ctx == NULL) {
+            av_log(NULL, AV_LOG_ERROR,
+                   "Cannot initialize the toRGB conversion context\n");
+            return;
+        }
+
+// img_convert parameters are          2 first destination, then 4 source
+// sws_scale   parameters are context, 4 first source,      then 2 destination
+        sws_scale(ci->toRGB_convert_ctx,
+                 picture->data, picture->linesize, 0, src_height,
+                 picture1.data, picture1.linesize);
+
+        pict = &picture1;
+    }
+
+    /* Insert filter code here */ /* ok */
+
+    // Get me next frame
+    if (0 > get_watermark_picture(ci, 0)) {
+        return;
+    }
+    // These are the three original static variables in the ffmpeg hack.
+    pFrameRGB = ci->pFrameRGB;
+    xm_size = ci->x_size;
+    ym_size = ci->y_size;
+
+    // I'll do the *4 => <<2 crap later. Most compilers understand that anyway.
+    // According to avcodec.h PIX_FMT_RGB32 is handled in endian specific manner.
+    for (y=0; y<src_height; y++) {
+        offs = y * (src_width * 4);
+        offsm = (((y * ym_size) / src_height) * 4) * xm_size; // offsm first in maskline. byteoffs!
+        for (x=0; x<src_width; x++) {
+            mpoffs = offsm + (((x * xm_size) / src_width) * 4);
+            p_pixel = (uint32_t *)&((pFrameRGB->data[0])[mpoffs]);
+            pixelm = *p_pixel; /* watermark pixel */
+            p_pixel = (uint32_t *)&((pict->data[0])[offs]);
+            pixel = *p_pixel;
+
+            if (((pixelm >> 16) & 0xff) > ci->thrR ||
+                ((pixelm >>  8) & 0xff) > ci->thrG ||
+                ((pixelm >>  0) & 0xff) > ci->thrB)
+            {
+                *p_pixel = pixelm;
+            } else {
+                *p_pixel = pixel;
+            }
+            offs += 4;
+        } // foreach X
+    } // foreach Y
+
+    if (pix_fmt != PIX_FMT_RGB32) {
+        ci->fromRGB_convert_ctx = sws_getCachedContext(ci->fromRGB_convert_ctx,
+                                      src_width, src_height, PIX_FMT_RGB32,
+                                      src_width, src_height, pix_fmt,
+                                      sws_flags, NULL, NULL, NULL);
+        if (ci->fromRGB_convert_ctx == NULL) {
+            av_log(NULL, AV_LOG_ERROR,
+                   "Cannot initialize the fromRGB conversion context\n");
+            return;
+        }
+// img_convert parameters are          2 first destination, then 4 source
+// sws_scale   parameters are context, 4 first source,      then 2 destination
+        sws_scale(ci->fromRGB_convert_ctx,
+                 picture1.data, picture1.linesize, 0, src_height,
+                 picture->data, picture->linesize);
+    }
+
+    av_free(buf);
+}
+
+
+/****************************************************************************
+ * This is the function ffmpeg.c callbacks.
+ ****************************************************************************/
+void Process(void *ctx,
+             AVPicture *picture,
+             enum PixelFormat pix_fmt,
+             int src_width,
+             int src_height,
+             int64_t pts)
+{
+    ContextInfo *ci = (ContextInfo *) ctx;
+    if (1 == ci->mode) {
+        Process1(ctx, picture, pix_fmt, src_width, src_height, pts);
+    } else {
+        Process0(ctx, picture, pix_fmt, src_width, src_height, pts);
+    }
+}
+
+
+/****************************************************************************
  * When cleanup == 0, we try to get the next frame. If no next frame, nothing
  * is done.
  *
- * This code follows the example on 
+ * This code follows the example on
  * http://www.inb.uni-luebeck.de/~boehme/using_libavcodec.html
  *
  * 0 = ok, -1 = error
@@ -253,11 +457,11 @@ int get_watermark_picture(ContextInfo *ci, int cleanup)
 
     // Yes, *pFrameRGB arguments must be null the first time otherwise it's not good..
     // This block is only executed the first time we enter this function.
-    if (0 == ci->pFrameRGB && 
-        0 == cleanup) 
+    if (0 == ci->pFrameRGB &&
+        0 == cleanup)
     {
-      
-        /* 
+
+        /*
          * The last three parameters specify the file format, buffer size and format
          * parameters; by simply specifying NULL or 0 we ask libavformat to auto-detect
          * the format and use a default buffer size. (Didn't work!)
@@ -268,7 +472,7 @@ int get_watermark_picture(ContextInfo *ci, int cleanup)
             // NULL instead of file_iformat to av_open_input_file()
             ci->i = strlen(ci->filename);
             if (0 == ci->i) {
-                av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() No filename to watermark vhook\n");
+                av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() No filename to watermark vhook\n");
                 return -1;
             }
             while (ci->i > 0) {
@@ -281,105 +485,105 @@ int get_watermark_picture(ContextInfo *ci, int cleanup)
                ci->p_ext = &(ci->filename[ci->i]);
             ci->file_iformat = av_find_input_format (ci->p_ext);
             if (0 == ci->file_iformat) {
-                av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Really failed to find iformat [%s]\n", ci->p_ext);
+                av_log(NULL, AV_LOG_INFO, "get_watermark_picture() attempt to use image2 for [%s]\n", ci->p_ext);
+                ci->file_iformat = av_find_input_format ("image2");
+            }
+            if (0 == ci->file_iformat) {
+                av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Really failed to find iformat [%s]\n", ci->p_ext);
                 return -1;
             }
-            // now continues the Martin template.    
-            
+            // now continues the Martin template.
+
             if (av_open_input_file(&ci->pFormatCtx, ci->filename, ci->file_iformat, 0, NULL)!=0) {
-                av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Failed to open input file [%s]\n", ci->filename);
+                av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to open input file [%s]\n", ci->filename);
                 return -1;
-            }            
+            }
         }
-        
-        /* 
+
+        /*
          * This fills the streams field of the AVFormatContext with valid information.
          */
         if(av_find_stream_info(ci->pFormatCtx)<0) {
-            av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Failed to find stream info\n");
+            av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to find stream info\n");
             return -1;
         }
-    
+
         /*
-         * As mentioned in the introduction, we'll handle only video streams, not audio 
+         * As mentioned in the introduction, we'll handle only video streams, not audio
          * streams. To make things nice and easy, we simply use the first video stream we
          * find.
          */
         ci->videoStream=-1;
         for(ci->i = 0; ci->i < ci->pFormatCtx->nb_streams; ci->i++)
-            if(ci->pFormatCtx->streams[ci->i]->codec.codec_type==CODEC_TYPE_VIDEO)
+            if(ci->pFormatCtx->streams[ci->i]->codec->codec_type==CODEC_TYPE_VIDEO)
             {
                 ci->videoStream = ci->i;
                 break;
             }
         if(ci->videoStream == -1) {
-            av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Failed to find any video stream\n");
+            av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to find any video stream\n");
             return -1;
         }
-        
+
         ci->st = ci->pFormatCtx->streams[ci->videoStream];
-        ci->x_size = ci->st->codec.width;
-        ci->y_size = ci->st->codec.height;
-        
+        ci->x_size = ci->st->codec->width;
+        ci->y_size = ci->st->codec->height;
+
         // Get a pointer to the codec context for the video stream
-        ci->pCodecCtx = &ci->pFormatCtx->streams[ci->videoStream]->codec;
-            
-        
+        ci->pCodecCtx = ci->pFormatCtx->streams[ci->videoStream]->codec;
+
+
         /*
          * OK, so now we've got a pointer to the so-called codec context for our video
          * stream, but we still have to find the actual codec and open it.
-         */    
+         */
         // Find the decoder for the video stream
         ci->pCodec = avcodec_find_decoder(ci->pCodecCtx->codec_id);
         if(ci->pCodec == NULL) {
-            av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Failed to find any codec\n");
+            av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to find any codec\n");
             return -1;
         }
-        
-        // Inform the codec that we can handle truncated bitstreams -- i.e.,
-        // bitstreams where frame boundaries can fall in the middle of packets
-        if (ci->pCodec->capabilities & CODEC_CAP_TRUNCATED)
-            ci->pCodecCtx->flags|=CODEC_FLAG_TRUNCATED;
-        
+
+
         // Open codec
         if(avcodec_open(ci->pCodecCtx, ci->pCodec)<0) {
-            av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Failed to open codec\n");
+            av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to open codec\n");
             return -1;
         }
-        
-        // Hack to correct wrong frame rates that seem to be generated by some 
+
+        // Hack to correct wrong frame rates that seem to be generated by some
         // codecs
         if (ci->pCodecCtx->time_base.den>1000 && ci->pCodecCtx->time_base.num==1)
-            ci->pCodecCtx->time_base.num=1000;    
-    
+            ci->pCodecCtx->time_base.num=1000;
+
         /*
          * Allocate a video frame to store the decoded images in.
          */
         ci->pFrame = avcodec_alloc_frame();
-    
-        
+
+
         /*
          * The RGB image pFrameRGB (of type AVFrame *) is allocated like this:
          */
         // Allocate an AVFrame structure
         ci->pFrameRGB=avcodec_alloc_frame();
         if(ci->pFrameRGB==NULL) {
-            av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Failed to alloc pFrameRGB\n");
+            av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to alloc pFrameRGB\n");
             return -1;
         }
-        
+
         // Determine required buffer size and allocate buffer
-        ci->numBytes = avpicture_get_size(PIX_FMT_RGBA32, ci->pCodecCtx->width,
+        ci->numBytes = avpicture_get_size(PIX_FMT_RGB32, ci->pCodecCtx->width,
             ci->pCodecCtx->height);
         ci->buffer = av_malloc(ci->numBytes);
-        
+
         // Assign appropriate parts of buffer to image planes in pFrameRGB
-        avpicture_fill((AVPicture *)ci->pFrameRGB, ci->buffer, PIX_FMT_RGBA32,
-            ci->pCodecCtx->width, ci->pCodecCtx->height);    
+        avpicture_fill((AVPicture *)ci->pFrameRGB, ci->buffer, PIX_FMT_RGB32,
+            ci->pCodecCtx->width, ci->pCodecCtx->height);
     }
     // TODO loop, pingpong etc?
-    if (0 == cleanup) 
-    {    
+    if (0 == cleanup)
+    {
 //        av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Get a frame\n");
         while(av_read_frame(ci->pFormatCtx, &ci->packet)>=0)
         {
@@ -387,55 +591,61 @@ int get_watermark_picture(ContextInfo *ci, int cleanup)
             if(ci->packet.stream_index == ci->videoStream)
             {
                 // Decode video frame
-                avcodec_decode_video(ci->pCodecCtx, ci->pFrame, &ci->frameFinished, 
+                avcodec_decode_video(ci->pCodecCtx, ci->pFrame, &ci->frameFinished,
                     ci->packet.data, ci->packet.size);
-        
+
                 // Did we get a video frame?
                 if(ci->frameFinished)
                 {
-                    // Convert the image from its native format to RGBA32
-                    img_convert((AVPicture *)ci->pFrameRGB, PIX_FMT_RGBA32, 
-                        (AVPicture*)(ci->pFrame), ci->pCodecCtx->pix_fmt, ci->pCodecCtx->width, 
-                        ci->pCodecCtx->height);
-        
+                    // Convert the image from its native format to RGB32
+                    ci->watermark_convert_ctx =
+                        sws_getCachedContext(ci->watermark_convert_ctx,
+                            ci->pCodecCtx->width, ci->pCodecCtx->height, ci->pCodecCtx->pix_fmt,
+                            ci->pCodecCtx->width, ci->pCodecCtx->height, PIX_FMT_RGB32,
+                            sws_flags, NULL, NULL, NULL);
+                    if (ci->watermark_convert_ctx == NULL) {
+                        av_log(NULL, AV_LOG_ERROR,
+                              "Cannot initialize the watermark conversion context\n");
+                        return -1;
+                    }
+// img_convert parameters are          2 first destination, then 4 source
+// sws_scale   parameters are context, 4 first source,      then 2 destination
+                    sws_scale(ci->watermark_convert_ctx,
+                             ci->pFrame->data, ci->pFrame->linesize, 0, ci->pCodecCtx->height,
+                             ci->pFrameRGB->data, ci->pFrameRGB->linesize);
+
                     // Process the video frame (save to disk etc.)
                     //fprintf(stderr,"banan() New frame!\n");
                     //DoSomethingWithTheImage(ci->pFrameRGB);
                     return 0;
                 }
             }
-        
+
             // Free the packet that was allocated by av_read_frame
             av_free_packet(&ci->packet);
         }
-        ci->is_done = 1;    
+        ci->is_done = 1;
         return 0;
     } // if 0 != cleanup
-    
-    if (0 != cleanup) 
+
+    if (0 != cleanup)
     {
         // Free the RGB image
-        if (0 != ci->buffer) {
-            av_free(ci->buffer);
-            ci->buffer = 0;
-        }
-        if (0 != ci->pFrameRGB) {
-            av_free(ci->pFrameRGB);
-            ci->pFrameRGB = 0;
-        } 
-        
+        av_freep(&ci->buffer);
+        av_freep(&ci->pFrameRGB);
+
         // Close the codec
         if (0 != ci->pCodecCtx) {
             avcodec_close(ci->pCodecCtx);
             ci->pCodecCtx = 0;
         }
-        
+
         // Close the video file
         if (0 != ci->pFormatCtx) {
-            av_close_input_file(ci->pFormatCtx);    
+            av_close_input_file(ci->pFormatCtx);
             ci->pFormatCtx = 0;
         }
-        
+
         ci->is_done = 0;
     }
     return 0;