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