From: simock85 <[email protected]>
Remove globals and hardcoded constants.
---
libavformat/output-example.c | 237 +++++++++++++++++++++++-------------------
1 files changed, 128 insertions(+), 109 deletions(-)
diff --git a/libavformat/output-example.c b/libavformat/output-example.c
index 3b28b7c..5b1fcaf 100644
--- a/libavformat/output-example.c
+++ b/libavformat/output-example.c
@@ -34,7 +34,6 @@
#include <string.h>
#include <math.h>
-#include "libavutil/mathematics.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"
@@ -43,19 +42,17 @@
/* 5 seconds stream duration */
#define STREAM_DURATION 5.0
#define STREAM_FRAME_RATE 25 /* 25 images/s */
-#define STREAM_NB_FRAMES ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
#define STREAM_PIX_FMT PIX_FMT_YUV420P /* default pix_fmt */
-static int sws_flags = SWS_BICUBIC;
-
/**************************************************************/
-/* audio output */
-float t, tincr, tincr2;
-int16_t *samples;
-uint8_t *audio_outbuf;
-int audio_outbuf_size;
-int audio_input_frame_size;
+typedef struct {
+ float t, tincr, tincr2;
+ int16_t *samples;
+ uint8_t *audio_outbuf;
+ int audio_outbuf_size;
+ int audio_input_frame_size;
+} AudioOut;
/*
* add an audio output stream
@@ -88,11 +85,13 @@ static AVStream *add_audio_stream(AVFormatContext *oc, enum
CodecID codec_id)
return st;
}
-static void open_audio(AVFormatContext *oc, AVStream *st)
+static AudioOut *open_audio(AVFormatContext *oc, AVStream *st)
{
AVCodecContext *c;
AVCodec *codec;
+ AudioOut *out = av_malloc(sizeof(AudioOut));
+
c = st->codec;
/* find the audio encoder */
@@ -109,52 +108,53 @@ static void open_audio(AVFormatContext *oc, AVStream *st)
}
/* init signal generator */
- t = 0;
- tincr = 2 * M_PI * 110.0 / c->sample_rate;
+ out->t = 0;
+ out->tincr = 2 * M_PI * 110.0 / c->sample_rate;
/* increment frequency by 110 Hz per second */
- tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
+ out->tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
- audio_outbuf_size = 10000;
- audio_outbuf = av_malloc(audio_outbuf_size);
+ out->audio_outbuf_size = 10000;
+ out->audio_outbuf = av_malloc(out->audio_outbuf_size);
/* ugly hack for PCM codecs (will be removed ASAP with new PCM
support to compute the input frame size in samples */
if (c->frame_size <= 1) {
- audio_input_frame_size = audio_outbuf_size / c->channels;
+ out->audio_input_frame_size = out->audio_outbuf_size / c->channels;
switch(st->codec->codec_id) {
case CODEC_ID_PCM_S16LE:
case CODEC_ID_PCM_S16BE:
case CODEC_ID_PCM_U16LE:
case CODEC_ID_PCM_U16BE:
- audio_input_frame_size >>= 1;
+ out->audio_input_frame_size >>= 1;
break;
default:
break;
}
} else {
- audio_input_frame_size = c->frame_size;
+ out->audio_input_frame_size = c->frame_size;
}
- samples = av_malloc(audio_input_frame_size * 2 * c->channels);
+ out->samples = av_malloc(out->audio_input_frame_size * 2 * c->channels);
+ return out;
}
-/* prepare a 16 bit dummy audio frame of 'frame_size' samples and
- 'nb_channels' channels */
-static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
+/* prepare a 16 bit dummy audio frame of 'nb_channels' channels
+ * passing the AudioOut struct*/
+static void get_audio_frame(AudioOut *out, int nb_channels)
{
int j, i, v;
int16_t *q;
- q = samples;
- for(j=0;j<frame_size;j++) {
- v = (int)(sin(t) * 10000);
+ q = out->samples;
+ for(j=0;j<out->audio_input_frame_size;j++) {
+ v = (int)(sin(out->t) * 10000);
for(i = 0; i < nb_channels; i++)
*q++ = v;
- t += tincr;
- tincr += tincr2;
+ out->t += out->tincr;
+ out->tincr += out->tincr2;
}
}
-static void write_audio_frame(AVFormatContext *oc, AVStream *st)
+static void write_audio_frame(AVFormatContext *oc, AVStream *st, AudioOut *out)
{
AVCodecContext *c;
AVPacket pkt;
@@ -162,15 +162,15 @@ static void write_audio_frame(AVFormatContext *oc,
AVStream *st)
c = st->codec;
- get_audio_frame(samples, audio_input_frame_size, c->channels);
+ get_audio_frame(out, c->channels);
- pkt.size= avcodec_encode_audio(c, audio_outbuf, audio_outbuf_size,
samples);
+ pkt.size = avcodec_encode_audio(c, out->audio_outbuf,
out->audio_outbuf_size, out->samples);
if (c->coded_frame && c->coded_frame->pts != AV_NOPTS_VALUE)
- pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base,
st->time_base);
+ pkt.pts = av_rescale_q(c->coded_frame->pts, c->time_base,
st->time_base);
pkt.flags |= AV_PKT_FLAG_KEY;
pkt.stream_index= st->index;
- pkt.data= audio_outbuf;
+ pkt.data = out->audio_outbuf;
/* write the compressed frame in the media file */
if (av_interleaved_write_frame(oc, &pkt) != 0) {
@@ -179,23 +179,29 @@ static void write_audio_frame(AVFormatContext *oc,
AVStream *st)
}
}
-static void close_audio(AVFormatContext *oc, AVStream *st)
+static void close_audio(AVStream *st, AudioOut *out)
{
avcodec_close(st->codec);
- av_free(samples);
- av_free(audio_outbuf);
+ av_free(out->samples);
+ av_free(out->audio_outbuf);
}
/**************************************************************/
-/* video output */
-AVFrame *picture, *tmp_picture;
-uint8_t *video_outbuf;
-int frame_count, video_outbuf_size;
+
+/* video output */
+typedef struct {
+ int frame_count;
+ AVFrame *picture, *tmp_picture;
+ uint8_t *video_outbuf;
+ int video_outbuf_size;
+ AVStream *st;
+} VideoOut;
/* add a video output stream */
-static AVStream *add_video_stream(AVFormatContext *oc, enum CodecID codec_id)
+static AVStream *add_video_stream(AVFormatContext *oc,
+ enum CodecID codec_id, float scale, int
framerate)
{
AVCodecContext *c;
AVStream *st;
@@ -213,13 +219,13 @@ static AVStream *add_video_stream(AVFormatContext *oc,
enum CodecID codec_id)
/* put sample parameters */
c->bit_rate = 400000;
/* resolution must be a multiple of two */
- c->width = 352;
- c->height = 288;
+ c->width = 352*scale;
+ c->height = 288*scale;
/* time base: this is the fundamental unit of time (in seconds) in terms
of which frame timestamps are represented. for fixed-fps content,
timebase should be 1/framerate and timestamp increments should be
identically 1. */
- c->time_base.den = STREAM_FRAME_RATE;
+ c->time_base.den = framerate;
c->time_base.num = 1;
c->gop_size = 12; /* emit one intra frame every twelve frames at most */
c->pix_fmt = STREAM_PIX_FMT;
@@ -260,9 +266,10 @@ static AVFrame *alloc_picture(enum PixelFormat pix_fmt,
int width, int height)
return picture;
}
-static void open_video(AVFormatContext *oc, AVStream *st)
+static VideoOut *open_video(AVFormatContext *oc, AVStream *st)
{
AVCodec *codec;
+ VideoOut *out = av_malloc(sizeof(VideoOut));
AVCodecContext *c;
c = st->codec;
@@ -280,7 +287,7 @@ static void open_video(AVFormatContext *oc, AVStream *st)
exit(1);
}
- video_outbuf = NULL;
+ out->video_outbuf = NULL;
if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
/* allocate output buffer */
/* XXX: API change will be done */
@@ -288,13 +295,13 @@ static void open_video(AVFormatContext *oc, AVStream *st)
as long as they're aligned enough for the architecture, and
they're freed appropriately (such as using av_free for buffers
allocated with av_malloc) */
- video_outbuf_size = 200000;
- video_outbuf = av_malloc(video_outbuf_size);
+ out->video_outbuf_size = 200000;
+ out->video_outbuf = av_malloc(out->video_outbuf_size);
}
/* allocate the encoded raw picture */
- picture = alloc_picture(c->pix_fmt, c->width, c->height);
- if (!picture) {
+ out->picture = alloc_picture(c->pix_fmt, c->width, c->height);
+ if (!out->picture) {
fprintf(stderr, "Could not allocate picture\n");
exit(1);
}
@@ -302,14 +309,16 @@ static void open_video(AVFormatContext *oc, AVStream *st)
/* if the output format is not YUV420P, then a temporary YUV420P
picture is needed too. It is then converted to the required
output format */
- tmp_picture = NULL;
+ out->tmp_picture = NULL;
if (c->pix_fmt != PIX_FMT_YUV420P) {
- tmp_picture = alloc_picture(PIX_FMT_YUV420P, c->width, c->height);
- if (!tmp_picture) {
+ out->tmp_picture = alloc_picture(PIX_FMT_YUV420P, c->width, c->height);
+ if (!out->tmp_picture) {
fprintf(stderr, "Could not allocate temporary picture\n");
exit(1);
}
}
+ out->st = st;
+ return out;
}
/* prepare a dummy image */
@@ -335,15 +344,17 @@ static void fill_yuv_image(AVFrame *pict, int
frame_index, int width, int height
}
}
-static void write_video_frame(AVFormatContext *oc, AVStream *st)
+static void write_video_frame(AVFormatContext *oc, VideoOut *out, int
tot_frames)
{
- int out_size, ret;
+ int out_size, ret = 0;
+ AVPacket pkt;
AVCodecContext *c;
static struct SwsContext *img_convert_ctx;
+ static int sws_flags = SWS_BICUBIC;
- c = st->codec;
+ c = out->st->codec;
- if (frame_count >= STREAM_NB_FRAMES) {
+ if (out->frame_count >= tot_frames) {
/* no more frame to compress. The codec has a latency of a few
frames if using B frames, so we get the last frames by
passing the same picture again */
@@ -362,41 +373,41 @@ static void write_video_frame(AVFormatContext *oc,
AVStream *st)
exit(1);
}
}
- fill_yuv_image(tmp_picture, frame_count, c->width, c->height);
- sws_scale(img_convert_ctx, tmp_picture->data,
tmp_picture->linesize,
- 0, c->height, picture->data, picture->linesize);
+ fill_yuv_image(out->tmp_picture, out->frame_count, c->width,
c->height);
+ sws_scale(img_convert_ctx, out->tmp_picture->data,
out->tmp_picture->linesize,
+ 0, c->height, out->picture->data,
out->picture->linesize);
} else {
- fill_yuv_image(picture, frame_count, c->width, c->height);
+ fill_yuv_image(out->picture, out->frame_count, c->width,
c->height);
}
}
if (oc->oformat->flags & AVFMT_RAWPICTURE) {
/* raw video case. The API will change slightly in the near
- futur for that */
+ future for that */
AVPacket pkt;
av_init_packet(&pkt);
pkt.flags |= AV_PKT_FLAG_KEY;
- pkt.stream_index= st->index;
- pkt.data= (uint8_t *)picture;
+ pkt.stream_index= out->st->index;
+ pkt.data= (uint8_t *)out->picture;
pkt.size= sizeof(AVPicture);
ret = av_interleaved_write_frame(oc, &pkt);
} else {
/* encode the image */
- out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size,
picture);
+ out_size = avcodec_encode_video(c, out->video_outbuf,
out->video_outbuf_size, out->picture);
/* if zero size, it means the image was buffered */
if (out_size > 0) {
AVPacket pkt;
av_init_packet(&pkt);
if (c->coded_frame->pts != AV_NOPTS_VALUE)
- pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base,
st->time_base);
+ pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base,
out->st->time_base);
if(c->coded_frame->key_frame)
pkt.flags |= AV_PKT_FLAG_KEY;
- pkt.stream_index= st->index;
- pkt.data= video_outbuf;
+ pkt.stream_index= out->st->index;
+ pkt.data= out->video_outbuf;
pkt.size= out_size;
/* write the compressed frame in the media file */
@@ -409,19 +420,7 @@ static void write_video_frame(AVFormatContext *oc,
AVStream *st)
fprintf(stderr, "Error while writing video frame\n");
exit(1);
}
- frame_count++;
-}
-
-static void close_video(AVFormatContext *oc, AVStream *st)
-{
- avcodec_close(st->codec);
- av_free(picture->data[0]);
- av_free(picture);
- if (tmp_picture) {
- av_free(tmp_picture->data[0]);
- av_free(tmp_picture);
- }
- av_free(video_outbuf);
+ out->frame_count++;
}
/**************************************************************/
@@ -434,13 +433,19 @@ int main(int argc, char **argv)
AVFormatContext *oc;
AVStream *audio_st, *video_st;
double audio_pts, video_pts;
+ VideoOut *out;
+ AudioOut *aout;
+ int opt;
+ float duration;
+ int framerate;
+ int tot_frames;
int i;
/* initialize libavcodec, and register all codecs and formats */
av_register_all();
- if (argc != 2) {
- printf("usage: %s output_file\n"
+ if (argc < 2) {
+ printf("usage: %s [-d stream_duration] [-r frame_rate] output_file\n"
"API example program to output a media file with libavformat.\n"
"The output format is automatically guessed according to the
file extension.\n"
"Raw images can also be output by using '%%d' in the filename\n"
@@ -448,7 +453,22 @@ int main(int argc, char **argv)
exit(1);
}
- filename = argv[1];
+ duration = STREAM_DURATION;
+ framerate = STREAM_FRAME_RATE;
+
+ while ((opt = getopt(argc, argv, "d:r:")) != -1) {
+ switch(opt) {
+ case 'd':
+ duration = atof(optarg);
+ break;
+ case 'r':
+ framerate = atoi(optarg);
+ break;
+ }
+ }
+
+ tot_frames = ((int)(duration * framerate));
+ filename = argv[optind];
/* auto detect the output format from the name. default is
mpeg. */
@@ -472,35 +492,34 @@ int main(int argc, char **argv)
snprintf(oc->filename, sizeof(oc->filename), "%s", filename);
/* add the audio and video streams using the default format codecs
- and initialize the codecs */
- video_st = NULL;
- audio_st = NULL;
- if (fmt->video_codec != CODEC_ID_NONE) {
- video_st = add_video_stream(oc, fmt->video_codec);
- }
- if (fmt->audio_codec != CODEC_ID_NONE) {
- audio_st = add_audio_stream(oc, fmt->audio_codec);
- }
-
- /* set the output parameters (must be done even if no
- parameters). */
- if (av_set_parameters(oc, NULL) < 0) {
- fprintf(stderr, "Invalid output format parameters\n");
- exit(1);
- }
+ and initialize the codecs */
+ video_st = NULL;
+ audio_st = NULL;
+ if (fmt->video_codec != CODEC_ID_NONE) {
+ video_st = add_video_stream(oc, fmt->video_codec, 1, framerate);
+ }
+ if (fmt->audio_codec != CODEC_ID_NONE) {
+ audio_st = add_audio_stream(oc, fmt->audio_codec);
+ }
+ /* set the output parameters (must be done even if no
+ parameters). */
+ if (av_set_parameters(oc, NULL) < 0) {
+ fprintf(stderr, "Invalid output format parameters\n");
+ exit(1);
+ }
av_dump_format(oc, 0, filename, 1);
/* now that all the parameters are set, we can open the audio and
video codecs and allocate the necessary encode buffers */
if (video_st)
- open_video(oc, video_st);
+ out = open_video(oc, video_st);
if (audio_st)
- open_audio(oc, audio_st);
+ aout = open_audio(oc, audio_st);
/* open the output file, if needed */
if (!(fmt->flags & AVFMT_NOFILE)) {
- if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {
+ if (avio_open(&oc->pb, filename, URL_WRONLY) < 0) {
fprintf(stderr, "Could not open '%s'\n", filename);
exit(1);
}
@@ -521,15 +540,15 @@ int main(int argc, char **argv)
else
video_pts = 0.0;
- if ((!audio_st || audio_pts >= STREAM_DURATION) &&
- (!video_st || video_pts >= STREAM_DURATION))
+ if ((!audio_st || audio_pts >= duration) &&
+ (!video_st || video_pts >= duration))
break;
/* write interleaved audio and video frames */
if (!video_st || (video_st && audio_st && audio_pts < video_pts)) {
- write_audio_frame(oc, audio_st);
+ write_audio_frame(oc, audio_st, aout);
} else {
- write_video_frame(oc, video_st);
+ write_video_frame(oc, out, tot_frames);
}
}
@@ -541,9 +560,9 @@ int main(int argc, char **argv)
/* close each codec */
if (video_st)
- close_video(oc, video_st);
+ close_video(oc, out);
if (audio_st)
- close_audio(oc, audio_st);
+ close_audio(audio_st, aout);
/* free the streams */
for(i = 0; i < oc->nb_streams; i++) {
--
1.7.4.1
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
