X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=ffmpeg.c;h=8a47834b07e7e75a562772703702fe053b2f9636;hb=6ebc89ac484bd32bd8650a927b1132c22336659e;hp=dc53f34c34698068d838f5577bffebc711b16b7b;hpb=46eab09341d3496ad680bb1bf609ea38c7deea66;p=ffmpeg diff --git a/ffmpeg.c b/ffmpeg.c index dc53f34c346..8a47834b07e 100644 --- a/ffmpeg.c +++ b/ffmpeg.c @@ -55,7 +55,6 @@ #undef time //needed because HAVE_AV_CONFIG_H is defined on top #include -#include "version.h" #include "cmdutils.h" #undef NDEBUG @@ -64,7 +63,7 @@ #undef exit const char program_name[] = "FFmpeg"; -static const int program_birth_year = 2000; +const int program_birth_year = 2000; /* select an input stream for an output stream */ typedef struct AVStreamMap { @@ -86,6 +85,7 @@ static const OptionDef options[]; static AVFormatContext *input_files[MAX_FILES]; static int64_t input_files_ts_offset[MAX_FILES]; +static double input_files_ts_scale[MAX_FILES][MAX_STREAMS]; static int nb_input_files = 0; static AVFormatContext *output_files[MAX_FILES]; @@ -113,9 +113,8 @@ static int frame_bottomBand = 0; static int frame_leftBand = 0; static int frame_rightBand = 0; static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX}; -static AVRational frame_rate = (AVRational) {0,0}; +static AVRational frame_rate; static float video_qscale = 0; -static int video_qdiff = 3; static uint16_t *intra_matrix = NULL; static uint16_t *inter_matrix = NULL; #if 0 //experimental, (can be removed) @@ -155,7 +154,7 @@ static char *subtitle_language = NULL; static float mux_preload= 0.5; static float mux_max_delay= 0.7; -static int64_t recording_time = 0; +static int64_t recording_time = INT64_MAX; static int64_t start_time = 0; static int64_t rec_timestamp = 0; static int64_t input_ts_offset = 0; @@ -175,7 +174,7 @@ static char *pass_logfilename = NULL; static int audio_stream_copy = 0; static int video_stream_copy = 0; static int subtitle_stream_copy = 0; -static int video_sync_method= 1; +static int video_sync_method= -1; static int audio_sync_method= 0; static float audio_drift_threshold= 0.1; static int copy_ts= 0; @@ -393,8 +392,6 @@ static int av_exit(int ret) for(i=0;icodec = avcodec_alloc_context(); memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext)); s->streams[i] = st; + + if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy) + st->stream_copy = 1; + else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy) + st->stream_copy = 1; + + if(!st->codec->thread_count) + st->codec->thread_count = 1; + if(st->codec->thread_count>1) + avcodec_thread_init(st->codec, st->codec->thread_count); + + if(st->codec->flags & CODEC_FLAG_BITEXACT) + nopts = 1; } + if (!nopts) + s->timestamp = av_gettime(); + av_close_input_file(ic); return 0; } @@ -587,15 +601,17 @@ static void do_audio_out(AVFormatContext *s, /* now encode as many frames as possible */ if (enc->frame_size > 1) { /* output resampled raw samples */ - av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out + 1); - av_fifo_write(&ost->fifo, buftmp, size_out); + av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out); + av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL); frame_bytes = enc->frame_size * 2 * enc->channels; - while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) { + while (av_fifo_size(&ost->fifo) >= frame_bytes) { AVPacket pkt; av_init_packet(&pkt); + av_fifo_read(&ost->fifo, audio_buf, frame_bytes); + //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio() ret = avcodec_encode_audio(enc, audio_out, audio_out_size, @@ -782,7 +798,7 @@ static void do_video_out(AVFormatContext *s, *frame_size = 0; - if(video_sync_method){ + if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){ double vdelta; vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts; //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c @@ -902,16 +918,17 @@ static void do_video_out(AVFormatContext *s, if(ret>0){ pkt.data= bit_buffer; pkt.size= ret; - if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE) + if(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 -> %"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) + if(enc->coded_frame->key_frame) pkt.flags |= PKT_FLAG_KEY; write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); *frame_size = ret; + video_size += ret; //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d", // enc->frame_number-1, enc->real_pict_num, ret, // enc->pict_type); @@ -1010,7 +1027,7 @@ static void print_report(AVFormatContext **output_files, enc = ost->st->codec; if (vid && enc->codec_type == CODEC_TYPE_VIDEO) { snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", - enc->coded_frame && !ost->st->stream_copy ? + !ost->st->stream_copy ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1); } if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) { @@ -1019,11 +1036,11 @@ static void print_report(AVFormatContext **output_files, frame_number = ost->frame_number; snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ", frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, - enc->coded_frame && !ost->st->stream_copy ? + !ost->st->stream_copy ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1); if(is_last_report) snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L"); - if(qp_hist && enc->coded_frame){ + if(qp_hist){ int j; int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA); if(qp>=0 && qpsize; ptr = pkt->data; - while (len > 0) { + + //while we have more to decode or while the decoder did output something on EOF + while (len > 0 || (!pkt && ist->next_pts != ist->pts)) { handle_eof: ist->pts= ist->next_pts; @@ -1283,7 +1302,6 @@ static int output_packet(AVInputStream *ist, int ist_index, break; case CODEC_TYPE_VIDEO: do_video_out(os, ost, ist, &picture, &frame_size); - video_size += frame_size; if (vstats_filename && frame_size) do_video_stats(os, ost, frame_size); break; @@ -1322,10 +1340,10 @@ static int output_packet(AVInputStream *ist, int ist_index, else opkt.pts= AV_NOPTS_VALUE; - if (pkt->dts == AV_NOPTS_VALUE) - opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base); - else - opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base); + if (pkt->dts == AV_NOPTS_VALUE) + opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base); + else + opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base); opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base); opkt.flags= pkt->flags; @@ -1385,9 +1403,8 @@ static int output_packet(AVInputStream *ist, int ist_index, 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) { + av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes); ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples); - } enc->frame_size = fs_tmp; } if(ret <= 0) { @@ -1620,6 +1637,8 @@ static int av_encode(AVFormatContext **output_files, } } if (!found) { + int i= ost->file_index; + dump_format(output_files[i], i, output_files[i]->filename, 1); fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n", ost->file_index, ost->index); av_exit(1); @@ -1670,12 +1689,18 @@ static int av_encode(AVFormatContext **output_files, codec->time_base = ist->st->time_base; switch(codec->codec_type) { case CODEC_TYPE_AUDIO: + if(audio_volume != 256) { + fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n"); + av_exit(1); + } codec->sample_rate = icodec->sample_rate; codec->channels = icodec->channels; codec->frame_size = icodec->frame_size; codec->block_align= icodec->block_align; if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3) codec->block_align= 0; + if(codec->codec_id == CODEC_ID_AC3) + codec->block_align= 0; break; case CODEC_TYPE_VIDEO: if(using_vhook) { @@ -1723,15 +1748,15 @@ static int av_encode(AVFormatContext **output_files, 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 ) ) + 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, codec->pix_fmt, - codec->width, codec->height ) ) { + if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt, + codec->width, codec->height)) { fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n"); av_exit(1); } @@ -1893,12 +1918,12 @@ static int av_encode(AVFormatContext **output_files, int out_file_index = meta_data_maps[i].out_file; int in_file_index = meta_data_maps[i].in_file; - if ( out_file_index < 0 || out_file_index >= nb_output_files ) { + 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 = AVERROR(EINVAL); goto fail; } - if ( in_file_index < 0 || in_file_index >= nb_input_files ) { + 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 = AVERROR(EINVAL); goto fail; @@ -1933,7 +1958,7 @@ static int av_encode(AVFormatContext **output_files, print_sdp(output_files, nb_output_files); } - if ( !using_stdin && verbose >= 0) { + if (!using_stdin && verbose >= 0) { fprintf(stderr, "Press [q] to stop encoding\n"); url_set_interrupt_cb(decode_interrupt_cb); } @@ -1995,7 +2020,7 @@ static int av_encode(AVFormatContext **output_files, } /* finish if recording time exhausted */ - if (recording_time > 0 && opts_min >= (recording_time / 1000000.0)) + if (opts_min >= (recording_time / 1000000.0)) break; /* finish if limit size exhausted */ @@ -2029,6 +2054,13 @@ static int av_encode(AVFormatContext **output_files, if (pkt.pts != AV_NOPTS_VALUE) pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base); + if(input_files_ts_scale[file_index][pkt.stream_index]){ + if(pkt.pts != AV_NOPTS_VALUE) + pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index]; + if(pkt.dts != AV_NOPTS_VALUE) + pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index]; + } + // 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 pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q); @@ -2177,8 +2209,6 @@ static void opt_format(const char *arg) } } -extern int ffm_nopts; - static int opt_default(const char *opt, const char *arg){ int type; const AVOption *o= NULL; @@ -2187,19 +2217,19 @@ static int opt_default(const char *opt, const char *arg){ for(type=0; typename; -#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[0]->flags & CODEC_FLAG_BITEXACT) - ffm_nopts = 1; -#endif - - if(avctx_opts[0]->debug) + if(avctx_opts[0]->debug || avformat_opts->debug) av_log_set_level(AV_LOG_DEBUG); return 0; } @@ -2483,16 +2507,6 @@ static void opt_qscale(const char *arg) } } -static void opt_qdiff(const char *arg) -{ - video_qdiff = atoi(arg); - if (video_qdiff < 0 || - video_qdiff > 31) { - fprintf(stderr, "qdiff must be >= 1 and <= 31\n"); - av_exit(1); - } -} - static void opt_strict(const char *arg) { strict= atoi(arg); @@ -2503,13 +2517,14 @@ static void opt_top_field_first(const char *arg) top_field_first= atoi(arg); } -static void opt_thread_count(const char *arg) +static int opt_thread_count(const char *opt, const char *arg) { - thread_count= atoi(arg); + thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX); #if !defined(HAVE_THREADS) if (verbose >= 0) fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n"); #endif + return 0; } static int opt_audio_rate(const char *opt, const char *arg) @@ -2639,6 +2654,23 @@ static void opt_map_meta_data(const char *arg) m->in_file = strtol(p, &p, 0); } +static void opt_input_ts_scale(const char *arg) +{ + unsigned int stream; + double scale; + char *p; + + stream = strtol(arg, &p, 0); + if (*p) + p++; + scale= strtod(p, &p); + + if(stream >= MAX_STREAMS) + av_exit(1); + + input_files_ts_scale[nb_input_files][stream]= scale; +} + static int opt_recording_time(const char *opt, const char *arg) { recording_time = parse_time_or_die(opt, arg, 1); @@ -2684,6 +2716,19 @@ static enum CodecID find_codec_or_die(const char *name, int type, int encoder) return codec->id; } +static void set_context_opts(void *ctx, void *opts_ctx, int flags) +{ + int i; + for(i=0; iflags & flags) == flags)) + av_set_string2(ctx, opt_names[i], str, 1); + } +} + static void opt_input_file(const char *filename) { AVFormatContext *ic; @@ -2695,7 +2740,7 @@ static void opt_input_file(const char *filename) filename = "pipe:"; using_stdin |= !strncmp(filename, "pipe:", 5) || - !strcmp( filename, "/dev/stdin" ); + !strcmp(filename, "/dev/stdin"); /* get default parameters from command line */ ic = av_alloc_format_context(); @@ -2716,13 +2761,7 @@ static void opt_input_file(const char *filename) if(pgmyuv_compatibility_hack) ap->video_codec_id= CODEC_ID_PGMYUV; - for(i=0; iflags & AV_OPT_FLAG_DECODING_PARAM)) - av_set_string(ic, opt_names[i], str); - } + set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM); ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0); ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0); @@ -2769,20 +2808,13 @@ static void opt_input_file(const char *filename) /* update the current parameters so that they match the one of the input stream */ for(i=0;inb_streams;i++) { - int j; AVCodecContext *enc = ic->streams[i]->codec; if(thread_count>1) avcodec_thread_init(enc, thread_count); enc->thread_count= thread_count; switch(enc->codec_type) { case CODEC_TYPE_AUDIO: - for(j=0; jflags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM)) - av_set_string(enc, opt_names[j], str); - } + set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM); //fprintf(stderr, "\nInput Audio channels: %d", enc->channels); audio_channels = enc->channels; audio_sample_rate = enc->sample_rate; @@ -2790,13 +2822,7 @@ static void opt_input_file(const char *filename) ic->streams[i]->discard= AVDISCARD_ALL; break; case CODEC_TYPE_VIDEO: - for(j=0; jflags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM)) - av_set_string(enc, opt_names[j], str); - } + set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM); frame_height = enc->height; frame_width = enc->width; frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height; @@ -2943,13 +2969,7 @@ static void new_video_stream(AVFormatContext *oc) video_enc->codec_id = codec_id; codec = avcodec_find_encoder(codec_id); - for(i=0; iflags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM)) - av_set_string(video_enc, opt_names[i], str); - } + set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM); video_enc->time_base.den = fps.num; video_enc->time_base.num = fps.den; @@ -2997,7 +3017,6 @@ static void new_video_stream(AVFormatContext *oc) if(inter_matrix) video_enc->inter_matrix = inter_matrix; - video_enc->max_qdiff = video_qdiff; video_enc->thread_count = thread_count; p= video_rc_override_string; for(i=0; p; i++){ @@ -3053,7 +3072,7 @@ static void new_audio_stream(AVFormatContext *oc) { AVStream *st; AVCodecContext *audio_enc; - int codec_id, i; + int codec_id; st = av_new_stream(oc, oc->nb_streams); if (!st) { @@ -3085,13 +3104,7 @@ static void new_audio_stream(AVFormatContext *oc) } else { codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO); - for(i=0; iflags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM)) - av_set_string(audio_enc, opt_names[i], str); - } + set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM); if (audio_codec_name) codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1); @@ -3122,7 +3135,6 @@ static void new_subtitle_stream(AVFormatContext *oc) { AVStream *st; AVCodecContext *subtitle_enc; - int i; st = av_new_stream(oc, oc->nb_streams); if (!st) { @@ -3139,13 +3151,7 @@ static void new_subtitle_stream(AVFormatContext *oc) if (subtitle_stream_copy) { st->stream_copy = 1; } else { - for(i=0; iflags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM)) - av_set_string(subtitle_enc, opt_names[i], str); - } + set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM); subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1); } @@ -3197,7 +3203,7 @@ static void opt_output_file(const char *filename) { AVFormatContext *oc; int use_video, use_audio, use_subtitle; - int input_has_video, input_has_audio, input_has_subtitle, i; + int input_has_video, input_has_audio, input_has_subtitle; AVFormatParameters params, *ap = ¶ms; if (!strcmp(filename, "-")) @@ -3221,8 +3227,9 @@ static void opt_output_file(const char *filename) 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) { - fprintf(stderr, "Could not read stream parameters from '%s'\n", filename); + int err = read_ffserver_streams(oc, filename); + if (err < 0) { + print_error(filename, err); av_exit(1); } } else { @@ -3301,7 +3308,7 @@ static void opt_output_file(const char *filename) if (url_exist(filename)) { int c; - if ( !using_stdin ) { + if (!using_stdin) { fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename); fflush(stderr); c = getchar(); @@ -3309,11 +3316,11 @@ static void opt_output_file(const char *filename) fprintf(stderr, "Not overwriting - exiting\n"); av_exit(1); } - } - else { + } + else { fprintf(stderr,"File '%s' already exists. Exiting.\n", filename); av_exit(1); - } + } } } @@ -3335,13 +3342,7 @@ static void opt_output_file(const char *filename) oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE); oc->loop_output = loop_output; - for(i=0; iflags & AV_OPT_FLAG_ENCODING_PARAM)) - av_set_string(oc, opt_names[i], str); - } + set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM); /* reset some options */ file_oformat = NULL; @@ -3423,7 +3424,10 @@ static void show_help(void) "Hyper fast Audio and Video encoder\n"); printf("\n"); show_help_options(options, "Main options:\n", - OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0); + OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0); + show_help_options(options, "\nAdvanced options:\n", + OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, + OPT_EXPERT); show_help_options(options, "\nVideo options:\n", OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, OPT_VIDEO); @@ -3442,11 +3446,11 @@ static void show_help(void) show_help_options(options, "\nAudio/Video grab options:\n", OPT_GRAB, OPT_GRAB); - show_help_options(options, "\nAdvanced options:\n", - OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, - OPT_EXPERT); + printf("\n"); av_opt_show(avctx_opts[0], NULL); + printf("\n"); av_opt_show(avformat_opts, NULL); + printf("\n"); av_opt_show(sws_opts, NULL); } @@ -3633,6 +3637,54 @@ static int opt_bsf(const char *opt, const char *arg) return 0; } +static int opt_preset(const char *opt, const char *arg) +{ + FILE *f=NULL; + char tmp[1000], tmp2[1000]; + int i; + const char *base[3]= { getenv("HOME"), + "/usr/local/share", + "/usr/share", + }; + + for(i=!base[0]; i<3 && !f; i++){ + snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg); + f= fopen(tmp, "r"); + if(!f){ + char *codec_name= *opt == 'v' ? video_codec_name : + *opt == 'a' ? audio_codec_name : + subtitle_codec_name; + snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i], i ? "" : ".", codec_name, arg); + f= fopen(tmp, "r"); + } + } + + if(!f){ + fprintf(stderr, "Preset file not found\n"); + av_exit(1); + } + + while(!feof(f)){ + int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2); + if(e!=2){ + fprintf(stderr, "Preset file invalid\n"); + av_exit(1); + } + if(!strcmp(tmp, "acodec")){ + opt_audio_codec(tmp2); + }else if(!strcmp(tmp, "vcodec")){ + opt_video_codec(tmp2); + }else if(!strcmp(tmp, "scodec")){ + opt_subtitle_codec(tmp2); + }else + opt_default(tmp, tmp2); + } + + fclose(f); + + return 0; +} + static const OptionDef options[] = { /* main options */ { "L", OPT_EXIT, {(void*)show_license}, "show license" }, @@ -3648,6 +3700,7 @@ static const OptionDef options[] = { { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, // { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" }, { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" }, + { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" }, { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" }, { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" }, { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" }, @@ -3655,6 +3708,7 @@ static const OptionDef options[] = { { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" }, { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" }, { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" }, + { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" }, { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, "add timings for benchmarking" }, { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, @@ -3666,7 +3720,7 @@ static const OptionDef options[] = { { "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 | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" }, { "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" }, + { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" }, { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" }, { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" }, { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" }, @@ -3680,7 +3734,6 @@ static const OptionDef options[] = { { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" }, { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" }, { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" }, - { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" }, { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" }, { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" }, { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" }, @@ -3698,7 +3751,6 @@ static const OptionDef options[] = { { "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 quantizer scale (VBR)", "q" }, - { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" }, { "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_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" }, @@ -3751,9 +3803,13 @@ static const OptionDef options[] = { { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" }, { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" }, - { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" }, - { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" }, - { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" }, + { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" }, + { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" }, + { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" }, + + { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" }, + { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" }, + { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" }, { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" }, { NULL, }, @@ -3768,13 +3824,16 @@ int main(int argc, char **argv) avdevice_register_all(); av_register_all(); + if(isatty(STDIN_FILENO)) + url_set_interrupt_cb(decode_interrupt_cb); + for(i=0; i