Use put_signed_pixels_clamped where appropriate

[ffmpeg] / ffmpeg.c

diff --git a/ffmpeg.c b/ffmpeg.c
index 4fe908d1a08805e9f8bbf70865fce5c21a3cf23c..189d7270faf65ef2f1ab4149ec28a32bac182d9e 100644 (file)
--- a/ffmpeg.c
+++ b/ffmpeg.c
@@ -18,30 +18,35 @@
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */

-#define HAVE_AV_CONFIG_H
+
+#include "config.h"
+#include <ctype.h>
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+#include <errno.h>

 #include <signal.h>
 #include <limits.h>
 #include "avformat.h"
 #include "swscale.h"
 #include "framehook.h"
 #include <signal.h>
 #include <limits.h>
 #include "avformat.h"
 #include "swscale.h"
 #include "framehook.h"

-#include "dsputil.h"

 #include "opt.h"
 #include "fifo.h"
 #include "opt.h"
 #include "fifo.h"

+#include "avstring.h"

 
 

-#ifdef __MINGW32__
-#include <conio.h>
-#else
+#if !defined(HAVE_GETRUSAGE) && defined(HAVE_GETPROCESSTIMES)
+#include <windows.h>
+#endif
+
+#if defined(HAVE_TERMIOS_H)

 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
 #include <termios.h>
 #include <sys/resource.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
 #include <termios.h>
 #include <sys/resource.h>

-#endif
-#ifdef CONFIG_OS2
-#include <sys/types.h>
-#include <sys/select.h>
-#include <stdlib.h>
+#elif defined(HAVE_CONIO_H)
+#include <conio.h>

 #endif
 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
 #include <time.h>
 #endif
 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
 #include <time.h>


@@ -56,6 +61,11 @@
 #define INFINITY HUGE_VAL
 #endif
 
 #define INFINITY HUGE_VAL
 #endif
 

+#undef exit
+
+static const char program_name[] = "FFmpeg";
+static const int program_birth_year = 2000;
+

 /* select an input stream for an output stream */
 typedef struct AVStreamMap {
     int file_index;
 /* select an input stream for an output stream */
 typedef struct AVStreamMap {
     int file_index;


@@ -73,7 +83,6 @@ typedef struct AVMetaDataMap {
 extern const OptionDef options[];
 
 static void show_help(void);
 extern const OptionDef options[];
 
 static void show_help(void);

-static void show_license(void);

 static int opt_default(const char *opt, const char *arg);
 
 #define MAX_FILES 20
 static int opt_default(const char *opt, const char *arg);
 
 #define MAX_FILES 20


@@ -107,8 +116,7 @@ static int frame_bottomBand = 0;
 static int frame_leftBand  = 0;
 static int frame_rightBand = 0;
 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 static int frame_leftBand  = 0;
 static int frame_rightBand = 0;
 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};

-static int frame_rate = 25;
-static int frame_rate_base = 1;
+static AVRational frame_rate = (AVRational) {25,1};

 static float video_qscale = 0;
 static int video_qdiff = 3;
 static uint16_t *intra_matrix = NULL;
 static float video_qscale = 0;
 static int video_qdiff = 3;
 static uint16_t *intra_matrix = NULL;


@@ -120,14 +128,12 @@ static int video_rc_qmod_freq=0;
 #endif
 static char *video_rc_override_string=NULL;
 static char *video_rc_eq="tex^qComp";
 #endif
 static char *video_rc_override_string=NULL;
 static char *video_rc_eq="tex^qComp";

-static int me_method = ME_EPZS;

 static int video_disable = 0;
 static int video_discard = 0;
 static int video_disable = 0;
 static int video_discard = 0;

-static int video_codec_id = CODEC_ID_NONE;
+static char *video_codec_name = NULL;

 static int video_codec_tag = 0;
 static int same_quality = 0;
 static int do_deinterlace = 0;
 static int video_codec_tag = 0;
 static int same_quality = 0;
 static int do_deinterlace = 0;

-static int packet_size = 0;

 static int strict = 0;
 static int top_field_first = -1;
 static int me_threshold = 0;
 static int strict = 0;
 static int top_field_first = -1;
 static int me_threshold = 0;


@@ -138,16 +144,16 @@ static int qp_hist = 0;
 
 static int intra_only = 0;
 static int audio_sample_rate = 44100;
 
 static int intra_only = 0;
 static int audio_sample_rate = 44100;

-static int audio_bit_rate = 64000;

 #define QSCALE_NONE -99999
 static float audio_qscale = QSCALE_NONE;
 static int audio_disable = 0;
 static int audio_channels = 1;
 #define QSCALE_NONE -99999
 static float audio_qscale = QSCALE_NONE;
 static int audio_disable = 0;
 static int audio_channels = 1;

-static int audio_codec_id = CODEC_ID_NONE;
+static char  *audio_codec_name = NULL;

 static int audio_codec_tag = 0;
 static char *audio_language = NULL;
 
 static int audio_codec_tag = 0;
 static char *audio_language = NULL;
 

-static int subtitle_codec_id = CODEC_ID_NONE;
+static int subtitle_disable = 0;
+static char *subtitle_codec_name = NULL;

 static char *subtitle_language = NULL;
 
 static float mux_preload= 0.5;
 static char *subtitle_language = NULL;
 
 static float mux_preload= 0.5;


@@ -167,7 +173,6 @@ static int do_benchmark = 0;
 static int do_hex_dump = 0;
 static int do_pkt_dump = 0;
 static int do_psnr = 0;
 static int do_hex_dump = 0;
 static int do_pkt_dump = 0;
 static int do_psnr = 0;

-static int do_vstats = 0;

 static int do_pass = 0;
 static char *pass_logfilename = NULL;
 static int audio_stream_copy = 0;
 static int do_pass = 0;
 static char *pass_logfilename = NULL;
 static int audio_stream_copy = 0;


@@ -175,28 +180,19 @@ static int video_stream_copy = 0;
 static int subtitle_stream_copy = 0;
 static int video_sync_method= 1;
 static int audio_sync_method= 0;
 static int subtitle_stream_copy = 0;
 static int video_sync_method= 1;
 static int audio_sync_method= 0;

+static float audio_drift_threshold= 0.1;

 static int copy_ts= 0;
 static int opt_shortest = 0; //
 static int video_global_header = 0;
 static int copy_ts= 0;
 static int opt_shortest = 0; //
 static int video_global_header = 0;

+static char *vstats_filename;
+static FILE *vstats_file;
+static int opt_programid = 0;

 
 static int rate_emu = 0;
 
 
 static int rate_emu = 0;
 

-#ifdef CONFIG_BKTR
-static const char *video_grab_format = "bktr";
-#else
-#ifdef CONFIG_VIDEO4LINUX2
-static const char *video_grab_format = "video4linux2";
-#else
-static const char *video_grab_format = "video4linux";
-#endif
-#endif
-static char *video_device = NULL;
-static char *grab_device = NULL;

 static int  video_channel = 0;
 static int  video_channel = 0;

-static char *video_standard = "ntsc";
+static char *video_standard;

 
 

-static const char *audio_grab_format = "audio_device";
-static char *audio_device = NULL;

 static int audio_volume = 256;
 
 static int using_stdin = 0;
 static int audio_volume = 256;
 
 static int using_stdin = 0;


@@ -210,17 +206,19 @@ static int64_t extra_size = 0;
 static int nb_frames_dup = 0;
 static int nb_frames_drop = 0;
 static int input_sync;
 static int nb_frames_dup = 0;
 static int nb_frames_drop = 0;
 static int input_sync;

-static int limit_filesize = 0; //
+static uint64_t limit_filesize = 0; //

 
 static int pgmyuv_compatibility_hack=0;
 
 static int pgmyuv_compatibility_hack=0;

-static int dts_delta_threshold = 10;
+static float dts_delta_threshold = 10;

 
 static int sws_flags = SWS_BICUBIC;
 
 
 static int sws_flags = SWS_BICUBIC;
 

-const char **opt_names=NULL;
-int opt_name_count=0;
-AVCodecContext *avctx_opts;
-AVFormatContext *avformat_opts;
+static const char **opt_names;
+static int opt_name_count;
+static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
+static AVFormatContext *avformat_opts;
+static struct SwsContext *sws_opts;
+static int64_t timer_start;

 
 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
 
 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;


@@ -285,12 +283,10 @@ typedef struct AVInputFile {
     int eof_reached;      /* true if eof reached */
     int ist_index;        /* index of first stream in ist_table */
     int buffer_size;      /* current total buffer size */
     int eof_reached;      /* true if eof reached */
     int ist_index;        /* index of first stream in ist_table */
     int buffer_size;      /* current total buffer size */

-    int buffer_size_max;  /* buffer size at which we consider we can stop
-                             buffering */

     int nb_streams;       /* nb streams we are aware of */
 } AVInputFile;
 
     int nb_streams;       /* nb streams we are aware of */
 } AVInputFile;
 

-#ifndef __MINGW32__
+#ifdef HAVE_TERMIOS_H

 
 /* init terminal so that we can grab keys */
 static struct termios oldtty;
 
 /* init terminal so that we can grab keys */
 static struct termios oldtty;


@@ -298,7 +294,7 @@ static struct termios oldtty;
 
 static void term_exit(void)
 {
 
 static void term_exit(void)
 {

-#ifndef __MINGW32__
+#ifdef HAVE_TERMIOS_H

     tcsetattr (0, TCSANOW, &oldtty);
 #endif
 }
     tcsetattr (0, TCSANOW, &oldtty);
 #endif
 }


@@ -314,7 +310,7 @@ sigterm_handler(int sig)
 
 static void term_init(void)
 {
 
 static void term_init(void)
 {

-#ifndef __MINGW32__
+#ifdef HAVE_TERMIOS_H

     struct termios tty;
 
     tcgetattr (0, &tty);
     struct termios tty;
 
     tcgetattr (0, &tty);


@@ -347,10 +343,7 @@ static void term_init(void)
 /* read a key without blocking */
 static int read_key(void)
 {
 /* read a key without blocking */
 static int read_key(void)
 {

-#ifdef __MINGW32__
-    if(kbhit())
-        return(getch());
-#else
+#if defined(HAVE_TERMIOS_H)

     int n = 1;
     unsigned char ch;
 #ifndef CONFIG_BEOS_NETSERVER
     int n = 1;
     unsigned char ch;
 #ifndef CONFIG_BEOS_NETSERVER


@@ -370,6 +363,9 @@ static int read_key(void)
 
         return n;
     }
 
         return n;
     }

+#elif defined(HAVE_CONIO_H)
+    if(kbhit())
+        return(getch());

 #endif
     return -1;
 }
 #endif
     return -1;
 }


@@ -408,10 +404,12 @@ static double
 get_sync_ipts(const AVOutputStream *ost)
 {
     const AVInputStream *ist = ost->sync_ist;
 get_sync_ipts(const AVOutputStream *ost)
 {
     const AVInputStream *ist = ost->sync_ist;

-    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
+    return (double)(ist->pts - start_time)/AV_TIME_BASE;

 }
 
 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
 }
 
 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){

+    int ret;
+

     while(bsfc){
         AVPacket new_pkt= *pkt;
         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
     while(bsfc){
         AVPacket new_pkt= *pkt;
         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,


@@ -427,7 +425,11 @@ static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx
         bsfc= bsfc->next;
     }
 
         bsfc= bsfc->next;
     }
 

-    av_interleaved_write_frame(s, pkt);
+    ret= av_interleaved_write_frame(s, pkt);
+    if(ret < 0){
+        print_error("av_interleaved_write_frame()", ret);
+        exit(1);
+    }

 }
 
 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
 }
 
 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)


@@ -461,7 +463,7 @@ static void do_audio_out(AVFormatContext *s,
 
         //FIXME resample delay
         if(fabs(delta) > 50){
 
         //FIXME resample delay
         if(fabs(delta) > 50){

-            if(ist->is_start){
+            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){

                 if(byte_delta < 0){
                     byte_delta= FFMAX(byte_delta, -size);
                     size += byte_delta;
                 if(byte_delta < 0){
                     byte_delta= FFMAX(byte_delta, -size);
                     size += byte_delta;


@@ -488,7 +490,7 @@ static void do_audio_out(AVFormatContext *s,
                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
                 }
             }else if(audio_sync_method>1){
                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
                 }
             }else if(audio_sync_method>1){

-                int comp= clip(delta, -audio_sync_method, audio_sync_method);
+                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);

                 assert(ost->audio_resample);
                 if(verbose > 2)
                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
                 assert(ost->audio_resample);
                 if(verbose > 2)
                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);


@@ -610,13 +612,15 @@ static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void
                 picture2 = picture;
             }
         } else {
                 picture2 = picture;
             }
         } else {

-            img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
+            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);

         }
     } else {
         picture2 = picture;
     }
 
         }
     } else {
         picture2 = picture;
     }
 

-    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
+    if (ENABLE_VHOOK)
+        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
+                           1000000 * ist->pts / AV_TIME_BASE);

 
     if (picture != picture2)
         *picture = *picture2;
 
     if (picture != picture2)
         *picture = *picture2;


@@ -665,7 +669,7 @@ static void do_subtitle_out(AVFormatContext *s,
         pkt.stream_index = ost->index;
         pkt.data = subtitle_out;
         pkt.size = subtitle_out_size;
         pkt.stream_index = ost->index;
         pkt.data = subtitle_out;
         pkt.size = subtitle_out_size;

-        pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
+        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);

         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
             /* XXX: the pts correction is handled here. Maybe handling
                it in the codec would be better */
         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
             /* XXX: the pts correction is handled here. Maybe handling
                it in the codec would be better */


@@ -690,7 +694,6 @@ static void do_video_out(AVFormatContext *s,
     int nb_frames, i, ret;
     AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
     AVFrame picture_crop_temp, picture_pad_temp;
     int nb_frames, i, ret;
     AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
     AVFrame picture_crop_temp, picture_pad_temp;

-    uint8_t *buf = NULL, *buf1 = NULL;

     AVCodecContext *enc, *dec;
 
     avcodec_get_frame_defaults(&picture_crop_temp);
     AVCodecContext *enc, *dec;
 
     avcodec_get_frame_defaults(&picture_crop_temp);


@@ -730,9 +733,9 @@ static void do_video_out(AVFormatContext *s,
         return;
 
     if (ost->video_crop) {
         return;
 
     if (ost->video_crop) {

-        if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
+        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {

             av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
             av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");

-            goto the_end;
+            return;

         }
         formatted_picture = &picture_crop_temp;
     } else {
         }
         formatted_picture = &picture_crop_temp;
     } else {


@@ -745,9 +748,9 @@ static void do_video_out(AVFormatContext *s,
     if (ost->video_pad) {
         final_picture = &ost->pict_tmp;
         if (ost->video_resample) {
     if (ost->video_pad) {
         final_picture = &ost->pict_tmp;
         if (ost->video_resample) {

-            if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
+            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {

                 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
                 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");

-                goto the_end;
+                return;

             }
             resampling_dst = &picture_pad_temp;
         }
             }
             resampling_dst = &picture_pad_temp;
         }


@@ -761,7 +764,7 @@ static void do_video_out(AVFormatContext *s,
     }
 
     if (ost->video_pad) {
     }
 
     if (ost->video_pad) {

-        img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
+        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,

                 enc->height, enc->width, enc->pix_fmt,
                 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
     }
                 enc->height, enc->width, enc->pix_fmt,
                 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
     }


@@ -794,7 +797,7 @@ static void do_video_out(AVFormatContext *s,
             /* better than nothing: use input picture interlaced
                settings */
             big_picture.interlaced_frame = in_picture->interlaced_frame;
             /* better than nothing: use input picture interlaced
                settings */
             big_picture.interlaced_frame = in_picture->interlaced_frame;

-            if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
+            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){

                 if(top_field_first == -1)
                     big_picture.top_field_first = in_picture->top_field_first;
                 else
                 if(top_field_first == -1)
                     big_picture.top_field_first = in_picture->top_field_first;
                 else


@@ -846,9 +849,6 @@ static void do_video_out(AVFormatContext *s,
         ost->sync_opts++;
         ost->frame_number++;
     }
         ost->sync_opts++;
         ost->frame_number++;
     }

- the_end:
-    av_free(buf);
-    av_free(buf1);

 }
 
 static double psnr(double d){
 }
 
 static double psnr(double d){


@@ -859,37 +859,27 @@ static double psnr(double d){
 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
                            int frame_size)
 {
 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
                            int frame_size)
 {

-    static FILE *fvstats=NULL;
-    char filename[40];
-    time_t today2;
-    struct tm *today;

     AVCodecContext *enc;
     int frame_number;
     AVCodecContext *enc;
     int frame_number;

-    int64_t ti;

     double ti1, bitrate, avg_bitrate;
 
     double ti1, bitrate, avg_bitrate;
 

-    if (!fvstats) {
-        today2 = time(NULL);
-        today = localtime(&today2);
-        snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
-                                               today->tm_min,
-                                               today->tm_sec);
-        fvstats = fopen(filename,"w");
-        if (!fvstats) {
+    /* this is executed just the first time do_video_stats is called */
+    if (!vstats_file) {
+        vstats_file = fopen(vstats_filename, "w");
+        if (!vstats_file) {

             perror("fopen");
             exit(1);
         }
     }
 
             perror("fopen");
             exit(1);
         }
     }
 

-    ti = INT64_MAX;

     enc = ost->st->codec;
     if (enc->codec_type == CODEC_TYPE_VIDEO) {
         frame_number = ost->frame_number;
     enc = ost->st->codec;
     if (enc->codec_type == CODEC_TYPE_VIDEO) {
         frame_number = ost->frame_number;

-        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
+        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);

         if (enc->flags&CODEC_FLAG_PSNR)
         if (enc->flags&CODEC_FLAG_PSNR)

-            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
+            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));

 
 

-        fprintf(fvstats,"f_size= %6d ", frame_size);
+        fprintf(vstats_file,"f_size= %6d ", frame_size);

         /* compute pts value */
         ti1 = ost->sync_opts * av_q2d(enc->time_base);
         if (ti1 < 0.01)
         /* compute pts value */
         ti1 = ost->sync_opts * av_q2d(enc->time_base);
         if (ti1 < 0.01)


@@ -897,9 +887,9 @@ static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
 
         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
 
         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;

-        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
+        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",

             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
             (double)video_size / 1024, ti1, bitrate, avg_bitrate);

-        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
+        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));

     }
 }
 
     }
 }
 


@@ -933,7 +923,9 @@ static void print_report(AVFormatContext **output_files,
 
     oc = output_files[0];
 
 
     oc = output_files[0];
 

-    total_size = url_ftell(&oc->pb);
+    total_size = url_fsize(&oc->pb);
+    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
+        total_size= url_ftell(&oc->pb);

 
     buf[0] = '\0';
     ti1 = 1e10;
 
     buf[0] = '\0';
     ti1 = 1e10;


@@ -947,9 +939,12 @@ static void print_report(AVFormatContext **output_files,
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA);
         }
         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA);
         }
         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {

+            float t = (av_gettime()-timer_start) / 1000000.0;
+

             frame_number = ost->frame_number;
             frame_number = ost->frame_number;

-            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
-                    frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
+            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
+                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
+                     enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);

             if(is_last_report)
                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
             if(qp_hist && enc->coded_frame){
             if(is_last_report)
                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
             if(qp_hist && enc->coded_frame){


@@ -984,7 +979,7 @@ static void print_report(AVFormatContext **output_files,
             vid = 1;
         }
         /* compute min output value */
             vid = 1;
         }
         /* compute min output value */

-        pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
+        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);

         if ((pts < ti1) && (pts > 0))
             ti1 = pts;
     }
         if ((pts < ti1) && (pts > 0))
             ti1 = pts;
     }


@@ -1065,10 +1060,11 @@ static int output_packet(AVInputStream *ist, int ist_index,
             switch(ist->st->codec->codec_type) {
             case CODEC_TYPE_AUDIO:{
                 if(pkt)
             switch(ist->st->codec->codec_type) {
             case CODEC_TYPE_AUDIO:{
                 if(pkt)

-                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
+                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
+                data_size= samples_size;

                     /* XXX: could avoid copy if PCM 16 bits with same
                        endianness as CPU */
                     /* XXX: could avoid copy if PCM 16 bits with same
                        endianness as CPU */

-                ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
+                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,

                                            ptr, len);
                 if (ret < 0)
                     goto fail_decode;
                                            ptr, len);
                 if (ret < 0)
                     goto fail_decode;


@@ -1120,165 +1116,166 @@ static int output_packet(AVInputStream *ist, int ist_index,
                 goto fail_decode;
             }
         } else {
                 goto fail_decode;
             }
         } else {

-                switch(ist->st->codec->codec_type) {
-                case CODEC_TYPE_AUDIO:
-                    ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
-                        (ist->st->codec->sample_rate * ist->st->codec->channels);
-                    break;
-                case CODEC_TYPE_VIDEO:
-                    if (ist->st->codec->time_base.num != 0) {
-                        ist->next_pts += ((int64_t)AV_TIME_BASE *
-                                          ist->st->codec->time_base.num) /
-                            ist->st->codec->time_base.den;
-                    }
-                    break;
+            switch(ist->st->codec->codec_type) {
+            case CODEC_TYPE_AUDIO:
+                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
+                    (ist->st->codec->sample_rate * ist->st->codec->channels);
+                break;
+            case CODEC_TYPE_VIDEO:
+                if (ist->st->codec->time_base.num != 0) {
+                    ist->next_pts += ((int64_t)AV_TIME_BASE *
+                                      ist->st->codec->time_base.num) /
+                        ist->st->codec->time_base.den;

                 }
                 }

-                data_buf = ptr;
-                data_size = len;
-                ret = len;
-                len = 0;
-            }
-
-            buffer_to_free = NULL;
-            if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
-                pre_process_video_frame(ist, (AVPicture *)&picture,
-                                        &buffer_to_free);
+                break;

             }
             }

-
-            // preprocess audio (volume)
-            if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
-                if (audio_volume != 256) {
-                    short *volp;
-                    volp = samples;
-                    for(i=0;i<(data_size / sizeof(short));i++) {
-                        int v = ((*volp) * audio_volume + 128) >> 8;
-                        if (v < -32768) v = -32768;
-                        if (v >  32767) v = 32767;
-                        *volp++ = v;
-                    }
+            data_buf = ptr;
+            data_size = len;
+            ret = len;
+            len = 0;
+        }
+
+        buffer_to_free = NULL;
+        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
+            pre_process_video_frame(ist, (AVPicture *)&picture,
+                                    &buffer_to_free);
+        }
+
+        // preprocess audio (volume)
+        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
+            if (audio_volume != 256) {
+                short *volp;
+                volp = samples;
+                for(i=0;i<(data_size / sizeof(short));i++) {
+                    int v = ((*volp) * audio_volume + 128) >> 8;
+                    if (v < -32768) v = -32768;
+                    if (v >  32767) v = 32767;
+                    *volp++ = v;

                 }
             }
                 }
             }

+        }

 
 

-            /* frame rate emulation */
-            if (ist->st->codec->rate_emu) {
-                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
-                int64_t now = av_gettime() - ist->start;
-                if (pts > now)
-                    usleep(pts - now);
+        /* frame rate emulation */
+        if (ist->st->codec->rate_emu) {
+            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
+            int64_t now = av_gettime() - ist->start;
+            if (pts > now)
+                usleep(pts - now);

 
 

-                ist->frame++;
-            }
+            ist->frame++;
+        }

 
 #if 0
 
 #if 0

-            /* mpeg PTS deordering : if it is a P or I frame, the PTS
-               is the one of the next displayed one */
-            /* XXX: add mpeg4 too ? */
-            if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
-                if (ist->st->codec->pict_type != B_TYPE) {
-                    int64_t tmp;
-                    tmp = ist->last_ip_pts;
-                    ist->last_ip_pts  = ist->frac_pts.val;
-                    ist->frac_pts.val = tmp;
-                }
+        /* mpeg PTS deordering : if it is a P or I frame, the PTS
+           is the one of the next displayed one */
+        /* XXX: add mpeg4 too ? */
+        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
+            if (ist->st->codec->pict_type != B_TYPE) {
+                int64_t tmp;
+                tmp = ist->last_ip_pts;
+                ist->last_ip_pts  = ist->frac_pts.val;
+                ist->frac_pts.val = tmp;

             }
             }

+        }

 #endif
 #endif

-            /* if output time reached then transcode raw format,
-               encode packets and output them */
-            if (start_time == 0 || ist->pts >= start_time)
-                for(i=0;i<nb_ostreams;i++) {
-                    int frame_size;
+        /* if output time reached then transcode raw format,
+           encode packets and output them */
+        if (start_time == 0 || ist->pts >= start_time)
+            for(i=0;i<nb_ostreams;i++) {
+                int frame_size;

 
 

-                    ost = ost_table[i];
-                    if (ost->source_index == ist_index) {
-                        os = output_files[ost->file_index];
+                ost = ost_table[i];
+                if (ost->source_index == ist_index) {
+                    os = output_files[ost->file_index];

 
 #if 0
 
 #if 0

-                        printf("%d: got pts=%0.3f %0.3f\n", i,
-                               (double)pkt->pts / AV_TIME_BASE,
-                               ((double)ist->pts / AV_TIME_BASE) -
-                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
+                    printf("%d: got pts=%0.3f %0.3f\n", i,
+                           (double)pkt->pts / AV_TIME_BASE,
+                           ((double)ist->pts / AV_TIME_BASE) -
+                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));

 #endif
 #endif

-                        /* set the input output pts pairs */
-                        //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
-
-                        if (ost->encoding_needed) {
-                            switch(ost->st->codec->codec_type) {
-                            case CODEC_TYPE_AUDIO:
-                                do_audio_out(os, ost, ist, data_buf, data_size);
-                                break;
-                            case CODEC_TYPE_VIDEO:
-                                    do_video_out(os, ost, ist, &picture, &frame_size);
-                                    video_size += frame_size;
-                                    if (do_vstats && frame_size)
-                                        do_video_stats(os, ost, frame_size);
-                                break;
-                            case CODEC_TYPE_SUBTITLE:
-                                do_subtitle_out(os, ost, ist, &subtitle,
-                                                pkt->pts);
-                                break;
-                            default:
-                                av_abort();
-                            }
-                        } else {
-                            AVFrame avframe; //FIXME/XXX remove this
-                            AVPacket opkt;
-                            av_init_packet(&opkt);
-
-                            /* no reencoding needed : output the packet directly */
-                            /* force the input stream PTS */
-
-                            avcodec_get_frame_defaults(&avframe);
-                            ost->st->codec->coded_frame= &avframe;
-                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
-
-                            if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
-                                audio_size += data_size;
-                            else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
-                                video_size += data_size;
-                                ost->sync_opts++;
-                            }
+                    /* set the input output pts pairs */
+                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;

 
 

-                            opkt.stream_index= ost->index;
-                            if(pkt->pts != AV_NOPTS_VALUE)
-                                opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
-                            else
-                                opkt.pts= AV_NOPTS_VALUE;
-
-                            {
-                                int64_t dts;
-                                if (pkt->dts == AV_NOPTS_VALUE)
-                                    dts = ist->next_pts;
-                                else
-                                    dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
-                                opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
-                            }
-                            opkt.flags= pkt->flags;
+                    if (ost->encoding_needed) {
+                        switch(ost->st->codec->codec_type) {
+                        case CODEC_TYPE_AUDIO:
+                            do_audio_out(os, ost, ist, data_buf, data_size);
+                            break;
+                        case CODEC_TYPE_VIDEO:
+                            do_video_out(os, ost, ist, &picture, &frame_size);
+                            video_size += frame_size;
+                            if (vstats_filename && frame_size)
+                                do_video_stats(os, ost, frame_size);
+                            break;
+                        case CODEC_TYPE_SUBTITLE:
+                            do_subtitle_out(os, ost, ist, &subtitle,
+                                            pkt->pts);
+                            break;
+                        default:
+                            abort();
+                        }
+                    } else {
+                        AVFrame avframe; //FIXME/XXX remove this
+                        AVPacket opkt;
+                        av_init_packet(&opkt);

 
 

-                            //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
-                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
-                                opkt.destruct= av_destruct_packet;
+                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
+                            continue;

 
 

-                            write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
-                            ost->st->codec->frame_number++;
-                            ost->frame_number++;
-                            av_free_packet(&opkt);
+                        /* no reencoding needed : output the packet directly */
+                        /* force the input stream PTS */
+
+                        avcodec_get_frame_defaults(&avframe);
+                        ost->st->codec->coded_frame= &avframe;
+                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
+
+                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
+                            audio_size += data_size;
+                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
+                            video_size += data_size;
+                            ost->sync_opts++;

                         }
                         }

+
+                        opkt.stream_index= ost->index;
+                        if(pkt->pts != AV_NOPTS_VALUE)
+                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
+                        else
+                            opkt.pts= AV_NOPTS_VALUE;
+
+                            if (pkt->dts == AV_NOPTS_VALUE)
+                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
+                            else
+                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
+
+                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
+                        opkt.flags= pkt->flags;
+
+                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
+                        if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
+                            opkt.destruct= av_destruct_packet;
+
+                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
+                        ost->st->codec->frame_number++;
+                        ost->frame_number++;
+                        av_free_packet(&opkt);

                     }
                 }
                     }
                 }

-            av_free(buffer_to_free);
-            /* XXX: allocate the subtitles in the codec ? */
-            if (subtitle_to_free) {
-                if (subtitle_to_free->rects != NULL) {
-                    for (i = 0; i < subtitle_to_free->num_rects; i++) {
-                        av_free(subtitle_to_free->rects[i].bitmap);
-                        av_free(subtitle_to_free->rects[i].rgba_palette);
-                    }
-                    av_freep(&subtitle_to_free->rects);
+            }
+        av_free(buffer_to_free);
+        /* XXX: allocate the subtitles in the codec ? */
+        if (subtitle_to_free) {
+            if (subtitle_to_free->rects != NULL) {
+                for (i = 0; i < subtitle_to_free->num_rects; i++) {
+                    av_free(subtitle_to_free->rects[i].bitmap);
+                    av_free(subtitle_to_free->rects[i].rgba_palette);

                 }
                 }

-                subtitle_to_free->num_rects = 0;
-                subtitle_to_free = NULL;
+                av_freep(&subtitle_to_free->rects);

             }
             }

+            subtitle_to_free->num_rects = 0;
+            subtitle_to_free = NULL;

         }
         }

+    }

  discard_packet:
     if (pkt == NULL) {
         /* EOF handling */
  discard_packet:
     if (pkt == NULL) {
         /* EOF handling */


@@ -1351,6 +1348,39 @@ static int output_packet(AVInputStream *ist, int ist_index,
     return -1;
 }
 
     return -1;
 }
 

+static void print_sdp(AVFormatContext **avc, int n)
+{
+    char sdp[2048];
+
+    avf_sdp_create(avc, n, sdp, sizeof(sdp));
+    printf("SDP:\n%s\n", sdp);
+}
+
+static int stream_index_from_inputs(AVFormatContext **input_files,
+                                    int nb_input_files,
+                                    AVInputFile *file_table,
+                                    AVInputStream **ist_table,
+                                    enum CodecType type,
+                                    int programid)
+{
+    int p, q, z;
+    for(z=0; z<nb_input_files; z++) {
+        AVFormatContext *ic = input_files[z];
+        for(p=0; p<ic->nb_programs; p++) {
+            AVProgram *program = ic->programs[p];
+            if(program->id != programid)
+                continue;
+            for(q=0; q<program->nb_stream_indexes; q++) {
+                int sidx = program->stream_index[q];
+                int ris = file_table[z].ist_index + sidx;
+                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
+                    return ris;
+            }
+        }
+    }
+
+    return -1;
+}

 
 /*
  * The following code is the main loop of the file converter
 
 /*
  * The following code is the main loop of the file converter


@@ -1367,8 +1397,8 @@ static int av_encode(AVFormatContext **output_files,
     AVOutputStream *ost, **ost_table = NULL;
     AVInputStream *ist, **ist_table = NULL;
     AVInputFile *file_table;
     AVOutputStream *ost, **ost_table = NULL;
     AVInputStream *ist, **ist_table = NULL;
     AVInputFile *file_table;

-    AVFormatContext *stream_no_data;

     int key;
     int key;

+    int want_sdp = 1;

 
     file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
     if (!file_table)
 
     file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
     if (!file_table)


@@ -1478,25 +1508,36 @@ static int av_encode(AVFormatContext **output_files,
                 }
 
             } else {
                 }
 
             } else {

-                /* get corresponding input stream index : we select the first one with the right type */
-                found = 0;
-                for(j=0;j<nb_istreams;j++) {
-                    ist = ist_table[j];
-                    if (ist->discard &&
-                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
+                if(opt_programid) {
+                    found = 0;
+                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
+                    if(j != -1) {

                         ost->source_index = j;
                         found = 1;
                         ost->source_index = j;
                         found = 1;

-                        break;

                     }
                     }

-                }
-
-                if (!found) {
-                    /* try again and reuse existing stream */
+                } else {
+                    /* get corresponding input stream index : we select the first one with the right type */
+                    found = 0;

                     for(j=0;j<nb_istreams;j++) {
                         ist = ist_table[j];
                     for(j=0;j<nb_istreams;j++) {
                         ist = ist_table[j];

-                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
+                        if (ist->discard &&
+                            ist->st->codec->codec_type == ost->st->codec->codec_type) {

                             ost->source_index = j;
                             found = 1;
                             ost->source_index = j;
                             found = 1;

+                            break;
+                        }
+                    }
+                }
+
+                if (!found) {
+                    if(! opt_programid) {
+                        /* try again and reuse existing stream */
+                        for(j=0;j<nb_istreams;j++) {
+                            ist = ist_table[j];
+                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
+                                ost->source_index = j;
+                                found = 1;
+                            }

                         }
                     }
                     if (!found) {
                         }
                     }
                     if (!found) {


@@ -1517,16 +1558,28 @@ static int av_encode(AVFormatContext **output_files,
     /* for each output stream, we compute the right encoding parameters */
     for(i=0;i<nb_ostreams;i++) {
         ost = ost_table[i];
     /* for each output stream, we compute the right encoding parameters */
     for(i=0;i<nb_ostreams;i++) {
         ost = ost_table[i];

+        os = output_files[ost->file_index];

         ist = ist_table[ost->source_index];
 
         codec = ost->st->codec;
         icodec = ist->st->codec;
 
         ist = ist_table[ost->source_index];
 
         codec = ost->st->codec;
         icodec = ist->st->codec;
 

+        if (!ost->st->language[0])
+            av_strlcpy(ost->st->language, ist->st->language,
+                       sizeof(ost->st->language));
+

         if (ost->st->stream_copy) {
             /* if stream_copy is selected, no need to decode or encode */
             codec->codec_id = icodec->codec_id;
             codec->codec_type = icodec->codec_type;
         if (ost->st->stream_copy) {
             /* if stream_copy is selected, no need to decode or encode */
             codec->codec_id = icodec->codec_id;
             codec->codec_type = icodec->codec_type;

-            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
+
+            if(!codec->codec_tag){
+                if(   !os->oformat->codec_tag
+                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
+                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
+                    codec->codec_tag = icodec->codec_tag;
+            }
+

             codec->bit_rate = icodec->bit_rate;
             codec->extradata= icodec->extradata;
             codec->extradata_size= icodec->extradata_size;
             codec->bit_rate = icodec->bit_rate;
             codec->extradata= icodec->extradata;
             codec->extradata_size= icodec->extradata_size;


@@ -1540,8 +1593,14 @@ static int av_encode(AVFormatContext **output_files,
                 codec->channels = icodec->channels;
                 codec->frame_size = icodec->frame_size;
                 codec->block_align= icodec->block_align;
                 codec->channels = icodec->channels;
                 codec->frame_size = icodec->frame_size;
                 codec->block_align= icodec->block_align;

+                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
+                    codec->block_align= 0;

                 break;
             case CODEC_TYPE_VIDEO:
                 break;
             case CODEC_TYPE_VIDEO:

+                if(using_vhook) {
+                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
+                    exit(1);
+                }

                 codec->pix_fmt = icodec->pix_fmt;
                 codec->width = icodec->width;
                 codec->height = icodec->height;
                 codec->pix_fmt = icodec->pix_fmt;
                 codec->width = icodec->width;
                 codec->height = icodec->height;


@@ -1550,7 +1609,7 @@ static int av_encode(AVFormatContext **output_files,
             case CODEC_TYPE_SUBTITLE:
                 break;
             default:
             case CODEC_TYPE_SUBTITLE:
                 break;
             default:

-                av_abort();
+                abort();

             }
         } else {
             switch(codec->codec_type) {
             }
         } else {
             switch(codec->codec_type) {


@@ -1586,7 +1645,7 @@ static int av_encode(AVFormatContext **output_files,
                                                     codec->sample_rate, icodec->sample_rate);
                     if(!ost->resample){
                         printf("Can't resample.  Aborting.\n");
                                                     codec->sample_rate, icodec->sample_rate);
                     if(!ost->resample){
                         printf("Can't resample.  Aborting.\n");

-                        av_abort();
+                        abort();

                     }
                 }
                 ist->decoding_needed = 1;
                     }
                 }
                 ist->decoding_needed = 1;


@@ -1621,9 +1680,11 @@ static int av_encode(AVFormatContext **output_files,
                 if (ost->video_resample) {
                     avcodec_get_frame_defaults(&ost->pict_tmp);
                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
                 if (ost->video_resample) {
                     avcodec_get_frame_defaults(&ost->pict_tmp);
                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,

-                                         codec->width, codec->height ) )
-                        goto fail;
-
+                                         codec->width, codec->height ) ) {
+                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
+                        exit(1);
+                    }
+                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);

                     ost->img_resample_ctx = sws_getContext(
                             icodec->width - (frame_leftBand + frame_rightBand),
                             icodec->height - (frame_topBand + frame_bottomBand),
                     ost->img_resample_ctx = sws_getContext(
                             icodec->width - (frame_leftBand + frame_rightBand),
                             icodec->height - (frame_topBand + frame_bottomBand),


@@ -1646,7 +1707,7 @@ static int av_encode(AVFormatContext **output_files,
                 ist->decoding_needed = 1;
                 break;
             default:
                 ist->decoding_needed = 1;
                 break;
             default:

-                av_abort();
+                abort();

                 break;
             }
             /* two pass mode */
                 break;
             }
             /* two pass mode */


@@ -1770,19 +1831,13 @@ static int av_encode(AVFormatContext **output_files,
         ist = ist_table[i];
         is = input_files[ist->file_index];
         ist->pts = 0;
         ist = ist_table[i];
         is = input_files[ist->file_index];
         ist->pts = 0;

-        ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
-        if(ist->st->start_time == AV_NOPTS_VALUE)
-            ist->next_pts=0;
-        if(input_files_ts_offset[ist->file_index])
+        ist->next_pts=0;
+        if(   input_files_ts_offset[ist->file_index] != -is->start_time
+           && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))

             ist->next_pts= AV_NOPTS_VALUE;
         ist->is_start = 1;
     }
 
             ist->next_pts= AV_NOPTS_VALUE;
         ist->is_start = 1;
     }
 

-    /* compute buffer size max (should use a complete heuristic) */
-    for(i=0;i<nb_input_files;i++) {
-        file_table[i].buffer_size_max = 2048;
-    }
-

     /* set meta data information from input file if required */
     for (i=0;i<nb_meta_data_maps;i++) {
         AVFormatContext *out_file;
     /* set meta data information from input file if required */
     for (i=0;i<nb_meta_data_maps;i++) {
         AVFormatContext *out_file;


@@ -1792,12 +1847,12 @@ static int av_encode(AVFormatContext **output_files,
         int in_file_index = meta_data_maps[i].in_file;
         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
         int in_file_index = meta_data_maps[i].in_file;
         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);

-            ret = -EINVAL;
+            ret = AVERROR(EINVAL);

             goto fail;
         }
         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
             goto fail;
         }
         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);

-            ret = -EINVAL;
+            ret = AVERROR(EINVAL);

             goto fail;
         }
 
             goto fail;
         }
 


@@ -1819,9 +1874,15 @@ static int av_encode(AVFormatContext **output_files,
         os = output_files[i];
         if (av_write_header(os) < 0) {
             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
         os = output_files[i];
         if (av_write_header(os) < 0) {
             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);

-            ret = -EINVAL;
+            ret = AVERROR(EINVAL);

             goto fail;
         }
             goto fail;
         }

+        if (strcmp(output_files[i]->oformat->name, "rtp")) {
+            want_sdp = 0;
+        }
+    }
+    if (want_sdp) {
+        print_sdp(output_files, nb_output_files);

     }
 
     if ( !using_stdin && verbose >= 0) {
     }
 
     if ( !using_stdin && verbose >= 0) {


@@ -1830,8 +1891,8 @@ static int av_encode(AVFormatContext **output_files,
     }
     term_init();
 
     }
     term_init();
 

-    stream_no_data = 0;

     key = -1;
     key = -1;

+    timer_start = av_gettime();

 
     for(; received_sigterm == 0;) {
         int file_index, ist_index;
 
     for(; received_sigterm == 0;) {
         int file_index, ist_index;


@@ -1890,23 +1951,21 @@ static int av_encode(AVFormatContext **output_files,
             break;
 
         /* finish if limit size exhausted */
             break;
 
         /* finish if limit size exhausted */

-        if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
+        if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))

             break;
 
         /* read a frame from it and output it in the fifo */
         is = input_files[file_index];
         if (av_read_frame(is, &pkt) < 0) {
             file_table[file_index].eof_reached = 1;
             break;
 
         /* read a frame from it and output it in the fifo */
         is = input_files[file_index];
         if (av_read_frame(is, &pkt) < 0) {
             file_table[file_index].eof_reached = 1;

-            if (opt_shortest) break; else continue; //
+            if (opt_shortest)
+                break;
+            else
+                continue;

         }
 
         }
 

-        if (!pkt.size) {
-            stream_no_data = is;
-        } else {
-            stream_no_data = 0;
-        }

         if (do_pkt_dump) {
         if (do_pkt_dump) {

-            av_pkt_dump(stdout, &pkt, do_hex_dump);
+            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);

         }
         /* the following test is needed in case new streams appear
            dynamically in stream : we ignore them */
         }
         /* the following test is needed in case new streams appear
            dynamically in stream : we ignore them */


@@ -1917,18 +1976,22 @@ static int av_encode(AVFormatContext **output_files,
         if (ist->discard)
             goto discard_packet;
 
         if (ist->discard)
             goto discard_packet;
 

+        if (pkt.dts != AV_NOPTS_VALUE)
+            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
+        if (pkt.pts != AV_NOPTS_VALUE)
+            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
+

 //        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
 //        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {

-            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
-            if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
+            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
+            int64_t delta= pkt_dts - ist->next_pts;
+            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){

                 input_files_ts_offset[ist->file_index]-= delta;
                 if (verbose > 2)
                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
                 input_files_ts_offset[ist->file_index]-= delta;
                 if (verbose > 2)
                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);

-                for(i=0; i<file_table[file_index].nb_streams; i++){
-                    int index= file_table[file_index].ist_index + i;
-                    ist_table[index]->next_pts += delta;
-                    ist_table[index]->is_start=1;
-                }
+                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
+                if(pkt.pts != AV_NOPTS_VALUE)
+                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);

             }
         }
 
             }
         }
 


@@ -2022,7 +2085,7 @@ static int av_encode(AVFormatContext **output_files,
     }
     return ret;
  fail:
     }
     return ret;
  fail:

-    ret = -ENOMEM;
+    ret = AVERROR(ENOMEM);

     goto fail1;
 }
 
     goto fail1;
 }
 


@@ -2055,6 +2118,7 @@ static void opt_format(const char *arg)
         pgmyuv_compatibility_hack=1;
 //        opt_image_format(arg);
         arg = "image2";
         pgmyuv_compatibility_hack=1;
 //        opt_image_format(arg);
         arg = "image2";

+        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");

     }
 
     file_iformat = av_find_input_format(arg);
     }
 
     file_iformat = av_find_input_format(arg);


@@ -2083,17 +2147,27 @@ static void opt_me_threshold(const char *arg)
 static void opt_verbose(const char *arg)
 {
     verbose = atoi(arg);
 static void opt_verbose(const char *arg)
 {
     verbose = atoi(arg);

-    av_log_set_level(atoi(arg));
+    av_log_level = atoi(arg);

 }
 
 static void opt_frame_rate(const char *arg)
 {
 }
 
 static void opt_frame_rate(const char *arg)
 {

-    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
+    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {

         fprintf(stderr, "Incorrect frame rate\n");
         exit(1);
     }
 }
 
         fprintf(stderr, "Incorrect frame rate\n");
         exit(1);
     }
 }
 

+static void opt_bitrate(const char *opt, const char *arg)
+{
+    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
+
+    opt_default(opt, arg);
+
+    if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
+        fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
+}
+

 static void opt_frame_crop_top(const char *arg)
 {
     frame_topBand = atoi(arg);
 static void opt_frame_crop_top(const char *arg)
 {
     frame_topBand = atoi(arg);


@@ -2168,7 +2242,7 @@ static void opt_frame_crop_right(const char *arg)
 
 static void opt_frame_size(const char *arg)
 {
 
 static void opt_frame_size(const char *arg)
 {

-    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
+    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {

         fprintf(stderr, "Incorrect frame size\n");
         exit(1);
     }
         fprintf(stderr, "Incorrect frame size\n");
         exit(1);
     }


@@ -2264,10 +2338,24 @@ static void opt_frame_pad_right(const char *arg)
     }
 }
 
     }
 }
 

+void list_pix_fmts(void)
+{
+    int i;
+    char pix_fmt_str[128];
+    for (i=-1; i < PIX_FMT_NB; i++) {
+        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
+        fprintf(stdout, "%s\n", pix_fmt_str);
+    }
+}

 
 static void opt_frame_pix_fmt(const char *arg)
 {
 
 static void opt_frame_pix_fmt(const char *arg)
 {

-    frame_pix_fmt = avcodec_get_pix_fmt(arg);
+    if (strcmp(arg, "list"))
+        frame_pix_fmt = avcodec_get_pix_fmt(arg);
+    else {
+        list_pix_fmts();
+        exit(0);
+    }

 }
 
 static void opt_frame_aspect_ratio(const char *arg)
 }
 
 static void opt_frame_aspect_ratio(const char *arg)


@@ -2313,11 +2401,6 @@ static void opt_qdiff(const char *arg)
     }
 }
 
     }
 }
 

-static void opt_packet_size(const char *arg)
-{
-    packet_size= atoi(arg);
-}
-

 static void opt_strict(const char *arg)
 {
     strict= atoi(arg);
 static void opt_strict(const char *arg)
 {
     strict= atoi(arg);


@@ -2337,11 +2420,6 @@ static void opt_thread_count(const char *arg)
 #endif
 }
 
 #endif
 }
 

-static void opt_audio_bitrate(const char *arg)
-{
-    audio_bit_rate = atoi(arg) * 1000;
-}
-

 static void opt_audio_rate(const char *arg)
 {
     audio_sample_rate = atoi(arg);
 static void opt_audio_rate(const char *arg)
 {
     audio_sample_rate = atoi(arg);


@@ -2352,16 +2430,6 @@ static void opt_audio_channels(const char *arg)
     audio_channels = atoi(arg);
 }
 
     audio_channels = atoi(arg);
 }
 

-static void opt_video_device(const char *arg)
-{
-    video_device = av_strdup(arg);
-}
-
-static void opt_grab_device(const char *arg)
-{
-    grab_device = av_strdup(arg);
-}
-

 static void opt_video_channel(const char *arg)
 {
     video_channel = strtol(arg, NULL, 0);
 static void opt_video_channel(const char *arg)
 {
     video_channel = strtol(arg, NULL, 0);


@@ -2372,37 +2440,20 @@ static void opt_video_standard(const char *arg)
     video_standard = av_strdup(arg);
 }
 
     video_standard = av_strdup(arg);
 }
 

-static void opt_audio_device(const char *arg)
-{
-    audio_device = av_strdup(arg);
-}
-
-static void opt_codec(int *pstream_copy, int *pcodec_id,
+static void opt_codec(int *pstream_copy, char **pcodec_name,

                       int codec_type, const char *arg)
 {
                       int codec_type, const char *arg)
 {

-    AVCodec *p;
-
+    av_freep(pcodec_name);

     if (!strcmp(arg, "copy")) {
         *pstream_copy = 1;
     } else {
     if (!strcmp(arg, "copy")) {
         *pstream_copy = 1;
     } else {

-        p = first_avcodec;
-        while (p) {
-            if (!strcmp(p->name, arg) && p->type == codec_type)
-                break;
-            p = p->next;
-        }
-        if (p == NULL) {
-            fprintf(stderr, "Unknown codec '%s'\n", arg);
-            exit(1);
-        } else {
-            *pcodec_id = p->id;
-        }
+        *pcodec_name = av_strdup(arg);

     }
 }
 
 static void opt_audio_codec(const char *arg)
 {
     }
 }
 
 static void opt_audio_codec(const char *arg)
 {

-    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
+    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);

 }
 
 static void opt_audio_tag(const char *arg)
 }
 
 static void opt_audio_tag(const char *arg)


@@ -2423,6 +2474,7 @@ static void opt_video_tag(const char *arg)
         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
 }
 
         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
 }
 

+#ifdef CONFIG_VHOOK

 static void add_frame_hooker(const char *arg)
 {
     int argc = 0;
 static void add_frame_hooker(const char *arg)
 {
     int argc = 0;


@@ -2443,44 +2495,16 @@ static void add_frame_hooker(const char *arg)
         exit(1);
     }
 }
         exit(1);
     }
 }

-
-const char *motion_str[] = {
-    "zero",
-    "full",
-    "log",
-    "phods",
-    "epzs",
-    "x1",
-    "hex",
-    "umh",
-    "iter",
-    NULL,
-};
-
-static void opt_motion_estimation(const char *arg)
-{
-    const char **p;
-    p = motion_str;
-    for(;;) {
-        if (!*p) {
-            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
-            exit(1);
-        }
-        if (!strcmp(*p, arg))
-            break;
-        p++;
-    }
-    me_method = (p - motion_str) + 1;
-}
+#endif

 
 static void opt_video_codec(const char *arg)
 {
 
 static void opt_video_codec(const char *arg)
 {

-    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
+    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);

 }
 
 static void opt_subtitle_codec(const char *arg)
 {
 }
 
 static void opt_subtitle_codec(const char *arg)
 {

-    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
+    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);

 }
 
 static void opt_map(const char *arg)
 }
 
 static void opt_map(const char *arg)


@@ -2523,24 +2547,56 @@ static void opt_map_meta_data(const char *arg)
     m->in_file = strtol(p, (char **)&p, 0);
 }
 
     m->in_file = strtol(p, (char **)&p, 0);
 }
 

+static int64_t parse_time_or_die(const char *timestr, int is_duration)
+{
+    int64_t us = parse_date(timestr, is_duration);
+    if (us == INT64_MIN) {
+        fprintf(stderr, "Invalid %s specification: %s\n",
+                is_duration ? "duration" : "date", timestr);
+        exit(1);
+    }
+    return us;
+}
+

 static void opt_recording_time(const char *arg)
 {
 static void opt_recording_time(const char *arg)
 {

-    recording_time = parse_date(arg, 1);
+    recording_time = parse_time_or_die(arg, 1);

 }
 
 static void opt_start_time(const char *arg)
 {
 }
 
 static void opt_start_time(const char *arg)
 {

-    start_time = parse_date(arg, 1);
+    start_time = parse_time_or_die(arg, 1);

 }
 
 static void opt_rec_timestamp(const char *arg)
 {
 }
 
 static void opt_rec_timestamp(const char *arg)
 {

-    rec_timestamp = parse_date(arg, 0) / 1000000;
+    rec_timestamp = parse_time_or_die(arg, 0) / 1000000;

 }
 
 static void opt_input_ts_offset(const char *arg)
 {
 }
 
 static void opt_input_ts_offset(const char *arg)
 {

-    input_ts_offset = parse_date(arg, 1);
+    input_ts_offset = parse_time_or_die(arg, 1);
+}
+
+static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
+{
+    char *codec_string = encoder ? "encoder" : "decoder";
+    AVCodec *codec;
+
+    if(!name)
+        return CODEC_ID_NONE;
+    codec = encoder ?
+        avcodec_find_encoder_by_name(name) :
+        avcodec_find_decoder_by_name(name);
+    if(!codec) {
+        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
+        exit(1);
+    }
+    if(codec->type != type) {
+        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
+        exit(1);
+    }
+    return codec->id;

 }
 
 static void opt_input_file(const char *filename)
 }
 
 static void opt_input_file(const char *filename)


@@ -2563,23 +2619,22 @@ static void opt_input_file(const char *filename)
     ap->prealloced_context = 1;
     ap->sample_rate = audio_sample_rate;
     ap->channels = audio_channels;
     ap->prealloced_context = 1;
     ap->sample_rate = audio_sample_rate;
     ap->channels = audio_channels;

-    ap->time_base.den = frame_rate;
-    ap->time_base.num = frame_rate_base;
+    ap->time_base.den = frame_rate.num;
+    ap->time_base.num = frame_rate.den;

     ap->width = frame_width + frame_padleft + frame_padright;
     ap->height = frame_height + frame_padtop + frame_padbottom;
     ap->pix_fmt = frame_pix_fmt;
     ap->width = frame_width + frame_padleft + frame_padright;
     ap->height = frame_height + frame_padtop + frame_padbottom;
     ap->pix_fmt = frame_pix_fmt;

-    ap->device  = grab_device;

     ap->channel = video_channel;
     ap->standard = video_standard;
     ap->channel = video_channel;
     ap->standard = video_standard;

-    ap->video_codec_id = video_codec_id;
-    ap->audio_codec_id = audio_codec_id;
+    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
+    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);

     if(pgmyuv_compatibility_hack)
         ap->video_codec_id= CODEC_ID_PGMYUV;
 
     for(i=0; i<opt_name_count; i++){
     if(pgmyuv_compatibility_hack)
         ap->video_codec_id= CODEC_ID_PGMYUV;
 
     for(i=0; i<opt_name_count; i++){

-        AVOption *opt;
+        const AVOption *opt;

         double d= av_get_double(avformat_opts, opt_names[i], &opt);
         double d= av_get_double(avformat_opts, opt_names[i], &opt);

-        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
+        if(!isnan(d) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))

             av_set_double(ic, opt_names[i], d);
     }
     /* open the input file with generic libav function */
             av_set_double(ic, opt_names[i], d);
     }
     /* open the input file with generic libav function */


@@ -2588,6 +2643,12 @@ static void opt_input_file(const char *filename)
         print_error(filename, err);
         exit(1);
     }
         print_error(filename, err);
         exit(1);
     }

+    if(opt_programid) {
+        int i;
+        for(i=0; i<ic->nb_programs; i++)
+            if(ic->programs[i]->id != opt_programid)
+                ic->programs[i]->discard = AVDISCARD_ALL;
+    }

 
     ic->loop_input = loop_input;
 
 
     ic->loop_input = loop_input;
 


@@ -2619,17 +2680,15 @@ static void opt_input_file(const char *filename)
     for(i=0;i<ic->nb_streams;i++) {
         int j;
         AVCodecContext *enc = ic->streams[i]->codec;
     for(i=0;i<ic->nb_streams;i++) {
         int j;
         AVCodecContext *enc = ic->streams[i]->codec;

-#if defined(HAVE_THREADS)

         if(thread_count>1)
             avcodec_thread_init(enc, thread_count);
         if(thread_count>1)
             avcodec_thread_init(enc, thread_count);

-#endif

         enc->thread_count= thread_count;
         switch(enc->codec_type) {
         case CODEC_TYPE_AUDIO:
             for(j=0; j<opt_name_count; j++){
         enc->thread_count= thread_count;
         switch(enc->codec_type) {
         case CODEC_TYPE_AUDIO:
             for(j=0; j<opt_name_count; j++){

-                AVOption *opt;
-                double d= av_get_double(avctx_opts, opt_names[j], &opt);
-                if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
+                const AVOption *opt;
+                double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
+                if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))

                     av_set_double(enc, opt_names[j], d);
             }
             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
                     av_set_double(enc, opt_names[j], d);
             }
             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);


@@ -2640,9 +2699,9 @@ static void opt_input_file(const char *filename)
             break;
         case CODEC_TYPE_VIDEO:
             for(j=0; j<opt_name_count; j++){
             break;
         case CODEC_TYPE_VIDEO:
             for(j=0; j<opt_name_count; j++){

-                AVOption *opt;
-                double d= av_get_double(avctx_opts, opt_names[j], &opt);
-                if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
+                const AVOption *opt;
+                double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
+                if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))

                     av_set_double(enc, opt_names[j], d);
             }
             frame_height = enc->height;
                     av_set_double(enc, opt_names[j], d);
             }
             frame_height = enc->height;


@@ -2664,8 +2723,8 @@ static void opt_input_file(const char *filename)
                     (float)rfps / rfps_base, rfps, rfps_base);
             }
             /* update the current frame rate to match the stream frame rate */
                     (float)rfps / rfps_base, rfps, rfps_base);
             }
             /* update the current frame rate to match the stream frame rate */

-            frame_rate      = rfps;
-            frame_rate_base = rfps_base;
+            frame_rate.num = rfps;
+            frame_rate.den = rfps_base;

 
             enc->rate_emu = rate_emu;
             if(video_disable)
 
             enc->rate_emu = rate_emu;
             if(video_disable)


@@ -2676,11 +2735,13 @@ static void opt_input_file(const char *filename)
         case CODEC_TYPE_DATA:
             break;
         case CODEC_TYPE_SUBTITLE:
         case CODEC_TYPE_DATA:
             break;
         case CODEC_TYPE_SUBTITLE:

+            if(subtitle_disable)
+                ic->streams[i]->discard = AVDISCARD_ALL;

             break;
         case CODEC_TYPE_UNKNOWN:
             break;
         default:
             break;
         case CODEC_TYPE_UNKNOWN:
             break;
         default:

-            av_abort();
+            abort();

         }
     }
 
         }
     }
 


@@ -2694,25 +2755,20 @@ static void opt_input_file(const char *filename)
     file_iformat = NULL;
     file_oformat = NULL;
 
     file_iformat = NULL;
     file_oformat = NULL;
 

-    grab_device = NULL;

     video_channel = 0;
 
     rate_emu = 0;
 }
 
     video_channel = 0;
 
     rate_emu = 0;
 }
 

-static void opt_grab(const char *arg)
+static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
+                                         int *has_subtitle_ptr)

 {
 {

-    file_iformat = av_find_input_format(arg);
-    opt_input_file("");
-}
-
-static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
-{
-    int has_video, has_audio, i, j;
+    int has_video, has_audio, has_subtitle, i, j;

     AVFormatContext *ic;
 
     has_video = 0;
     has_audio = 0;
     AVFormatContext *ic;
 
     has_video = 0;
     has_audio = 0;

+    has_subtitle = 0;

     for(j=0;j<nb_input_files;j++) {
         ic = input_files[j];
         for(i=0;i<ic->nb_streams;i++) {
     for(j=0;j<nb_input_files;j++) {
         ic = input_files[j];
         for(i=0;i<ic->nb_streams;i++) {


@@ -2724,17 +2780,20 @@ static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
             case CODEC_TYPE_VIDEO:
                 has_video = 1;
                 break;
             case CODEC_TYPE_VIDEO:
                 has_video = 1;
                 break;

+            case CODEC_TYPE_SUBTITLE:
+                has_subtitle = 1;
+                break;

             case CODEC_TYPE_DATA:
             case CODEC_TYPE_UNKNOWN:
             case CODEC_TYPE_DATA:
             case CODEC_TYPE_UNKNOWN:

-            case CODEC_TYPE_SUBTITLE:

                 break;
             default:
                 break;
             default:

-                av_abort();
+                abort();

             }
         }
     }
     *has_video_ptr = has_video;
     *has_audio_ptr = has_audio;
             }
         }
     }
     *has_video_ptr = has_video;
     *has_audio_ptr = has_audio;

+    *has_subtitle_ptr = has_subtitle;

 }
 
 static void new_video_stream(AVFormatContext *oc)
 }
 
 static void new_video_stream(AVFormatContext *oc)


@@ -2748,13 +2807,12 @@ static void new_video_stream(AVFormatContext *oc)
         fprintf(stderr, "Could not alloc stream\n");
         exit(1);
     }
         fprintf(stderr, "Could not alloc stream\n");
         exit(1);
     }

+    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);

     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
     video_bitstream_filters= NULL;
 
     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
     video_bitstream_filters= NULL;
 

-#if defined(HAVE_THREADS)

     if(thread_count>1)
         avcodec_thread_init(st->codec, thread_count);
     if(thread_count>1)
         avcodec_thread_init(st->codec, thread_count);

-#endif

 
     video_enc = st->codec;
 
 
     video_enc = st->codec;
 


@@ -2764,11 +2822,11 @@ static void new_video_stream(AVFormatContext *oc)
     if(   (video_global_header&1)
        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
     if(   (video_global_header&1)
        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;

-        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
+        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;

     }
     if(video_global_header&2){
         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
     }
     if(video_global_header&2){
         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;

-        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
+        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;

     }
 
     if (video_stream_copy) {
     }
 
     if (video_stream_copy) {


@@ -2780,24 +2838,24 @@ static void new_video_stream(AVFormatContext *oc)
         AVCodec *codec;
 
         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
         AVCodec *codec;
 
         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);

-        if (video_codec_id != CODEC_ID_NONE)
-            codec_id = video_codec_id;
+        if (video_codec_name)
+            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);

 
         video_enc->codec_id = codec_id;
         codec = avcodec_find_encoder(codec_id);
 
         for(i=0; i<opt_name_count; i++){
 
         video_enc->codec_id = codec_id;
         codec = avcodec_find_encoder(codec_id);
 
         for(i=0; i<opt_name_count; i++){

-             AVOption *opt;
-             double d= av_get_double(avctx_opts, opt_names[i], &opt);
-             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
+             const AVOption *opt;
+             double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
+             if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))

                  av_set_double(video_enc, opt_names[i], d);
         }
 
                  av_set_double(video_enc, opt_names[i], d);
         }
 

-        video_enc->time_base.den = frame_rate;
-        video_enc->time_base.num = frame_rate_base;
+        video_enc->time_base.den = frame_rate.num;
+        video_enc->time_base.num = frame_rate.den;

         if(codec && codec->supported_framerates){
             const AVRational *p= codec->supported_framerates;
         if(codec && codec->supported_framerates){
             const AVRational *p= codec->supported_framerates;

-            AVRational req= (AVRational){frame_rate, frame_rate_base};
+            AVRational req= (AVRational){frame_rate.num, frame_rate.den};

             const AVRational *best=NULL;
             AVRational best_error= (AVRational){INT_MAX, 1};
             for(; p->den!=0; p++){
             const AVRational *best=NULL;
             AVRational best_error= (AVRational){INT_MAX, 1};
             for(; p->den!=0; p++){


@@ -2868,21 +2926,15 @@ static void new_video_stream(AVFormatContext *oc)
             if(p) p++;
         }
         video_enc->rc_override_count=i;
             if(p) p++;
         }
         video_enc->rc_override_count=i;

-        video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
+        if (!video_enc->rc_initial_buffer_occupancy)
+            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;

         video_enc->me_threshold= me_threshold;
         video_enc->intra_dc_precision= intra_dc_precision - 8;
         video_enc->strict_std_compliance = strict;
 
         video_enc->me_threshold= me_threshold;
         video_enc->intra_dc_precision= intra_dc_precision - 8;
         video_enc->strict_std_compliance = strict;
 

-        if(packet_size){
-            video_enc->rtp_mode= 1;
-            video_enc->rtp_payload_size= packet_size;
-        }
-

         if (do_psnr)
             video_enc->flags|= CODEC_FLAG_PSNR;
 
         if (do_psnr)
             video_enc->flags|= CODEC_FLAG_PSNR;
 

-        video_enc->me_method = me_method;
-

         /* two pass mode */
         if (do_pass) {
             if (do_pass == 1) {
         /* two pass mode */
         if (do_pass) {
             if (do_pass == 1) {


@@ -2895,7 +2947,7 @@ static void new_video_stream(AVFormatContext *oc)
 
     /* reset some key parameters */
     video_disable = 0;
 
     /* reset some key parameters */
     video_disable = 0;

-    video_codec_id = CODEC_ID_NONE;
+    av_freep(&video_codec_name);

     video_stream_copy = 0;
 }
 
     video_stream_copy = 0;
 }
 


@@ -2910,14 +2962,13 @@ static void new_audio_stream(AVFormatContext *oc)
         fprintf(stderr, "Could not alloc stream\n");
         exit(1);
     }
         fprintf(stderr, "Could not alloc stream\n");
         exit(1);
     }

+    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);

 
     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
     audio_bitstream_filters= NULL;
 
 
     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
     audio_bitstream_filters= NULL;
 

-#if defined(HAVE_THREADS)

     if(thread_count>1)
         avcodec_thread_init(st->codec, thread_count);
     if(thread_count>1)
         avcodec_thread_init(st->codec, thread_count);

-#endif

 
     audio_enc = st->codec;
     audio_enc->codec_type = CODEC_TYPE_AUDIO;
 
     audio_enc = st->codec;
     audio_enc->codec_type = CODEC_TYPE_AUDIO;


@@ -2928,7 +2979,7 @@ static void new_audio_stream(AVFormatContext *oc)
 
     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
 
     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;

-        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
+        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;

     }
     if (audio_stream_copy) {
         st->stream_copy = 1;
     }
     if (audio_stream_copy) {
         st->stream_copy = 1;


@@ -2937,62 +2988,49 @@ static void new_audio_stream(AVFormatContext *oc)
         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
 
         for(i=0; i<opt_name_count; i++){
         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
 
         for(i=0; i<opt_name_count; i++){

-            AVOption *opt;
-            double d= av_get_double(avctx_opts, opt_names[i], &opt);
-            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
+            const AVOption *opt;
+            double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
+            if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))

                 av_set_double(audio_enc, opt_names[i], d);
         }
 
                 av_set_double(audio_enc, opt_names[i], d);
         }
 

-        if (audio_codec_id != CODEC_ID_NONE)
-            codec_id = audio_codec_id;
+        if (audio_codec_name)
+            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);

         audio_enc->codec_id = codec_id;
 
         audio_enc->codec_id = codec_id;
 

-        audio_enc->bit_rate = audio_bit_rate;

         if (audio_qscale > QSCALE_NONE) {
             audio_enc->flags |= CODEC_FLAG_QSCALE;
             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
         }
         audio_enc->thread_count = thread_count;
         if (audio_qscale > QSCALE_NONE) {
             audio_enc->flags |= CODEC_FLAG_QSCALE;
             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
         }
         audio_enc->thread_count = thread_count;

-        /* For audio codecs other than AC3 or DTS we limit */
-        /* the number of coded channels to stereo   */
-        if (audio_channels > 2 && codec_id != CODEC_ID_AC3
-            && codec_id != CODEC_ID_DTS) {
-            audio_enc->channels = 2;
-        } else
-            audio_enc->channels = audio_channels;
+        audio_enc->channels = audio_channels;

     }
     audio_enc->sample_rate = audio_sample_rate;
     audio_enc->time_base= (AVRational){1, audio_sample_rate};
     if (audio_language) {
     }
     audio_enc->sample_rate = audio_sample_rate;
     audio_enc->time_base= (AVRational){1, audio_sample_rate};
     if (audio_language) {

-        pstrcpy(st->language, sizeof(st->language), audio_language);
+        av_strlcpy(st->language, audio_language, sizeof(st->language));

         av_free(audio_language);
         audio_language = NULL;
     }
 
     /* reset some key parameters */
     audio_disable = 0;
         av_free(audio_language);
         audio_language = NULL;
     }
 
     /* reset some key parameters */
     audio_disable = 0;

-    audio_codec_id = CODEC_ID_NONE;
+    av_freep(&audio_codec_name);

     audio_stream_copy = 0;
 }
 
     audio_stream_copy = 0;
 }
 

-static void opt_new_subtitle_stream(void)
+static void new_subtitle_stream(AVFormatContext *oc)

 {
 {

-    AVFormatContext *oc;

     AVStream *st;
     AVCodecContext *subtitle_enc;
     int i;
 
     AVStream *st;
     AVCodecContext *subtitle_enc;
     int i;
 

-    if (nb_output_files <= 0) {
-        fprintf(stderr, "At least one output file must be specified\n");
-        exit(1);
-    }
-    oc = output_files[nb_output_files - 1];
-

     st = av_new_stream(oc, oc->nb_streams);
     if (!st) {
         fprintf(stderr, "Could not alloc stream\n");
         exit(1);
     }
     st = av_new_stream(oc, oc->nb_streams);
     if (!st) {
         fprintf(stderr, "Could not alloc stream\n");
         exit(1);
     }

+    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);

 
     subtitle_enc = st->codec;
     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
 
     subtitle_enc = st->codec;
     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;


@@ -3000,21 +3038,22 @@ static void opt_new_subtitle_stream(void)
         st->stream_copy = 1;
     } else {
         for(i=0; i<opt_name_count; i++){
         st->stream_copy = 1;
     } else {
         for(i=0; i<opt_name_count; i++){

-             AVOption *opt;
-             double d= av_get_double(avctx_opts, opt_names[i], &opt);
-             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
+             const AVOption *opt;
+             double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
+             if(!isnan(d) && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))

                  av_set_double(subtitle_enc, opt_names[i], d);
         }
                  av_set_double(subtitle_enc, opt_names[i], d);
         }

-        subtitle_enc->codec_id = subtitle_codec_id;
+        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);

     }
 
     if (subtitle_language) {
     }
 
     if (subtitle_language) {

-        pstrcpy(st->language, sizeof(st->language), subtitle_language);
+        av_strlcpy(st->language, subtitle_language, sizeof(st->language));

         av_free(subtitle_language);
         subtitle_language = NULL;
     }
 
         av_free(subtitle_language);
         subtitle_language = NULL;
     }
 

-    subtitle_codec_id = CODEC_ID_NONE;
+    subtitle_disable = 0;
+    av_freep(&subtitle_codec_name);

     subtitle_stream_copy = 0;
 }
 
     subtitle_stream_copy = 0;
 }
 


@@ -3040,10 +3079,22 @@ static void opt_new_video_stream(void)
     new_video_stream(oc);
 }
 
     new_video_stream(oc);
 }
 

+static void opt_new_subtitle_stream(void)
+{
+    AVFormatContext *oc;
+    if (nb_output_files <= 0) {
+        fprintf(stderr, "At least one output file must be specified\n");
+        exit(1);
+    }
+    oc = output_files[nb_output_files - 1];
+    new_subtitle_stream(oc);
+}
+

 static void opt_output_file(const char *filename)
 {
     AVFormatContext *oc;
 static void opt_output_file(const char *filename)
 {
     AVFormatContext *oc;

-    int use_video, use_audio, input_has_video, input_has_audio, i;
+    int use_video, use_audio, use_subtitle;
+    int input_has_video, input_has_audio, input_has_subtitle, i;

     AVFormatParameters params, *ap = &params;
 
     if (!strcmp(filename, "-"))
     AVFormatParameters params, *ap = &params;
 
     if (!strcmp(filename, "-"))


@@ -3054,17 +3105,17 @@ static void opt_output_file(const char *filename)
     if (!file_oformat) {
         file_oformat = guess_format(NULL, filename, NULL);
         if (!file_oformat) {
     if (!file_oformat) {
         file_oformat = guess_format(NULL, filename, NULL);
         if (!file_oformat) {

-            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
+            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",

                     filename);
             exit(1);
         }
     }
 
     oc->oformat = file_oformat;
                     filename);
             exit(1);
         }
     }
 
     oc->oformat = file_oformat;

-    pstrcpy(oc->filename, sizeof(oc->filename), filename);
+    av_strlcpy(oc->filename, filename, sizeof(oc->filename));

 
     if (!strcmp(file_oformat->name, "ffm") &&
 
     if (!strcmp(file_oformat->name, "ffm") &&

-        strstart(filename, "http:", NULL)) {
+        av_strstart(filename, "http:", NULL)) {

         /* special case for files sent to ffserver: we get the stream
            parameters from ffserver */
         if (read_ffserver_streams(oc, filename) < 0) {
         /* special case for files sent to ffserver: we get the stream
            parameters from ffserver */
         if (read_ffserver_streams(oc, filename) < 0) {


@@ -3072,17 +3123,21 @@ static void opt_output_file(const char *filename)
             exit(1);
         }
     } else {
             exit(1);
         }
     } else {

-        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
-        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
+        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
+        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
+        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;

 
         /* disable if no corresponding type found and at least one
            input file */
         if (nb_input_files > 0) {
 
         /* disable if no corresponding type found and at least one
            input file */
         if (nb_input_files > 0) {

-            check_audio_video_inputs(&input_has_video, &input_has_audio);
+            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
+                                         &input_has_subtitle);

             if (!input_has_video)
                 use_video = 0;
             if (!input_has_audio)
                 use_audio = 0;
             if (!input_has_video)
                 use_video = 0;
             if (!input_has_audio)
                 use_audio = 0;

+            if (!input_has_subtitle)
+                use_subtitle = 0;

         }
 
         /* manual disable */
         }
 
         /* manual disable */


@@ -3092,6 +3147,9 @@ static void opt_output_file(const char *filename)
         if (video_disable) {
             use_video = 0;
         }
         if (video_disable) {
             use_video = 0;
         }

+        if (subtitle_disable) {
+            use_subtitle = 0;
+        }

 
         if (use_video) {
             new_video_stream(oc);
 
         if (use_video) {
             new_video_stream(oc);


@@ -3101,18 +3159,22 @@ static void opt_output_file(const char *filename)
             new_audio_stream(oc);
         }
 
             new_audio_stream(oc);
         }
 

+        if (use_subtitle) {
+            new_subtitle_stream(oc);
+        }
+

         oc->timestamp = rec_timestamp;
 
         if (str_title)
         oc->timestamp = rec_timestamp;
 
         if (str_title)

-            pstrcpy(oc->title, sizeof(oc->title), str_title);
+            av_strlcpy(oc->title, str_title, sizeof(oc->title));

         if (str_author)
         if (str_author)

-            pstrcpy(oc->author, sizeof(oc->author), str_author);
+            av_strlcpy(oc->author, str_author, sizeof(oc->author));

         if (str_copyright)
         if (str_copyright)

-            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
+            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));

         if (str_comment)
         if (str_comment)

-            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
+            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));

         if (str_album)
         if (str_album)

-            pstrcpy(oc->album, sizeof(oc->album), str_album);
+            av_strlcpy(oc->album, str_album, sizeof(oc->album));

     }
 
     output_files[nb_output_files++] = oc;
     }
 
     output_files[nb_output_files++] = oc;


@@ -3129,7 +3191,7 @@ static void opt_output_file(const char *filename)
         /* test if it already exists to avoid loosing precious files */
         if (!file_overwrite &&
             (strchr(filename, ':') == NULL ||
         /* test if it already exists to avoid loosing precious files */
         if (!file_overwrite &&
             (strchr(filename, ':') == NULL ||

-             strstart(filename, "file:", NULL))) {
+             av_strstart(filename, "file:", NULL))) {

             if (url_exist(filename)) {
                 int c;
 
             if (url_exist(filename)) {
                 int c;
 


@@ -3168,9 +3230,9 @@ static void opt_output_file(const char *filename)
     oc->loop_output = loop_output;
 
     for(i=0; i<opt_name_count; i++){
     oc->loop_output = loop_output;
 
     for(i=0; i<opt_name_count; i++){

-        AVOption *opt;
+        const AVOption *opt;

         double d = av_get_double(avformat_opts, opt_names[i], &opt);
         double d = av_get_double(avformat_opts, opt_names[i], &opt);

-        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
+        if(!isnan(d) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))

             av_set_double(oc, opt_names[i], d);
     }
 
             av_set_double(oc, opt_names[i], d);
     }
 


@@ -3179,103 +3241,6 @@ static void opt_output_file(const char *filename)
     file_iformat = NULL;
 }
 
     file_iformat = NULL;
 }
 

-/* prepare dummy protocols for grab */
-static void prepare_grab(void)
-{
-    int has_video, has_audio, i, j;
-    AVFormatContext *oc;
-    AVFormatContext *ic;
-    AVFormatParameters vp1, *vp = &vp1;
-    AVFormatParameters ap1, *ap = &ap1;
-
-    /* see if audio/video inputs are needed */
-    has_video = 0;
-    has_audio = 0;
-    memset(ap, 0, sizeof(*ap));
-    memset(vp, 0, sizeof(*vp));
-    vp->time_base.num= 1;
-    for(j=0;j<nb_output_files;j++) {
-        oc = output_files[j];
-        for(i=0;i<oc->nb_streams;i++) {
-            AVCodecContext *enc = oc->streams[i]->codec;
-            switch(enc->codec_type) {
-            case CODEC_TYPE_AUDIO:
-                if (enc->sample_rate > ap->sample_rate)
-                    ap->sample_rate = enc->sample_rate;
-                if (enc->channels > ap->channels)
-                    ap->channels = enc->channels;
-                has_audio = 1;
-                break;
-            case CODEC_TYPE_VIDEO:
-                if (enc->width > vp->width)
-                    vp->width = enc->width;
-                if (enc->height > vp->height)
-                    vp->height = enc->height;
-
-                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
-                    vp->time_base = enc->time_base;
-                    vp->width += frame_leftBand + frame_rightBand;
-                    vp->width -= (frame_padleft + frame_padright);
-                    vp->height += frame_topBand + frame_bottomBand;
-                    vp->height -= (frame_padtop + frame_padbottom);
-                }
-                has_video = 1;
-                break;
-            default:
-                av_abort();
-            }
-        }
-    }
-
-    if (has_video == 0 && has_audio == 0) {
-        fprintf(stderr, "Output file must have at least one audio or video stream\n");
-        exit(1);
-    }
-
-    if (has_video) {
-        AVInputFormat *fmt1;
-        fmt1 = av_find_input_format(video_grab_format);
-        vp->device  = video_device;
-        vp->channel = video_channel;
-        vp->standard = video_standard;
-        vp->pix_fmt = frame_pix_fmt;
-        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
-            fprintf(stderr, "Could not find video grab device\n");
-            exit(1);
-        }
-        /* If not enough info to get the stream parameters, we decode the
-           first frames to get it. */
-        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
-            fprintf(stderr, "Could not find video grab parameters\n");
-            exit(1);
-        }
-        /* by now video grab has one stream */
-        ic->streams[0]->r_frame_rate.num = vp->time_base.den;
-        ic->streams[0]->r_frame_rate.den = vp->time_base.num;
-        input_files[nb_input_files] = ic;
-
-        if (verbose >= 0)
-            dump_format(ic, nb_input_files, "", 0);
-
-        nb_input_files++;
-    }
-    if (has_audio && audio_grab_format) {
-        AVInputFormat *fmt1;
-        fmt1 = av_find_input_format(audio_grab_format);
-        ap->device = audio_device;
-        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
-            fprintf(stderr, "Could not find audio grab device\n");
-            exit(1);
-        }
-        input_files[nb_input_files] = ic;
-
-        if (verbose >= 0)
-            dump_format(ic, nb_input_files, "", 0);
-
-        nb_input_files++;
-    }
-}
-

 /* same option as mencoder */
 static void opt_pass(const char *pass_str)
 {
 /* same option as mencoder */
 static void opt_pass(const char *pass_str)
 {


@@ -3288,32 +3253,35 @@ static void opt_pass(const char *pass_str)
     do_pass = pass;
 }
 
     do_pass = pass;
 }
 

-#if defined(__MINGW32__) || defined(CONFIG_OS2)
-static int64_t getutime(void)
-{
-  return av_gettime();
-}
-#else

 static int64_t getutime(void)
 {
 static int64_t getutime(void)
 {

+#ifdef HAVE_GETRUSAGE

     struct rusage rusage;
 
     getrusage(RUSAGE_SELF, &rusage);
     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
     struct rusage rusage;
 
     getrusage(RUSAGE_SELF, &rusage);
     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;

-}
+#elif defined(HAVE_GETPROCESSTIMES)
+    HANDLE proc;
+    FILETIME c, e, k, u;
+    proc = GetCurrentProcess();
+    GetProcessTimes(proc, &c, &e, &k, &u);
+    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
+#else
+    return av_gettime();

 #endif
 #endif

+}

 
 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
 extern int ffm_nopts;
 #endif
 
 
 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
 extern int ffm_nopts;
 #endif
 

-static void show_formats(void)
+static void opt_show_formats(void)

 {
     AVInputFormat *ifmt;
     AVOutputFormat *ofmt;
     URLProtocol *up;
     AVCodec *p, *p2;
 {
     AVInputFormat *ifmt;
     AVOutputFormat *ofmt;
     URLProtocol *up;
     AVCodec *p, *p2;

-    const char **pp, *last_name;
+    const char *last_name;

 
     printf("File formats:\n");
     last_name= "000";
 
     printf("File formats:\n");
     last_name= "000";


@@ -3414,26 +3382,14 @@ static void show_formats(void)
     printf("\n");
 
     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
     printf("\n");
 
     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");

-    printf("Motion estimation methods:\n");
-    pp = motion_str;
-    while (*pp) {
-        printf(" %s", *pp);
-        if ((pp - motion_str + 1) == ME_ZERO)
-            printf("(fastest)");
-        else if ((pp - motion_str + 1) == ME_FULL)
-            printf("(slowest)");
-        else if ((pp - motion_str + 1) == ME_EPZS)
-            printf("(default)");
-        pp++;
-    }
-    printf("\n\n");
+    printf("\n");

     printf(
     printf(

-"Note, the names of encoders and decoders dont always match, so there are\n"
+"Note, the names of encoders and decoders do not always match, so there are\n"

 "several cases where the above table shows encoder only or decoder only entries\n"
 "several cases where the above table shows encoder only or decoder only entries\n"

-"even though both encoding and decoding are supported for example, the h263\n"
-"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
-"worse\n");
-    exit(1);
+"even though both encoding and decoding are supported. For example, the h263\n"
+"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
+"worse.\n");
+    exit(0);

 }
 
 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
 }
 
 static void parse_matrix_coeffs(uint16_t *dest, const char *str)


@@ -3465,6 +3421,12 @@ static void opt_intra_matrix(const char *arg)
     parse_matrix_coeffs(intra_matrix, arg);
 }
 
     parse_matrix_coeffs(intra_matrix, arg);
 }
 

+static void opt_show_help(void)
+{
+    show_help();
+    exit(0);
+}
+

 static void opt_target(const char *arg)
 {
     int norm = -1;
 static void opt_target(const char *arg)
 {
     int norm = -1;


@@ -3482,7 +3444,7 @@ static void opt_target(const char *arg)
     } else {
         int fr;
         /* Calculate FR via float to avoid int overflow */
     } else {
         int fr;
         /* Calculate FR via float to avoid int overflow */

-        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
+        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);

         if(fr == 25000) {
             norm = 0;
         } else if((fr == 29970) || (fr == 23976)) {
         if(fr == 25000) {
             norm = 0;
         } else if((fr == 29970) || (fr == 23976)) {


@@ -3536,8 +3498,9 @@ static void opt_target(const char *arg)
         opt_default("minrate", "1150000");
         opt_default("bufsize", "327680"); // 40*1024*8;
 
         opt_default("minrate", "1150000");
         opt_default("bufsize", "327680"); // 40*1024*8;
 

-        audio_bit_rate = 224000;
+        opt_default("ab", "224000");

         audio_sample_rate = 44100;
         audio_sample_rate = 44100;

+        audio_channels = 2;

 
         opt_default("packetsize", "2324");
         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
 
         opt_default("packetsize", "2324");
         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;


@@ -3565,7 +3528,7 @@ static void opt_target(const char *arg)
         opt_default("flags", "+SCAN_OFFSET");
 
 
         opt_default("flags", "+SCAN_OFFSET");
 
 

-        audio_bit_rate = 224000;
+        opt_default("ab", "224000");

         audio_sample_rate = 44100;
 
         opt_default("packetsize", "2324");
         audio_sample_rate = 44100;
 
         opt_default("packetsize", "2324");


@@ -3588,7 +3551,7 @@ static void opt_target(const char *arg)
         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
 
         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
 

-        audio_bit_rate = 448000;
+        opt_default("ab", "448000");

         audio_sample_rate = 48000;
 
     } else if(!strncmp(arg, "dv", 2)) {
         audio_sample_rate = 48000;
 
     } else if(!strncmp(arg, "dv", 2)) {


@@ -3609,56 +3572,74 @@ static void opt_target(const char *arg)
     }
 }
 
     }
 }
 

-static void opt_video_bsf(const char *arg)
+static void opt_vstats_file (const char *arg)

 {
 {

-    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
-    AVBitStreamFilterContext **bsfp;
-
-    if(!bsfc){
-        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
-        exit(1);
-    }
+    av_free (vstats_filename);
+    vstats_filename=av_strdup (arg);
+}

 
 

-    bsfp= &video_bitstream_filters;
-    while(*bsfp)
-        bsfp= &(*bsfp)->next;
+static void opt_vstats (void)
+{
+    char filename[40];
+    time_t today2 = time(NULL);
+    struct tm *today = localtime(&today2);

 
 

-    *bsfp= bsfc;
+    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
+             today->tm_sec);
+    opt_vstats_file(filename);

 }
 
 }
 

-//FIXME avoid audio - video code duplication
-static void opt_audio_bsf(const char *arg)
+static void opt_bsf(const char *opt, const char *arg)

 {
     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
     AVBitStreamFilterContext **bsfp;
 
     if(!bsfc){
 {
     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
     AVBitStreamFilterContext **bsfp;
 
     if(!bsfc){

-        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
+        fprintf(stderr, "Unknown bitstream filter %s\n", arg);

         exit(1);
     }
 
         exit(1);
     }
 

-    bsfp= &audio_bitstream_filters;
+    bsfp= *opt == 'v' ? &video_bitstream_filters : &audio_bitstream_filters;

     while(*bsfp)
         bsfp= &(*bsfp)->next;
 
     *bsfp= bsfc;
 }
 
     while(*bsfp)
         bsfp= &(*bsfp)->next;
 
     *bsfp= bsfc;
 }
 

-static void show_version(void)
+static void opt_show_license(void)

 {
 {

-    /* TODO: add function interface to avutil and avformat */
-    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
-           "libavutil   %d\n"
-           "libavcodec  %d\n"
-           "libavformat %d\n",
-           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
-    exit(1);
+    show_license();
+    exit(0);
+}
+
+static void opt_show_version(void)
+{
+    show_version(program_name);
+    exit(0);

 }
 
 static int opt_default(const char *opt, const char *arg){
 }
 
 static int opt_default(const char *opt, const char *arg){

-    AVOption *o= av_set_string(avctx_opts, opt, arg);
+    int type;
+    const AVOption *o= NULL;
+    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
+
+    for(type=0; type<CODEC_TYPE_NB; type++){
+        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
+        if(o2)
+            o = av_set_string(avctx_opts[type], opt, arg);
+    }

     if(!o)
         o = av_set_string(avformat_opts, opt, arg);
     if(!o)
         o = av_set_string(avformat_opts, opt, arg);

+    if(!o)
+        o = av_set_string(sws_opts, opt, arg);
+    if(!o){
+        if(opt[0] == 'a')
+            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
+        else if(opt[0] == 'v')
+            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
+        else if(opt[0] == 's')
+            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
+    }

     if(!o)
         return -1;
 
     if(!o)
         return -1;
 


@@ -3670,28 +3651,28 @@ static int opt_default(const char *opt, const char *arg){
 
 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
     /* disable generate of real time pts in ffm (need to be supressed anyway) */
 
 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
     /* disable generate of real time pts in ffm (need to be supressed anyway) */

-    if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
+    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)

         ffm_nopts = 1;
 #endif
 
         ffm_nopts = 1;
 #endif
 

-    if(avctx_opts->debug)
-        av_log_set_level(AV_LOG_DEBUG);
+    if(avctx_opts[0]->debug)
+        av_log_level = AV_LOG_DEBUG;

     return 0;
 }
 
 const OptionDef options[] = {
     /* main options */
     return 0;
 }
 
 const OptionDef options[] = {
     /* main options */

-    { "L", 0, {(void*)show_license}, "show license" },
-    { "h", 0, {(void*)show_help}, "show help" },
-    { "version", 0, {(void*)show_version}, "show version" },
-    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
+    { "L", 0, {(void*)opt_show_license}, "show license" },
+    { "h", 0, {(void*)opt_show_help}, "show help" },
+    { "version", 0, {(void*)opt_show_version}, "show version" },
+    { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },

     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },

-    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
-    { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
+    { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
+    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //

     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },


@@ -3714,19 +3695,22 @@ const OptionDef options[] = {
     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },

+    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },

     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //

-    { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
+    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
+    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },

 
     /* video options */
 
     /* video options */

+    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
+    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },

     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },

-    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },

     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },

-    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
+    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },

     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },


@@ -3744,10 +3728,7 @@ const OptionDef options[] = {
     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },

-    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
-      "method" },

     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },

-    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },

     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
       "use same video quality as source (implies VBR)" },
     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
       "use same video quality as source (implies VBR)" },


@@ -3756,8 +3737,11 @@ const OptionDef options[] = {
     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
       "deinterlace pictures" },
     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
       "deinterlace pictures" },
     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },

-    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
+    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
+    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
+#ifdef CONFIG_VHOOK

     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },

+#endif

     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },


@@ -3767,7 +3751,8 @@ const OptionDef options[] = {
     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
 
     /* audio options */
     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
 
     /* audio options */

-    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
+    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
+    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },

     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },


@@ -3779,88 +3764,39 @@ const OptionDef options[] = {
     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
 
     /* subtitle options */
     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
 
     /* subtitle options */

+    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },

     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
 
     /* grab options */
     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
 
     /* grab options */

-    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },

     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },

-    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
-
-    /* G.2 grab options */
-    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
-    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
+    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },

 
     /* muxer options */
     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
 
 
     /* muxer options */
     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
 

-    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
-    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
+    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
+    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },

 
     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
     { NULL, },
 };
 
 
     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
     { NULL, },
 };
 

-static void show_banner(void)
-{
-    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2006 Fabrice Bellard, et al.\n");
-    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
-    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
-    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
-    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
-    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
-#ifdef __GNUC__
-    fprintf(stderr, ", gcc: " __VERSION__ "\n");
-#else
-    fprintf(stderr, ", using a non-gcc compiler\n");
-#endif
-}
-
-static void show_license(void)
+/**
+ * Trivial log callback.
+ * Only suitable for show_help and similar since it lacks prefix handling.
+ */
+static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)

 {
 {

-    show_banner();
-#ifdef CONFIG_GPL
-    printf(
-    "FFmpeg is free software; you can redistribute it and/or modify\n"
-    "it under the terms of the GNU General Public License as published by\n"
-    "the Free Software Foundation; either version 2 of the License, or\n"
-    "(at your option) any later version.\n"
-    "\n"
-    "FFmpeg is distributed in the hope that it will be useful,\n"
-    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
-    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
-    "GNU General Public License for more details.\n"
-    "\n"
-    "You should have received a copy of the GNU General Public License\n"
-    "along with FFmpeg; if not, write to the Free Software\n"
-    "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
-    );
-#else
-    printf(
-    "FFmpeg is free software; you can redistribute it and/or\n"
-    "modify it under the terms of the GNU Lesser General Public\n"
-    "License as published by the Free Software Foundation; either\n"
-    "version 2.1 of the License, or (at your option) any later version.\n"
-    "\n"
-    "FFmpeg is distributed in the hope that it will be useful,\n"
-    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
-    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
-    "Lesser General Public License for more details.\n"
-    "\n"
-    "You should have received a copy of the GNU Lesser General Public\n"
-    "License along with FFmpeg; if not, write to the Free Software\n"
-    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
-    );
-#endif
-    exit(1);
+    vfprintf(stdout, fmt, vl);

 }
 
 static void show_help(void)
 {
 }
 
 static void show_help(void)
 {

-    show_banner();
+    av_log_set_callback(log_callback_help);

     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
            "Hyper fast Audio and Video encoder\n");
     printf("\n");
     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
            "Hyper fast Audio and Video encoder\n");
     printf("\n");


@@ -3887,53 +3823,14 @@ static void show_help(void)
     show_help_options(options, "\nAdvanced options:\n",
                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
                       OPT_EXPERT);
     show_help_options(options, "\nAdvanced options:\n",
                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
                       OPT_EXPERT);

-    av_opt_show(avctx_opts, NULL);
+    av_opt_show(avctx_opts[0], NULL);

     av_opt_show(avformat_opts, NULL);
     av_opt_show(avformat_opts, NULL);

-
-    exit(1);
-}
-
-void parse_arg_file(const char *filename)
-{
-    opt_output_file(filename);
+    av_opt_show(sws_opts, NULL);

 }
 
 }
 

-int main(int argc, char **argv)
+static int av_exit()

 {
     int i;
 {
     int i;

-    int64_t ti;
-
-    av_register_all();
-
-    avctx_opts= avcodec_alloc_context();
-    avformat_opts = av_alloc_format_context();
-
-    if (argc <= 1)
-        show_help();
-    else
-        show_banner();
-
-    /* parse options */
-    parse_options(argc, argv, options);
-
-    /* file converter / grab */
-    if (nb_output_files <= 0) {
-        fprintf(stderr, "Must supply at least one output file\n");
-        exit(1);
-    }
-
-    if (nb_input_files == 0) {
-        input_sync = 1;
-        prepare_grab();
-    }
-
-    ti = getutime();
-    av_encode(output_files, nb_output_files, input_files, nb_input_files,
-              stream_maps, nb_stream_maps);
-    ti = getutime() - ti;
-    if (do_benchmark) {
-        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
-    }

 
     /* close files */
     for(i=0;i<nb_output_files;i++) {
 
     /* close files */
     for(i=0;i<nb_output_files;i++) {


@@ -3953,15 +3850,25 @@ int main(int argc, char **argv)
 
     av_free_static();
 
 
     av_free_static();
 

-    if(intra_matrix)
-        av_free(intra_matrix);
-    if(inter_matrix)
-        av_free(inter_matrix);
+    av_free(intra_matrix);
+    av_free(inter_matrix);

 
 

-#ifdef POWERPC_PERFORMANCE_REPORT
+    if (vstats_file)
+        fclose(vstats_file);
+    av_free(vstats_filename);
+
+    av_free(opt_names);
+
+    av_free(video_codec_name);
+    av_free(audio_codec_name);
+    av_free(subtitle_codec_name);
+
+    av_free(video_standard);
+
+#ifdef CONFIG_POWERPC_PERF

     extern void powerpc_display_perf_report(void);
     powerpc_display_perf_report();
     extern void powerpc_display_perf_report(void);
     powerpc_display_perf_report();

-#endif /* POWERPC_PERFORMANCE_REPORT */
+#endif /* CONFIG_POWERPC_PERF */

 
     if (received_sigterm) {
         fprintf(stderr,
 
     if (received_sigterm) {
         fprintf(stderr,


@@ -3973,3 +3880,47 @@ int main(int argc, char **argv)
     exit(0); /* not all OS-es handle main() return value */
     return 0;
 }
     exit(0); /* not all OS-es handle main() return value */
     return 0;
 }

+
+int main(int argc, char **argv)
+{
+    int i;
+    int64_t ti;
+
+    av_register_all();
+
+    for(i=0; i<CODEC_TYPE_NB; i++){
+        avctx_opts[i]= avcodec_alloc_context2(i);
+    }
+    avformat_opts = av_alloc_format_context();
+    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
+
+    show_banner(program_name, program_birth_year);
+    if (argc <= 1) {
+        show_help();
+        exit(1);
+    }
+
+    /* parse options */
+    parse_options(argc, argv, options, opt_output_file);
+
+    /* file converter / grab */
+    if (nb_output_files <= 0) {
+        fprintf(stderr, "Must supply at least one output file\n");
+        exit(1);
+    }
+
+    if (nb_input_files == 0) {
+        fprintf(stderr, "Must supply at least one input file\n");
+        exit(1);
+    }
+
+    ti = getutime();
+    av_encode(output_files, nb_output_files, input_files, nb_input_files,
+              stream_maps, nb_stream_maps);
+    ti = getutime() - ti;
+    if (do_benchmark) {
+        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
+    }
+
+    return av_exit();
+}