#include "libavutil/channel_layout.h"
#include "libavutil/parseutils.h"
#include "libavutil/samplefmt.h"
-#include "libavutil/colorspace.h"
#include "libavutil/fifo.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/dict.h"
const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
-static void exit_program(void)
+static void avconv_cleanup(int ret)
{
int i, j;
/* close files */
for (i = 0; i < nb_output_files; i++) {
AVFormatContext *s = output_files[i]->ctx;
- if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
+ if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE) && s->pb)
avio_close(s->pb);
avformat_free_context(s);
av_dict_free(&output_files[i]->opts);
AVDictionaryEntry *t;
if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
- exit(1);
+ exit_program(1);
}
}
if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
codec_string, codec->name);
- exit(1);
+ exit_program(1);
}
/*
new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
av_buffer_default_free, NULL, 0);
if (!new_pkt.buf)
- exit(1);
+ exit_program(1);
} else if (a < 0) {
av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
bsfc->filter->name, pkt->stream_index,
avctx->codec ? avctx->codec->name : "copy");
print_error("", a);
if (exit_on_error)
- exit(1);
+ exit_program(1);
}
*pkt = new_pkt;
ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
if (exit_on_error) {
av_log(NULL, AV_LOG_FATAL, "aborting.\n");
- exit(1);
+ exit_program(1);
}
av_log(NULL, AV_LOG_WARNING, "changing to %"PRId64". This may result "
"in incorrect timestamps in the output file.\n",
ret = av_interleaved_write_frame(s, pkt);
if (ret < 0) {
print_error("av_interleaved_write_frame()", ret);
- exit(1);
+ exit_program(1);
}
}
if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
- exit(1);
+ exit_program(1);
}
if (got_packet) {
}
}
-#if FF_API_DEINTERLACE
-static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
-{
- AVCodecContext *dec;
- AVPicture *picture2;
- AVPicture picture_tmp;
- uint8_t *buf = 0;
-
- dec = ist->st->codec;
-
- /* deinterlace : must be done before any resize */
- if (do_deinterlace) {
- int size;
-
- /* create temporary picture */
- size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
- buf = av_malloc(size);
- if (!buf)
- return;
-
- picture2 = &picture_tmp;
- avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
-
- if (avpicture_deinterlace(picture2, picture,
- dec->pix_fmt, dec->width, dec->height) < 0) {
- /* if error, do not deinterlace */
- av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
- av_free(buf);
- buf = NULL;
- picture2 = picture;
- }
- } else {
- picture2 = picture;
- }
-
- if (picture != picture2)
- *picture = *picture2;
- *bufp = buf;
-}
-#endif
-
static void do_subtitle_out(AVFormatContext *s,
OutputStream *ost,
InputStream *ist,
if (pts == AV_NOPTS_VALUE) {
av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
if (exit_on_error)
- exit(1);
+ exit_program(1);
return;
}
subtitle_out_max_size, sub);
if (subtitle_out_size < 0) {
av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
- exit(1);
+ exit_program(1);
}
av_init_packet(&pkt);
ret = avcodec_encode_video2(enc, &pkt, in_picture, &got_packet);
if (ret < 0) {
av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
- exit(1);
+ exit_program(1);
}
if (got_packet) {
vstats_file = fopen(vstats_filename, "w");
if (!vstats_file) {
perror("fopen");
- exit(1);
+ exit_program(1);
}
}
return ret;
if (filtered_frame->pts != AV_NOPTS_VALUE) {
+ int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
filtered_frame->pts = av_rescale_q(filtered_frame->pts,
ost->filter->filter->inputs[0]->time_base,
ost->st->codec->time_base) -
- av_rescale_q(of->start_time,
+ av_rescale_q(start_time,
AV_TIME_BASE_Q,
ost->st->codec->time_base);
}
ret = encode(enc, &pkt, NULL, &got_packet);
if (ret < 0) {
av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
- exit(1);
+ exit_program(1);
}
*size += ret;
if (ost->logfile && enc->stats_out) {
if (ost->source_index != ist_index)
return 0;
- if (of->start_time && ist->last_dts < of->start_time)
+ if (of->start_time != AV_NOPTS_VALUE && ist->last_dts < of->start_time)
return 0;
return 1;
static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
{
OutputFile *of = output_files[ost->file_index];
- int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
+ InputFile *f = input_files [ist->file_index];
+ int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
+ int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
AVPacket opkt;
av_init_packet(&opkt);
return;
if (of->recording_time != INT64_MAX &&
- ist->last_dts >= of->recording_time + of->start_time) {
+ ist->last_dts >= of->recording_time + start_time) {
ost->finished = 1;
return;
}
+ if (f->recording_time != INT64_MAX) {
+ start_time = f->ctx->start_time;
+ if (f->start_time != AV_NOPTS_VALUE)
+ start_time += f->start_time;
+ if (ist->last_dts >= f->recording_time + start_time) {
+ ost->finished = 1;
+ return;
+ }
+ }
+
/* force the input stream PTS */
if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
audio_size += pkt->size;
if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY)) {
opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
if (!opkt.buf)
- exit(1);
+ exit_program(1);
}
} else {
opkt.data = pkt->data;
av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
"layout for Input Stream #%d.%d\n", ist->file_index,
ist->st->index);
- exit(1);
+ exit_program(1);
}
decoded_frame->channel_layout = avctx->channel_layout;
if (ist_in_filtergraph(filtergraphs[i], ist) &&
configure_filtergraph(filtergraphs[i]) < 0) {
av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
- exit(1);
+ exit_program(1);
}
}
static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
{
AVFrame *decoded_frame, *f;
- void *buffer_to_free = NULL;
int i, ret = 0, err = 0, resample_changed;
if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
decoded_frame->pkt_dts);
pkt->size = 0;
-#if FF_API_DEINTERLACE
- pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
-#endif
if (ist->st->sample_aspect_ratio.num)
decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
if (ist_in_filtergraph(filtergraphs[i], ist) &&
configure_filtergraph(filtergraphs[i]) < 0) {
av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
- exit(1);
+ exit_program(1);
}
}
av_frame_unref(ist->filter_frame);
av_frame_unref(decoded_frame);
- av_free(buffer_to_free);
return err < 0 ? err : ret;
}
AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
if (!avc)
- exit(1);
+ exit_program(1);
for (i = 0; i < nb_output_files; i++)
avc[i] = output_files[i]->ctx;
if (!av_dict_get(ist->opts, "threads", NULL, 0))
av_dict_set(&ist->opts, "threads", "auto", 0);
if ((ret = avcodec_open2(ist->st->codec, codec, &ist->opts)) < 0) {
+ char errbuf[128];
if (ret == AVERROR_EXPERIMENTAL)
abort_codec_experimental(codec, 0);
- snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
- ist->file_index, ist->st->index);
+
+ av_strerror(ret, errbuf, sizeof(errbuf));
+
+ snprintf(error, error_len,
+ "Error while opening decoder for input stream "
+ "#%d:%d : %s",
+ ist->file_index, ist->st->index, errbuf);
return ret;
}
assert_avoptions(ist->opts);
ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
if (!ost->forced_kf_pts) {
av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
- exit(1);
+ exit_program(1);
}
p = kf;
}
if (ost->stream_copy) {
+ AVRational sar;
uint64_t extra_size;
av_assert0(ist && !ost->filter);
case AVMEDIA_TYPE_AUDIO:
if (audio_volume != 256) {
av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
- exit(1);
+ exit_program(1);
}
codec->channel_layout = icodec->channel_layout;
codec->sample_rate = icodec->sample_rate;
codec->width = icodec->width;
codec->height = icodec->height;
codec->has_b_frames = icodec->has_b_frames;
- if (!codec->sample_aspect_ratio.num) {
- codec->sample_aspect_ratio =
- ost->st->sample_aspect_ratio =
- ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
- ist->st->codec->sample_aspect_ratio.num ?
- ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
- }
+ if (ost->frame_aspect_ratio)
+ sar = av_d2q(ost->frame_aspect_ratio * codec->height / codec->width, 255);
+ else if (ist->st->sample_aspect_ratio.num)
+ sar = ist->st->sample_aspect_ratio;
+ else
+ sar = icodec->sample_aspect_ratio;
+ ost->st->sample_aspect_ratio = codec->sample_aspect_ratio = sar;
break;
case AVMEDIA_TYPE_SUBTITLE:
codec->width = icodec->width;
fg = init_simple_filtergraph(ist, ost);
if (configure_filtergraph(fg)) {
av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
- exit(1);
+ exit_program(1);
}
}
if (!f) {
av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
logfilename, strerror(errno));
- exit(1);
+ exit_program(1);
}
ost->logfile = f;
} else {
if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
logfilename);
- exit(1);
+ exit_program(1);
}
codec->stats_in = logbuffer;
}
oc->interrupt_callback = int_cb;
if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
char errbuf[128];
- const char *errbuf_ptr = errbuf;
- if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
- errbuf_ptr = strerror(AVUNERROR(ret));
- snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
+ av_strerror(ret, errbuf, sizeof(errbuf));
+ snprintf(error, sizeof(error),
+ "Could not write header for output file #%d "
+ "(incorrect codec parameters ?): %s",
+ i, errbuf);
ret = AVERROR(EINVAL);
goto dump_format;
}
if (ret != AVERROR_EOF) {
print_error(is->filename, ret);
if (exit_on_error)
- exit(1);
+ exit_program(1);
}
ifile->eof_reached = 1;
av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
ist->file_index, ist->st->index);
if (exit_on_error)
- exit(1);
+ exit_program(1);
}
discard_packet:
int ret;
int64_t ti;
- atexit(exit_program);
+ register_exit(avconv_cleanup);
av_log_set_flags(AV_LOG_SKIP_REPEATED);
parse_loglevel(argc, argv, options);
/* parse options and open all input/output files */
ret = avconv_parse_options(argc, argv);
if (ret < 0)
- exit(1);
+ exit_program(1);
if (nb_output_files <= 0 && nb_input_files == 0) {
show_usage();
av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
- exit(1);
+ exit_program(1);
}
/* file converter / grab */
if (nb_output_files <= 0) {
fprintf(stderr, "At least one output file must be specified\n");
- exit(1);
+ exit_program(1);
}
ti = getutime();
if (transcode() < 0)
- exit(1);
+ exit_program(1);
ti = getutime() - ti;
if (do_benchmark) {
int maxrss = getmaxrss() / 1024;
printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
}
- exit(0);
+ exit_program(0);
return 0;
}
projects / ffmpeg / blobdiff