static int audio_volume = 256;
+static int exit_on_error = 0;
static int using_stdin = 0;
static int using_vhook = 0;
static int verbose = 1;
bsfc->filter->name, pkt->stream_index,
avctx->codec ? avctx->codec->name : "copy");
print_error("", a);
+ if (exit_on_error)
+ av_exit(1);
}
*pkt= new_pkt;
int size_out, frame_bytes, ret;
AVCodecContext *enc= ost->st->codec;
AVCodecContext *dec= ist->st->codec;
+ int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
+ int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
/* SC: dynamic allocation of buffers */
if (!audio_buf)
ost->audio_resample = 1;
if (ost->audio_resample && !ost->resample) {
+ if (dec->sample_fmt != SAMPLE_FMT_S16) {
+ fprintf(stderr, "Audio resampler only works with 16 bits per sample, patch welcome.\n");
+ av_exit(1);
+ }
ost->resample = audio_resample_init(enc->channels, dec->channels,
enc->sample_rate, dec->sample_rate);
if (!ost->resample) {
buftmp = audio_buf;
size_out = audio_resample(ost->resample,
(short *)buftmp, (short *)buf,
- size / (ist->st->codec->channels * 2));
- size_out = size_out * enc->channels * 2;
+ size / (ist->st->codec->channels * isize));
+ size_out = size_out * enc->channels * osize;
} else {
buftmp = buf;
size_out = size;
if (dec->sample_fmt!=enc->sample_fmt) {
const void *ibuf[6]= {buftmp};
void *obuf[6]= {audio_out2};
- int istride[6]= {av_get_bits_per_sample_format(dec->sample_fmt)/8};
- int ostride[6]= {av_get_bits_per_sample_format(enc->sample_fmt)/8};
+ int istride[6]= {isize};
+ int ostride[6]= {osize};
int len= size_out/istride[0];
if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
printf("av_audio_convert() failed\n");
+ if (exit_on_error)
+ av_exit(1);
return;
}
buftmp = audio_out2;
- /* FIXME: existing code assume that size_out equals framesize*channels*2
- remove this legacy cruft */
- size_out = len*2;
+ size_out = len*osize;
}
/* now encode as many frames as possible */
}
av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
- frame_bytes = enc->frame_size * 2 * enc->channels;
+ frame_bytes = enc->frame_size * osize * enc->channels;
while (av_fifo_size(&ost->fifo) >= frame_bytes) {
AVPacket pkt;
}
} else {
AVPacket pkt;
+ int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
av_init_packet(&pkt);
- ost->sync_opts += size_out / (2 * enc->channels);
+ ost->sync_opts += size_out / (osize * enc->channels);
/* output a pcm frame */
- /* XXX: change encoding codec API to avoid this ? */
- switch(enc->codec->id) {
- case CODEC_ID_PCM_S32LE:
- case CODEC_ID_PCM_S32BE:
- case CODEC_ID_PCM_U32LE:
- case CODEC_ID_PCM_U32BE:
- case CODEC_ID_PCM_F32BE:
- size_out = size_out << 1;
- break;
- case CODEC_ID_PCM_S24LE:
- case CODEC_ID_PCM_S24BE:
- case CODEC_ID_PCM_U24LE:
- case CODEC_ID_PCM_U24BE:
- case CODEC_ID_PCM_S24DAUD:
- size_out = size_out / 2 * 3;
- break;
- case CODEC_ID_PCM_S16LE:
- case CODEC_ID_PCM_S16BE:
- case CODEC_ID_PCM_U16LE:
- case CODEC_ID_PCM_U16BE:
- break;
- default:
- size_out = size_out >> 1;
- break;
- }
+ /* determine the size of the coded buffer */
+ size_out /= osize;
+ if (coded_bps)
+ size_out *= coded_bps;
+
//FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
ret = avcodec_encode_audio(enc, audio_out, size_out,
(short *)buftmp);
if(avpicture_deinterlace(picture2, picture,
dec->pix_fmt, dec->width, dec->height) < 0) {
/* if error, do not deinterlace */
+ fprintf(stderr, "Deinterlacing failed\n");
av_free(buf);
buf = NULL;
picture2 = picture;
if (pts == AV_NOPTS_VALUE) {
fprintf(stderr, "Subtitle packets must have a pts\n");
+ if (exit_on_error)
+ av_exit(1);
return;
}
if (ost->video_crop) {
if (av_picture_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");
+ if (exit_on_error)
+ av_exit(1);
return;
}
formatted_picture = &picture_crop_temp;
if (ost->video_resample) {
if (av_picture_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");
+ if (exit_on_error)
+ av_exit(1);
return;
}
resampling_dst = &picture_pad_temp;
n = 0;
for(k=0;k<nb_output_files;k++) {
os = output_files[k];
- for(i=0;i<os->nb_streams;i++) {
+ for(i=0;i<os->nb_streams;i++,n++) {
int found;
- ost = ost_table[n++];
+ ost = ost_table[n];
ost->file_index = k;
ost->index = i;
ost->st = os->streams[i];
if (nb_stream_maps > 0) {
- ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
- stream_maps[n-1].stream_index;
+ ost->source_index = file_table[stream_maps[n].file_index].ist_index +
+ stream_maps[n].stream_index;
/* Sanity check that the stream types match */
if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
int i= ost->file_index;
dump_format(output_files[i], i, output_files[i]->filename, 1);
fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
- stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
+ stream_maps[n].file_index, stream_maps[n].stream_index,
ost->file_index, ost->index);
av_exit(1);
}
ist = ist_table[ost->source_index];
ist->discard = 0;
ost->sync_ist = (nb_stream_maps > 0) ?
- ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
- stream_maps[n-1].sync_stream_index] : ist;
+ ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
+ stream_maps[n].sync_stream_index] : ist;
}
}
if (verbose >= 0)
fprintf(stderr, "Error while decoding stream #%d.%d\n",
ist->file_index, ist->index);
-
+ if (exit_on_error)
+ av_exit(1);
av_free_packet(&pkt);
goto redo;
}
return 0;
}
-static void opt_frame_rate(const char *arg)
+static int opt_frame_rate(const char *opt, const char *arg)
{
if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
- fprintf(stderr, "Incorrect frame rate\n");
+ fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
av_exit(1);
}
+ return 0;
}
static int opt_bitrate(const char *opt, const char *arg)
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;
+ if(ic->streams[i]->sample_aspect_ratio.num)
+ frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
+ else
+ frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
+ frame_aspect_ratio *= (float) 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;
if (video_stream_copy) {
st->stream_copy = 1;
video_enc->codec_type = CODEC_TYPE_VIDEO;
+ st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
} else {
const char *p;
int i;
video_enc->height = frame_height + frame_padtop + frame_padbottom;
video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
video_enc->pix_fmt = frame_pix_fmt;
+ st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
if(codec && codec->pix_fmts){
const enum PixelFormat *p= codec->pix_fmts;
opt_format("vcd");
opt_frame_size(norm ? "352x240" : "352x288");
- opt_frame_rate(frame_rates[norm]);
+ opt_frame_rate(NULL, frame_rates[norm]);
opt_default("gop", norm ? "18" : "15");
opt_default("b", "1150000");
opt_format("svcd");
opt_frame_size(norm ? "480x480" : "480x576");
- opt_frame_rate(frame_rates[norm]);
+ opt_frame_rate(NULL, frame_rates[norm]);
opt_default("gop", norm ? "18" : "15");
opt_default("b", "2040000");
opt_format("dvd");
opt_frame_size(norm ? "720x480" : "720x576");
- opt_frame_rate(frame_rates[norm]);
+ opt_frame_rate(NULL, frame_rates[norm]);
opt_default("gop", norm ? "18" : "15");
opt_default("b", "6000000");
opt_frame_size(norm ? "720x480" : "720x576");
opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
(norm ? "yuv411p" : "yuv420p"));
- opt_frame_rate(frame_rates[norm]);
+ opt_frame_rate(NULL, frame_rates[norm]);
audio_sample_rate = 48000;
audio_channels = 2;
{ "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
{ "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
{ "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
+ { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
/* video 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" },
- { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
+ { "r", OPT_FUNC2 | 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, 'list' as argument shows all the pixel formats supported", "format" },
projects / ffmpeg / blobdiff