Skip to content

F
ffmpeg.wasm-core
Commit a38469e1 authored by Fabrice Bellard's avatar Fabrice Bellard
Browse files
Options

unified grab & convertion loops (should be easier to achieve correct... 

unified grab & convertion loops (should be easier to achieve correct synchronization now - but still work to do!) - added ffplay support


Originally committed as revision 144 to svn://svn.ffmpeg.org/ffmpeg/trunk
parent 2744a37f
Hide whitespace changes
Inline Side-by-side
Showing with 170 additions and 435 deletions
ffmpeg.c
View file @ a38469e1
......@@ -97,6 +97,7 @@ static char *str_copyright = NULL;
static char *str_comment = NULL;
static int do_benchmark = 0;
static int do_hex_dump = 0;
static int do_play = 0;
typedef struct AVOutputStream {
int file_index; /* file index */
......@@ -188,425 +189,30 @@ static int read_key(void)
return -1;
}
#define AUDIO_FIFO_SIZE 8192
#else
/* main loop for grabbing */
int av_grab(AVFormatContext *s)
/* no interactive support */
static void term_exit(void)
{
UINT8 audio_buf[AUDIO_FIFO_SIZE];
UINT8 audio_buf1[AUDIO_FIFO_SIZE];
UINT8 audio_out[AUDIO_FIFO_SIZE];
UINT8 video_buffer[1024*1024];
char buf[256];
short *samples;
URLContext *audio_handle = NULL, *video_handle = NULL;
int ret;
AVCodecContext *enc, *first_video_enc = NULL;
int frame_size, frame_bytes;
int use_audio, use_video;
int frame_rate, sample_rate, channels;
int width, height, frame_number, i, pix_fmt = 0;
AVOutputStream *ost_table[s->nb_streams], *ost;
UINT8 *picture_in_buf = NULL, *picture_420p = NULL;
int audio_fifo_size = 0, picture_size = 0;
INT64 time_start;
/* init output stream info */
for(i=0;i<s->nb_streams;i++)
ost_table[i] = NULL;
/* output stream init */
for(i=0;i<s->nb_streams;i++) {
ost = av_mallocz(sizeof(AVOutputStream));
if (!ost)
goto fail;
ost->index = i;
ost->st = s->streams[i];
ost_table[i] = ost;
}
use_audio = 0;
use_video = 0;
frame_rate = 0;
sample_rate = 0;
frame_size = 0;
channels = 1;
width = 0;
height = 0;
frame_number = 0;
for(i=0;i<s->nb_streams;i++) {
AVCodec *codec;
ost = ost_table[i];
enc = &ost->st->codec;
codec = avcodec_find_encoder(enc->codec_id);
if (!codec) {
fprintf(stderr, "Unknown codec\n");
return -1;
}
if (avcodec_open(enc, codec) < 0) {
fprintf(stderr, "Incorrect encode parameters\n");
return -1;
}
switch(enc->codec_type) {
case CODEC_TYPE_AUDIO:
use_audio = 1;
if (enc->sample_rate > sample_rate)
sample_rate = enc->sample_rate;
if (enc->frame_size > frame_size)
frame_size = enc->frame_size;
if (enc->channels > channels)
channels = enc->channels;
break;
case CODEC_TYPE_VIDEO:
if (!first_video_enc)
first_video_enc = enc;
use_video = 1;
if (enc->frame_rate > frame_rate)
frame_rate = enc->frame_rate;
if (enc->width > width)
width = enc->width;
if (enc->height > height)
height = enc->height;
break;
}
}
/* audio */
samples = NULL;
if (use_audio) {
snprintf(buf, sizeof(buf), "audio:%d,%d", sample_rate, channels);
ret = url_open(&audio_handle, buf, URL_RDONLY);
if (ret < 0) {
fprintf(stderr, "Could not open audio device: disabling audio capture\n");
use_audio = 0;
} else {
URLFormat f;
/* read back exact grab parameters */
if (url_getformat(audio_handle, &f) < 0) {
fprintf(stderr, "could not read back video grab parameters\n");
goto fail;
}
sample_rate = f.sample_rate;
channels = f.channels;
audio_fifo_size = ((AUDIO_FIFO_SIZE / 2) / audio_handle->packet_size) *
audio_handle->packet_size;
fprintf(stderr, "Audio sampling: %d Hz, %s\n",
sample_rate, channels == 2 ? "stereo" : "mono");
}
}
/* video */
if (use_video) {
snprintf(buf, sizeof(buf), "video:%d,%d,%f",
width, height, (float)frame_rate / FRAME_RATE_BASE);
ret = url_open(&video_handle, buf, URL_RDONLY);
if (ret < 0) {
fprintf(stderr,"Could not init video 4 linux capture: disabling video capture\n");
use_video = 0;
} else {
URLFormat f;
const char *pix_fmt_str;
/* read back exact grab parameters */
if (url_getformat(video_handle, &f) < 0) {
fprintf(stderr, "could not read back video grab parameters\n");
goto fail;
}
width = f.width;
height = f.height;
pix_fmt = f.pix_fmt;
switch(pix_fmt) {
case PIX_FMT_YUV420P:
pix_fmt_str = "420P";
break;
case PIX_FMT_YUV422:
pix_fmt_str = "422";
break;
case PIX_FMT_RGB24:
pix_fmt_str = "RGB24";
break;
case PIX_FMT_BGR24:
pix_fmt_str = "BGR24";
break;
default:
pix_fmt_str = "???";
break;
}
picture_size = video_handle->packet_size;
picture_in_buf = malloc(picture_size);
if (!picture_in_buf)
goto fail;
/* allocate a temporary picture if not grabbing in 420P format */
if (pix_fmt != PIX_FMT_YUV420P) {
picture_420p = malloc((width * height * 3) / 2);
}
fprintf(stderr, "Video sampling: %dx%d, %s format, %0.2f fps\n",
width, height, pix_fmt_str, (float)frame_rate / FRAME_RATE_BASE);
}
}
if (!use_video && !use_audio) {
fprintf(stderr,"Could not open grab devices : exiting\n");
exit(1);
}
/* init built in conversion functions */
for(i=0;i<s->nb_streams;i++) {
ost = ost_table[i];
enc = &ost->st->codec;
switch(enc->codec_type) {
case CODEC_TYPE_AUDIO:
ost->audio_resample = 0;
if ((enc->channels != channels ||
enc->sample_rate != sample_rate)) {
ost->audio_resample = 1;
ost->resample = audio_resample_init(enc->channels, channels,
enc->sample_rate, sample_rate);
}
if (fifo_init(&ost->fifo, (2 * audio_fifo_size * enc->sample_rate *
enc->channels) / sample_rate))
goto fail;
break;
case CODEC_TYPE_VIDEO:
ost->video_resample = 0;
if (enc->width != width ||
enc->height != height) {
UINT8 *buf;
ost->video_resample = 1;
buf = malloc((enc->width * enc->height * 3) / 2);
if (!buf)
goto fail;
ost->pict_tmp.data[0] = buf;
ost->pict_tmp.data[1] = buf + enc->width * height;
ost->pict_tmp.data[2] = ost->pict_tmp.data[1] + (enc->width * height) / 4;
ost->pict_tmp.linesize[0] = enc->width;
ost->pict_tmp.linesize[1] = enc->width / 2;
ost->pict_tmp.linesize[2] = enc->width / 2;
ost->img_resample_ctx = img_resample_init(
ost->st->codec.width, ost->st->codec.height,
width, height);
}
}
}
fprintf(stderr, "Press [q] to stop encoding\n");
s->format->write_header(s);
time_start = gettime();
term_init();
for(;;) {
/* if 'q' pressed, exits */
if (read_key() == 'q')
break;
/* read & compress audio frames */
if (use_audio) {
int ret, nb_samples, nb_samples_out;
UINT8 *buftmp;
for(;;) {
ret = url_read(audio_handle, audio_buf, audio_fifo_size);
if (ret <= 0)
break;
/* fill each codec fifo by doing the right sample
rate conversion. This is not optimal because we
do too much work, but it is easy to do */
nb_samples = ret / (channels * 2);
for(i=0;i<s->nb_streams;i++) {
ost = ost_table[i];
enc = &ost->st->codec;
if (enc->codec_type == CODEC_TYPE_AUDIO) {
/* rate & stereo convertion */
if (!ost->audio_resample) {
buftmp = audio_buf;
nb_samples_out = nb_samples;
} else {
buftmp = audio_buf1;
nb_samples_out = audio_resample(ost->resample,
(short *)buftmp, (short *)audio_buf,
nb_samples);
}
fifo_write(&ost->fifo, buftmp, nb_samples_out * enc->channels * 2,
&ost->fifo.wptr);
}
}
/* compress as many frame as possible with each audio codec */
for(i=0;i<s->nb_streams;i++) {
ost = ost_table[i];
enc = &ost->st->codec;
if (enc->codec_type == CODEC_TYPE_AUDIO) {
frame_bytes = enc->frame_size * 2 * enc->channels;
while (fifo_read(&ost->fifo, audio_buf,
frame_bytes, &ost->fifo.rptr) == 0) {
ret = avcodec_encode_audio(enc,
audio_out, sizeof(audio_out),
(short *)audio_buf);
s->format->write_packet(s, ost->index, audio_out, ret);
}
}
}
}
}
if (use_video) {
AVPicture *picture1, *picture2, *picture;
AVPicture picture_tmp0, picture_tmp1;
ret = url_read(video_handle, picture_in_buf, picture_size);
if (ret < 0)
break;
picture2 = &picture_tmp0;
avpicture_fill(picture2, picture_in_buf, pix_fmt, width, height);
if (pix_fmt != PIX_FMT_YUV420P) {
picture = &picture_tmp1;
avpicture_fill(picture, picture_420p,
PIX_FMT_YUV420P, width, height);
img_convert(picture, PIX_FMT_YUV420P,
picture2, pix_fmt,
width, height);
} else {
picture = picture2;
}
for(i=0;i<s->nb_streams;i++) {
ost = ost_table[i];
enc = &ost->st->codec;
if (enc->codec_type == CODEC_TYPE_VIDEO) {
int n1, n2, nb;
/* feed each codec with its requested frame rate */
n1 = ((INT64)frame_number * enc->frame_rate) / frame_rate;
n2 = (((INT64)frame_number + 1) * enc->frame_rate) / frame_rate;
nb = n2 - n1;
if (nb > 0) {
/* resize the picture if needed */
if (ost->video_resample) {
picture1 = &ost->pict_tmp;
img_resample(ost->img_resample_ctx,
picture1, picture);
} else {
picture1 = picture;
}
ret = avcodec_encode_video(enc, video_buffer,
sizeof(video_buffer),
picture1);
s->format->write_packet(s, ost->index, video_buffer, ret);
}
}
}
frame_number++;
}
/* write report */
{
char buf[1024];
INT64 total_size;
float ti, bitrate;
static float last_ti;
INT64 ti1;
total_size = url_ftell(&s->pb);
ti1 = gettime() - time_start;
/* check elapsed time */
if (recording_time && ti1 >= recording_time)
break;
ti = ti1 / 1000000.0;
if (ti < 0.1)
ti = 0.1;
/* dispaly twice per second */
if ((ti - last_ti) >= 0.5) {
last_ti = ti;
bitrate = (int)((total_size * 8) / ti / 1000.0);
buf[0] = '\0';
if (use_video) {
sprintf(buf + strlen(buf), "frame=%5d fps=%4.1f q=%2d ",
frame_number, (float)frame_number / ti, first_video_enc->quality);
}
sprintf(buf + strlen(buf), "size=%8LdkB time=%0.1f bitrate=%6.1fkbits/s",
total_size / 1024, ti, bitrate);
fprintf(stderr, "%s \r", buf);
fflush(stderr);
}
}
}
term_exit();
for(i=0;i<s->nb_streams;i++) {
ost = ost_table[i];
enc = &ost->st->codec;
avcodec_close(enc);
}
s->format->write_trailer(s);
if (audio_handle)
url_close(audio_handle);
if (video_handle)
url_close(video_handle);
/* write report */
{
float ti, bitrate;
INT64 total_size;
total_size = url_ftell(&s->pb);
ti = (gettime() - time_start) / 1000000.0;
if (ti < 0.1)
ti = 0.1;
bitrate = (int)((total_size * 8) / ti / 1000.0);
}
fprintf(stderr, "\033[K\nTotal time = %0.1f s, %Ld KBytes, %0.1f kbits/s\n",
ti, total_size / 1024, bitrate);
if (use_video) {
fprintf(stderr, "Total frames = %d\n", frame_number);
}
}
static void term_init(void)
{
}
ret = 0;
fail1:
if (picture_in_buf)
free(picture_in_buf);
if (picture_420p)
free(picture_420p);
for(i=0;i<s->nb_streams;i++) {
ost = ost_table[i];
if (ost) {
if (ost->fifo.buffer)
fifo_free(&ost->fifo);
if (ost->pict_tmp.data[0])
free(ost->pict_tmp.data[0]);
if (ost->video_resample)
img_resample_close(ost->img_resample_ctx);
if (ost->audio_resample)
audio_resample_close(ost->resample);
free(ost);
}
}
return ret;
fail:
ret = -ENOMEM;
goto fail1;
static int read_key(void)
{
return -1;
}
#endif /* CONFIG_WIN32 */
#endif
int read_ffserver_streams(AVFormatContext *s, const char *filename)
{
int i;
AVFormatContext *ic;
ic = av_open_input_file(filename, FFM_PACKET_SIZE);
ic = av_open_input_file(filename, NULL, FFM_PACKET_SIZE, NULL);
if (!ic)
return -EIO;
/* copy stream format */
......@@ -1156,9 +762,22 @@ static int av_encode(AVFormatContext **output_files,
/* open files and write file headers */
for(i=0;i<nb_output_files;i++) {
os = output_files[i];
os->format->write_header(os);
if (os->format->write_header(os) < 0) {
fprintf(stderr, "Could not write header for output file #%d (incorrect codec paramters ?)\n", i);
ret = -EINVAL;
goto fail;
}
}
#ifndef CONFIG_WIN32
if (!do_play) {
fprintf(stderr, "Press [q] to stop encoding\n");
} else {
fprintf(stderr, "Press [q] to stop playing\n");
}
#endif
term_init();
start_time = gettime();
min_pts = 0;
for(;;) {
......@@ -1171,8 +790,12 @@ static int av_encode(AVFormatContext **output_files,
AVPicture picture;
short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
/* select the input file with the smallest pts */
redo:
/* if 'q' pressed, exits */
if (read_key() == 'q')
break;
/* select the input file with the smallest pts */
file_index = -1;
min_pts = MAXINT64;
for(i=0;i<nb_istreams;i++) {
......@@ -1189,7 +812,6 @@ static int av_encode(AVFormatContext **output_files,
if (recording_time > 0 && min_pts >= recording_time)
break;
/* read a packet from it and output it in the fifo */
is = input_files[file_index];
if (av_read_packet(is, &pkt) < 0) {
file_table[file_index].eof_reached = 1;
......@@ -1358,6 +980,7 @@ static int av_encode(AVFormatContext **output_files,
}
}
}
term_exit();
/* dump report by using the first video and audio streams */
{
......@@ -2090,6 +1713,95 @@ void opt_output_file(const char *filename)
video_codec_id = CODEC_ID_NONE;
}
#ifdef CONFIG_GRAB
/* prepare dummy protocols for grab */
void prepare_grab(void)
{
int has_video, has_audio, i, j;
AVFormatContext *oc;
AVFormatContext *ic;
AVFormatParameters ap1, *ap = &ap1;
/* see if audio/video inputs are needed */
has_video = 0;
has_audio = 0;
memset(ap, 0, sizeof(*ap));
for(j=0;j<nb_output_files;j++) {
oc = output_files[j];
for(i=0;i<oc->nb_streams;i++) {
AVCodecContext *enc = &oc->streams[i]->codec;
switch(enc->codec_type) {
case CODEC_TYPE_AUDIO:
if (enc->sample_rate > ap->sample_rate)
ap->sample_rate = enc->sample_rate;
if (enc->channels > ap->channels)
ap->channels = enc->channels;
has_audio = 1;
break;
case CODEC_TYPE_VIDEO:
if (enc->width > ap->width)
ap->width = enc->width;
if (enc->height > ap->height)
ap->height = enc->height;
if (enc->frame_rate > ap->frame_rate)
ap->frame_rate = enc->frame_rate;
has_video = 1;
break;
}
}
}
if (has_video == 0 && has_audio == 0) {
fprintf(stderr, "Output file must have at least one audio or video stream\n");
exit(1);
}
if (has_video) {
ic = av_open_input_file("", "video_grab_device", 0, ap);
if (!ic) {
fprintf(stderr, "Could not open video grab device\n");
exit(1);
}
input_files[nb_input_files] = ic;
dump_format(ic, nb_input_files, v4l_device, 0);
nb_input_files++;
}
if (has_audio) {
ic = av_open_input_file("", "audio_device", 0, ap);
if (!ic) {
fprintf(stderr, "Could not open audio grab device\n");
exit(1);
}
input_files[nb_input_files] = ic;
dump_format(ic, nb_input_files, audio_device, 0);
nb_input_files++;
}
}
#else
void prepare_grab(void)
{
fprintf(stderr, "Must supply at least one input file\n");
exit(1);
}
#endif
/* open the necessary output devices for playing */
void prepare_play(void)
{
file_format = guess_format("audio_device", NULL, NULL);
if (!file_format) {
fprintf(stderr, "Could not find audio device\n");
exit(1);
}
opt_output_file(audio_device);
}
#ifndef CONFIG_WIN32
INT64 getutime(void)
{
......@@ -2165,13 +1877,24 @@ void show_formats(void)
void show_help(void)
{
const char *prog;
const OptionDef *po;
int i, expert;
prog = do_play ? "ffplay" : "ffmpeg";
printf("ffmpeg version " FFMPEG_VERSION ", Copyright (c) 2000,2001 Gerard Lantau\n"
"usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
"Hyper fast MPEG1/MPEG4/H263/RV and AC3/MPEG audio encoder\n"
"\n"
printf("%s version " FFMPEG_VERSION ", Copyright (c) 2000, 2001 Gerard Lantau\n",
prog);
if (!do_play) {
printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
"Hyper fast MPEG1/MPEG4/H263/RV and AC3/MPEG audio encoder\n");
} else {
printf("usage: ffplay [options] input_file...\n"
"Simple audio player\n");
}
printf("\n"
"Main options are:\n");
for(i=0;i<2;i++) {
if (i == 1)
......@@ -2246,12 +1969,19 @@ int main(int argc, char **argv)
int optindex, i;
const char *opt, *arg;
const OptionDef *po;
INT64 ti;
register_all();
/* detect if invoked as player */
i = strlen(argv[0]);
if (i >= 6 && !strcmp(argv[0] + i - 6, "ffplay"))
do_play = 1;
if (argc <= 1)
show_help();
/* parse options */
optindex = 1;
while (optindex < argc) {
opt = argv[optindex++];
......@@ -2280,35 +2010,40 @@ int main(int argc, char **argv)
po->u.func_arg(arg);
}
} else {
opt_output_file(opt);
if (!do_play) {
opt_output_file(opt);
} else {
opt_input_file(opt);
}
}
}
if (nb_input_files == 0) {
#ifdef CONFIG_GRAB
if (nb_output_files != 1) {
fprintf(stderr, "Only one output file supported when grabbing\n");
exit(1);
}
av_grab(output_files[0]);
#else
fprintf(stderr, "Must supply at least one input file\n");
#endif
} else {
INT64 ti;
if (!do_play) {
/* file converter / grab */
if (nb_output_files <= 0) {
fprintf(stderr, "Must supply at least one output file\n");
exit(1);
}
ti = getutime();
av_encode(output_files, nb_output_files, input_files, nb_input_files,
stream_maps, nb_stream_maps);
ti = getutime() - ti;
if (do_benchmark) {
printf("bench: utime=%0.3fs\n", ti / 1000000.0);
if (nb_input_files == 0) {
prepare_grab();
}
} else {
/* player */
if (nb_input_files <= 0) {
fprintf(stderr, "Must supply at least one input file\n");
exit(1);
}
prepare_play();
}
ti = getutime();
av_encode(output_files, nb_output_files, input_files, nb_input_files,
stream_maps, nb_stream_maps);
ti = getutime() - ti;
if (do_benchmark) {
printf("bench: utime=%0.3fs\n", ti / 1000000.0);
}
/* close files */
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment