开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
ffmpeg.c
资源名称：ffmpeg-0.3.4.tar.gz　[点击查看]
上传用户：jxp0626
上传日期：2007-01-08
资源大小：102k
文件大小：23k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Unix_Linux

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