this file got skipped during the API update
[libav.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 }