* 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 "framehook.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>
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 sws_flags = SWS_BICUBIC;
-const char **opt_names=NULL;
-int opt_name_count=0;
-AVCodecContext *avctx_opts[CODEC_TYPE_NB];
-AVFormatContext *avformat_opts;
-struct SwsContext *sws_opts;
-static int64_t timer_start = 0;
+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 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;
}
pkt->pts);
break;
default:
- av_abort();
+ abort();
}
} else {
AVFrame avframe; //FIXME/XXX remove this
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;
fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
exit(1);
}
-#ifdef CONFIG_SWSCALER
sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
-#endif
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 */
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)
}
}
-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;
(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();
}
}
case CODEC_TYPE_SUBTITLE:
break;
default:
- av_abort();
+ abort();
}
}
}
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++){
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) {
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;
}
}
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;
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)) {
}
if(!o)
o = av_set_string(avformat_opts, opt, arg);
-#ifdef CONFIG_SWSCALER
if(!o)
o = av_set_string(sws_opts, opt, arg);
-#endif
if(!o){
if(opt[0] == 'a')
o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
{ "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", "" },
{ "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},
"\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(
OPT_EXPERT);
av_opt_show(avctx_opts[0], NULL);
av_opt_show(avformat_opts, NULL);
-#ifdef CONFIG_SWSCALER
av_opt_show(sws_opts, NULL);
-#endif
exit(1);
}
avctx_opts[i]= avcodec_alloc_context2(i);
}
avformat_opts = av_alloc_format_context();
-#ifdef CONFIG_SWSCALER
- sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, sws_flags, NULL,NULL,NULL);
-#endif
+ sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
if (argc <= 1)
show_help();
projects / ffmpeg / blobdiff