Those reviews are a bit stricter than usual just to give you some
guidelines. Don't get discouraged if we pick all possible issue.
On 7/29/11 11:02 PM, Simone Marzola wrote:
From: simock85<[email protected]>
changed constants into opt args
output-example: changed constants into opt args
The commit message should be a bit less implicit
"
avf: cleanup output-example.c
Remove globals and hardcoded constants.
"
---
libavformat/output-example.c | 239 ++++++++++++++++++++++++-----------------
1 files changed, 140 insertions(+), 99 deletions(-)
diff --git a/libavformat/output-example.c b/libavformat/output-example.c
index 3b28b7c..6972e58 100644
--- a/libavformat/output-example.c
+++ b/libavformat/output-example.c
@@ -34,28 +34,25 @@
#include<string.h>
#include<math.h>
-#include "libavutil/mathematics.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"
#undef exit
-/* 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_NB_FRAMES(DURATION, F_RATE) ((int)(DURATION * F_RATE))
#define STREAM_PIX_FMT PIX_FMT_YUV420P /* default pix_fmt */
Keeping the defaults as macro constants isn't bad and usually helps
understanding what's going on
static int sws_flags = SWS_BICUBIC;
how many times is it used? It could be probably moved in the only place
it is used.
/**************************************************************/
-/* 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 */
you might want to update the comment
-static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
+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);
you should change the formatting and add a space between pkt.size and =.
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.flags |= AV_PKT_FLAG_KEY;
pkt.stream_index= st->index;
- pkt.data= audio_outbuf;
+ pkt.data= out->audio_outbuf;
Ditto
/* write the compressed frame in the media file */
if (av_interleaved_write_frame(oc,&pkt) != 0) {
@@ -179,23 +179,28 @@ 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 */
+int frame_count;
why?
-AVFrame *picture, *tmp_picture;
-uint8_t *video_outbuf;
-int frame_count, video_outbuf_size;
+/* video output */
+typedef struct {
+ 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 +218,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 +265,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 +286,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 +294,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 +308,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 +343,18 @@ 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, char
*hidden, int tot_frames)
I see something spurious
{
- int out_size, ret;
+ int out_size, ret = 0;
+ AVPacket pkt;
AVCodecContext *c;
static struct SwsContext *img_convert_ctx;
- c = st->codec;
+ av_init_packet(&pkt);
- if (frame_count>= STREAM_NB_FRAMES) {
+ c = out->st->codec;
+
+ if (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,66 +373,70 @@ 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, 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, frame_count, c->width, c->height);
}
}
+ pkt.data = NULL;
if (oc->oformat->flags& AVFMT_RAWPICTURE) {
/* raw video case. The API will change slightly in the near
futur 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 */
- ret = av_interleaved_write_frame(oc,&pkt);
- } else {
- ret = 0;
}
}
+
+ if(pkt.data) {
+ if(hidden) {
+ int len = strlen(hidden);
+ memcpy(pkt.data+pkt.size, hidden, len);
+ pkt.size+=len;
+ }
I guess that's from one of my experimental branches, please drop it for
now (I'll ask you to play with the concept during the socis)
+
+ ret = av_interleaved_write_frame(oc,&pkt);
+ }
if (ret != 0) {
fprintf(stderr, "Error while writing video frame\n");
exit(1);
}
- frame_count++;
}
-static void close_video(AVFormatContext *oc, AVStream *st)
+static void close_video(AVFormatContext *oc, VideoOut *out)
{
- 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);
+ avcodec_close(out->st->codec);
+ av_free(out->picture->data[0]);
+ av_free(out->picture);
+ if (out->tmp_picture) {
+ av_free(out->tmp_picture->data[0]);
+ av_free(out->tmp_picture);
+ }
+ av_free(out->video_outbuf);
}
/**************************************************************/
@@ -432,15 +447,21 @@ int main(int argc, char **argv)
const char *filename;
AVOutputFormat *fmt;
AVFormatContext *oc;
- AVStream *audio_st, *video_st;
+ AVStream *audio_st, *video_st, *video_st2;
double audio_pts, video_pts;
+ VideoOut *out, *out2;
+ 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 output_file\n [-d stream_duration] [-r frame_rate]"
usually options come first
"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,6 +469,21 @@ int main(int argc, char **argv)
exit(1);
}
+ duration = 5.0; /* 5 secs stream */
+ framerate = 25; /* 25 images/sec */
+
+ while ((opt = getopt(argc, argv, "d:r:")) != -1) {
+ switch(opt) {
+ case 'd':
+ duration = atof(optarg);
+ break;
+ case 'r':
+ framerate = atoi(optarg);
+ break;
+ }
+ }
+
+ tot_frames = STREAM_NB_FRAMES(duration, framerate);
is it used somewhere else? drop this macro =)
filename = argv[1];
/* auto detect the output format from the name. default is
@@ -476,12 +512,14 @@ int main(int argc, char **argv)
video_st = NULL;
audio_st = NULL;
if (fmt->video_codec != CODEC_ID_NONE) {
- video_st = add_video_stream(oc, fmt->video_codec);
+ 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);
}
+ video_st2 = add_video_stream(oc, CODEC_ID_MPEG2VIDEO, 0.5, framerate);
Drop this for now =)
+
/* set the output parameters (must be done even if no
parameters). */
if (av_set_parameters(oc, NULL)< 0) {
@@ -494,13 +532,14 @@ int main(int argc, char **argv)
/* 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);
+ out2 = open_video(oc, video_st2);
/* 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 +560,17 @@ 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, NULL, tot_frames);
+ write_video_frame(oc, out2, "Test", tot_frames);
+ frame_count++;
}
}
@@ -541,9 +582,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++) {
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
