watermark.c.svn-base

mediastreamer2是开源的网络传输媒体流的库

/*
 * 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 "common.h"
#include "avformat.h"

#include "framehook.h"
#include "cmdutils.h"
#include "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;