[libav.git] / vhook / watermark.c

/*
 * Watermark Hook
 * Copyright (c) 2005 Marcus Engene myfirstname(at)mylastname.se
 *
 * flags to 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 filename of watermark image. You must specify this!
 *
 * MODE 0:
 * The watermarkpicture works like this. (Assuming colorintencities 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
 * result < 0, result = 0
 * If mask color is > 0x80 the abs difference is added to frame. If result
 * > 0xff, result = 0xff
 *
 * You can override the 0x80 level with the -t flag. Eg if threshold is 000000
 * the color values of watermark is added to 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, watermark pixel is going to be 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 to ffmpeg.
 *
 * This library 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.
 *
 * This library 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdlib.h>
//#include <fcntl.h>
#include <unistd.h>
#include <stdarg.h>

#include "common.h"
#include "avformat.h"

#include "framehook.h"
#include "cmdutils.h"

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;
} 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);

    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_RGBA32) {
        int size;

        size = avpicture_get_size(PIX_FMT_RGBA32, 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);
            return;
        }
        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_RGBA32 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_RGBA32) {
        if (img_convert(picture, pix_fmt,
                        &picture1, PIX_FMT_RGBA32, src_width, src_height) < 0) {
        }
    }

    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_RGBA32) {
        int size;

        size = avpicture_get_size(PIX_FMT_RGBA32, 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);
            return;
        }
        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_RGBA32 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_RGBA32) {
        if (img_convert(picture, pix_fmt,
                        &picture1, PIX_FMT_RGBA32, src_width, src_height) < 0) {
        }
    }

    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) {
        return Process1(ctx, picture, pix_fmt, src_width, src_height, pts);
    } else {
        return 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;
        }

        // 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_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_RGBA32, 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);
    }
    // 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 RGBA32
                    img_convert((AVPicture *)ci->pFrameRGB, PIX_FMT_RGBA32,
                        (AVPicture*)(ci->pFrame), ci->pCodecCtx->pix_fmt, ci->pCodecCtx->width,
                        ci->pCodecCtx->height);

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