57cdd07348e965cfba5ee3c7e676f4c6c2952f91
[ffmpeg.git] / ffmpeg.c
1 /*
2  * Basic user interface for ffmpeg system
3  * Copyright (c) 2000 Gerard Lantau
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  */
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <netinet/in.h>
22 #include <linux/videodev.h>
23 #include <linux/soundcard.h>
24 #include <unistd.h>
25 #include <fcntl.h>
26 #include <sys/ioctl.h>
27 #include <sys/mman.h>
28 #include <errno.h>
29 #include <sys/time.h>
30 #include <getopt.h>
31
32 #include "mpegenc.h"
33 #include "mpegvideo.h"
34
35 static AVFormat *file_format;
36 static int frame_width  = 160;
37 static int frame_height = 128;
38 static int frame_rate = 25;
39 static int bit_rate = 200000;
40 static int video_disable = 0;
41
42 static const char *video_filename, *audio_filename;
43 static float recording_time = 10.0;
44 static int nb_frames;
45 static int gop_size = 12;
46 static int intra_only = 0;
47 static int audio_freq = 44100;
48 static int audio_bit_rate = 64000;
49 static int audio_disable = 0;
50 static int audio_channels = 1;
51
52 static long long time_start;
53
54
55 static int file_read_picture(AVEncodeContext *s, 
56                              UINT8 *picture[3],
57                              int width, int height,
58                              int picture_number)
59 {
60     FILE *f;
61     char buf[1024];
62     static int init = 0;
63     static UINT8 *pict[3];
64     if (!init) {
65         pict[0] = malloc(width * height);
66         pict[1] = malloc(width * height / 4);
67         pict[2] = malloc(width * height / 4);
68         init = 1;
69     }
70     
71     picture[0] = pict[0];
72     picture[1] = pict[1];
73     picture[2] = pict[2];
74
75     sprintf(buf, "%s%d.Y", video_filename, picture_number);
76     f=fopen(buf, "r");
77     if (!f) {
78         return -1;
79     }
80
81     fread(picture[0], 1, width * height, f);
82     fclose(f);
83
84     sprintf(buf, "%s%d.U", video_filename, picture_number);
85     f=fopen(buf, "r");
86     if (!f) {
87         perror(buf);
88         exit(1);
89     }
90     fread(picture[1], 1, width * height / 4, f);
91     fclose(f);
92     
93     sprintf(buf, "%s%d.V", video_filename, picture_number);
94     f=fopen(buf, "r");
95     if (!f) {
96         perror(buf);
97         exit(1);
98     }
99     fread(picture[2], 1, width * height / 4, f);
100     fclose(f);
101     return 0;
102 }
103
104 static void display_stats(AVEncodeContext *video_ctx, 
105                           AVEncodeContext *audio_ctx,
106                           int batch_mode, int the_end)
107 {
108     if (video_ctx && 
109         ((video_ctx->frame_number % video_ctx->rate) == 0 || 
110         the_end)) {
111         float ti;
112         
113         if (batch_mode) {
114             ti = (float)video_ctx->frame_number / video_ctx->rate;
115         } else {
116             ti = (gettime() - time_start) / 1000000.0;
117             if (ti < 0.1)
118                     ti = 0.1;
119         }
120         
121         fprintf(stderr,
122                 "frame=%5d size=%8dkB time=%0.1f fps=%4.1f bitrate=%6.1fkbits/s q=%2d\r", 
123                 video_ctx->frame_number,
124                 data_out_size / 1024,
125                 ti,
126                 video_ctx->frame_number / ti,
127                 (data_out_size * 8 / ti / 1000),
128                 ((MpegEncContext *)video_ctx->priv_data)->qscale);
129         if (the_end) {
130             fprintf(stderr,"\n");
131         }
132         fflush(stderr);
133     }
134 #if 0
135     if (the_end && batch_mode && audio_ctx) {
136         duration = (gettime() - ti) / 1000000.0;
137         factor = 0;
138         if (ti > 0) {
139             factor = (float)nb_samples / s->sample_rate / duration;
140         }
141         fprintf(stderr, "%0.1f seconds compressed in %0.1f seconds (speed factor: %0.1f)\n",
142                 (float)nb_samples / s->sample_rate, 
143                 duration,
144                 factor);
145     }
146 #endif
147 }
148
149 void raw_write_data(void *opaque, 
150                     unsigned char *buf, int size)
151 {
152     FILE *outfile = opaque;
153     fwrite(buf, 1, size, outfile);
154     data_out_size += size;
155 }
156
157 int raw_seek(void *opaque, long long offset, int whence)
158 {
159     FILE *outfile = opaque;
160     fseek(outfile, offset, whence);
161     return 0;
162 }
163
164 static void av_encode(AVFormatContext *ctx,
165                       const char *video_filename,
166                       const char *audio_filename)
167 {
168     UINT8 audio_buffer[4096];
169     UINT8 video_buffer[128*1024];
170     char buf[256];
171     short *samples;
172     int ret;
173     int audio_fd;
174     FILE *infile;
175     int sample_count;
176     int batch_mode;
177     AVEncodeContext *audio_enc, *video_enc;
178     int frame_size, frame_bytes;
179     AVEncoder *audio_encoder, *video_encoder;
180     UINT8 *picture[3];
181
182     /* audio */
183     audio_enc = ctx->audio_enc;
184     sample_count = 0;
185     infile = NULL;
186     frame_size = 0;
187     samples = NULL;
188     audio_fd = -1;
189     frame_bytes = 0;
190     batch_mode = 0;
191     if (audio_filename ||
192         video_filename)
193         batch_mode = 1;
194     
195     if (audio_enc) {
196         if (batch_mode) {
197             if (!audio_filename) {
198                 fprintf(stderr, "Must give audio input file\n");
199                 exit(1);
200             }
201             infile = fopen(audio_filename, "r");
202             if (!infile) {
203                 fprintf(stderr, "Could not open '%s'\n", audio_filename);
204                 exit(1);
205             }
206             audio_fd = -1;
207         } else {
208             audio_fd = audio_open(audio_enc->rate, audio_enc->channels);
209             if (audio_fd < 0) {
210                 fprintf(stderr, "Could not open audio device\n");
211                 exit(1);
212             }
213         }
214         
215         audio_encoder = avencoder_find(ctx->format->audio_codec);
216         if (avencoder_open(audio_enc, audio_encoder) < 0) {
217             fprintf(stderr, "Audio encoder: incorrect audio frequency or bitrate\n");
218             exit(1);
219         }
220         avencoder_string(buf, sizeof(buf), audio_enc);
221         fprintf(stderr, "  %s\n", buf);
222         
223         frame_size = audio_enc->frame_size;
224         
225         frame_bytes = frame_size * 2 * audio_enc->channels;
226         samples = malloc(frame_bytes);
227     }
228
229     /* video */
230     video_enc = ctx->video_enc;
231     if (video_enc) {
232         if (batch_mode) {
233             if (!video_filename) {
234                 fprintf(stderr, "Must give video input file\n");
235                 exit(1);
236             }
237         } else {
238             ret = v4l_init(video_enc->rate, video_enc->width, video_enc->height);
239             if (ret < 0) {
240                 fprintf(stderr,"Could not init video 4 linux capture\n");
241                 exit(1);
242             }
243         }
244         
245         video_encoder = avencoder_find(ctx->format->video_codec);
246         if (avencoder_open(video_enc, video_encoder) < 0) {
247             fprintf(stderr, "Error while initializing video codec\n");
248             exit(1);
249         }
250
251         avencoder_string(buf, sizeof(buf), video_enc);
252         fprintf(stderr, "  %s\n", buf);
253     }
254     
255     ctx->format->write_header(ctx);
256     time_start = gettime();
257
258     for(;;) {
259         /* read & compression audio frames */
260         if (audio_enc) {
261             if (!batch_mode) {
262                 for(;;) {
263                     ret = read(audio_fd, samples, frame_bytes);
264                     if (ret != frame_bytes)
265                         break;
266                     ret = avencoder_encode(audio_enc,
267                                            audio_buffer, sizeof(audio_buffer), samples);
268                     ctx->format->write_audio_frame(ctx, audio_buffer, ret);
269                 }
270             } else {
271                 if (video_enc)
272                     sample_count += audio_enc->rate / video_enc->rate;
273                 else
274                     sample_count += frame_size;
275                 while (sample_count > frame_size) {
276                     if (fread(samples, 1, frame_bytes, infile) == 0)
277                         goto the_end;
278                     
279                     ret = avencoder_encode(audio_enc,
280                                            audio_buffer, sizeof(audio_buffer), samples);
281                     ctx->format->write_audio_frame(ctx, audio_buffer, ret);
282
283                     sample_count -= frame_size;
284                 }
285             }
286         }
287
288         if (video_enc) {
289             /* read video image */
290             if (batch_mode) {
291                 ret = file_read_picture (video_enc, picture, 
292                                          video_enc->width, video_enc->height, 
293                                          video_enc->frame_number);
294             } else {
295                 ret = v4l_read_picture (picture, 
296                                         video_enc->width, video_enc->height, 
297                                         video_enc->frame_number);
298             }
299             if (ret < 0)
300                 break;
301             ret = avencoder_encode(video_enc, video_buffer, sizeof(video_buffer), picture);
302             ctx->format->write_video_picture(ctx, video_buffer, ret);
303         }
304         
305         display_stats(video_enc, NULL, batch_mode, 0);
306         if (video_enc && video_enc->frame_number >= nb_frames)
307             break;
308     }
309  the_end:
310     display_stats(video_enc, NULL, batch_mode, 1);
311
312     if (video_enc)
313         avencoder_close(video_enc);
314
315     if (audio_enc)
316         avencoder_close(audio_enc);
317     
318     ctx->format->write_trailer(ctx);
319
320     if (!infile) {
321         close(audio_fd);
322     } else {
323         fclose(infile);
324     }
325 }
326
327 typedef struct {
328     const char *str;
329     int width, height;
330 } SizeEntry;
331
332 SizeEntry sizes[] = {
333     { "sqcif", 128, 96 },
334     { "qcif", 176, 144 },
335     { "cif", 352, 288 },
336     { "4cif", 704, 576 },
337 };
338     
339 enum {
340     OPT_AR=256,
341     OPT_AB,
342     OPT_AN,
343     OPT_AC,
344     OPT_VN,
345 };
346
347 struct option long_options[] =
348 {
349     { "ar", required_argument, NULL, OPT_AR },
350     { "ab", required_argument, NULL, OPT_AB },
351     { "an", no_argument, NULL, OPT_AN },
352     { "ac", required_argument, NULL, OPT_AC },
353     { "vn", no_argument, NULL, OPT_VN },
354 };
355
356 enum {
357     OUT_FILE,
358     OUT_PIPE,
359     OUT_UDP,
360 };
361
362
363 void help(void)
364 {
365     AVFormat *f;
366
367     printf("ffmpeg version 1.0, Copyright (c) 2000 Gerard Lantau\n"
368            "usage: ffmpeg [options] outfile [video_infile] [audio_infile]\n"
369            "Hyper fast MPEG1 video/H263/RV and AC3/MPEG audio layer 2 encoder\n"
370            "\n"
371            "Main options are:\n"
372            "\n"
373            "-L           print the LICENSE\n"
374            "-s size      set frame size                   [%dx%d]\n"
375            "-f format    set encoding format              [%s]\n"
376            "-r fps       set frame rate                   [%d]\n"
377            "-b bitrate   set the total bitrate in kbit/s  [%d]\n"
378            "-t time      set recording time in seconds    [%0.1f]\n"
379            "-ar freq     set the audio sampling freq      [%d]\n"
380            "-ab bitrate  set the audio bitrate in kbit/s  [%d]\n"
381            "-ac channels set the number of audio channels [%d]\n"
382            "-an          disable audio recording          [%s]\n"
383            "-vn          disable video recording          [%s]\n"
384            "\n"
385            "Frame sizes abbreviations: sqcif qcif cif 4cif\n",
386            frame_width, frame_height,
387            file_format->name,
388            frame_rate,
389            bit_rate / 1000,
390            recording_time,
391            audio_freq,
392            audio_bit_rate / 1000,
393            audio_channels,
394            audio_disable ? "yes" : "no",
395            video_disable ? "yes" : "no");
396
397     printf("Encoding video formats:");
398     for(f = first_format; f != NULL; f = f->next)
399         printf(" %s", f->name);
400     printf("\n");
401
402     printf("outfile can be a file name, - (pipe) or 'udp:host:port'\n"
403            "\n"
404            "Advanced options are:\n"
405            "-d device    set video4linux device name\n"
406            "-g gop_size  set the group of picture size    [%d]\n"
407            "-i           use only intra frames            [%s]\n"
408            "-c comment   set the comment string\n"
409            "\n",
410            gop_size,
411            intra_only ? "yes" : "no");
412 }
413
414 void licence(void)
415 {
416     printf(
417     "ffmpeg version 1.0\n"
418     "Copyright (c) 2000 Gerard Lantau\n"
419     "This program is free software; you can redistribute it and/or modify\n"
420     "it under the terms of the GNU General Public License as published by\n"
421     "the Free Software Foundation; either version 2 of the License, or\n"
422     "(at your option) any later version.\n"
423     "\n"
424     "This program is distributed in the hope that it will be useful,\n"
425     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
426     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
427     "GNU General Public License for more details.\n"
428     "\n"
429     "You should have received a copy of the GNU General Public License\n"
430     "along with this program; if not, write to the Free Software\n"
431     "Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n"
432     );
433 }
434
435 static unsigned char output_buffer[32768];
436
437 int main(int argc, char **argv)
438 {
439     AVEncodeContext video_enc1, *video_enc = &video_enc1;
440     AVEncodeContext audio_enc1, *audio_enc = &audio_enc1;
441     UDPContext udp_ctx1, *udp_ctx = &udp_ctx1;
442     AVFormatContext av_ctx1, *av_ctx = &av_ctx1;
443     FILE *outfile;
444     int i, c;
445     char *filename;
446     int output_type;
447     int use_video, use_audio;
448
449     register_avencoder(&ac3_encoder);
450     register_avencoder(&mp2_encoder);
451     register_avencoder(&mpeg1video_encoder);
452     register_avencoder(&h263_encoder);
453     register_avencoder(&rv10_encoder);
454     register_avencoder(&mjpeg_encoder);
455
456     register_avformat(&mp2_format);
457     register_avformat(&ac3_format);
458     register_avformat(&mpeg1video_format);
459     register_avformat(&h263_format);
460     register_avformat(&mpeg_mux_format);
461     register_avformat(&ra_format);
462     register_avformat(&rm_format);
463     register_avformat(&asf_format);
464     register_avformat(&mpjpeg_format);
465     register_avformat(&swf_format);
466
467     file_format = NULL;
468     
469     for(;;) {
470         c = getopt_long_only(argc, argv, "s:f:r:b:t:hd:g:ic:L", 
471                              long_options, NULL);
472         if (c == -1)
473             break;
474         switch(c) {
475         case 'L':
476             licence();
477             exit(1);
478         case 'h':
479             help();
480             exit(1);
481         case 's':
482             {
483                 int n = sizeof(sizes) / sizeof(SizeEntry);
484                 const char *p;
485
486                 for(i=0;i<n;i++) {
487                     if (!strcmp(sizes[i].str, optarg)) {
488                         frame_width = sizes[i].width;
489                         frame_height = sizes[i].height;
490                         break;
491                     }
492                 }
493                 if (i == n) {
494                     p = optarg;
495                     frame_width = strtol(p, (char **)&p, 10);
496                     if (*p)
497                         p++;
498                     frame_height = strtol(p, (char **)&p, 10);
499                 }
500             }
501             break;
502         case 'f':
503             {
504                 AVFormat *f;
505                 f = first_format;
506                 while (f != NULL && strcmp(f->name, optarg) != 0) f = f->next;
507                 if (f == NULL) {
508                     fprintf(stderr, "Invalid format: %s\n", optarg);
509                     exit(1);
510                 }
511                 file_format = f;
512             }
513             break;
514         case 'r':
515             {
516                 frame_rate = atoi(optarg);
517             }
518             break;
519         case 'b':
520             {
521                 bit_rate = atoi(optarg) * 1000;
522             }
523             break;
524         case 't':
525             {
526                 recording_time = atof(optarg);
527                 break;
528             }
529             /* audio specific */
530         case OPT_AR:
531             {
532                 audio_freq = atoi(optarg);
533                 break;
534             }
535         case OPT_AB:
536             {
537                 audio_bit_rate = atoi(optarg) * 1000;
538                 break;
539             }
540         case OPT_AN:
541             audio_disable = 1;
542             break;
543         case OPT_VN:
544             video_disable = 1;
545             break;
546         case OPT_AC:
547             {
548                 audio_channels = atoi(optarg);
549                 if (audio_channels != 1 && 
550                     audio_channels != 2) {
551                     fprintf(stderr, "Incorrect number of channels: %d\n", audio_channels);
552                     exit(1);
553                 }
554             }
555             break;
556             /* advanced options */
557         case 'd':
558             v4l_device = optarg;
559             break;
560         case 'g':
561             gop_size = atoi(optarg);
562             break;
563         case 'i':
564             intra_only = 1;
565             break;
566         case 'c':
567             comment_string = optarg;
568             break;
569         default:
570             exit(2);
571         }
572     }
573
574     if (optind >= argc) {
575         help();
576         exit(1);
577     }
578
579     filename = argv[optind++];
580     video_filename = NULL;
581     audio_filename = NULL;
582
583     /* auto detect format */
584     if (file_format == NULL)
585         file_format = guess_format(NULL, filename, NULL);
586
587     if (file_format == NULL)
588         file_format = &mpeg_mux_format;
589
590     /* check parameters */
591     if (frame_width <= 0 || frame_height <= 0) {
592         fprintf(stderr, "Incorrect frame size\n");
593         exit(1);
594     }
595     if ((frame_width % 16) != 0 || (frame_height % 16) != 0) {
596         fprintf(stderr, "Frame size must be a multiple of 16\n");
597         exit(1);
598     }
599     
600     if (bit_rate < 5000 || bit_rate >= 10000000) {
601         fprintf(stderr, "Invalid bit rate\n");
602         exit(1);
603     }
604
605     if (frame_rate < 1 || frame_rate >= 60) {
606         fprintf(stderr, "Invalid frame rate\n");
607         exit(1);
608     }
609
610     nb_frames = (int)(recording_time * frame_rate);
611     if (nb_frames < 1) {
612         fprintf(stderr, "Invalid recording time\n");
613         exit(1);
614     }
615
616     use_video = file_format->video_codec != CODEC_ID_NONE;
617     use_audio = file_format->audio_codec != CODEC_ID_NONE;
618     if (audio_disable) {
619         use_audio = 0;
620     }
621     if (video_disable) {
622         use_video = 0;
623     }
624         
625     if (use_video == 0 && use_audio == 0) {
626         fprintf(stderr, "No audio or video selected\n");
627         exit(1);
628     }
629
630     fprintf(stderr, "Recording: %s, %0.1f seconds\n",
631             file_format->name, 
632             recording_time);
633
634     /* open output media */
635
636     if (strstart(filename, "udp:", NULL)) {
637         output_type = OUT_UDP;
638         outfile = NULL;
639         memset(udp_ctx, 0, sizeof(*udp_ctx));
640         if (udp_tx_open(udp_ctx, filename, 0) < 0) {
641             fprintf(stderr, "Could not open UDP socket\n");
642             exit(1);
643         }
644     } else if (!strcmp(filename, "-")) {
645         output_type = OUT_PIPE;
646         outfile = stdout;
647     } else {
648         output_type = OUT_FILE;
649         outfile = fopen(filename, "w");
650         if (!outfile) {
651             perror(filename);
652             exit(1);
653         }
654     }
655
656     av_ctx->video_enc = NULL;
657     av_ctx->audio_enc = NULL;
658
659     if (output_type == OUT_UDP) {
660         init_put_byte(&av_ctx->pb, output_buffer, sizeof(output_buffer),
661                       udp_ctx, udp_write_data, NULL);
662     } else {
663         init_put_byte(&av_ctx->pb, output_buffer, sizeof(output_buffer),
664                       outfile, raw_write_data, raw_seek);
665     }
666
667     if (use_video) {
668         if (optind < argc) {
669             video_filename = argv[optind++];
670         }
671         /* init mpeg video encoding context */
672         memset(video_enc, 0, sizeof(*video_enc));
673         video_enc->bit_rate = bit_rate;
674         video_enc->rate = frame_rate; 
675
676         video_enc->width = frame_width;
677         video_enc->height = frame_height;
678         if (!intra_only)
679             video_enc->gop_size = gop_size;
680         else
681             video_enc->gop_size = 0;
682
683         av_ctx->video_enc = video_enc;
684         av_ctx->format = file_format;
685     }
686
687     if (use_audio) {
688         if (optind < argc) {
689             audio_filename = argv[optind++];
690         }
691         audio_enc->bit_rate = audio_bit_rate;
692         audio_enc->rate = audio_freq;
693         audio_enc->channels = audio_channels;
694         av_ctx->audio_enc = audio_enc;
695     }
696     av_ctx->format = file_format;
697     av_ctx->is_streamed = 0;
698
699     av_encode(av_ctx, video_filename, audio_filename);
700
701     /* close output media */
702
703     switch(output_type) {
704     case OUT_FILE:
705         fclose(outfile);
706         break;
707     case OUT_PIPE:
708         break;
709     case OUT_UDP:
710         udp_tx_close(udp_ctx);
711         break;
712     }
713     fprintf(stderr, "\n");
714     
715     return 0;
716 }
717