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