vhook/watermark.c

   1 /*
   2  * Watermark Hook
   3  * Copyright (c) 2005 Marcus Engene myfirstname(at)mylastname.se
   4  *
   5  * parameters for watermark:
   6  *  -m nbr = nbr is 0..1. 0 is the default mode, see below.
   7  *  -t nbr = nbr is six digit hex. Threshold.
   8  *  -f file = file is the watermark image filename. You must specify this!
   9  *
  10  * MODE 0:
  11  * The watermark picture works like this (assuming color intensities 0..0xff):
  12  * Per color do this:
  13  * If mask color is 0x80, no change to the original frame.
  14  * If mask color is < 0x80 the abs difference is subtracted from the frame. If
  15  * result < 0, result = 0
  16  * If mask color is > 0x80 the abs difference is added to the frame. If result
  17  * > 0xff, result = 0xff
  18  *
  19  * You can override the 0x80 level with the -t flag. E.g. if threshold is
  20  * 000000 the color value of watermark is added to the destination.
  21  *
  22  * This way a mask that is visible both in light pictures and in dark can be
  23  * made (fex by using a picture generated by Gimp and the bump map tool).
  24  *
  25  * An example watermark file is at
  26  * http://engene.se/ffmpeg_watermark.gif
  27  *
  28  * MODE 1:
  29  * Per color do this:
  30  * If mask color > threshold color then the watermark pixel is used.
  31  *
  32  * Example usage:
  33  *  ffmpeg -i infile -vhook '/path/watermark.so -f wm.gif' -an out.mov
  34  *  ffmpeg -i infile -vhook '/path/watermark.so -f wm.gif -m 1 -t 222222' -an out.mov
  35  *
  36  * Note that the entire vhook argument is encapsulated in ''. This
  37  * way, arguments to the vhook won't be mixed up with those for ffmpeg.
  38  *
  39  * This file is part of FFmpeg.
  40  *
  41  * FFmpeg is free software; you can redistribute it and/or
  42  * modify it under the terms of the GNU Lesser General Public
  43  * License as published by the Free Software Foundation; either
  44  * version 2.1 of the License, or (at your option) any later version.
  45  *
  46  * FFmpeg is distributed in the hope that it will be useful,
  47  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  48  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  49  * Lesser General Public License for more details.
  50  *
  51  * You should have received a copy of the GNU Lesser General Public
  52  * License along with FFmpeg; if not, write to the Free Software
  53  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  54  */
  55
  56 #include <stdlib.h>
  57 //#include <fcntl.h>
  58 #include <unistd.h>
  59 #include <stdarg.h>
  60
  61 #include "libavutil/common.h"
  62 #include "libavformat/avformat.h"
  63 #include "libavformat/framehook.h"
  64 #include "libswscale/swscale.h"
  65 #include "cmdutils.h"
  66
  67 static int sws_flags = SWS_BICUBIC;
  68
  69 typedef struct {
  70     char            filename[2000];
  71     int             x_size;
  72     int             y_size;
  73
  74     /* get_watermark_picture() variables */
  75     AVFormatContext *pFormatCtx;
  76     const char     *p_ext;
  77     int             videoStream;
  78     int             frameFinished;
  79     AVCodecContext *pCodecCtx;
  80     AVCodec        *pCodec;
  81     AVFrame        *pFrame;
  82     AVPacket        packet;
  83     int             numBytes;
  84     uint8_t        *buffer;
  85     int             i;
  86     AVInputFormat  *file_iformat;
  87     AVStream       *st;
  88     int             is_done;
  89     AVFrame        *pFrameRGB;
  90     int             thrR;
  91     int             thrG;
  92     int             thrB;
  93     int             mode;
  94
  95     // This vhook first converts frame to RGB ...
  96     struct SwsContext *toRGB_convert_ctx;
  97     // ... then converts a watermark and applies it to the RGB frame ...
  98     struct SwsContext *watermark_convert_ctx;
  99     // ... and finally converts back frame from RGB to initial format
 100     struct SwsContext *fromRGB_convert_ctx;
 101 } ContextInfo;
 102
 103 int get_watermark_picture(ContextInfo *ci, int cleanup);
 104
 105
 106 /****************************************************************************
 107  *
 108  ****************************************************************************/
 109 void Release(void *ctx)
 110 {
 111     ContextInfo *ci;
 112     ci = (ContextInfo *) ctx;
 113
 114     if (ci) {
 115         get_watermark_picture(ci, 1);
 116         sws_freeContext(ci->toRGB_convert_ctx);
 117         sws_freeContext(ci->watermark_convert_ctx);
 118         sws_freeContext(ci->fromRGB_convert_ctx);
 119     }
 120     av_free(ctx);
 121 }
 122
 123
 124 /****************************************************************************
 125  *
 126  ****************************************************************************/
 127 int Configure(void **ctxp, int argc, char *argv[])
 128 {
 129     ContextInfo *ci;
 130     int c;
 131     int tmp = 0;
 132
 133     if (0 == (*ctxp = av_mallocz(sizeof(ContextInfo)))) return -1;
 134     ci = (ContextInfo *) *ctxp;
 135
 136     optind = 1;
 137
 138     // Struct is mallocz:ed so no need to reset.
 139     ci->thrR = 0x80;
 140     ci->thrG = 0x80;
 141     ci->thrB = 0x80;
 142
 143     while ((c = getopt(argc, argv, "f:m:t:")) > 0) {
 144         switch (c) {
 145             case 'f':
 146                 strncpy(ci->filename, optarg, 1999);
 147                 ci->filename[1999] = 0;
 148                 break;
 149             case 'm':
 150                 ci->mode = atoi(optarg);
 151                 break;
 152             case 't':
 153                 if (1 != sscanf(optarg, "%x", &tmp)) {
 154                     av_log(NULL, AV_LOG_ERROR, "Watermark: argument to -t must be a 6 digit hex number\n");
 155                     return -1;
 156                 }
 157                 ci->thrR = (tmp >> 16) & 0xff;
 158                 ci->thrG = (tmp >> 8) & 0xff;
 159                 ci->thrB = (tmp >> 0) & 0xff;
 160                 break;
 161             default:
 162                 av_log(NULL, AV_LOG_ERROR, "Watermark: Unrecognized argument '%s'\n", argv[optind]);
 163                 return -1;
 164         }
 165     }
 166
 167     //
 168     if (0 == ci->filename[0]) {
 169         av_log(NULL, AV_LOG_ERROR, "Watermark: There is no filename specified.\n");
 170         return -1;
 171     }
 172
 173     av_register_all();
 174     return get_watermark_picture(ci, 0);
 175 }
 176
 177
 178 /****************************************************************************
 179  * For mode 0 (the original one)
 180  ****************************************************************************/
 181 static void Process0(void *ctx,
 182               AVPicture *picture,
 183               enum PixelFormat pix_fmt,
 184               int src_width,
 185               int src_height,
 186               int64_t pts)
 187 {
 188     ContextInfo *ci = (ContextInfo *) ctx;
 189     char *buf = 0;
 190     AVPicture picture1;
 191     AVPicture *pict = picture;
 192
 193     AVFrame *pFrameRGB;
 194     int xm_size;
 195     int ym_size;
 196
 197     int x;
 198     int y;
 199     int offs, offsm;
 200     int mpoffs;
 201     uint32_t *p_pixel = 0;
 202     uint32_t pixel_meck;
 203     uint32_t pixel;
 204     uint32_t pixelm;
 205     int tmp;
 206     int thrR = ci->thrR;
 207     int thrG = ci->thrG;
 208     int thrB = ci->thrB;
 209
 210     if (pix_fmt != PIX_FMT_RGB32) {
 211         int size;
 212
 213         size = avpicture_get_size(PIX_FMT_RGB32, src_width, src_height);
 214         buf = av_malloc(size);
 215
 216         avpicture_fill(&picture1, buf, PIX_FMT_RGB32, src_width, src_height);
 217
 218         // if we already got a SWS context, let's realloc if is not re-useable
 219         ci->toRGB_convert_ctx = sws_getCachedContext(ci->toRGB_convert_ctx,
 220                                     src_width, src_height, pix_fmt,
 221                                     src_width, src_height, PIX_FMT_RGB32,
 222                                     sws_flags, NULL, NULL, NULL);
 223         if (ci->toRGB_convert_ctx == NULL) {
 224             av_log(NULL, AV_LOG_ERROR,
 225                    "Cannot initialize the toRGB conversion context\n");
 226             return;
 227         }
 228
 229 // img_convert parameters are          2 first destination, then 4 source
 230 // sws_scale   parameters are context, 4 first source,      then 2 destination
 231         sws_scale(ci->toRGB_convert_ctx,
 232                  picture->data, picture->linesize, 0, src_height,
 233                  picture1.data, picture1.linesize);
 234
 235         pict = &picture1;
 236     }
 237
 238     /* Insert filter code here */ /* ok */
 239
 240     // Get me next frame
 241     if (0 > get_watermark_picture(ci, 0)) {
 242         return;
 243     }
 244     // These are the three original static variables in the ffmpeg hack.
 245     pFrameRGB = ci->pFrameRGB;
 246     xm_size = ci->x_size;
 247     ym_size = ci->y_size;
 248
 249     // I'll do the *4 => <<2 crap later. Most compilers understand that anyway.
 250     // According to avcodec.h PIX_FMT_RGB32 is handled in endian specific manner.
 251     for (y=0; y<src_height; y++) {
 252         offs = y * (src_width * 4);
 253         offsm = (((y * ym_size) / src_height) * 4) * xm_size; // offsm first in maskline. byteoffs!
 254         for (x=0; x<src_width; x++) {
 255             mpoffs = offsm + (((x * xm_size) / src_width) * 4);
 256             p_pixel = (uint32_t *)&((pFrameRGB->data[0])[mpoffs]);
 257             pixelm = *p_pixel;
 258             p_pixel = (uint32_t *)&((pict->data[0])[offs]);
 259             pixel = *p_pixel;
 260 //          pixelm = *((uint32_t *)&(pFrameRGB->data[mpoffs]));
 261             pixel_meck = pixel & 0xff000000;
 262
 263             // R
 264             tmp = (int)((pixel >> 16) & 0xff) + (int)((pixelm >> 16) & 0xff) - thrR;
 265             if (tmp > 255) tmp = 255;
 266             if (tmp < 0) tmp = 0;
 267             pixel_meck |= (tmp << 16) & 0xff0000;
 268             // G
 269             tmp = (int)((pixel >> 8) & 0xff) + (int)((pixelm >> 8) & 0xff) - thrG;
 270             if (tmp > 255) tmp = 255;
 271             if (tmp < 0) tmp = 0;
 272             pixel_meck |= (tmp << 8) & 0xff00;
 273             // B
 274             tmp = (int)((pixel >> 0) & 0xff) + (int)((pixelm >> 0) & 0xff) - thrB;
 275             if (tmp > 255) tmp = 255;
 276             if (tmp < 0) tmp = 0;
 277             pixel_meck |= (tmp << 0) & 0xff;
 278
 279
 280             // test:
 281             //pixel_meck = pixel & 0xff000000;
 282             //pixel_meck |= (pixelm & 0x00ffffff);
 283
 284             *p_pixel = pixel_meck;
 285
 286             offs += 4;
 287         } // foreach X
 288     } // foreach Y
 289
 290
 291
 292
 293     if (pix_fmt != PIX_FMT_RGB32) {
 294         ci->fromRGB_convert_ctx = sws_getCachedContext(ci->fromRGB_convert_ctx,
 295                                       src_width, src_height, PIX_FMT_RGB32,
 296                                       src_width, src_height, pix_fmt,
 297                                       sws_flags, NULL, NULL, NULL);
 298         if (ci->fromRGB_convert_ctx == NULL) {
 299             av_log(NULL, AV_LOG_ERROR,
 300                    "Cannot initialize the fromRGB conversion context\n");
 301             return;
 302         }
 303 // img_convert parameters are          2 first destination, then 4 source
 304 // sws_scale   parameters are context, 4 first source,      then 2 destination
 305         sws_scale(ci->fromRGB_convert_ctx,
 306                  picture1.data, picture1.linesize, 0, src_height,
 307                  picture->data, picture->linesize);
 308     }
 309
 310     av_free(buf);
 311 }
 312
 313
 314 /****************************************************************************
 315  * For mode 1 (the original one)
 316  ****************************************************************************/
 317 static void Process1(void *ctx,
 318               AVPicture *picture,
 319               enum PixelFormat pix_fmt,
 320               int src_width,
 321               int src_height,
 322               int64_t pts)
 323 {
 324     ContextInfo *ci = (ContextInfo *) ctx;
 325     char *buf = 0;
 326     AVPicture picture1;
 327     AVPicture *pict = picture;
 328
 329     AVFrame *pFrameRGB;
 330     int xm_size;
 331     int ym_size;
 332
 333     int x;
 334     int y;
 335     int offs, offsm;
 336     int mpoffs;
 337     uint32_t *p_pixel = 0;
 338     uint32_t pixel;
 339     uint32_t pixelm;
 340
 341     if (pix_fmt != PIX_FMT_RGB32) {
 342         int size;
 343
 344         size = avpicture_get_size(PIX_FMT_RGB32, src_width, src_height);
 345         buf = av_malloc(size);
 346
 347         avpicture_fill(&picture1, buf, PIX_FMT_RGB32, src_width, src_height);
 348
 349         // if we already got a SWS context, let's realloc if is not re-useable
 350         ci->toRGB_convert_ctx = sws_getCachedContext(ci->toRGB_convert_ctx,
 351                                     src_width, src_height, pix_fmt,
 352                                     src_width, src_height, PIX_FMT_RGB32,
 353                                     sws_flags, NULL, NULL, NULL);
 354         if (ci->toRGB_convert_ctx == NULL) {
 355             av_log(NULL, AV_LOG_ERROR,
 356                    "Cannot initialize the toRGB conversion context\n");
 357             return;
 358         }
 359
 360 // img_convert parameters are          2 first destination, then 4 source
 361 // sws_scale   parameters are context, 4 first source,      then 2 destination
 362         sws_scale(ci->toRGB_convert_ctx,
 363                  picture->data, picture->linesize, 0, src_height,
 364                  picture1.data, picture1.linesize);
 365
 366         pict = &picture1;
 367     }
 368
 369     /* Insert filter code here */ /* ok */
 370
 371     // Get me next frame
 372     if (0 > get_watermark_picture(ci, 0)) {
 373         return;
 374     }
 375     // These are the three original static variables in the ffmpeg hack.
 376     pFrameRGB = ci->pFrameRGB;
 377     xm_size = ci->x_size;
 378     ym_size = ci->y_size;
 379
 380     // I'll do the *4 => <<2 crap later. Most compilers understand that anyway.
 381     // According to avcodec.h PIX_FMT_RGB32 is handled in endian specific manner.
 382     for (y=0; y<src_height; y++) {
 383         offs = y * (src_width * 4);
 384         offsm = (((y * ym_size) / src_height) * 4) * xm_size; // offsm first in maskline. byteoffs!
 385         for (x=0; x<src_width; x++) {
 386             mpoffs = offsm + (((x * xm_size) / src_width) * 4);
 387             p_pixel = (uint32_t *)&((pFrameRGB->data[0])[mpoffs]);
 388             pixelm = *p_pixel; /* watermark pixel */
 389             p_pixel = (uint32_t *)&((pict->data[0])[offs]);
 390             pixel = *p_pixel;
 391
 392             if (((pixelm >> 16) & 0xff) > ci->thrR ||
 393                 ((pixelm >>  8) & 0xff) > ci->thrG ||
 394                 ((pixelm >>  0) & 0xff) > ci->thrB)
 395             {
 396                 *p_pixel = pixelm;
 397             } else {
 398                 *p_pixel = pixel;
 399             }
 400             offs += 4;
 401         } // foreach X
 402     } // foreach Y
 403
 404     if (pix_fmt != PIX_FMT_RGB32) {
 405         ci->fromRGB_convert_ctx = sws_getCachedContext(ci->fromRGB_convert_ctx,
 406                                       src_width, src_height, PIX_FMT_RGB32,
 407                                       src_width, src_height, pix_fmt,
 408                                       sws_flags, NULL, NULL, NULL);
 409         if (ci->fromRGB_convert_ctx == NULL) {
 410             av_log(NULL, AV_LOG_ERROR,
 411                    "Cannot initialize the fromRGB conversion context\n");
 412             return;
 413         }
 414 // img_convert parameters are          2 first destination, then 4 source
 415 // sws_scale   parameters are context, 4 first source,      then 2 destination
 416         sws_scale(ci->fromRGB_convert_ctx,
 417                  picture1.data, picture1.linesize, 0, src_height,
 418                  picture->data, picture->linesize);
 419     }
 420
 421     av_free(buf);
 422 }
 423
 424
 425 /****************************************************************************
 426  * This is the function ffmpeg.c callbacks.
 427  ****************************************************************************/
 428 void Process(void *ctx,
 429              AVPicture *picture,
 430              enum PixelFormat pix_fmt,
 431              int src_width,
 432              int src_height,
 433              int64_t pts)
 434 {
 435     ContextInfo *ci = (ContextInfo *) ctx;
 436     if (1 == ci->mode) {
 437         Process1(ctx, picture, pix_fmt, src_width, src_height, pts);
 438     } else {
 439         Process0(ctx, picture, pix_fmt, src_width, src_height, pts);
 440     }
 441 }
 442
 443
 444 /****************************************************************************
 445  * When cleanup == 0, we try to get the next frame. If no next frame, nothing
 446  * is done.
 447  *
 448  * This code follows the example on
 449  * http://www.inb.uni-luebeck.de/~boehme/using_libavcodec.html
 450  *
 451  * 0 = ok, -1 = error
 452  ****************************************************************************/
 453 int get_watermark_picture(ContextInfo *ci, int cleanup)
 454 {
 455     if (1 == ci->is_done && 0 == cleanup) return 0;
 456
 457     // Yes, *pFrameRGB arguments must be null the first time otherwise it's not good..
 458     // This block is only executed the first time we enter this function.
 459     if (0 == ci->pFrameRGB &&
 460         0 == cleanup)
 461     {
 462
 463         /*
 464          * The last three parameters specify the file format, buffer size and format
 465          * parameters; by simply specifying NULL or 0 we ask libavformat to auto-detect
 466          * the format and use a default buffer size. (Didn't work!)
 467          */
 468         if (av_open_input_file(&ci->pFormatCtx, ci->filename, NULL, 0, NULL) != 0) {
 469
 470             // Martin says this should not be necessary but it failed for me sending in
 471             // NULL instead of file_iformat to av_open_input_file()
 472             ci->i = strlen(ci->filename);
 473             if (0 == ci->i) {
 474                 av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() No filename to watermark vhook\n");
 475                 return -1;
 476             }
 477             while (ci->i > 0) {
 478                 if (ci->filename[ci->i] == '.') {
 479                     ci->i++;
 480                     break;
 481                 }
 482                 ci->i--;
 483             }
 484                ci->p_ext = &(ci->filename[ci->i]);
 485             ci->file_iformat = av_find_input_format (ci->p_ext);
 486             if (0 == ci->file_iformat) {
 487                 av_log(NULL, AV_LOG_INFO, "get_watermark_picture() attempt to use image2 for [%s]\n", ci->p_ext);
 488                 ci->file_iformat = av_find_input_format ("image2");
 489             }
 490             if (0 == ci->file_iformat) {
 491                 av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Really failed to find iformat [%s]\n", ci->p_ext);
 492                 return -1;
 493             }
 494             // now continues the Martin template.
 495
 496             if (av_open_input_file(&ci->pFormatCtx, ci->filename, ci->file_iformat, 0, NULL)!=0) {
 497                 av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to open input file [%s]\n", ci->filename);
 498                 return -1;
 499             }
 500         }
 501
 502         /*
 503          * This fills the streams field of the AVFormatContext with valid information.
 504          */
 505         if(av_find_stream_info(ci->pFormatCtx)<0) {
 506             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to find stream info\n");
 507             return -1;
 508         }
 509
 510         /*
 511          * As mentioned in the introduction, we'll handle only video streams, not audio
 512          * streams. To make things nice and easy, we simply use the first video stream we
 513          * find.
 514          */
 515         ci->videoStream=-1;
 516         for(ci->i = 0; ci->i < ci->pFormatCtx->nb_streams; ci->i++)
 517             if(ci->pFormatCtx->streams[ci->i]->codec->codec_type==CODEC_TYPE_VIDEO)
 518             {
 519                 ci->videoStream = ci->i;
 520                 break;
 521             }
 522         if(ci->videoStream == -1) {
 523             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to find any video stream\n");
 524             return -1;
 525         }
 526
 527         ci->st = ci->pFormatCtx->streams[ci->videoStream];
 528         ci->x_size = ci->st->codec->width;
 529         ci->y_size = ci->st->codec->height;
 530
 531         // Get a pointer to the codec context for the video stream
 532         ci->pCodecCtx = ci->pFormatCtx->streams[ci->videoStream]->codec;
 533
 534
 535         /*
 536          * OK, so now we've got a pointer to the so-called codec context for our video
 537          * stream, but we still have to find the actual codec and open it.
 538          */
 539         // Find the decoder for the video stream
 540         ci->pCodec = avcodec_find_decoder(ci->pCodecCtx->codec_id);
 541         if(ci->pCodec == NULL) {
 542             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to find any codec\n");
 543             return -1;
 544         }
 545
 546
 547         // Open codec
 548         if(avcodec_open(ci->pCodecCtx, ci->pCodec)<0) {
 549             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to open codec\n");
 550             return -1;
 551         }
 552
 553         // Hack to correct wrong frame rates that seem to be generated by some
 554         // codecs
 555         if (ci->pCodecCtx->time_base.den>1000 && ci->pCodecCtx->time_base.num==1)
 556             ci->pCodecCtx->time_base.num=1000;
 557
 558         /*
 559          * Allocate a video frame to store the decoded images in.
 560          */
 561         ci->pFrame = avcodec_alloc_frame();
 562
 563
 564         /*
 565          * The RGB image pFrameRGB (of type AVFrame *) is allocated like this:
 566          */
 567         // Allocate an AVFrame structure
 568         ci->pFrameRGB=avcodec_alloc_frame();
 569         if(ci->pFrameRGB==NULL) {
 570             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to alloc pFrameRGB\n");
 571             return -1;
 572         }
 573
 574         // Determine required buffer size and allocate buffer
 575         ci->numBytes = avpicture_get_size(PIX_FMT_RGB32, ci->pCodecCtx->width,
 576             ci->pCodecCtx->height);
 577         ci->buffer = av_malloc(ci->numBytes);
 578
 579         // Assign appropriate parts of buffer to image planes in pFrameRGB
 580         avpicture_fill((AVPicture *)ci->pFrameRGB, ci->buffer, PIX_FMT_RGB32,
 581             ci->pCodecCtx->width, ci->pCodecCtx->height);
 582     }
 583     // TODO loop, pingpong etc?
 584     if (0 == cleanup)
 585     {
 586 //        av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Get a frame\n");
 587         while(av_read_frame(ci->pFormatCtx, &ci->packet)>=0)
 588         {
 589             // Is this a packet from the video stream?
 590             if(ci->packet.stream_index == ci->videoStream)
 591             {
 592                 // Decode video frame
 593                 avcodec_decode_video(ci->pCodecCtx, ci->pFrame, &ci->frameFinished,
 594                     ci->packet.data, ci->packet.size);
 595
 596                 // Did we get a video frame?
 597                 if(ci->frameFinished)
 598                 {
 599                     // Convert the image from its native format to RGB32
 600                     ci->watermark_convert_ctx =
 601                         sws_getCachedContext(ci->watermark_convert_ctx,
 602                             ci->pCodecCtx->width, ci->pCodecCtx->height, ci->pCodecCtx->pix_fmt,
 603                             ci->pCodecCtx->width, ci->pCodecCtx->height, PIX_FMT_RGB32,
 604                             sws_flags, NULL, NULL, NULL);
 605                     if (ci->watermark_convert_ctx == NULL) {
 606                         av_log(NULL, AV_LOG_ERROR,
 607                               "Cannot initialize the watermark conversion context\n");
 608                         return -1;
 609                     }
 610 // img_convert parameters are          2 first destination, then 4 source
 611 // sws_scale   parameters are context, 4 first source,      then 2 destination
 612                     sws_scale(ci->watermark_convert_ctx,
 613                              ci->pFrame->data, ci->pFrame->linesize, 0, ci->pCodecCtx->height,
 614                              ci->pFrameRGB->data, ci->pFrameRGB->linesize);
 615
 616                     // Process the video frame (save to disk etc.)
 617                     //fprintf(stderr,"banan() New frame!\n");
 618                     //DoSomethingWithTheImage(ci->pFrameRGB);
 619                     return 0;
 620                 }
 621             }
 622
 623             // Free the packet that was allocated by av_read_frame
 624             av_free_packet(&ci->packet);
 625         }
 626         ci->is_done = 1;
 627         return 0;
 628     } // if 0 != cleanup
 629
 630     if (0 != cleanup)
 631     {
 632         // Free the RGB image
 633         av_freep(&ci->buffer);
 634         av_freep(&ci->pFrameRGB);
 635
 636         // Close the codec
 637         if (0 != ci->pCodecCtx) {
 638             avcodec_close(ci->pCodecCtx);
 639             ci->pCodecCtx = 0;
 640         }
 641
 642         // Close the video file
 643         if (0 != ci->pFormatCtx) {
 644             av_close_input_file(ci->pFormatCtx);
 645             ci->pFormatCtx = 0;
 646         }
 647
 648         ci->is_done = 0;
 649     }
 650     return 0;
 651 }
 652
 653
 654 void parse_arg_file(const char *filename)
 655 {
 656 }