/* * Watermark Hook * Copyright (c) 2005 Marcus Engene myfirstname(at)mylastname.se * * 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 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 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). * * 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' -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 for ffmpeg. * * This file is part of FFmpeg. * * 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.1 of the License, or (at your option) any later version. * * 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 FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include <stdlib.h> //#include <fcntl.h> #include <unistd.h> #include <stdarg.h> #include "libavutil/common.h" #include "libavformat/avformat.h" #include "libavformat/framehook.h" #include "libswscale/swscale.h" static int sws_flags = SWS_BICUBIC; typedef struct { char filename[2000]; int x_size; int y_size; /* get_watermark_picture() variables */ AVFormatContext *pFormatCtx; const char *p_ext; int videoStream; int frameFinished; AVCodecContext *pCodecCtx; AVCodec *pCodec; AVFrame *pFrame; AVPacket packet; int numBytes; uint8_t *buffer; int i; AVInputFormat *file_iformat; AVStream *st; 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); 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 = 1; // Struct is mallocz:ed so no need to reset. 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_ERROR, "Watermark: Unrecognized argument '%s'\n", argv[optind]); 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); } /**************************************************************************** * For mode 0 (the original one) ****************************************************************************/ 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 x; int y; int offs, offsm; int mpoffs; uint32_t *p_pixel = 0; uint32_t pixel_meck; uint32_t pixel; uint32_t pixelm; int tmp; int thrR = ci->thrR; int thrG = ci->thrG; int thrB = ci->thrB; 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; p_pixel = (uint32_t *)&((pict->data[0])[offs]); pixel = *p_pixel; // pixelm = *((uint32_t *)&(pFrameRGB->data[mpoffs])); pixel_meck = pixel & 0xff000000; // R 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) - 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) - 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; } // 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); } /**************************************************************************** * 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 * http://www.inb.uni-luebeck.de/~boehme/using_libavcodec.html * * 0 = ok, -1 = error ****************************************************************************/ int get_watermark_picture(ContextInfo *ci, int cleanup) { if (1 == ci->is_done && 0 == cleanup) return 0; // 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) { /* * 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!) */ if (av_open_input_file(&ci->pFormatCtx, ci->filename, NULL, 0, NULL) != 0) { // Martin says this should not be necessary but it failed for me sending in // NULL instead of file_iformat to av_open_input_file() ci->i = strlen(ci->filename); if (0 == ci->i) { av_log(NULL, AV_LOG_ERROR, "get_watermark_picture() No filename to watermark vhook\n"); return -1; } while (ci->i > 0) { if (ci->filename[ci->i] == '.') { ci->i++; break; } ci->i--; } 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_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. if (av_open_input_file(&ci->pFormatCtx, ci->filename, ci->file_iformat, 0, NULL)!=0) { 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_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 * 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) { ci->videoStream = ci->i; break; } if(ci->videoStream == -1) { 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; // Get a pointer to the codec context for the video stream 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_ERROR, "get_watermark_picture() Failed to find any codec\n"); return -1; } // Open codec if(avcodec_open(ci->pCodecCtx, ci->pCodec)<0) { 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 // codecs if (ci->pCodecCtx->time_base.den>1000 && ci->pCodecCtx->time_base.num==1) 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_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_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_RGB32, ci->pCodecCtx->width, ci->pCodecCtx->height); } // TODO loop, pingpong etc? 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) { // Is this a packet from the video stream? if(ci->packet.stream_index == ci->videoStream) { // Decode video frame 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 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; return 0; } // if 0 != cleanup if (0 != cleanup) { // Free the RGB image 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); ci->pFormatCtx = 0; } ci->is_done = 0; } return 0; } void parse_arg_file(const char *filename) { }