vhook watermark patch by (Marcus Engene: ffmpeg, engene se)
[ffmpeg.git] / 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 = 0;
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_DEBUG, "Unrecognized argument '%s'\n", argv[optind]);
114                 return -1;
115         }
116     }
117     
118     //
119     if (0 == ci->filename[0]) return -1;
120         
121     av_register_all();
122     return get_watermark_picture(ci, 0);
123
124     return 0;
125 }
126
127
128 /****************************************************************************
129  * Why is this a void returning functions? I want to be able to go wrong!
130  ****************************************************************************/
131 void Process(void *ctx, 
132              AVPicture *picture, 
133              enum PixelFormat pix_fmt, 
134              int src_width, 
135              int src_height, 
136              int64_t pts)
137 {
138     ContextInfo *ci = (ContextInfo *) ctx;
139     char *buf = 0;
140     AVPicture picture1;
141     AVPicture *pict = picture;
142     
143     AVFrame *pFrameRGB;
144     int xm_size;
145     int ym_size;
146
147 //    int retval = -1;
148     int x;
149     int y;
150     int offs, offsm;
151     int mpoffs;
152     uint32_t *p_pixel = 0;
153     uint32_t pixel_meck;
154     uint32_t pixel;
155     uint32_t pixelm;
156     int tmp;    
157     
158         
159 //??    (void) ci;
160
161     if (pix_fmt != PIX_FMT_RGBA32) {
162         int size;
163
164         size = avpicture_get_size(PIX_FMT_RGBA32, src_width, src_height);
165         buf = av_malloc(size);
166
167         avpicture_fill(&picture1, buf, PIX_FMT_RGBA32, src_width, src_height);
168         if (img_convert(&picture1, PIX_FMT_RGBA32, 
169                         picture, pix_fmt, src_width, src_height) < 0) {
170             av_free(buf);
171             return;
172         }
173         pict = &picture1;
174     }
175
176     /* Insert filter code here */ /* ok */
177
178     // Get me next frame    
179     if (0 > get_watermark_picture(ci, 0)) {
180         return;
181     }     
182     // These are the three original static variables in the ffmpeg hack.
183     pFrameRGB = ci->pFrameRGB;
184     xm_size = ci->x_size;
185     ym_size = ci->y_size;
186     
187     // I'll do the *4 => <<2 crap later. Most compilers understand that anyway.
188     // According to avcodec.h PIX_FMT_RGBA32 is handled in endian specific manner.
189     for (y=0; y<src_height; y++) {
190         offs = y * (src_width * 4);
191         offsm = (((y * ym_size) / src_height) * 4) * xm_size; // offsm first in maskline. byteoffs!
192         for (x=0; x<src_width; x++) {
193             mpoffs = offsm + (((x * xm_size) / src_width) * 4);
194             p_pixel = (uint32_t *)&((pFrameRGB->data[0])[mpoffs]);
195             pixelm = *p_pixel;
196             p_pixel = (uint32_t *)&((pict->data[0])[offs]);
197             pixel = *p_pixel;
198 //          pixelm = *((uint32_t *)&(pFrameRGB->data[mpoffs]));
199             pixel_meck = pixel & 0xff000000;
200
201             // R
202             tmp = (int)((pixel >> 16) & 0xff) + (int)((pixelm >> 16) & 0xff) - 0x80;
203             if (tmp > 255) tmp = 255;
204             if (tmp < 0) tmp = 0;
205             pixel_meck |= (tmp << 16) & 0xff0000;
206             // G
207             tmp = (int)((pixel >> 8) & 0xff) + (int)((pixelm >> 8) & 0xff) - 0x80;
208             if (tmp > 255) tmp = 255;
209             if (tmp < 0) tmp = 0;
210             pixel_meck |= (tmp << 8) & 0xff00;
211             // B
212             tmp = (int)((pixel >> 0) & 0xff) + (int)((pixelm >> 0) & 0xff) - 0x80;
213             if (tmp > 255) tmp = 255;
214             if (tmp < 0) tmp = 0;
215             pixel_meck |= (tmp << 0) & 0xff;
216             
217             
218             // test:
219             //pixel_meck = pixel & 0xff000000;
220             //pixel_meck |= (pixelm & 0x00ffffff);
221
222             *p_pixel = pixel_meck;
223
224             offs += 4; 
225         } // foreach X
226     } // foreach Y    
227     
228     
229     
230
231     if (pix_fmt != PIX_FMT_RGBA32) {
232         if (img_convert(picture, pix_fmt, 
233                         &picture1, PIX_FMT_RGBA32, src_width, src_height) < 0) {
234         }
235     }
236
237     av_free(buf);
238 }
239
240
241 /****************************************************************************
242  * When cleanup == 0, we try to get the next frame. If no next frame, nothing
243  * is done.
244  *
245  * This code follows the example on 
246  * http://www.inb.uni-luebeck.de/~boehme/using_libavcodec.html
247  *
248  * 0 = ok, -1 = error
249  ****************************************************************************/
250 int get_watermark_picture(ContextInfo *ci, int cleanup)
251 {
252     if (1 == ci->is_done && 0 == cleanup) return 0;
253
254     // Yes, *pFrameRGB arguments must be null the first time otherwise it's not good..
255     // This block is only executed the first time we enter this function.
256     if (0 == ci->pFrameRGB && 
257         0 == cleanup) 
258     {
259       
260         /* 
261          * The last three parameters specify the file format, buffer size and format
262          * parameters; by simply specifying NULL or 0 we ask libavformat to auto-detect
263          * the format and use a default buffer size. (Didn't work!)
264          */
265         if (av_open_input_file(&ci->pFormatCtx, ci->filename, NULL, 0, NULL) != 0) {
266
267             // Martin says this should not be necessary but it failed for me sending in
268             // NULL instead of file_iformat to av_open_input_file()
269             ci->i = strlen(ci->filename);
270             if (0 == ci->i) {
271                 av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() No filename to watermark vhook\n");
272                 return -1;
273             }
274             while (ci->i > 0) {
275                 if (ci->filename[ci->i] == '.') {
276                     ci->i++;
277                     break;
278                 }
279                 ci->i--;
280             }
281                ci->p_ext = &(ci->filename[ci->i]);
282             ci->file_iformat = av_find_input_format (ci->p_ext);
283             if (0 == ci->file_iformat) {
284                 av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Really failed to find iformat [%s]\n", ci->p_ext);
285                 return -1;
286             }
287             // now continues the Martin template.    
288             
289             if (av_open_input_file(&ci->pFormatCtx, ci->filename, ci->file_iformat, 0, NULL)!=0) {
290                 av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Failed to open input file [%s]\n", ci->filename);
291                 return -1;
292             }            
293         }
294         
295         /* 
296          * This fills the streams field of the AVFormatContext with valid information.
297          */
298         if(av_find_stream_info(ci->pFormatCtx)<0) {
299             av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Failed to find stream info\n");
300             return -1;
301         }
302     
303         /*
304          * As mentioned in the introduction, we'll handle only video streams, not audio 
305          * streams. To make things nice and easy, we simply use the first video stream we
306          * find.
307          */
308         ci->videoStream=-1;
309         for(ci->i = 0; ci->i < ci->pFormatCtx->nb_streams; ci->i++)
310             if(ci->pFormatCtx->streams[ci->i]->codec.codec_type==CODEC_TYPE_VIDEO)
311             {
312                 ci->videoStream = ci->i;
313                 break;
314             }
315         if(ci->videoStream == -1) {
316             av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Failed to find any video stream\n");
317             return -1;
318         }
319         
320         ci->st = ci->pFormatCtx->streams[ci->videoStream];
321         ci->x_size = ci->st->codec.width;
322         ci->y_size = ci->st->codec.height;
323         
324         // Get a pointer to the codec context for the video stream
325         ci->pCodecCtx = &ci->pFormatCtx->streams[ci->videoStream]->codec;
326             
327         
328         /*
329          * OK, so now we've got a pointer to the so-called codec context for our video
330          * stream, but we still have to find the actual codec and open it.
331          */    
332         // Find the decoder for the video stream
333         ci->pCodec = avcodec_find_decoder(ci->pCodecCtx->codec_id);
334         if(ci->pCodec == NULL) {
335             av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Failed to find any codec\n");
336             return -1;
337         }
338         
339         // Inform the codec that we can handle truncated bitstreams -- i.e.,
340         // bitstreams where frame boundaries can fall in the middle of packets
341         if (ci->pCodec->capabilities & CODEC_CAP_TRUNCATED)
342             ci->pCodecCtx->flags|=CODEC_FLAG_TRUNCATED;
343         
344         // Open codec
345         if(avcodec_open(ci->pCodecCtx, ci->pCodec)<0) {
346             av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Failed to open codec\n");
347             return -1;
348         }
349         
350         // Hack to correct wrong frame rates that seem to be generated by some 
351         // codecs
352         if (ci->pCodecCtx->time_base.den>1000 && ci->pCodecCtx->time_base.num==1)
353             ci->pCodecCtx->time_base.num=1000;    
354     
355         /*
356          * Allocate a video frame to store the decoded images in.
357          */
358         ci->pFrame = avcodec_alloc_frame();
359     
360         
361         /*
362          * The RGB image pFrameRGB (of type AVFrame *) is allocated like this:
363          */
364         // Allocate an AVFrame structure
365         ci->pFrameRGB=avcodec_alloc_frame();
366         if(ci->pFrameRGB==NULL) {
367             av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Failed to alloc pFrameRGB\n");
368             return -1;
369         }
370         
371         // Determine required buffer size and allocate buffer
372         ci->numBytes = avpicture_get_size(PIX_FMT_RGBA32, ci->pCodecCtx->width,
373             ci->pCodecCtx->height);
374         ci->buffer = av_malloc(ci->numBytes);
375         
376         // Assign appropriate parts of buffer to image planes in pFrameRGB
377         avpicture_fill((AVPicture *)ci->pFrameRGB, ci->buffer, PIX_FMT_RGBA32,
378             ci->pCodecCtx->width, ci->pCodecCtx->height);    
379     }
380     // TODO loop, pingpong etc?
381     if (0 == cleanup) 
382     {    
383 //        av_log(NULL, AV_LOG_DEBUG, "get_watermark_picture() Get a frame\n");
384         while(av_read_frame(ci->pFormatCtx, &ci->packet)>=0)
385         {
386             // Is this a packet from the video stream?
387             if(ci->packet.stream_index == ci->videoStream)
388             {
389                 // Decode video frame
390                 avcodec_decode_video(ci->pCodecCtx, ci->pFrame, &ci->frameFinished, 
391                     ci->packet.data, ci->packet.size);
392         
393                 // Did we get a video frame?
394                 if(ci->frameFinished)
395                 {
396                     // Convert the image from its native format to RGBA32
397                     img_convert((AVPicture *)ci->pFrameRGB, PIX_FMT_RGBA32, 
398                         (AVPicture*)(ci->pFrame), ci->pCodecCtx->pix_fmt, ci->pCodecCtx->width, 
399                         ci->pCodecCtx->height);
400         
401                     // Process the video frame (save to disk etc.)
402                     //fprintf(stderr,"banan() New frame!\n");
403                     //DoSomethingWithTheImage(ci->pFrameRGB);
404                     return 0;
405                 }
406             }
407         
408             // Free the packet that was allocated by av_read_frame
409             av_free_packet(&ci->packet);
410         }
411         ci->is_done = 1;    
412         return 0;
413     } // if 0 != cleanup
414     
415     if (0 != cleanup) 
416     {
417         // Free the RGB image
418         if (0 != ci->buffer) {
419             av_free(ci->buffer);
420             ci->buffer = 0;
421         }
422         if (0 != ci->pFrameRGB) {
423             av_free(ci->pFrameRGB);
424             ci->pFrameRGB = 0;
425         } 
426         
427         // Close the codec
428         if (0 != ci->pCodecCtx) {
429             avcodec_close(ci->pCodecCtx);
430             ci->pCodecCtx = 0;
431         }
432         
433         // Close the video file
434         if (0 != ci->pFormatCtx) {
435             av_close_input_file(ci->pFormatCtx);    
436             ci->pFormatCtx = 0;
437         }
438         
439         ci->is_done = 0;
440     }
441     return 0;
442 }
443
444
445 void parse_arg_file(const char *filename)
446 {
447 }