git.sesse.net Git - ffmpeg/blob - vhook/watermark.c

   1 /*
   2  * Watermark Hook
   3  * Copyright (c) 2005 Marcus Engene myfirstname(at)mylastname.se
   4  *
   5  * The watermarkpicture works like this. (Assuming colorintencities 0..0xff)
   6  * Per color do this:
   7  * If mask color is 0x80, no change to original frame.
   8  * If mask color is < 0x80 the abs difference is subtracted from frame. If
   9  * result < 0, result = 0
  10  * If mask color is > 0x80 the abs difference is added to frame. If result
  11  * > 0xff, result = 0xff
  12  *
  13  * This way a mask that is visible both in light pictures and in dark can be
  14  * made (fex by using a picture generated by gimp and the bump map tool).
  15  *
  16  * An example watermark file is at
  17  * http://engene.se/ffmpeg_watermark.gif
  18  *
  19  * Example usage:
  20  *  ffmpeg -i infile -vhook '/path/watermark.so -f wm.gif' out.mov
  21  *
  22  * Note that the entire vhook argument is encapsulated in ''. This
  23  * way, arguments to the vhook won't be mixed up with those to ffmpeg.
  24  *
  25  * This library is free software; you can redistribute it and/or
  26  * modify it under the terms of the GNU Lesser General Public
  27  * License as published by the Free Software Foundation; either
  28  * version 2 of the License, or (at your option) any later version.
  29  *
  30  * This library is distributed in the hope that it will be useful,
  31  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  32  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  33  * Lesser General Public License for more details.
  34  *
  35  * You should have received a copy of the GNU Lesser General Public
  36  * License along with this library; if not, write to the Free Software
  37  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  38  */
  39
  40 //#include <stdlib.h>
  41 //#include <fcntl.h>
  42 #include <unistd.h>
  43 #include <stdarg.h>
  44
  45 #include "common.h"
  46 #include "avformat.h"
  47
  48 #include "framehook.h"
  49
  50 typedef struct {
  51     char            filename[2000];
  52     int             x_size;
  53     int             y_size;
  54
  55     /* get_watermark_picture() variables */
  56     AVFormatContext *pFormatCtx;
  57     const char     *p_ext;
  58     int             videoStream;
  59     int             frameFinished;
  60     AVCodecContext *pCodecCtx;
  61     AVCodec        *pCodec;
  62     AVFrame        *pFrame;
  63     AVPacket        packet;
  64     int             numBytes;
  65     uint8_t        *buffer;
  66     int             i;
  67     AVInputFormat  *file_iformat;
  68     AVStream       *st;
  69     int             is_done;
  70     AVFrame        *pFrameRGB;
  71 } ContextInfo;
  72
  73 int get_watermark_picture(ContextInfo *ci, int cleanup);
  74
  75
  76 /****************************************************************************
  77  *
  78  ****************************************************************************/
  79 void Release(void *ctx)
  80 {
  81     ContextInfo *ci;
  82     ci = (ContextInfo *) ctx;
  83
  84     if (ci) get_watermark_picture(ci, 1);
  85
  86     if (ctx)
  87         av_free(ctx);
  88 }
  89
  90
  91 /****************************************************************************
  92  *
  93  ****************************************************************************/
  94 int Configure(void **ctxp, int argc, char *argv[])
  95 {
  96     ContextInfo *ci;
  97     int c;
  98
  99     if (0 == (*ctxp = av_mallocz(sizeof(ContextInfo)))) return -1;
 100     ci = (ContextInfo *) *ctxp;
 101
 102     optind = 1;
 103
 104     // Struct is mallocz:ed so no need to reset.
 105
 106     while ((c = getopt(argc, argv, "f:")) > 0) {
 107         switch (c) {
 108             case 'f':
 109                 strncpy(ci->filename, optarg, 1999);
 110                 ci->filename[1999] = 0;
 111                 break;
 112             default:
 113                 av_log(NULL, AV_LOG_ERROR, "Watermark: Unrecognized argument '%s'\n", argv[optind]);
 114                 return -1;
 115         }
 116     }
 117
 118     //
 119     if (0 == ci->filename[0]) {
 120         av_log(NULL, AV_LOG_ERROR, "Watermark: There is no filename specified.\n");
 121         return -1;
 122     }
 123
 124     av_register_all();
 125     return get_watermark_picture(ci, 0);
 126 }
 127
 128
 129 /****************************************************************************
 130  * Why is this a void returning functions? I want to be able to go wrong!
 131  ****************************************************************************/
 132 void Process(void *ctx,
 133              AVPicture *picture,
 134              enum PixelFormat pix_fmt,
 135              int src_width,
 136              int src_height,
 137              int64_t pts)
 138 {
 139     ContextInfo *ci = (ContextInfo *) ctx;
 140     char *buf = 0;
 141     AVPicture picture1;
 142     AVPicture *pict = picture;
 143
 144     AVFrame *pFrameRGB;
 145     int xm_size;
 146     int ym_size;
 147
 148 //    int retval = -1;
 149     int x;
 150     int y;
 151     int offs, offsm;
 152     int mpoffs;
 153     uint32_t *p_pixel = 0;
 154     uint32_t pixel_meck;
 155     uint32_t pixel;
 156     uint32_t pixelm;
 157     int tmp;
 158
 159
 160 //??    (void) ci;
 161
 162     if (pix_fmt != PIX_FMT_RGBA32) {
 163         int size;
 164
 165         size = avpicture_get_size(PIX_FMT_RGBA32, src_width, src_height);
 166         buf = av_malloc(size);
 167
 168         avpicture_fill(&picture1, buf, PIX_FMT_RGBA32, src_width, src_height);
 169         if (img_convert(&picture1, PIX_FMT_RGBA32,
 170                         picture, pix_fmt, src_width, src_height) < 0) {
 171             av_free(buf);
 172             return;
 173         }
 174         pict = &picture1;
 175     }
 176
 177     /* Insert filter code here */ /* ok */
 178
 179     // Get me next frame
 180     if (0 > get_watermark_picture(ci, 0)) {
 181         return;
 182     }
 183     // These are the three original static variables in the ffmpeg hack.
 184     pFrameRGB = ci->pFrameRGB;
 185     xm_size = ci->x_size;
 186     ym_size = ci->y_size;
 187
 188     // I'll do the *4 => <<2 crap later. Most compilers understand that anyway.
 189     // According to avcodec.h PIX_FMT_RGBA32 is handled in endian specific manner.
 190     for (y=0; y<src_height; y++) {
 191         offs = y * (src_width * 4);
 192         offsm = (((y * ym_size) / src_height) * 4) * xm_size; // offsm first in maskline. byteoffs!
 193         for (x=0; x<src_width; x++) {
 194             mpoffs = offsm + (((x * xm_size) / src_width) * 4);
 195             p_pixel = (uint32_t *)&((pFrameRGB->data[0])[mpoffs]);
 196             pixelm = *p_pixel;
 197             p_pixel = (uint32_t *)&((pict->data[0])[offs]);
 198             pixel = *p_pixel;
 199 //          pixelm = *((uint32_t *)&(pFrameRGB->data[mpoffs]));
 200             pixel_meck = pixel & 0xff000000;
 201
 202             // R
 203             tmp = (int)((pixel >> 16) & 0xff) + (int)((pixelm >> 16) & 0xff) - 0x80;
 204             if (tmp > 255) tmp = 255;
 205             if (tmp < 0) tmp = 0;
 206             pixel_meck |= (tmp << 16) & 0xff0000;
 207             // G
 208             tmp = (int)((pixel >> 8) & 0xff) + (int)((pixelm >> 8) & 0xff) - 0x80;
 209             if (tmp > 255) tmp = 255;
 210             if (tmp < 0) tmp = 0;
 211             pixel_meck |= (tmp << 8) & 0xff00;
 212             // B
 213             tmp = (int)((pixel >> 0) & 0xff) + (int)((pixelm >> 0) & 0xff) - 0x80;
 214             if (tmp > 255) tmp = 255;
 215             if (tmp < 0) tmp = 0;
 216             pixel_meck |= (tmp << 0) & 0xff;
 217
 218
 219             // test:
 220             //pixel_meck = pixel & 0xff000000;
 221             //pixel_meck |= (pixelm & 0x00ffffff);
 222
 223             *p_pixel = pixel_meck;
 224
 225             offs += 4;
 226         } // foreach X
 227     } // foreach Y
 228
 229
 230
 231
 232     if (pix_fmt != PIX_FMT_RGBA32) {
 233         if (img_convert(picture, pix_fmt,
 234                         &picture1, PIX_FMT_RGBA32, src_width, src_height) < 0) {
 235         }
 236     }
 237
 238     av_free(buf);
 239 }
 240
 241
 242 /****************************************************************************
 243  * When cleanup == 0, we try to get the next frame. If no next frame, nothing
 244  * is done.
 245  *
 246  * This code follows the example on
 247  * http://www.inb.uni-luebeck.de/~boehme/using_libavcodec.html
 248  *
 249  * 0 = ok, -1 = error
 250  ****************************************************************************/
 251 int get_watermark_picture(ContextInfo *ci, int cleanup)
 252 {
 253     if (1 == ci->is_done && 0 == cleanup) return 0;
 254
 255     // Yes, *pFrameRGB arguments must be null the first time otherwise it's not good..
 256     // This block is only executed the first time we enter this function.
 257     if (0 == ci->pFrameRGB &&
 258         0 == cleanup)
 259     {
 260
 261         /*
 262          * The last three parameters specify the file format, buffer size and format
 263          * parameters; by simply specifying NULL or 0 we ask libavformat to auto-detect
 264          * the format and use a default buffer size. (Didn't work!)
 265          */
 266         if (av_open_input_file(&ci->pFormatCtx, ci->filename, NULL, 0, NULL) != 0) {
 267
 268             // Martin says this should not be necessary but it failed for me sending in
 269             // NULL instead of file_iformat to av_open_input_file()
 270             ci->i = strlen(ci->filename);
 271             if (0 == ci->i) {
 272                 av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() No filename to watermark vhook\n");
 273                 return -1;
 274             }
 275             while (ci->i > 0) {
 276                 if (ci->filename[ci->i] == '.') {
 277                     ci->i++;
 278                     break;
 279                 }
 280                 ci->i--;
 281             }
 282                ci->p_ext = &(ci->filename[ci->i]);
 283             ci->file_iformat = av_find_input_format (ci->p_ext);
 284             if (0 == ci->file_iformat) {
 285                 av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Really failed to find iformat [%s]\n", ci->p_ext);
 286                 return -1;
 287             }
 288             // now continues the Martin template.
 289
 290             if (av_open_input_file(&ci->pFormatCtx, ci->filename, ci->file_iformat, 0, NULL)!=0) {
 291                 av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to open input file [%s]\n", ci->filename);
 292                 return -1;
 293             }
 294         }
 295
 296         /*
 297          * This fills the streams field of the AVFormatContext with valid information.
 298          */
 299         if(av_find_stream_info(ci->pFormatCtx)<0) {
 300             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to find stream info\n");
 301             return -1;
 302         }
 303
 304         /*
 305          * As mentioned in the introduction, we'll handle only video streams, not audio
 306          * streams. To make things nice and easy, we simply use the first video stream we
 307          * find.
 308          */
 309         ci->videoStream=-1;
 310         for(ci->i = 0; ci->i < ci->pFormatCtx->nb_streams; ci->i++)
 311             if(ci->pFormatCtx->streams[ci->i]->codec->codec_type==CODEC_TYPE_VIDEO)
 312             {
 313                 ci->videoStream = ci->i;
 314                 break;
 315             }
 316         if(ci->videoStream == -1) {
 317             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to find any video stream\n");
 318             return -1;
 319         }
 320
 321         ci->st = ci->pFormatCtx->streams[ci->videoStream];
 322         ci->x_size = ci->st->codec->width;
 323         ci->y_size = ci->st->codec->height;
 324
 325         // Get a pointer to the codec context for the video stream
 326         ci->pCodecCtx = ci->pFormatCtx->streams[ci->videoStream]->codec;
 327
 328
 329         /*
 330          * OK, so now we've got a pointer to the so-called codec context for our video
 331          * stream, but we still have to find the actual codec and open it.
 332          */
 333         // Find the decoder for the video stream
 334         ci->pCodec = avcodec_find_decoder(ci->pCodecCtx->codec_id);
 335         if(ci->pCodec == NULL) {
 336             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to find any codec\n");
 337             return -1;
 338         }
 339
 340         // Inform the codec that we can handle truncated bitstreams -- i.e.,
 341         // bitstreams where frame boundaries can fall in the middle of packets
 342         if (ci->pCodec->capabilities & CODEC_CAP_TRUNCATED)
 343             ci->pCodecCtx->flags|=CODEC_FLAG_TRUNCATED;
 344
 345         // Open codec
 346         if(avcodec_open(ci->pCodecCtx, ci->pCodec)<0) {
 347             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to open codec\n");
 348             return -1;
 349         }
 350
 351         // Hack to correct wrong frame rates that seem to be generated by some
 352         // codecs
 353         if (ci->pCodecCtx->time_base.den>1000 && ci->pCodecCtx->time_base.num==1)
 354             ci->pCodecCtx->time_base.num=1000;
 355
 356         /*
 357          * Allocate a video frame to store the decoded images in.
 358          */
 359         ci->pFrame = avcodec_alloc_frame();
 360
 361
 362         /*
 363          * The RGB image pFrameRGB (of type AVFrame *) is allocated like this:
 364          */
 365         // Allocate an AVFrame structure
 366         ci->pFrameRGB=avcodec_alloc_frame();
 367         if(ci->pFrameRGB==NULL) {
 368             av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() Failed to alloc pFrameRGB\n");
 369             return -1;
 370         }
 371
 372         // Determine required buffer size and allocate buffer
 373         ci->numBytes = avpicture_get_size(PIX_FMT_RGBA32, ci->pCodecCtx->width,
 374             ci->pCodecCtx->height);
 375         ci->buffer = av_malloc(ci->numBytes);
 376
 377         // Assign appropriate parts of buffer to image planes in pFrameRGB
 378         avpicture_fill((AVPicture *)ci->pFrameRGB, ci->buffer, PIX_FMT_RGBA32,
 379             ci->pCodecCtx->width, ci->pCodecCtx->height);
 380     }
 381     // TODO loop, pingpong etc?
 382     if (0 == cleanup)
 383     {
 384 //        av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Get a frame\n");
 385         while(av_read_frame(ci->pFormatCtx, &ci->packet)>=0)
 386         {
 387             // Is this a packet from the video stream?
 388             if(ci->packet.stream_index == ci->videoStream)
 389             {
 390                 // Decode video frame
 391                 avcodec_decode_video(ci->pCodecCtx, ci->pFrame, &ci->frameFinished,
 392                     ci->packet.data, ci->packet.size);
 393
 394                 // Did we get a video frame?
 395                 if(ci->frameFinished)
 396                 {
 397                     // Convert the image from its native format to RGBA32
 398                     img_convert((AVPicture *)ci->pFrameRGB, PIX_FMT_RGBA32,
 399                         (AVPicture*)(ci->pFrame), ci->pCodecCtx->pix_fmt, ci->pCodecCtx->width,
 400                         ci->pCodecCtx->height);
 401
 402                     // Process the video frame (save to disk etc.)
 403                     //fprintf(stderr,"banan() New frame!\n");
 404                     //DoSomethingWithTheImage(ci->pFrameRGB);
 405                     return 0;
 406                 }
 407             }
 408
 409             // Free the packet that was allocated by av_read_frame
 410             av_free_packet(&ci->packet);
 411         }
 412         ci->is_done = 1;
 413         return 0;
 414     } // if 0 != cleanup
 415
 416     if (0 != cleanup)
 417     {
 418         // Free the RGB image
 419         if (0 != ci->buffer) {
 420             av_free(ci->buffer);
 421             ci->buffer = 0;
 422         }
 423         if (0 != ci->pFrameRGB) {
 424             av_free(ci->pFrameRGB);
 425             ci->pFrameRGB = 0;
 426         }
 427
 428         // Close the codec
 429         if (0 != ci->pCodecCtx) {
 430             avcodec_close(ci->pCodecCtx);
 431             ci->pCodecCtx = 0;
 432         }
 433
 434         // Close the video file
 435         if (0 != ci->pFormatCtx) {
 436             av_close_input_file(ci->pFormatCtx);
 437             ci->pFormatCtx = 0;
 438         }
 439
 440         ci->is_done = 0;
 441     }
 442     return 0;
 443 }
 444
 445
 446 void parse_arg_file(const char *filename)
 447 {
 448 }