* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+/* needed for usleep() */
+#define _XOPEN_SOURCE 500
+
#include "config.h"
#include <ctype.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <limits.h>
+#include <unistd.h>
#include "libavformat/avformat.h"
#include "libavdevice/avdevice.h"
#include "libswscale/swscale.h"
#include "libavformat/framehook.h"
#include "libavcodec/opt.h"
+#include "libavcodec/audioconvert.h"
#include "libavutil/fifo.h"
#include "libavutil/avstring.h"
#include "libavformat/os_support.h"
#endif
#if defined(HAVE_TERMIOS_H)
-#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/time.h>
static AVFormatContext *output_files[MAX_FILES];
static int nb_output_files = 0;
-static AVStreamMap stream_maps[MAX_FILES];
+static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
static int nb_stream_maps;
static AVMetaDataMap meta_data_maps[MAX_FILES];
static int frame_height = 0;
static float frame_aspect_ratio = 0;
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
+static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
static int frame_padtop = 0;
static int frame_padbottom = 0;
static int frame_padleft = 0;
/* audio only */
int audio_resample;
ReSampleContext *resample; /* for audio resampling */
+ int reformat_pair;
+ AVAudioConvert *reformat_ctx;
AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
FILE *logfile;
} AVOutputStream;
uint8_t *buftmp;
static uint8_t *audio_buf = NULL;
static uint8_t *audio_out = NULL;
+ static uint8_t *audio_out2 = NULL;
const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
int size_out, frame_bytes, ret;
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) {
}
}
+#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
+ if (dec->sample_fmt!=enc->sample_fmt &&
+ MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
+ if (!audio_out2)
+ audio_out2 = av_malloc(audio_out_size);
+ if (!audio_out2)
+ av_exit(1);
+ if (ost->reformat_ctx)
+ av_audio_convert_free(ost->reformat_ctx);
+ ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
+ dec->sample_fmt, 1, NULL, 0);
+ if (!ost->reformat_ctx) {
+ fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
+ avcodec_get_sample_fmt_name(dec->sample_fmt),
+ avcodec_get_sample_fmt_name(enc->sample_fmt));
+ av_exit(1);
+ }
+ ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
+ }
+
if(audio_sync_method){
double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
- av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
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 len= size_out/istride[0];
+ if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
+ printf("av_audio_convert() failed\n");
+ return;
+ }
+ buftmp = audio_out2;
+ /* FIXME: existing code assume that size_out equals framesize*channels*2
+ remove this legacy cruft */
+ size_out = len*2;
+ }
+
/* 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);
+ if (av_fifo_realloc2(&ost->fifo, av_fifo_size(&ost->fifo) + size_out) < 0) {
+ fprintf(stderr, "av_fifo_realloc2() failed\n");
+ av_exit(1);
+ }
av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
frame_bytes = enc->frame_size * 2 * enc->channels;
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:
if (ist->decoding_needed) {
switch(ist->st->codec->codec_type) {
case CODEC_TYPE_AUDIO:{
- if(pkt)
- samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
+ if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
+ samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
+ av_free(samples);
+ samples= av_malloc(samples_size);
+ }
data_size= samples_size;
/* XXX: could avoid copy if PCM 16 bits with same
endianness as CPU */
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;
}
}
case CODEC_TYPE_AUDIO:
if (av_fifo_init(&ost->fifo, 1024))
goto fail;
+ ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
icodec->request_channels = codec->channels;
ist->decoding_needed = 1;
sws_freeContext(ost->img_resample_ctx);
if (ost->resample)
audio_resample_close(ost->resample);
+ if (ost->reformat_ctx)
+ av_audio_convert_free(ost->reformat_ctx);
av_free(ost);
}
}
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)
}
}
-static void list_pix_fmts(void)
+static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
{
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);
+ char fmt_str[128];
+ for (i=-1; i < nb_fmts; i++) {
+ get_fmt_string (fmt_str, sizeof(fmt_str), i);
+ fprintf(stdout, "%s\n", fmt_str);
}
}
if (strcmp(arg, "list"))
frame_pix_fmt = avcodec_get_pix_fmt(arg);
else {
- list_pix_fmts();
+ list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
av_exit(0);
}
}
return 0;
}
+static void opt_audio_sample_fmt(const char *arg)
+{
+ if (strcmp(arg, "list"))
+ audio_sample_fmt = avcodec_get_sample_fmt(arg);
+ else {
+ list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
+ av_exit(0);
+ }
+}
+
static int opt_audio_rate(const char *opt, const char *arg)
{
audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
ap->width = frame_width + frame_padleft + frame_padright;
ap->height = frame_height + frame_padtop + frame_padbottom;
ap->pix_fmt = frame_pix_fmt;
+ // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
ap->channel = video_channel;
ap->standard = video_standard;
ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
//fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
audio_channels = enc->channels;
audio_sample_rate = enc->sample_rate;
+ audio_sample_fmt = enc->sample_fmt;
if(audio_disable)
ic->streams[i]->discard= AVDISCARD_ALL;
break;
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;
st->stream_copy = 1;
audio_enc->channels = audio_channels;
} else {
+ AVCodec *codec;
codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
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);
audio_enc->codec_id = codec_id;
+ codec = avcodec_find_encoder(codec_id);
if (audio_qscale > QSCALE_NONE) {
audio_enc->flags |= CODEC_FLAG_QSCALE;
}
audio_enc->thread_count = thread_count;
audio_enc->channels = audio_channels;
+ audio_enc->sample_fmt = audio_sample_fmt;
+
+ if(codec && codec->sample_fmts){
+ const enum SampleFormat *p= codec->sample_fmts;
+ for(; *p!=-1; p++){
+ if(*p == audio_enc->sample_fmt)
+ break;
+ }
+ if(*p == -1)
+ audio_enc->sample_fmt = codec->sample_fmts[0];
+ }
}
audio_enc->sample_rate = audio_sample_rate;
audio_enc->time_base= (AVRational){1, audio_sample_rate};
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;
{ "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" },
{ "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
{ "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
{ "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
+ { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
/* subtitle options */
{ "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
projects / ffmpeg / blobdiff