* 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 "dsputil.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>
-#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>
#define INFINITY HUGE_VAL
#endif
+#undef exit
+
/* select an input stream for an output stream */
typedef struct AVStreamMap {
int file_index;
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;
#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_codec_id = CODEC_ID_NONE;
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 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 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 copy_ts= 0;
static int opt_shortest = 0; //
static int video_global_header = 0;
+static char *vstats_filename;
+static FILE *fvstats;
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 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 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 dts_delta_threshold = 10;
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;
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;
-#ifndef __MINGW32__
+#ifdef HAVE_TERMIOS_H
/* init terminal so that we can grab keys */
static struct termios oldtty;
static void term_exit(void)
{
-#ifndef __MINGW32__
+#ifdef HAVE_TERMIOS_H
tcsetattr (0, TCSANOW, &oldtty);
#endif
}
static void term_init(void)
{
-#ifndef __MINGW32__
+#ifdef HAVE_TERMIOS_H
struct termios tty;
tcgetattr (0, &tty);
/* 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
return n;
}
+#elif defined(HAVE_CONIO_H)
+ if(kbhit())
+ return(getch());
#endif
return -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);
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;
}
- frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
+ frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
+ 1000000 * ist->pts / AV_TIME_BASE);
if (picture != picture2)
*picture = *picture2;
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);
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");
- goto the_end;
+ return;
}
formatted_picture = &picture_crop_temp;
} else {
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");
- goto the_end;
+ return;
}
resampling_dst = &picture_pad_temp;
}
}
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);
}
/* 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
ost->sync_opts++;
ost->frame_number++;
}
- the_end:
- av_free(buf);
- av_free(buf1);
}
static double psnr(double d){
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;
int64_t ti;
double ti1, bitrate, avg_bitrate;
+ /* this is executed just the first time do_video_stats is called */
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");
+ fvstats = fopen(vstats_filename, "w");
if (!fvstats) {
perror("fopen");
exit(1);
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;
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;
- 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){
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 */
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
- /* 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
- /* 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
- 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
- /* 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);
+
+ /* 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++;
+ }
- //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;
+ 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;
- 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);
+ {
+ 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;
+
+ //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 */
AVOutputStream *ost, **ost_table = NULL;
AVInputStream *ist, **ist_table = NULL;
AVInputFile *file_table;
- AVFormatContext *stream_no_data;
int key;
file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
codec->block_align= icodec->block_align;
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;
case CODEC_TYPE_SUBTITLE:
break;
default:
- av_abort();
+ abort();
}
} else {
switch(codec->codec_type) {
codec->sample_rate, icodec->sample_rate);
if(!ost->resample){
printf("Can't resample. Aborting.\n");
- av_abort();
+ abort();
}
}
ist->decoding_needed = 1;
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),
ist->decoding_needed = 1;
break;
default:
- av_abort();
+ abort();
break;
}
/* two pass mode */
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;
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);
- ret = -EINVAL;
+ ret = AVERROR(EINVAL);
goto fail;
}
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;
}
}
}
term_init();
- stream_no_data = 0;
key = -1;
+ timer_start = av_gettime();
for(; received_sigterm == 0;) {
int file_index, ist_index;
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 */
if (opt_shortest) break; else continue; //
}
- if (!pkt.size) {
- stream_no_data = is;
- } else {
- stream_no_data = 0;
- }
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 */
}
return ret;
fail:
- ret = -ENOMEM;
+ ret = AVERROR(ENOMEM);
goto fail1;
}
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);
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);
}
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);
}
}
}
+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)
{
- 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_packet_size(const char *arg)
-{
- packet_size= atoi(arg);
-}
-
static void opt_strict(const char *arg)
{
strict= atoi(arg);
#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);
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);
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,
int codec_type, const char *arg)
{
}
}
-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;
-}
-
static void opt_video_codec(const char *arg)
{
opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
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->device = grab_device;
ap->channel = video_channel;
ap->standard = video_standard;
ap->video_codec_id = video_codec_id;
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);
-#endif
enc->thread_count= thread_count;
switch(enc->codec_type) {
case CODEC_TYPE_AUDIO:
for(j=0; j<opt_name_count; j++){
const AVOption *opt;
- double d= av_get_double(avctx_opts, opt_names[j], &opt);
+ double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
av_set_double(enc, opt_names[j], d);
}
case CODEC_TYPE_VIDEO:
for(j=0; j<opt_name_count; j++){
const AVOption *opt;
- double d= av_get_double(avctx_opts, opt_names[j], &opt);
+ double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
av_set_double(enc, opt_names[j], d);
}
(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)
case CODEC_TYPE_UNKNOWN:
break;
default:
- av_abort();
+ abort();
}
}
file_iformat = NULL;
file_oformat = NULL;
- grab_device = NULL;
video_channel = 0;
rate_emu = 0;
}
-static void opt_grab(const char *arg)
-{
- 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;
case CODEC_TYPE_SUBTITLE:
break;
default:
- av_abort();
+ abort();
}
}
}
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;
-#if defined(HAVE_THREADS)
if(thread_count>1)
avcodec_thread_init(st->codec, thread_count);
-#endif
video_enc = st->codec;
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;
- avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
+ avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
}
if (video_stream_copy) {
for(i=0; i<opt_name_count; i++){
const AVOption *opt;
- double d= av_get_double(avctx_opts, opt_names[i], &opt);
+ double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
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;
- 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++){
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;
- video_enc->me_method = me_method;
-
/* two pass mode */
if (do_pass) {
if (do_pass == 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;
-#if defined(HAVE_THREADS)
if(thread_count>1)
avcodec_thread_init(st->codec, thread_count);
-#endif
audio_enc = st->codec;
audio_enc->codec_type = CODEC_TYPE_AUDIO;
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;
for(i=0; i<opt_name_count; i++){
const AVOption *opt;
- double d= av_get_double(avctx_opts, opt_names[i], &opt);
+ double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
av_set_double(audio_enc, opt_names[i], d);
}
codec_id = audio_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->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;
}
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;
} else {
for(i=0; i<opt_name_count; i++){
const AVOption *opt;
- double d= av_get_double(avctx_opts, opt_names[i], &opt);
+ double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
av_set_double(subtitle_enc, opt_names[i], d);
}
}
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;
}
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;
- pstrcpy(oc->filename, sizeof(oc->filename), filename);
+ av_strlcpy(oc->filename, filename, sizeof(oc->filename));
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) {
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)
- pstrcpy(oc->author, sizeof(oc->author), str_author);
+ av_strlcpy(oc->author, str_author, sizeof(oc->author));
if (str_copyright)
- pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
+ av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
if (str_comment)
- pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
+ av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
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;
/* 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;
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;
-#warning FIXME: find a better interface
- if(video_device&&!strncmp(video_device,"x11:",4)) {
- video_grab_format="x11grab";
- }
- 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)
{
do_pass = pass;
}
-#if defined(__MINGW32__) || defined(CONFIG_OS2)
-static int64_t getutime(void)
-{
- return av_gettime();
-}
-#else
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;
-}
+#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
+}
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
extern int ffm_nopts;
AVOutputFormat *ofmt;
URLProtocol *up;
AVCodec *p, *p2;
- const char **pp, *last_name;
+ const char *last_name;
printf("File formats:\n");
last_name= "000";
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(
-"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"
-"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");
+"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(1);
}
} 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)) {
opt_default("minrate", "1150000");
opt_default("bufsize", "327680"); // 40*1024*8;
- audio_bit_rate = 224000;
+ opt_default("ab", "224000");
audio_sample_rate = 44100;
audio_channels = 2;
opt_default("flags", "+SCAN_OFFSET");
- audio_bit_rate = 224000;
+ opt_default("ab", "224000");
audio_sample_rate = 44100;
opt_default("packetsize", "2324");
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)) {
}
}
+static void opt_vstats_file (const char *arg)
+{
+ av_free (vstats_filename);
+ vstats_filename=av_strdup (arg);
+}
+
+static void opt_vstats (void)
+{
+ char filename[40];
+ time_t today2 = time(NULL);
+ struct tm *today = localtime(&today2);
+
+ snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
+ today->tm_sec);
+ opt_vstats_file(filename);
+}
+
static void opt_video_bsf(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);
+ fprintf(stderr, "Unknown bitstream filter %s\n", arg);
exit(1);
}
AVBitStreamFilterContext **bsfp;
if(!bsfc){
- fprintf(stderr, "Unkown bitstream filter %s\n", arg);
+ fprintf(stderr, "Unknown bitstream filter %s\n", arg);
exit(1);
}
}
static int opt_default(const char *opt, const char *arg){
- const 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(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 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
- if(avctx_opts->debug)
+ if(avctx_opts[0]->debug)
av_log_level = AV_LOG_DEBUG;
return 0;
}
{ "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" }, //
+ { "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" },
/* video options */
{ "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" },
- { "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" },
{ "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", "" },
- { "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)" },
{ "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" },
{ "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
{ "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" },
{ "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", },
+ { "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" },
{ "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" },
- { "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" },
"\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"
+ "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
);
#else
printf(
exit(1);
}
+/**
+ * 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)
+{
+ vfprintf(stdout, fmt, vl);
+}
+
static void show_help(void)
{
+ av_log_set_callback(log_callback_help);
show_banner();
printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
"Hyper fast Audio and Video encoder\n");
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(sws_opts, NULL);
exit(1);
}
av_register_all();
- avctx_opts= avcodec_alloc_context();
+ 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);
if (argc <= 1)
show_help();
}
if (nb_input_files == 0) {
- input_sync = 1;
- prepare_grab();
+ fprintf(stderr, "Must supply at least one input file\n");
+ exit(1);
}
ti = getutime();
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);
+
+ if (fvstats)
+ fclose(fvstats);
+ av_free(vstats_filename);
+
+ av_free(opt_names);
+
+ av_free(video_standard);
-#ifdef POWERPC_PERFORMANCE_REPORT
+#ifdef CONFIG_POWERPC_PERF
extern void powerpc_display_perf_report(void);
powerpc_display_perf_report();
-#endif /* POWERPC_PERFORMANCE_REPORT */
+#endif /* CONFIG_POWERPC_PERF */
if (received_sigterm) {
fprintf(stderr,
projects / ffmpeg / blobdiff