* FFmpeg main
* Copyright (c) 2000-2003 Fabrice Bellard
*
- * This library is free software; you can redistribute it and/or
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
*
- * This library is distributed in the hope that it will be useful,
+ * FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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 <signal.h>
#include <limits.h>
#include "avformat.h"
+#include "swscale.h"
#include "framehook.h"
#include "dsputil.h"
#include "opt.h"
+#include "fifo.h"
-#ifndef CONFIG_WIN32
+#ifdef __MINGW32__
+#include <conio.h>
+#else
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <termios.h>
#include <sys/resource.h>
-#include <signal.h>
#endif
#ifdef CONFIG_OS2
#include <sys/types.h>
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
#include <time.h>
+#include "version.h"
#include "cmdutils.h"
#undef NDEBUG
static AVInputFormat *file_iformat;
static AVOutputFormat *file_oformat;
-static AVImageFormat *image_format;
static int frame_width = 0;
static int frame_height = 0;
static float frame_aspect_ratio = 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 int video_bit_rate = 200*1000;
-static int video_bit_rate_tolerance = 4000*1000;
static float video_qscale = 0;
-static int video_qmin = 2;
-static int video_qmax = 31;
-static int video_lmin = 2*FF_QP2LAMBDA;
-static int video_lmax = 31*FF_QP2LAMBDA;
-static int video_mb_lmin = 2*FF_QP2LAMBDA;
-static int video_mb_lmax = 31*FF_QP2LAMBDA;
static int video_qdiff = 3;
-static float video_qblur = 0.5;
-static float video_qsquish = 0.0;
-static float video_qcomp = 0.5;
static uint16_t *intra_matrix = NULL;
static uint16_t *inter_matrix = NULL;
#if 0 //experimental, (can be removed)
#endif
static char *video_rc_override_string=NULL;
static char *video_rc_eq="tex^qComp";
-static int video_rc_buffer_size=0;
-static float video_rc_buffer_aggressivity=1.0;
-static int video_rc_max_rate=0;
-static int video_rc_min_rate=0;
-static float video_rc_initial_cplx=0;
-static float video_b_qfactor = 1.25;
-static float video_b_qoffset = 1.25;
-static float video_i_qfactor = -0.8;
-static float video_i_qoffset = 0.0;
-static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
-static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
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 b_frames = 0;
-static int b_strategy = 0;
-static int pre_me = 0;
static int do_deinterlace = 0;
-static int workaround_bugs = FF_BUG_AUTODETECT;
static int packet_size = 0;
-static int error_rate = 0;
static int strict = 0;
static int top_field_first = -1;
-static int sc_threshold = 0;
static int me_threshold = 0;
-static int mb_threshold = 0;
static int intra_dc_precision = 8;
-static int me_penalty_compensation= 256;
-static int frame_skip_threshold= 0;
-static int frame_skip_factor= 0;
-static int frame_skip_exp= 0;
-extern int loop_input; /* currently a hack */
+static int loop_input = 0;
static int loop_output = AVFMT_NOOUTPUTLOOP;
-static int genpts = 0;
static int qp_hist = 0;
-static int gop_size = 12;
static int intra_only = 0;
static int audio_sample_rate = 44100;
static int audio_bit_rate = 64000;
static int subtitle_codec_id = CODEC_ID_NONE;
static char *subtitle_language = NULL;
-static int mux_rate= 0;
-static int mux_packet_size= 0;
static float mux_preload= 0.5;
static float mux_max_delay= 0.7;
static char *str_author = NULL;
static char *str_copyright = NULL;
static char *str_comment = NULL;
+static char *str_album = NULL;
static int do_benchmark = 0;
static int do_hex_dump = 0;
static int do_pkt_dump = 0;
static int rate_emu = 0;
#ifdef CONFIG_BKTR
-static char *video_grab_format = "bktr";
+static const char *video_grab_format = "bktr";
+#else
+#ifdef CONFIG_VIDEO4LINUX2
+static const char *video_grab_format = "video4linux2";
#else
-static char *video_grab_format = "video4linux";
+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 *audio_grab_format = "audio_device";
+static const char *audio_grab_format = "audio_device";
static char *audio_device = NULL;
static int audio_volume = 256;
static int verbose = 1;
static int thread_count= 1;
static int q_pressed = 0;
-static int me_range = 0;
static int64_t video_size = 0;
static int64_t audio_size = 0;
static int64_t extra_size = 0;
static int 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 AVBitStreamFilterContext *video_bitstream_filters=NULL;
+static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
+static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
struct AVInputStream *sync_ist; /* input stream to sync against */
int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
/* video only */
- int video_resample; /* video_resample and video_crop are mutually exclusive */
+ int video_resample;
AVFrame pict_tmp; /* temporary image for resampling */
- ImgReSampleContext *img_resample_ctx; /* for image resampling */
+ struct SwsContext *img_resample_ctx; /* for image resampling */
+ int resample_height;
- int video_crop; /* video_resample and video_crop are mutually exclusive */
+ int video_crop;
int topBand; /* cropping area sizes */
int leftBand;
- int video_pad; /* video_resample and video_pad are mutually exclusive */
+ int video_pad;
int padtop; /* padding area sizes */
int padbottom;
int padleft;
/* audio only */
int audio_resample;
ReSampleContext *resample; /* for audio resampling */
- FifoBuffer fifo; /* for compression: one audio fifo per codec */
+ AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
FILE *logfile;
} AVOutputStream;
int nb_streams; /* nb streams we are aware of */
} AVInputFile;
-#ifndef CONFIG_WIN32
+#ifndef __MINGW32__
/* init terminal so that we can grab keys */
static struct termios oldtty;
+#endif
static void term_exit(void)
{
+#ifndef __MINGW32__
tcsetattr (0, TCSANOW, &oldtty);
+#endif
}
static volatile sig_atomic_t received_sigterm = 0;
static void term_init(void)
{
+#ifndef __MINGW32__
struct termios tty;
tcgetattr (0, &tty);
tty.c_cc[VTIME] = 0;
tcsetattr (0, TCSANOW, &tty);
+ signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
+#endif
signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
- signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
/*
register a function to be called at normal program termination
/* read a key without blocking */
static int read_key(void)
{
+#ifdef __MINGW32__
+ if(kbhit())
+ return(getch());
+#else
int n = 1;
unsigned char ch;
#ifndef CONFIG_BEOS_NETSERVER
return n;
}
+#endif
return -1;
}
return q_pressed || (q_pressed = read_key() == 'q');
}
-#else
-
-static volatile int received_sigterm = 0;
-
-/* no interactive support */
-static void term_exit(void)
-{
-}
-
-static void term_init(void)
-{
-}
-
-static int read_key(void)
-{
- return 0;
-}
-
-#endif
-
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
{
int i, err;
return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
}
+static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
+ while(bsfc){
+ AVPacket new_pkt= *pkt;
+ int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
+ &new_pkt.data, &new_pkt.size,
+ pkt->data, pkt->size,
+ pkt->flags & PKT_FLAG_KEY);
+ if(a){
+ av_free_packet(pkt);
+ new_pkt.destruct= av_destruct_packet;
+ }
+ *pkt= new_pkt;
+
+ bsfc= bsfc->next;
+ }
+
+ av_interleaved_write_frame(s, pkt);
+}
+
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
static void do_audio_out(AVFormatContext *s,
if(audio_sync_method){
double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
- - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
+ - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
assert(ost->audio_resample);
if(verbose > 2)
fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
-// fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2));
+// fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
}
}
}else
ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
- - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
+ - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
if (ost->audio_resample) {
buftmp = audio_buf;
/* now encode as many frames as possible */
if (enc->frame_size > 1) {
/* output resampled raw samples */
- fifo_write(&ost->fifo, buftmp, size_out,
- &ost->fifo.wptr);
+ av_fifo_write(&ost->fifo, buftmp, size_out);
frame_bytes = enc->frame_size * 2 * enc->channels;
- while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
- &ost->fifo.rptr) == 0) {
+ while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
AVPacket pkt;
av_init_packet(&pkt);
if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
pkt.flags |= PKT_FLAG_KEY;
- av_interleaved_write_frame(s, &pkt);
+ write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
ost->sync_opts += enc->frame_size;
}
break;
}
ret = avcodec_encode_audio(enc, audio_out, size_out,
- (short *)buftmp);
+ (short *)buftmp);
audio_size += ret;
pkt.stream_index= ost->index;
pkt.data= audio_out;
if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
pkt.flags |= PKT_FLAG_KEY;
- av_interleaved_write_frame(s, &pkt);
+ write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
}
}
picture2 = picture;
}
} else {
- if (img_convert(picture2, dec->pix_fmt, picture,
- dec->pix_fmt, dec->width, dec->height) < 0) {
- /* if error, do not copy */
- av_free(buf);
- buf = NULL;
- picture2 = picture;
- }
+ img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
}
} else {
picture2 = picture;
/* we begin to correct av delay at this threshold */
#define AV_DELAY_MAX 0.100
-
-/* Expects img to be yuv420 */
-static void fill_pad_region(AVPicture* img, int height, int width,
- int padtop, int padbottom, int padleft, int padright, int *color) {
-
- int i, y, shift;
- uint8_t *optr;
-
- for (i = 0; i < 3; i++) {
- shift = (i == 0) ? 0 : 1;
-
- if (padtop || padleft) {
- memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
- padleft) >> shift));
- }
-
- if (padleft || padright) {
- optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
- (img->linesize[i] - (padright >> shift));
-
- for (y = 0; y < ((height - (padtop + padbottom) - 1) >> shift); y++) {
- memset(optr, color[i], (padleft + padright) >> shift);
- optr += img->linesize[i];
- }
- }
-
- if (padbottom || padright) {
- optr = img->data[i] + (((img->linesize[i] * (height - padbottom)) - padright) >> shift);
- memset(optr, color[i], (((img->linesize[i] * padbottom) + padright) >> shift));
- }
- }
-}
-
static void do_subtitle_out(AVFormatContext *s,
AVOutputStream *ost,
AVInputStream *ist,
else
pkt.pts += 90 * sub->end_display_time;
}
- av_interleaved_write_frame(s, &pkt);
+ write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
}
}
int *frame_size)
{
int nb_frames, i, ret;
- AVFrame *final_picture, *formatted_picture;
- AVFrame picture_format_temp, picture_crop_temp;
+ 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;
- enum PixelFormat target_pixfmt;
- avcodec_get_frame_defaults(&picture_format_temp);
avcodec_get_frame_defaults(&picture_crop_temp);
+ avcodec_get_frame_defaults(&picture_pad_temp);
enc = ost->st->codec;
dec = ist->st->codec;
nb_frames = 0;
else if (vdelta > 1.1)
nb_frames = lrintf(vdelta);
-//fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
+//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
if (nb_frames == 0){
++nb_frames_drop;
if (verbose>2)
if (nb_frames <= 0)
return;
- /* convert pixel format if needed */
- target_pixfmt = ost->video_resample || ost->video_pad
- ? PIX_FMT_YUV420P : enc->pix_fmt;
- if (dec->pix_fmt != target_pixfmt) {
- int size;
-
- /* create temporary picture */
- size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
- buf = av_malloc(size);
- if (!buf)
- return;
- formatted_picture = &picture_format_temp;
- avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
-
- if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
- (AVPicture *)in_picture, dec->pix_fmt,
- dec->width, dec->height) < 0) {
-
- if (verbose >= 0)
- fprintf(stderr, "pixel format conversion not handled\n");
-
+ if (ost->video_crop) {
+ if (img_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;
}
+ formatted_picture = &picture_crop_temp;
} else {
formatted_picture = in_picture;
}
- /* XXX: resampling could be done before raw format conversion in
- some cases to go faster */
- /* XXX: only works for YUV420P */
- if (ost->video_resample) {
+ final_picture = formatted_picture;
+ padding_src = formatted_picture;
+ resampling_dst = &ost->pict_tmp;
+ if (ost->video_pad) {
final_picture = &ost->pict_tmp;
- img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
-
- if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
- fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
- ost->padtop, ost->padbottom, ost->padleft, ost->padright,
- padcolor);
- }
-
- if (enc->pix_fmt != PIX_FMT_YUV420P) {
- int size;
-
- av_free(buf);
- /* create temporary picture */
- size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
- buf = av_malloc(size);
- if (!buf)
- return;
- final_picture = &picture_format_temp;
- avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
-
- if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
- (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
- enc->width, enc->height) < 0) {
-
- if (verbose >= 0)
- fprintf(stderr, "pixel format conversion not handled\n");
-
+ if (ost->video_resample) {
+ if (img_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;
}
- }
- } else if (ost->video_crop) {
- picture_crop_temp.data[0] = formatted_picture->data[0] +
- (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
-
- picture_crop_temp.data[1] = formatted_picture->data[1] +
- ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
- (ost->leftBand >> 1);
-
- picture_crop_temp.data[2] = formatted_picture->data[2] +
- ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
- (ost->leftBand >> 1);
-
- picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
- picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
- picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
- final_picture = &picture_crop_temp;
- } else if (ost->video_pad) {
- final_picture = &ost->pict_tmp;
-
- for (i = 0; i < 3; i++) {
- uint8_t *optr, *iptr;
- int shift = (i == 0) ? 0 : 1;
- int y, yheight;
-
- /* set offset to start writing image into */
- optr = final_picture->data[i] + (((final_picture->linesize[i] *
- ost->padtop) + ost->padleft) >> shift);
- iptr = formatted_picture->data[i];
-
- yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
- for (y = 0; y < yheight; y++) {
- /* copy unpadded image row into padded image row */
- memcpy(optr, iptr, formatted_picture->linesize[i]);
- optr += final_picture->linesize[i];
- iptr += formatted_picture->linesize[i];
- }
+ resampling_dst = &picture_pad_temp;
}
+ }
- fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
- ost->padtop, ost->padbottom, ost->padleft, ost->padright,
- padcolor);
-
- if (enc->pix_fmt != PIX_FMT_YUV420P) {
- int size;
-
- av_free(buf);
- /* create temporary picture */
- size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
- buf = av_malloc(size);
- if (!buf)
- return;
- final_picture = &picture_format_temp;
- avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
-
- if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
- (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
- enc->width, enc->height) < 0) {
-
- if (verbose >= 0)
- fprintf(stderr, "pixel format conversion not handled\n");
+ if (ost->video_resample) {
+ padding_src = NULL;
+ final_picture = &ost->pict_tmp;
+ sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
+ 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
+ }
- goto the_end;
- }
- }
- } else {
- final_picture = formatted_picture;
+ if (ost->video_pad) {
+ img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
+ enc->height, enc->width, enc->pix_fmt,
+ ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
}
+
/* duplicates frame if needed */
for(i=0;i<nb_frames;i++) {
AVPacket pkt;
avoid any copies. We support temorarily the older
method. */
AVFrame* old_frame = enc->coded_frame;
- enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
+ enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
pkt.data= (uint8_t *)final_picture;
pkt.size= sizeof(AVPicture);
if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
if(dec->coded_frame && dec->coded_frame->key_frame)
pkt.flags |= PKT_FLAG_KEY;
- av_interleaved_write_frame(s, &pkt);
- enc->coded_frame = old_frame;
+ write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
+ enc->coded_frame = old_frame;
} else {
AVFrame big_picture;
// big_picture.pts = AV_NOPTS_VALUE;
big_picture.pts= ost->sync_opts;
// big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
-//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
+//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
ret = avcodec_encode_video(enc,
bit_buffer, bit_buffer_size,
&big_picture);
+ if (ret == -1) {
+ fprintf(stderr, "Video encoding failed\n");
+ exit(1);
+ }
//enc->frame_number = enc->real_pict_num;
if(ret>0){
pkt.data= bit_buffer;
pkt.size= ret;
if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
-/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
+/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
if(enc->coded_frame && enc->coded_frame->key_frame)
pkt.flags |= PKT_FLAG_KEY;
- av_interleaved_write_frame(s, &pkt);
+ write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
*frame_size = ret;
//fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
// enc->frame_number-1, enc->real_pict_num, ret,
}
static void print_report(AVFormatContext **output_files,
- AVOutputStream **ost_table, int nb_ostreams,
- int is_last_report)
+ AVOutputStream **ost_table, int nb_ostreams,
+ int is_last_report)
{
char buf[1024];
AVOutputStream *ost;
"size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
(double)total_size / 1024, ti1, bitrate);
- if (verbose > 1)
- snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
- nb_frames_dup, nb_frames_drop);
+ if (verbose > 1)
+ snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
+ nb_frames_dup, nb_frames_drop);
if (verbose >= 0)
fprintf(stderr, "%s \r", buf);
int data_size, got_picture;
AVFrame picture;
void *buffer_to_free;
- static int samples_size= 0;
+ static unsigned int samples_size= 0;
static short *samples= NULL;
AVSubtitle subtitle, *subtitle_to_free;
int got_subtitle;
}
#endif
/* if output time reached then transcode raw format,
- encode packets and output them */
+ encode packets and output them */
if (start_time == 0 || ist->pts >= start_time)
for(i=0;i<nb_ostreams;i++) {
int frame_size;
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;
- av_interleaved_write_frame(os, &opkt);
+
+ 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);
if (ost->encoding_needed) {
for(;;) {
AVPacket pkt;
+ int fifo_bytes;
av_init_packet(&pkt);
pkt.stream_index= ost->index;
switch(ost->st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
- ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
+ fifo_bytes = av_fifo_size(&ost->fifo);
+ ret = 0;
+ /* encode any samples remaining in fifo */
+ if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
+ int fs_tmp = enc->frame_size;
+ enc->frame_size = fifo_bytes / (2 * enc->channels);
+ if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
+ ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
+ }
+ enc->frame_size = fs_tmp;
+ }
+ if(ret <= 0) {
+ ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
+ }
audio_size += ret;
pkt.flags |= PKT_FLAG_KEY;
break;
pkt.size= ret;
if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
- av_interleaved_write_frame(os, &pkt);
+ write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
}
}
}
nb_ostreams = 0;
for(i=0;i<nb_output_files;i++) {
os = output_files[i];
+ if (!os->nb_streams) {
+ fprintf(stderr, "Output file does not contain any stream\n");
+ exit(1);
+ }
nb_ostreams += os->nb_streams;
}
if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
codec->bit_rate = icodec->bit_rate;
codec->extradata= icodec->extradata;
codec->extradata_size= icodec->extradata_size;
- codec->time_base = icodec->time_base;
+ if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
+ codec->time_base = icodec->time_base;
+ else
+ codec->time_base = ist->st->time_base;
switch(codec->codec_type) {
case CODEC_TYPE_AUDIO:
codec->sample_rate = icodec->sample_rate;
codec->block_align= icodec->block_align;
break;
case CODEC_TYPE_VIDEO:
+ codec->pix_fmt = icodec->pix_fmt;
codec->width = icodec->width;
codec->height = icodec->height;
codec->has_b_frames = icodec->has_b_frames;
} else {
switch(codec->codec_type) {
case CODEC_TYPE_AUDIO:
- if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
+ if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
goto fail;
if (codec->channels == icodec->channels &&
ost->encoding_needed = 1;
break;
case CODEC_TYPE_VIDEO:
- if (codec->width == icodec->width &&
- codec->height == icodec->height &&
- frame_topBand == 0 &&
- frame_bottomBand == 0 &&
- frame_leftBand == 0 &&
- frame_rightBand == 0 &&
- frame_padtop == 0 &&
- frame_padbottom == 0 &&
- frame_padleft == 0 &&
- frame_padright == 0)
- {
- ost->video_resample = 0;
- ost->video_crop = 0;
- ost->video_pad = 0;
- } else if ((codec->width == icodec->width -
- (frame_leftBand + frame_rightBand)) &&
- (codec->height == icodec->height -
- (frame_topBand + frame_bottomBand)))
- {
- ost->video_resample = 0;
- ost->video_crop = 1;
+ ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
+ ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
+ ost->video_resample = ((codec->width != icodec->width -
+ (frame_leftBand + frame_rightBand) +
+ (frame_padleft + frame_padright)) ||
+ (codec->height != icodec->height -
+ (frame_topBand + frame_bottomBand) +
+ (frame_padtop + frame_padbottom)) ||
+ (codec->pix_fmt != icodec->pix_fmt));
+ if (ost->video_crop) {
ost->topBand = frame_topBand;
ost->leftBand = frame_leftBand;
- } else if ((codec->width == icodec->width +
- (frame_padleft + frame_padright)) &&
- (codec->height == icodec->height +
- (frame_padtop + frame_padbottom))) {
- ost->video_resample = 0;
- ost->video_crop = 0;
- ost->video_pad = 1;
+ }
+ if (ost->video_pad) {
ost->padtop = frame_padtop;
ost->padleft = frame_padleft;
ost->padbottom = frame_padbottom;
ost->padright = frame_padright;
+ 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;
+ }
+ }
+ if (ost->video_resample) {
avcodec_get_frame_defaults(&ost->pict_tmp);
- if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
- codec->width, codec->height ) )
- goto fail;
- } else {
- ost->video_resample = 1;
- ost->video_crop = 0; // cropping is handled as part of resample
- avcodec_get_frame_defaults(&ost->pict_tmp);
- if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
+ if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
codec->width, codec->height ) )
goto fail;
- ost->img_resample_ctx = img_resample_full_init(
- codec->width, codec->height,
- icodec->width, icodec->height,
- frame_topBand, frame_bottomBand,
- frame_leftBand, frame_rightBand,
- frame_padtop, frame_padbottom,
- frame_padleft, frame_padright);
-
- ost->padtop = frame_padtop;
- ost->padleft = frame_padleft;
- ost->padbottom = frame_padbottom;
- ost->padright = frame_padright;
-
+ ost->img_resample_ctx = sws_getContext(
+ icodec->width - (frame_leftBand + frame_rightBand),
+ icodec->height - (frame_topBand + frame_bottomBand),
+ icodec->pix_fmt,
+ codec->width - (frame_padleft + frame_padright),
+ codec->height - (frame_padtop + frame_padbottom),
+ codec->pix_fmt,
+ sws_flags, NULL, NULL, NULL);
+ if (ost->img_resample_ctx == NULL) {
+ fprintf(stderr, "Cannot get resampling context\n");
+ exit(1);
+ }
+ ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
}
ost->encoding_needed = 1;
ist->decoding_needed = 1;
/* init pts */
for(i=0;i<nb_istreams;i++) {
ist = ist_table[i];
- is = input_files[ist->file_index];
+ 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)
}
}
-#ifndef CONFIG_WIN32
if ( !using_stdin && verbose >= 0) {
fprintf(stderr, "Press [q] to stop encoding\n");
url_set_interrupt_cb(decode_interrupt_cb);
}
-#endif
term_init();
stream_no_data = 0;
if (ist->discard)
goto discard_packet;
-// fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
+// 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(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
+ if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !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]);
fclose(ost->logfile);
ost->logfile = NULL;
}
- fifo_free(&ost->fifo); /* works even if fifo is not
- initialized but set to zero */
+ av_fifo_free(&ost->fifo); /* works even if fifo is not
+ initialized but set to zero */
av_free(ost->pict_tmp.data[0]);
if (ost->video_resample)
- img_resample_close(ost->img_resample_ctx);
+ sws_freeContext(ost->img_resample_ctx);
if (ost->audio_resample)
audio_resample_close(ost->resample);
av_free(ost);
}
#endif
-static void opt_image_format(const char *arg)
-{
- AVImageFormat *f;
-
- for(f = first_image_format; f != NULL; f = f->next) {
- if (!strcmp(arg, f->name))
- break;
- }
- if (!f) {
- fprintf(stderr, "Unknown image format: '%s'\n", arg);
- exit(1);
- }
- image_format = f;
-}
-
static void opt_format(const char *arg)
{
/* compatibility stuff for pgmyuv */
}
}
-static void opt_video_bitrate(const char *arg)
-{
- video_bit_rate = atoi(arg) * 1000;
-}
-
-static void opt_video_bitrate_tolerance(const char *arg)
-{
- video_bit_rate_tolerance = atoi(arg) * 1000;
-}
-
-static void opt_video_bitrate_max(const char *arg)
-{
- video_rc_max_rate = atoi(arg) * 1000;
-}
-
-static void opt_video_bitrate_min(const char *arg)
-{
- video_rc_min_rate = atoi(arg) * 1000;
-}
-
-static void opt_video_buffer_size(const char *arg)
-{
- video_rc_buffer_size = atoi(arg) * 8*1024;
-}
-
static void opt_video_rc_eq(char *arg)
{
video_rc_eq = arg;
video_rc_override_string = arg;
}
-
-static void opt_workaround_bugs(const char *arg)
-{
- workaround_bugs = atoi(arg);
-}
-
static void opt_me_threshold(const char *arg)
{
me_threshold = atoi(arg);
}
-static void opt_mb_threshold(const char *arg)
-{
- mb_threshold = atoi(arg);
-}
-
static void opt_verbose(const char *arg)
{
verbose = atoi(arg);
{
if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
fprintf(stderr, "Incorrect frame rate\n");
- exit(1);
+ exit(1);
}
}
exit(1);
}
if ((frame_topBand) >= frame_height){
- fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
+ fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
exit(1);
}
frame_height -= frame_topBand;
exit(1);
}
if ((frame_bottomBand) >= frame_height){
- fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
+ fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
exit(1);
}
frame_height -= frame_bottomBand;
exit(1);
}
if ((frame_leftBand) >= frame_width){
- fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
+ fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
exit(1);
}
frame_width -= frame_leftBand;
exit(1);
}
if ((frame_rightBand) >= frame_width){
- fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
+ fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
exit(1);
}
frame_width -= frame_rightBand;
#define SCALEBITS 10
#define ONE_HALF (1 << (SCALEBITS - 1))
-#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
+#define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
#define RGB_TO_Y(r, g, b) \
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
p = strchr(arg, ':');
if (p) {
x = strtol(arg, (char **)&arg, 10);
- if (arg == p)
- y = strtol(arg+1, (char **)&arg, 10);
- if (x > 0 && y > 0)
- ar = (double)x / (double)y;
+ if (arg == p)
+ y = strtol(arg+1, (char **)&arg, 10);
+ if (x > 0 && y > 0)
+ ar = (double)x / (double)y;
} else
ar = strtod(arg, (char **)&arg);
if (!ar) {
fprintf(stderr, "Incorrect aspect ratio specification.\n");
- exit(1);
- }
- frame_aspect_ratio = ar;
-}
-
-static void opt_gop_size(const char *arg)
-{
- gop_size = atoi(arg);
-}
-
-static void opt_b_frames(const char *arg)
-{
- b_frames = atoi(arg);
- if (b_frames > FF_MAX_B_FRAMES) {
- fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
- exit(1);
- } else if (b_frames < 1) {
- fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
exit(1);
}
-}
-
-static void opt_pre_me(const char *arg)
-{
- pre_me = atoi(arg);
+ frame_aspect_ratio = ar;
}
static void opt_qscale(const char *arg)
{
video_qscale = atof(arg);
- if (video_qscale < 0.01 ||
+ if (video_qscale <= 0 ||
video_qscale > 255) {
- fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
- exit(1);
- }
-}
-
-static void opt_qsquish(const char *arg)
-{
- video_qsquish = atof(arg);
- if (video_qsquish < 0.0 ||
- video_qsquish > 99.0) {
- fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
- exit(1);
- }
-}
-
-static void opt_lmax(const char *arg)
-{
- video_lmax = atof(arg)*FF_QP2LAMBDA;
-}
-
-static void opt_lmin(const char *arg)
-{
- video_lmin = atof(arg)*FF_QP2LAMBDA;
-}
-
-static void opt_qmin(const char *arg)
-{
- video_qmin = atoi(arg);
- if (video_qmin < 1 ||
- video_qmin > 31) {
- fprintf(stderr, "qmin must be >= 1 and <= 31\n");
- exit(1);
- }
-}
-
-static void opt_qmax(const char *arg)
-{
- video_qmax = atoi(arg);
- if (video_qmax < 1 ||
- video_qmax > 31) {
- fprintf(stderr, "qmax must be >= 1 and <= 31\n");
- exit(1);
- }
-}
-
-static void opt_mb_lmin(const char *arg)
-{
- video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
- if (video_mb_lmin < 1 ||
- video_mb_lmin > FF_LAMBDA_MAX) {
- fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
- exit(1);
- }
-}
-
-static void opt_mb_lmax(const char *arg)
-{
- video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
- if (video_mb_lmax < 1 ||
- video_mb_lmax > FF_LAMBDA_MAX) {
- fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
+ fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
exit(1);
}
}
}
}
-static void opt_qblur(const char *arg)
-{
- video_qblur = atof(arg);
-}
-
-static void opt_qcomp(const char *arg)
-{
- video_qcomp = atof(arg);
-}
-
-static void opt_rc_initial_cplx(const char *arg)
-{
- video_rc_initial_cplx = atof(arg);
-}
-static void opt_b_qfactor(const char *arg)
-{
- video_b_qfactor = atof(arg);
-}
-static void opt_i_qfactor(const char *arg)
-{
- video_i_qfactor = atof(arg);
-}
-static void opt_b_qoffset(const char *arg)
-{
- video_b_qoffset = atof(arg);
-}
-static void opt_i_qoffset(const char *arg)
-{
- video_i_qoffset = atof(arg);
-}
-
-static void opt_ibias(const char *arg)
-{
- video_intra_quant_bias = atoi(arg);
-}
-static void opt_pbias(const char *arg)
-{
- video_inter_quant_bias = atoi(arg);
-}
-
static void opt_packet_size(const char *arg)
{
packet_size= atoi(arg);
}
-static void opt_error_rate(const char *arg)
-{
- error_rate= atoi(arg);
-}
-
static void opt_strict(const char *arg)
{
strict= atoi(arg);
top_field_first= atoi(arg);
}
-static void opt_sc_threshold(const char *arg)
-{
- sc_threshold= atoi(arg);
-}
-
-static void opt_me_range(const char *arg)
-{
- me_range = atoi(arg);
-}
-
static void opt_thread_count(const char *arg)
{
thread_count= atoi(arg);
"phods",
"epzs",
"x1",
+ "hex",
+ "umh",
+ "iter",
NULL,
};
!strcmp( filename, "/dev/stdin" );
/* get default parameters from command line */
+ ic = av_alloc_format_context();
+
memset(ap, 0, sizeof(*ap));
+ 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->width = frame_width + frame_padleft + frame_padright;
ap->height = frame_height + frame_padtop + frame_padbottom;
- ap->image_format = image_format;
ap->pix_fmt = frame_pix_fmt;
ap->device = grab_device;
ap->channel = video_channel;
if(pgmyuv_compatibility_hack)
ap->video_codec_id= CODEC_ID_PGMYUV;
+ for(i=0; i<opt_name_count; i++){
+ AVOption *opt;
+ double d= av_get_double(avformat_opts, opt_names[i], &opt);
+ if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
+ av_set_double(ic, opt_names[i], d);
+ }
/* open the input file with generic libav function */
err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
if (err < 0) {
exit(1);
}
- if(genpts)
- ic->flags|= AVFMT_FLAG_GENPTS;
+ ic->loop_input = loop_input;
/* If not enough info to get the stream parameters, we decode the
first frames to get it. (used in mpeg case for example) */
}
frame_height = enc->height;
frame_width = enc->width;
- frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
- frame_pix_fmt = enc->pix_fmt;
+ frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
+ frame_pix_fmt = enc->pix_fmt;
rfps = ic->streams[i]->r_frame_rate.num;
rfps_base = ic->streams[i]->r_frame_rate.den;
- enc->workaround_bugs = workaround_bugs;
if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
if(me_threshold)
enc->debug |= FF_DEBUG_MV;
nb_input_files++;
file_iformat = NULL;
file_oformat = NULL;
- image_format = NULL;
grab_device = NULL;
video_channel = 0;
fprintf(stderr, "Could not alloc stream\n");
exit(1);
}
+ 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);
av_set_double(video_enc, opt_names[i], d);
}
- video_enc->bit_rate = video_bit_rate;
- video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
video_enc->time_base.den = frame_rate;
video_enc->time_base.num = frame_rate_base;
if(codec && codec->supported_framerates){
video_enc->width = frame_width + frame_padright + frame_padleft;
video_enc->height = frame_height + frame_padtop + frame_padbottom;
- video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
+ video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
video_enc->pix_fmt = frame_pix_fmt;
if(codec && codec->pix_fmts){
video_enc->pix_fmt = codec->pix_fmts[0];
}
- if (!intra_only)
- video_enc->gop_size = gop_size;
- else
+ if (intra_only)
video_enc->gop_size = 0;
if (video_qscale || same_quality) {
video_enc->flags |= CODEC_FLAG_QSCALE;
if(inter_matrix)
video_enc->inter_matrix = inter_matrix;
- video_enc->pre_me = pre_me;
-
- if (b_frames) {
- video_enc->max_b_frames = b_frames;
- video_enc->b_frame_strategy = b_strategy;
- video_enc->b_quant_factor = 2.0;
- }
- video_enc->qmin = video_qmin;
- video_enc->qmax = video_qmax;
- video_enc->lmin = video_lmin;
- video_enc->lmax = video_lmax;
- video_enc->rc_qsquish = video_qsquish;
- video_enc->mb_lmin = video_mb_lmin;
- video_enc->mb_lmax = video_mb_lmax;
video_enc->max_qdiff = video_qdiff;
- video_enc->qblur = video_qblur;
- video_enc->qcompress = video_qcomp;
video_enc->rc_eq = video_rc_eq;
- video_enc->workaround_bugs = workaround_bugs;
video_enc->thread_count = thread_count;
p= video_rc_override_string;
for(i=0; p; i++){
if(p) p++;
}
video_enc->rc_override_count=i;
-
- video_enc->rc_max_rate = video_rc_max_rate;
- video_enc->rc_min_rate = video_rc_min_rate;
- video_enc->rc_buffer_size = video_rc_buffer_size;
- video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
- video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
- video_enc->rc_initial_cplx= video_rc_initial_cplx;
- video_enc->i_quant_factor = video_i_qfactor;
- video_enc->b_quant_factor = video_b_qfactor;
- video_enc->i_quant_offset = video_i_qoffset;
- video_enc->b_quant_offset = video_b_qoffset;
- video_enc->intra_quant_bias = video_intra_quant_bias;
- video_enc->inter_quant_bias = video_inter_quant_bias;
+ video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
video_enc->me_threshold= me_threshold;
- video_enc->mb_threshold= mb_threshold;
video_enc->intra_dc_precision= intra_dc_precision - 8;
video_enc->strict_std_compliance = strict;
- video_enc->error_rate = error_rate;
- video_enc->scenechange_threshold= sc_threshold;
- video_enc->me_range = me_range;
- video_enc->me_penalty_compensation= me_penalty_compensation;
- video_enc->frame_skip_threshold= frame_skip_threshold;
- video_enc->frame_skip_factor= frame_skip_factor;
- video_enc->frame_skip_exp= frame_skip_exp;
if(packet_size){
video_enc->rtp_mode= 1;
fprintf(stderr, "Could not alloc stream\n");
exit(1);
}
+
+ 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);
audio_enc = st->codec;
audio_enc->codec_type = CODEC_TYPE_AUDIO;
+ audio_enc->strict_std_compliance = strict;
if(audio_codec_tag)
audio_enc->codec_tag= audio_codec_tag;
audio_enc->flags |= CODEC_FLAG_QSCALE;
audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
}
- audio_enc->strict_std_compliance = strict;
audio_enc->thread_count = thread_count;
/* For audio codecs other than AC3 or DTS we limit */
/* the number of coded channels to stereo */
static void opt_output_file(const char *filename)
{
AVFormatContext *oc;
- int use_video, use_audio, input_has_video, input_has_audio;
+ int use_video, use_audio, input_has_video, input_has_audio, i;
AVFormatParameters params, *ap = ¶ms;
if (!strcmp(filename, "-"))
new_audio_stream(oc);
}
- if (!oc->nb_streams) {
- fprintf(stderr, "No audio or video streams available\n");
- exit(1);
- }
-
oc->timestamp = rec_timestamp;
- if (str_title)
+ if (str_title)
pstrcpy(oc->title, sizeof(oc->title), str_title);
if (str_author)
pstrcpy(oc->author, sizeof(oc->author), str_author);
pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
if (str_comment)
pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
+ if (str_album)
+ pstrcpy(oc->album, sizeof(oc->album), str_album);
}
output_files[nb_output_files++] = oc;
/* check filename in case of an image number is expected */
if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
- if (filename_number_test(oc->filename) < 0) {
+ if (!av_filename_number_test(oc->filename)) {
print_error(oc->filename, AVERROR_NUMEXPECTED);
exit(1);
}
fprintf(stderr, "Not overwriting - exiting\n");
exit(1);
}
- }
- else {
+ }
+ else {
fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
exit(1);
- }
+ }
}
}
}
memset(ap, 0, sizeof(*ap));
- ap->image_format = image_format;
if (av_set_parameters(oc, ap) < 0) {
fprintf(stderr, "%s: Invalid encoding parameters\n",
oc->filename);
exit(1);
}
- oc->packet_size= mux_packet_size;
- oc->mux_rate= mux_rate;
oc->preload= (int)(mux_preload*AV_TIME_BASE);
oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
oc->loop_output = loop_output;
+ for(i=0; i<opt_name_count; i++){
+ AVOption *opt;
+ double d = av_get_double(avformat_opts, opt_names[i], &opt);
+ if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
+ av_set_double(oc, opt_names[i], d);
+ }
+
/* reset some options */
file_oformat = NULL;
file_iformat = NULL;
- image_format = NULL;
}
/* prepare dummy protocols for grab */
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;
fmt1 = av_find_input_format(video_grab_format);
vp->device = video_device;
vp->channel = video_channel;
- vp->standard = video_standard;
+ 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) {
+ if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
fprintf(stderr, "Could not find video grab parameters\n");
exit(1);
}
do_pass = pass;
}
-#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
+#if defined(__MINGW32__) || defined(CONFIG_OS2)
static int64_t getutime(void)
{
return av_gettime();
}
#endif
+#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
extern int ffm_nopts;
+#endif
static void show_formats(void)
{
AVInputFormat *ifmt;
AVOutputFormat *ofmt;
- AVImageFormat *image_fmt;
URLProtocol *up;
AVCodec *p, *p2;
const char **pp, *last_name;
}
printf("\n");
- printf("Image formats (filename extensions, if any, follow):\n");
- for(image_fmt = first_image_format; image_fmt != NULL;
- image_fmt = image_fmt->next) {
- printf(
- " %s%s %-6s %s\n",
- image_fmt->img_read ? "D":" ",
- image_fmt->img_write ? "E":" ",
- image_fmt->name,
- image_fmt->extensions ? image_fmt->extensions:" ");
- }
- printf("\n");
-
printf("Codecs:\n");
last_name= "000";
for(;;){
exit(1);
}
-void parse_matrix_coeffs(uint16_t *dest, const char *str)
+static void parse_matrix_coeffs(uint16_t *dest, const char *str)
{
int i;
const char *p = str;
}
}
-void opt_inter_matrix(const char *arg)
+static void opt_inter_matrix(const char *arg)
{
inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
parse_matrix_coeffs(inter_matrix, arg);
}
-void opt_intra_matrix(const char *arg)
+static void opt_intra_matrix(const char *arg)
{
intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
parse_matrix_coeffs(intra_matrix, arg);
opt_frame_size(norm ? "352x240" : "352x288");
opt_frame_rate(frame_rates[norm]);
- opt_gop_size(norm ? "18" : "15");
+ opt_default("gop", norm ? "18" : "15");
- video_bit_rate = 1150000;
- video_rc_max_rate = 1150000;
- video_rc_min_rate = 1150000;
- video_rc_buffer_size = 40*1024*8;
+ opt_default("b", "1150000");
+ opt_default("maxrate", "1150000");
+ opt_default("minrate", "1150000");
+ opt_default("bufsize", "327680"); // 40*1024*8;
audio_bit_rate = 224000;
audio_sample_rate = 44100;
- mux_packet_size= 2324;
- mux_rate= 2352 * 75 * 8;
+ opt_default("packetsize", "2324");
+ opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
/* We have to offset the PTS, so that it is consistent with the SCR.
SCR starts at 36000, but the first two packs contain only padding
opt_frame_size(norm ? "480x480" : "480x576");
opt_frame_rate(frame_rates[norm]);
- opt_gop_size(norm ? "18" : "15");
+ opt_default("gop", norm ? "18" : "15");
- video_bit_rate = 2040000;
- video_rc_max_rate = 2516000;
- video_rc_min_rate = 0; //1145000;
- video_rc_buffer_size = 224*1024*8;
+ opt_default("b", "2040000");
+ opt_default("maxrate", "2516000");
+ opt_default("minrate", "0"); //1145000;
+ opt_default("bufsize", "1835008"); //224*1024*8;
opt_default("flags", "+SCAN_OFFSET");
audio_bit_rate = 224000;
audio_sample_rate = 44100;
- mux_packet_size= 2324;
+ opt_default("packetsize", "2324");
} else if(!strcmp(arg, "dvd")) {
opt_frame_size(norm ? "720x480" : "720x576");
opt_frame_rate(frame_rates[norm]);
- opt_gop_size(norm ? "18" : "15");
+ opt_default("gop", norm ? "18" : "15");
- video_bit_rate = 6000000;
- video_rc_max_rate = 9000000;
- video_rc_min_rate = 0; //1500000;
- video_rc_buffer_size = 224*1024*8;
+ opt_default("b", "6000000");
+ opt_default("maxrate", "9000000");
+ opt_default("minrate", "0"); //1500000;
+ opt_default("bufsize", "1835008"); //224*1024*8;
- mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
- mux_rate = 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;
audio_sample_rate = 48000;
- } else if(!strcmp(arg, "dv")) {
+ } else if(!strncmp(arg, "dv", 2)) {
opt_format("dv");
opt_frame_size(norm ? "720x480" : "720x576");
+ opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
+ (norm ? "yuv411p" : "yuv420p"));
opt_frame_rate(frame_rates[norm]);
audio_sample_rate = 48000;
}
}
+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);
+ exit(1);
+ }
+
+ bsfp= &video_bitstream_filters;
+ while(*bsfp)
+ bsfp= &(*bsfp)->next;
+
+ *bsfp= bsfc;
+}
+
+//FIXME avoid audio - video code duplication
+static void opt_audio_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);
+ exit(1);
+ }
+
+ bsfp= &audio_bitstream_filters;
+ while(*bsfp)
+ bsfp= &(*bsfp)->next;
+
+ *bsfp= bsfc;
+}
+
static void show_version(void)
{
+ /* TODO: add function interface to avutil and avformat */
fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
+ "libavutil %d\n"
"libavcodec %d\n"
"libavformat %d\n",
- avcodec_build(), LIBAVFORMAT_BUILD);
+ LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
exit(1);
}
static int opt_default(const char *opt, const char *arg){
AVOption *o= av_set_string(avctx_opts, opt, arg);
+ if(!o)
+ o = av_set_string(avformat_opts, opt, arg);
if(!o)
return -1;
opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
opt_names[opt_name_count++]= o->name;
+#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)
ffm_nopts = 1;
+#endif
if(avctx_opts->debug)
av_log_set_level(AV_LOG_DEBUG);
{ "version", 0, {(void*)show_version}, "show version" },
{ "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
{ "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
- { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_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]" },
{ "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
{ "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
{ "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
+ { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
{ "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
"add timings for benchmarking" },
{ "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
{ "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
"when dumping packets, also dump the payload" },
{ "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
- { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
+ { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
{ "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
{ "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
- { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
+ { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
{ "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", "" },
{ "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
{ "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_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", "" },
/* video options */
- { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
{ "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" },
{ "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
{ "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
{ "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
- { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
{ "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
{ "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
{ "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
- { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
- { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
- { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
- { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
- { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
- { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
- { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
- { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
- { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
- { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
- { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
- { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
- { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
- { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
- { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
- { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
- { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
- { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
- { "b_strategy", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&b_strategy}, "dynamic b frame selection strategy", "strategy" },
+ { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
+ { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
{ "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" },
- { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
- { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
- { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
- { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
{ "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", "" },
- { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
- { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
- { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
- { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
{ "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
- { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
{ "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)" },
{ "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", "" },
- { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
- { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
{ "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
- { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
{ "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
- { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
- { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
- { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
{ "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
- { "genpts", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&genpts }, "generate pts" },
{ "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
/* audio options */
{ "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
/* muxer options */
- { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
- { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
{ "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" },
+
{ "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 ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
- LIBAVCODEC_BUILD);
- fprintf(stderr, " configuration: %s\n", FFMPEG_CONFIGURATION);
+ 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: %s\n", __VERSION__);
+ fprintf(stderr, ", gcc: " __VERSION__ "\n");
#else
fprintf(stderr, ", using a non-gcc compiler\n");
#endif
show_banner();
#ifdef CONFIG_GPL
printf(
- "This program is free software; you can redistribute it and/or modify\n"
+ "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"
- "This program is distributed in the hope that it will be useful,\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 this program; if not, write to the Free Software\n"
- "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\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(
- "This library is free software; you can redistribute it and/or\n"
+ "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 of the License, or (at your option) any later version.\n"
+ "version 2.1 of the License, or (at your option) any later version.\n"
"\n"
- "This library is distributed in the hope that it will be useful,\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 this library; if not, write to the Free Software\n"
- "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\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);
OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
OPT_EXPERT);
av_opt_show(avctx_opts, NULL);
+ av_opt_show(avformat_opts, NULL);
exit(1);
}
av_register_all();
avctx_opts= avcodec_alloc_context();
+ avformat_opts = av_alloc_format_context();
if (argc <= 1)
show_help();
for(i=0;i<nb_output_files;i++) {
/* maybe av_close_output_file ??? */
AVFormatContext *s = output_files[i];
- int j;
+ int j;
if (!(s->oformat->flags & AVFMT_NOFILE))
- url_fclose(&s->pb);
- for(j=0;j<s->nb_streams;j++)
- av_free(s->streams[j]);
+ url_fclose(&s->pb);
+ for(j=0;j<s->nb_streams;j++) {
+ av_free(s->streams[j]->codec);
+ av_free(s->streams[j]);
+ }
av_free(s);
}
for(i=0;i<nb_input_files;i++)
powerpc_display_perf_report();
#endif /* POWERPC_PERFORMANCE_REPORT */
-#ifndef CONFIG_WIN32
if (received_sigterm) {
fprintf(stderr,
"Received signal %d: terminating.\n",
(int) received_sigterm);
exit (255);
}
-#endif
+
exit(0); /* not all OS-es handle main() return value */
return 0;
}
projects / ffmpeg / blobdiff