vhook/watermark.c

   1 /*
   2  * Watermark Hook
   3  * Copyright (c) 2005 Marcus Engene myfirstname(at)mylastname.se
   4  *
   5  * flags to 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 filename of watermark image. You must specify this!
   9  *
  10  * MODE 0:
  11  * The watermarkpicture works like this. (Assuming colorintencities 0..0xff)
  12  * Per color do this:
  13  * If mask color is 0x80, no change to original frame.
  14  * If mask color is < 0x80 the abs difference is subtracted from frame. If
  15  * result < 0, result = 0
  16  * If mask color is > 0x80 the abs difference is added to frame. If result
  17  * > 0xff, result = 0xff
  18  *
  19  * You can override the 0x80 level with the -t flag. Eg if threshold is 000000
  20  * the color values of watermark is added to 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, watermark pixel is going to be 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 to 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 "common.h"
  62 #include "avformat.h"
  63
  64 #include "framehook.h"
  65 #include "cmdutils.h"
  66
  67 typedef struct {
  68     char            filename[2000];
  69     int             x_size;
  70     int             y_size;
  71
  72     /* get_watermark_picture() variables */
  73     AVFormatContext *pFormatCtx;
  74     const char     *p_ext;
  75     int             videoStream;
  76     int             frameFinished;
  77     AVCodecContext *pCodecCtx;
  78     AVCodec        *pCodec;
  79     AVFrame        *pFrame;
  80     AVPacket        packet;
  81     int             numBytes;
  82     uint8_t        *buffer;
  83     int             i;
  84     AVInputFormat  *file_iformat;
  85     AVStream       *st;
  86     int             is_done;
  87     AVFrame        *pFrameRGB;
  88     int             thrR;
  89     int             thrG;
  90     int             thrB;
  91     int             mode;
  92 } ContextInfo;
  93
  94 int get_watermark_picture(ContextInfo *ci, int cleanup);
  95
  96
  97 /****************************************************************************
  98  *
  99  ****************************************************************************/
 100 void Release(void *ctx)
 101 {
 102     ContextInfo *ci;
 103     ci = (ContextInfo *) ctx;
 104
 105     if (ci) get_watermark_picture(ci, 1);
 106
 107     av_free(ctx);
 108 }
 109
 110
 111 /****************************************************************************
 112  *
 113  ****************************************************************************/
 114 int Configure(void **ctxp, int argc, char *argv[])
 115 {
 116     ContextInfo *ci;
 117     int c;
 118     int tmp = 0;
 119
 120     if (0 == (*ctxp = av_mallocz(sizeof(ContextInfo)))) return -1;
 121     ci = (ContextInfo *) *ctxp;
 122
 123     optind = 1;
 124
 125     // Struct is mallocz:ed so no need to reset.
 126     ci->thrR = 0x80;
 127     ci->thrG = 0x80;
 128     ci->thrB = 0x80;
 129
 130     while ((c = getopt(argc, argv, "f:m:t:")) > 0) {
 131         switch (c) {
 132             case 'f':
 133                 strncpy(ci->filename, optarg, 1999);
 134                 ci->filename[1999] = 0;
 135                 break;
 136             case 'm':
 137                 ci->mode = atoi(optarg);
 138                 break;
 139             case 't':
 140                 if (1 != sscanf(optarg, "%x", &tmp)) {
 141                     av_log(NULL, AV_LOG_ERROR, "Watermark: argument to -t must be a 6 digit hex number\n");
 142                     return -1;
 143                 }
 144                 ci->thrR = (tmp >> 16) & 0xff;
 145                 ci->thrG = (tmp >> 8) & 0xff;
 146                 ci->thrB = (tmp >> 0) & 0xff;
 147                 break;
 148             default:
 149                 av_log(NULL, AV_LOG_ERROR, "Watermark: Unrecognized argument '%s'\n", argv[optind]);
 150                 return -1;
 151         }
 152     }
 153
 154     //
 155     if (0 == ci->filename[0]) {
 156         av_log(NULL, AV_LOG_ERROR, "Watermark: There is no filename specified.\n");
 157         return -1;
 158     }
 159
 160     av_register_all();
 161     return get_watermark_picture(ci, 0);
 162 }
 163
 164
 165 /****************************************************************************
 166  * For mode 0 (the original one)
 167  ****************************************************************************/
 168 static void Process0(void *ctx,
 169               AVPicture *picture,
 170               enum PixelFormat pix_fmt,
 171               int src_width,
 172               int src_height,
 173               int64_t pts)
 174 {
 175     ContextInfo *ci = (ContextInfo *) ctx;
 176     char *buf = 0;
 177     AVPicture picture1;
 178     AVPicture *pict = picture;
 179
 180     AVFrame *pFrameRGB;
 181     int xm_size;
 182     int ym_size;
 183
 184     int x;
 185     int y;
 186     int offs, offsm;
 187     int mpoffs;
 188     uint32_t *p_pixel = 0;
 189     uint32_t pixel_meck;
 190     uint32_t pixel;
 191     uint32_t pixelm;
 192     int tmp;
 193     int thrR = ci->thrR;
 194     int thrG = ci->thrG;
 195     int thrB = ci->thrB;
 196
 197     if (pix_fmt != PIX_FMT_RGBA32) {
 198         int size;
 199
 200         size = avpicture_get_size(PIX_FMT_RGBA32, src_width, src_height);
 201         buf = av_malloc(size);
 202
 203         avpicture_fill(&picture1, buf, PIX_FMT_RGBA32, src_width, src_height);
 204         if (img_convert(&picture1, PIX_FMT_RGBA32,
 205                         picture, pix_fmt, src_width, src_height) < 0) {
 206             av_free(buf);
 207             return;
 208         }
 209         pict = &picture1;
 210     }
 211
 212     /* Insert filter code here */ /* ok */
 213
 214     // Get me next frame
 215     if (0 > get_watermark_picture(ci, 0)) {
 216         return;
 217     }
 218     // These are the three original static variables in the ffmpeg hack.
 219     pFrameRGB = ci->pFrameRGB;
 220     xm_size = ci->x_size;
 221     ym_size = ci->y_size;
 222
 223     // I'll do the *4 => <<2 crap later. Most compilers understand that anyway.
 224     // According to avcodec.h PIX_FMT_RGBA32 is handled in endian specific manner.
 225     for (y=0; y<src_height; y++) {
 226         offs = y * (src_width * 4);
 227         offsm = (((y * ym_size) / src_height) * 4) * xm_size; // offsm first in maskline. byteoffs!
 228         for (x=0; x<src_width; x++) {
 229             mpoffs = offsm + (((x * xm_size) / src_width) * 4);
 230             p_pixel = (uint32_t *)&((pFrameRGB->data[0])[mpoffs]);
 231             pixelm = *p_pixel;
 232             p_pixel = (uint32_t *)&((pict->data[0])[offs]);
 233             pixel = *p_pixel;
 234 //          pixelm = *((uint32_t *)&(pFrameRGB->data[mpoffs]));
 235             pixel_meck = pixel & 0xff000000;
 236
 237             // R
 238             tmp = (int)((pixel >> 16) & 0xff) + (int)((pixelm >> 16) & 0xff) - thrR;
 239             if (tmp > 255) tmp = 255;
 240             if (tmp < 0) tmp = 0;
 241             pixel_meck |= (tmp << 16) & 0xff0000;
 242             // G
 243             tmp = (int)((pixel >> 8) & 0xff) + (int)((pixelm >> 8) & 0xff) - thrG;
 244             if (tmp > 255) tmp = 255;
 245             if (tmp < 0) tmp = 0;
 246             pixel_meck |= (tmp << 8) & 0xff00;
 247             // B
 248             tmp = (int)((pixel >> 0) & 0xff) + (int)((pixelm >> 0) & 0xff) - thrB;
 249             if (tmp > 255) tmp = 255;
 250             if (tmp < 0) tmp = 0;
 251             pixel_meck |= (tmp << 0) & 0xff;
 252
 253
 254             // test:
 255             //pixel_meck = pixel & 0xff000000;
 256             //pixel_meck |= (pixelm & 0x00ffffff);
 257
 258             *p_pixel = pixel_meck;
 259
 260             offs += 4;
 261         } // foreach X
 262     } // foreach Y
 263
 264
 265
 266
 267     if (pix_fmt != PIX_FMT_RGBA32) {
 268         if (img_convert(picture, pix_fmt,
 269                         &picture1, PIX_FMT_RGBA32, src_width, src_height) < 0) {
 270         }
 271     }
 272
 273     av_free(buf);
 274 }
 275
 276
 277 /****************************************************************************
 278  * For mode 1 (the original one)
 279  ****************************************************************************/
 280 static void Process1(void *ctx,
 281               AVPicture *picture,
 282               enum PixelFormat pix_fmt,
 283               int src_width,
 284               int src_height,
 285               int64_t pts)
 286 {
 287     ContextInfo *ci = (ContextInfo *) ctx;
 288     char *buf = 0;
 289     AVPicture picture1;
 290     AVPicture *pict = picture;
 291
 292     AVFrame *pFrameRGB;
 293     int xm_size;
 294     int ym_size;
 295
 296     int x;
 297     int y;
 298     int offs, offsm;
 299     int mpoffs;
 300     uint32_t *p_pixel = 0;
 301     uint32_t pixel;
 302     uint32_t pixelm;
 303
 304     if (pix_fmt != PIX_FMT_RGBA32) {
 305         int size;
 306
 307         size = avpicture_get_size(PIX_FMT_RGBA32, src_width, src_height);
 308         buf = av_malloc(size);
 309
 310         avpicture_fill(&picture1, buf, PIX_FMT_RGBA32, src_width, src_height);
 311         if (img_convert(&picture1, PIX_FMT_RGBA32,
 312                         picture, pix_fmt, src_width, src_height) < 0) {
 313             av_free(buf);
 314             return;
 315         }
 316         pict = &picture1;
 317     }
 318
 319     /* Insert filter code here */ /* ok */
 320
 321     // Get me next frame
 322     if (0 > get_watermark_picture(ci, 0)) {
 323         return;
 324     }
 325     // These are the three original static variables in the ffmpeg hack.
 326     pFrameRGB = ci->pFrameRGB;
 327     xm_size = ci->x_size;
 328     ym_size = ci->y_size;
 329
 330     // I'll do the *4 => <<2 crap later. Most compilers understand that anyway.
 331     // According to avcodec.h PIX_FMT_RGBA32 is handled in endian specific manner.
 332     for (y=0; y<src_height; y++) {
 333         offs = y * (src_width * 4);
 334         offsm = (((y * ym_size) / src_height) * 4) * xm_size; // offsm first in maskline. byteoffs!
 335         for (x=0; x<src_width; x++) {
 336             mpoffs = offsm + (((x * xm_size) / src_width) * 4);
 337             p_pixel = (uint32_t *)&((pFrameRGB->data[0])[mpoffs]);
 338             pixelm = *p_pixel; /* watermark pixel */
 339             p_pixel = (uint32_t *)&((pict->data[0])[offs]);
 340             pixel = *p_pixel;
 341
 342             if (((pixelm >> 16) & 0xff) > ci->thrR ||
 343                 ((pixelm >>  8) & 0xff) > ci->thrG ||
 344                 ((pixelm >>  0) & 0xff) > ci->thrB)
 345             {
 346                 *p_pixel = pixelm;
 347             } else {
 348                 *p_pixel = pixel;
 349             }
 350             offs += 4;
 351         } // foreach X
 352     } // foreach Y
 353
 354     if (pix_fmt != PIX_FMT_RGBA32) {
 355         if (img_convert(picture, pix_fmt,
 356                         &picture1, PIX_FMT_RGBA32, src_width, src_height) < 0) {
 357         }
 358     }
 359
 360     av_free(buf);
 361 }
 362
 363
 364 /****************************************************************************
 365  * This is the function ffmpeg.c callbacks.
 366  ****************************************************************************/
 367 void Process(void *ctx,
 368              AVPicture *picture,
 369              enum PixelFormat pix_fmt,
 370              int src_width,
 371              int src_height,
 372              int64_t pts)
 373 {
 374     ContextInfo *ci = (ContextInfo *) ctx;
 375     if (1 == ci->mode) {
 376         return Process1(ctx, picture, pix_fmt, src_width, src_height, pts);
 377     } else {
 378         return Process0(ctx, picture, pix_fmt, src_width, src_height, pts);
 379     }
 380 }
 381
 382
 383 /****************************************************************************
 384  * When cleanup == 0, we try to get the next frame. If no next frame, nothing
 385  * is done.
 386  *
 387  * This code follows the example on
 388  * http://www.inb.uni-luebeck.de/~boehme/using_libavcodec.html
 389  *
 390  * 0 = ok, -1 = error
 391  ****************************************************************************/
 392 int get_watermark_picture(ContextInfo *ci, int cleanup)
 393 {
 394     if (1 == ci->is_done && 0 == cleanup) return 0;
 395
 396     // Yes, *pFrameRGB arguments must be null the first time otherwise it's not good..
 397     // This block is only executed the first time we enter this function.
 398     if (0 == ci->pFrameRGB &&
 399         0 == cleanup)
 400     {
 401
 402         /*
 403          * The last three parameters specify the file format, buffer size and format
 404          * parameters; by simply specifying NULL or 0 we ask libavformat to auto-detect
 405          * the format and use a default buffer size. (Didn't work!)
 406          */
 407         if (av_open_input_file(&ci->pFormatCtx, ci->filename, NULL, 0, NULL) != 0) {
 408
 409             // Martin says this should not be necessary but it failed for me sending in
 410             // NULL instead of file_iformat to av_open_input_file()
 411             ci->i = strlen(ci->filename);
 412             if (0 == ci->i) {
 413                 av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() No filename to watermark vhook\n");
 414                 return -1;
 415             }
 416             while (ci->i > 0) {
 417                 if (ci->filename[ci->i] == '.') {
 418                     ci->i++;
 419                     break;
 420                 }
 421                 ci->i--;
 422             }
 423                ci->p_ext = &(ci->filename[ci->i]);
 424             ci->file_iformat = av_find_input_format (ci->p_ext);
 425             if (0 == ci->file_iformat) {
 426                 av_log(NULL, AV_LOG_INFO, "get_watermark_picture() attempt to use image2 for [%s]\n", ci->p_ext);
 427                 ci->file_iformat = av_find_input_format ("image2");
 428             }
 429             if (0 == ci->file_iformat) {
 430                 av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Really failed to find iformat [%s]\n", ci->p_ext);
 431                 return -1;
 432             }
 433             // now continues the Martin template.
 434
 435             if (av_open_input_file(&ci->pFormatCtx, ci->filename, ci->file_iformat, 0, NULL)!=0) {
 436                 av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to open input file [%s]\n", ci->filename);
 437                 return -1;
 438             }
 439         }
 440
 441         /*
 442          * This fills the streams field of the AVFormatContext with valid information.
 443          */
 444         if(av_find_stream_info(ci->pFormatCtx)<0) {
 445             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to find stream info\n");
 446             return -1;
 447         }
 448
 449         /*
 450          * As mentioned in the introduction, we'll handle only video streams, not audio
 451          * streams. To make things nice and easy, we simply use the first video stream we
 452          * find.
 453          */
 454         ci->videoStream=-1;
 455         for(ci->i = 0; ci->i < ci->pFormatCtx->nb_streams; ci->i++)
 456             if(ci->pFormatCtx->streams[ci->i]->codec->codec_type==CODEC_TYPE_VIDEO)
 457             {
 458                 ci->videoStream = ci->i;
 459                 break;
 460             }
 461         if(ci->videoStream == -1) {
 462             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to find any video stream\n");
 463             return -1;
 464         }
 465
 466         ci->st = ci->pFormatCtx->streams[ci->videoStream];
 467         ci->x_size = ci->st->codec->width;
 468         ci->y_size = ci->st->codec->height;
 469
 470         // Get a pointer to the codec context for the video stream
 471         ci->pCodecCtx = ci->pFormatCtx->streams[ci->videoStream]->codec;
 472
 473
 474         /*
 475          * OK, so now we've got a pointer to the so-called codec context for our video
 476          * stream, but we still have to find the actual codec and open it.
 477          */
 478         // Find the decoder for the video stream
 479         ci->pCodec = avcodec_find_decoder(ci->pCodecCtx->codec_id);
 480         if(ci->pCodec == NULL) {
 481             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to find any codec\n");
 482             return -1;
 483         }
 484
 485         // Inform the codec that we can handle truncated bitstreams -- i.e.,
 486         // bitstreams where frame boundaries can fall in the middle of packets
 487         if (ci->pCodec->capabilities & CODEC_CAP_TRUNCATED)
 488             ci->pCodecCtx->flags|=CODEC_FLAG_TRUNCATED;
 489
 490         // Open codec
 491         if(avcodec_open(ci->pCodecCtx, ci->pCodec)<0) {
 492             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to open codec\n");
 493             return -1;
 494         }
 495
 496         // Hack to correct wrong frame rates that seem to be generated by some
 497         // codecs
 498         if (ci->pCodecCtx->time_base.den>1000 && ci->pCodecCtx->time_base.num==1)
 499             ci->pCodecCtx->time_base.num=1000;
 500
 501         /*
 502          * Allocate a video frame to store the decoded images in.
 503          */
 504         ci->pFrame = avcodec_alloc_frame();
 505
 506
 507         /*
 508          * The RGB image pFrameRGB (of type AVFrame *) is allocated like this:
 509          */
 510         // Allocate an AVFrame structure
 511         ci->pFrameRGB=avcodec_alloc_frame();
 512         if(ci->pFrameRGB==NULL) {
 513             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to alloc pFrameRGB\n");
 514             return -1;
 515         }
 516
 517         // Determine required buffer size and allocate buffer
 518         ci->numBytes = avpicture_get_size(PIX_FMT_RGBA32, ci->pCodecCtx->width,
 519             ci->pCodecCtx->height);
 520         ci->buffer = av_malloc(ci->numBytes);
 521
 522         // Assign appropriate parts of buffer to image planes in pFrameRGB
 523         avpicture_fill((AVPicture *)ci->pFrameRGB, ci->buffer, PIX_FMT_RGBA32,
 524             ci->pCodecCtx->width, ci->pCodecCtx->height);
 525     }
 526     // TODO loop, pingpong etc?
 527     if (0 == cleanup)
 528     {
 529 //        av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Get a frame\n");
 530         while(av_read_frame(ci->pFormatCtx, &ci->packet)>=0)
 531         {
 532             // Is this a packet from the video stream?
 533             if(ci->packet.stream_index == ci->videoStream)
 534             {
 535                 // Decode video frame
 536                 avcodec_decode_video(ci->pCodecCtx, ci->pFrame, &ci->frameFinished,
 537                     ci->packet.data, ci->packet.size);
 538
 539                 // Did we get a video frame?
 540                 if(ci->frameFinished)
 541                 {
 542                     // Convert the image from its native format to RGBA32
 543                     img_convert((AVPicture *)ci->pFrameRGB, PIX_FMT_RGBA32,
 544                         (AVPicture*)(ci->pFrame), ci->pCodecCtx->pix_fmt, ci->pCodecCtx->width,
 545                         ci->pCodecCtx->height);
 546
 547                     // Process the video frame (save to disk etc.)
 548                     //fprintf(stderr,"banan() New frame!\n");
 549                     //DoSomethingWithTheImage(ci->pFrameRGB);
 550                     return 0;
 551                 }
 552             }
 553
 554             // Free the packet that was allocated by av_read_frame
 555             av_free_packet(&ci->packet);
 556         }
 557         ci->is_done = 1;
 558         return 0;
 559     } // if 0 != cleanup
 560
 561     if (0 != cleanup)
 562     {
 563         // Free the RGB image
 564         av_freep(&ci->buffer);
 565         av_freep(&ci->pFrameRGB);
 566
 567         // Close the codec
 568         if (0 != ci->pCodecCtx) {
 569             avcodec_close(ci->pCodecCtx);
 570             ci->pCodecCtx = 0;
 571         }
 572
 573         // Close the video file
 574         if (0 != ci->pFormatCtx) {
 575             av_close_input_file(ci->pFormatCtx);
 576             ci->pFormatCtx = 0;
 577         }
 578
 579         ci->is_done = 0;
 580     }
 581     return 0;
 582 }
 583
 584
 585 void parse_arg_file(const char *filename)
 586 {
 587 }