* 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
+ * 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 "opt.h"
#include "fifo.h"
-#ifndef __MINGW32__
+#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>
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 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 const char *audio_grab_format = "audio_device";
-static char *audio_device = NULL;
static int audio_volume = 256;
static int using_stdin = 0;
/* 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;
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), av_fifo_size(&ost->fifo)/(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);
}
}
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)
// 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);
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);*/
}
}
- ti = MAXINT64;
+ ti = INT64_MAX;
enc = ost->st->codec;
if (enc->codec_type == CODEC_TYPE_VIDEO) {
frame_number = ost->frame_number;
case CODEC_TYPE_AUDIO:{
if(pkt)
samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
+ data_size= samples_size;
/* XXX: could avoid copy if PCM 16 bits with same
endianness as CPU */
- ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
+ ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
ptr, len);
if (ret < 0)
goto fail_decode;
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:
+ 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;
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;
}
}
-#ifndef __MINGW32__
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) > 1LL*dts_delta_threshold*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]);
}
return ret;
fail:
- ret = -ENOMEM;
+ ret = AVERROR(ENOMEM);
goto fail1;
}
}
#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_verbose(const char *arg)
{
verbose = atoi(arg);
- av_log_set_level(atoi(arg));
+ av_log_level = atoi(arg);
}
static void opt_frame_rate(const char *arg)
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)
{
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;
ap->standard = video_standard;
ap->video_codec_id = video_codec_id;
ap->video_codec_id= CODEC_ID_PGMYUV;
for(i=0; i<opt_name_count; i++){
- AVOption *opt;
+ const AVOption *opt;
double d= av_get_double(avformat_opts, opt_names[i], &opt);
if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
av_set_double(ic, opt_names[i], d);
switch(enc->codec_type) {
case CODEC_TYPE_AUDIO:
for(j=0; j<opt_name_count; j++){
- AVOption *opt;
+ const AVOption *opt;
double d= av_get_double(avctx_opts, opt_names[j], &opt);
if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
av_set_double(enc, opt_names[j], d);
break;
case CODEC_TYPE_VIDEO:
for(j=0; j<opt_name_count; j++){
- AVOption *opt;
+ const AVOption *opt;
double d= av_get_double(avctx_opts, opt_names[j], &opt);
if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
av_set_double(enc, opt_names[j], d);
if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
if (verbose >= 0)
- fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
+ fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
(float)rfps / rfps_base, rfps, rfps_base);
nb_input_files++;
file_iformat = NULL;
file_oformat = NULL;
- image_format = 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;
codec = avcodec_find_encoder(codec_id);
for(i=0; i<opt_name_count; i++){
- AVOption *opt;
+ const AVOption *opt;
double d= av_get_double(avctx_opts, opt_names[i], &opt);
if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
av_set_double(video_enc, opt_names[i], d);
if(p) p++;
}
video_enc->rc_override_count=i;
- video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
+ if (!video_enc->rc_initial_buffer_occupancy)
+ video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
video_enc->me_threshold= me_threshold;
video_enc->intra_dc_precision= intra_dc_precision - 8;
video_enc->strict_std_compliance = strict;
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;
codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
for(i=0; i<opt_name_count; i++){
- AVOption *opt;
+ const AVOption *opt;
double d= av_get_double(avctx_opts, opt_names[i], &opt);
if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
av_set_double(audio_enc, opt_names[i], d);
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 */
- if (audio_channels > 2 && codec_id != CODEC_ID_AC3
- && codec_id != CODEC_ID_DTS) {
- audio_enc->channels = 2;
- } else
- audio_enc->channels = audio_channels;
+ audio_enc->channels = audio_channels;
}
audio_enc->sample_rate = audio_sample_rate;
audio_enc->time_base= (AVRational){1, audio_sample_rate};
st->stream_copy = 1;
} else {
for(i=0; i<opt_name_count; i++){
- AVOption *opt;
+ const AVOption *opt;
double d= av_get_double(avctx_opts, opt_names[i], &opt);
if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
av_set_double(subtitle_enc, opt_names[i], d);
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)
}
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);
oc->loop_output = loop_output;
for(i=0; i<opt_name_count; i++){
- AVOption *opt;
+ const AVOption *opt;
double d = av_get_double(avformat_opts, opt_names[i], &opt);
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 */
-static void prepare_grab(void)
-{
- int has_video, has_audio, i, j;
- AVFormatContext *oc;
- AVFormatContext *ic;
- AVFormatParameters vp1, *vp = &vp1;
- AVFormatParameters ap1, *ap = &ap1;
-
- /* see if audio/video inputs are needed */
- has_video = 0;
- has_audio = 0;
- memset(ap, 0, sizeof(*ap));
- memset(vp, 0, sizeof(*vp));
- vp->time_base.num= 1;
- for(j=0;j<nb_output_files;j++) {
- oc = output_files[j];
- for(i=0;i<oc->nb_streams;i++) {
- AVCodecContext *enc = oc->streams[i]->codec;
- switch(enc->codec_type) {
- case CODEC_TYPE_AUDIO:
- if (enc->sample_rate > ap->sample_rate)
- ap->sample_rate = enc->sample_rate;
- if (enc->channels > ap->channels)
- ap->channels = enc->channels;
- has_audio = 1;
- break;
- case CODEC_TYPE_VIDEO:
- if (enc->width > vp->width)
- vp->width = enc->width;
- if (enc->height > vp->height)
- vp->height = enc->height;
-
- if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
- vp->time_base = enc->time_base;
- vp->width += frame_leftBand + frame_rightBand;
- vp->width -= (frame_padleft + frame_padright);
- vp->height += frame_topBand + frame_bottomBand;
- vp->height -= (frame_padtop + frame_padbottom);
- }
- has_video = 1;
- break;
- default:
- av_abort();
- }
- }
- }
-
- if (has_video == 0 && has_audio == 0) {
- fprintf(stderr, "Output file must have at least one audio or video stream\n");
- exit(1);
- }
-
- if (has_video) {
- AVInputFormat *fmt1;
- fmt1 = av_find_input_format(video_grab_format);
- vp->device = video_device;
- vp->channel = video_channel;
- vp->standard = video_standard;
- vp->pix_fmt = frame_pix_fmt;
- if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
- fprintf(stderr, "Could not find video grab device\n");
- exit(1);
- }
- /* If not enough info to get the stream parameters, we decode the
- first frames to get it. */
- if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
- fprintf(stderr, "Could not find video grab parameters\n");
- exit(1);
- }
- /* by now video grab has one stream */
- ic->streams[0]->r_frame_rate.num = vp->time_base.den;
- ic->streams[0]->r_frame_rate.den = vp->time_base.num;
- input_files[nb_input_files] = ic;
-
- if (verbose >= 0)
- dump_format(ic, nb_input_files, "", 0);
-
- nb_input_files++;
- }
- if (has_audio && audio_grab_format) {
- AVInputFormat *fmt1;
- fmt1 = av_find_input_format(audio_grab_format);
- ap->device = audio_device;
- if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
- fprintf(stderr, "Could not find audio grab device\n");
- exit(1);
- }
- input_files[nb_input_files] = ic;
-
- if (verbose >= 0)
- dump_format(ic, nb_input_files, "", 0);
-
- nb_input_files++;
- }
}
/* same option as mencoder */
{
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(;;){
audio_bit_rate = 224000;
audio_sample_rate = 44100;
+ audio_channels = 2;
opt_default("packetsize", "2324");
opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
}
static int opt_default(const char *opt, const char *arg){
- AVOption *o= av_set_string(avctx_opts, opt, arg);
+ const AVOption *o= av_set_string(avctx_opts, opt, arg);
if(!o)
o = av_set_string(avformat_opts, opt, arg);
if(!o)
#endif
if(avctx_opts->debug)
- av_log_set_level(AV_LOG_DEBUG);
+ av_log_level = AV_LOG_DEBUG;
return 0;
}
{ "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]" },
{ "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" },
- { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
+ { "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" },
{ "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
{ "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" },
static void show_banner(void)
{
- fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2006 Fabrice Bellard, et al.\n");
+ fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 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");
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"
+ "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"
+ "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
}
if (nb_input_files == 0) {
- input_sync = 1;
- prepare_grab();
+ fprintf(stderr, "Must supply at least one input file\n");
+ exit(1);
}
ti = getutime();
int j;
if (!(s->oformat->flags & AVFMT_NOFILE))
url_fclose(&s->pb);
- for(j=0;j<s->nb_streams;j++)
+ 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++)
if(inter_matrix)
av_free(inter_matrix);
-#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 */
-#ifndef __MINGW32__
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;
}