FFMPEG音频问题！高手请进!

[wansbest]

有个问题，我编译了下out_example那个示例。然后自己试着往里面加一段音频，所以将生成音频那段去掉重新写了从文件读取音频的代码。但之后发现，最后音频是写进去了，但速率明显不对，杂音也很大。小弟刚接触音视频和ffmpeg，调了很久也不知道怎么设置它的参数。各位前辈，有对ffmpeg熟悉的，有时间的话可不可以帮我看看这个小demo的问题出在哪儿！！！
代码如下

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <iostream>
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
extern "C" {
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
}
#undef exit

/* 5 seconds stream duration */
#define STREAM_DURATION   50.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 */


#define INPUT_FILE ""
#define OUTPUT_FILE "test.flv";
using namespace std;
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;

int audioStream = -1;
AVFormatContext *InFmtCtx = NULL;
AVCodecContext *InCodecCtx = NULL;
AVCodec *Incodec = NULL;
/*
*打开一个音频文件并找到相应的解码器和编码器
*/
static int open_input_audio(const char *infile)
{
	if (av_open_input_file(&InFmtCtx,infile,NULL,0,NULL)!=0)
	{
		cout<<"open "<<infile<<"failed!"<<endl;
		return 1;
	}

	if(InFmtCtx==NULL)
	{
		cout<<"open "<<infile<<"sucess but the AVFormatContext is NULL!"<<endl;
		return 1;
	}
	//查找文件当中的音频流
	if (av_find_stream_info(InFmtCtx) < 0)
	{
		cout<<"find stream info failed!"<<endl;
		return 1;
	}

	//找到第一路音频流
	for (int i=0; i<InFmtCtx->nb_streams; ++i)
	{
		if (InFmtCtx->streams[i]->codec->codec_type == CODEC_TYPE_AUDIO)
		{
			audioStream = i;
			break;
		}
	}
	if (-1 == audioStream)
	{
		cout<<"input file have no audio stream"<<endl;
		return 1;
	}


	//找到解码器并打开
	InCodecCtx = InFmtCtx->streams[audioStream]->codec;
	Incodec	= avcodec_find_decoder(InCodecCtx->codec_id);
	if (avcodec_open(InCodecCtx,Incodec) < 0)
	{
		cout<<"open decoder failed!"<<endl;
		return 1;
	}
	dump_format(InFmtCtx,0,infile,0);
	return 0;
}

/*
* add an audio output stream
*/

static AVStream *add_audio_stream(AVFormatContext *oc,int codec_id)
{
	AVCodecContext *c;
	AVStream *st;
	st = av_new_stream(oc, 1);
	if (!st) {
		fprintf(stderr, "Could not alloc stream\n");
		exit(1);
	}

	c = st->codec;
	c->codec_id = CodecID(codec_id);
	c->codec_type = CODEC_TYPE_AUDIO;

	/* put sample parameters */
	c->bit_rate = InFmtCtx->streams[audioStream]->codec->bit_rate;  
	c->sample_rate = InFmtCtx->streams[audioStream]->codec->sample_rate;  
	c->channels = InFmtCtx->streams[audioStream]->codec->channels;
	return st;
}
/*
*
*/
static void open_audio(AVFormatContext *oc, AVStream *st)
{
	
	AVCodecContext *c;
	AVCodec *codec;

	c = st->codec;

	/* find the audio encoder */
	codec = avcodec_find_encoder(c->codec_id);
	if (!codec) {
		fprintf(stderr, "codec not found\n");
		exit(1);
	}

	/* open it */
	if (avcodec_open(c, codec) < 0) {
		fprintf(stderr, "could not open codec\n");
		exit(1);
	}

	/* init signal generator */
	t = 0;
	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;

	audio_outbuf_size = 10000;
	audio_outbuf = (uint8_t *)av_malloc(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;
		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;
			break;
		default:
			break;
		}
	} else {
		audio_input_frame_size = c->frame_size;
	}
	samples = (int16_t *)av_malloc(audio_input_frame_size * 2 * c->channels);
}

/* prepare a 16 bit dummy audio frame of 'frame_size' samples and
*这儿应该是从输入文件中读取一帧数据
'nb_channels' channels */
static int get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
{
	static AVPacket packet;
	int len = -1;
	if (av_read_frame(InFmtCtx, &packet)>=0)
	{
		
		int out_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
		if(packet.stream_index==audioStream)
			len = avcodec_decode_audio2(InCodecCtx,(short*)samples,&out_size,packet.data,packet.size);
		if (len<0)
		{
			cout<<"decode error!\n";
			return -1;
		}
		else
		{
			return 1;
		}		
	
	}
	else
	{
		return 0;
	}

}

static void write_audio_frame(AVFormatContext *oc, AVStream *st)
{
	AVCodecContext *c;
	AVPacket pkt;
	av_init_packet(&pkt);

	c = st->codec;

	get_audio_frame(samples, audio_input_frame_size, c->channels);

	pkt.size= avcodec_encode_audio(c, audio_outbuf, audio_outbuf_size, samples);

	if (c->coded_frame->pts != /*AV_NOPTS_VALUE*/0x8000000000000000)
		pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
	pkt.flags |= PKT_FLAG_KEY;
	pkt.stream_index= st->index;
	pkt.data= audio_outbuf;

	/* write the compressed frame in the media file */
	if (av_write_frame(oc, &pkt) != 0) {
		fprintf(stderr, "Error while writing audio frame\n");
		exit(1);
	}
}

static void close_audio(AVFormatContext *oc, AVStream *st)
{
	avcodec_close(st->codec);

	av_free(samples);
	av_free(audio_outbuf);
}

[wansbest]

/**************************************************************/
/* video output */

AVFrame *picture, *tmp_picture;
uint8_t *video_outbuf;
int frame_count, video_outbuf_size;

/* add a video output stream */
static AVStream *add_video_stream(AVFormatContext *oc, int codec_id)
{
	AVCodecContext *c;
	AVStream *st;

	st = av_new_stream(oc, 0);
	if (!st) {
		fprintf(stderr, "Could not alloc stream\n");
		exit(1);
	}

	c = st->codec;
	c->codec_id = CodecID(codec_id);
	c->codec_type = CODEC_TYPE_VIDEO;

	/* put sample parameters */
	c->bit_rate = 400000;
	/* resolution must be a multiple of two */
	c->width = 352;
	c->height = 288;
	/* 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.num = 1;
	c->gop_size = 12; /* emit one intra frame every twelve frames at most */
	c->pix_fmt = STREAM_PIX_FMT;
	if (c->codec_id == CODEC_ID_MPEG2VIDEO) {
		/* just for testing, we also add B frames */
		c->max_b_frames = 2;
	}
	if (c->codec_id == CODEC_ID_MPEG1VIDEO){
		/* Needed to avoid using macroblocks in which some coeffs overflow.
		This does not happen with normal video, it just happens here as
		the motion of the chroma plane does not match the luma plane. */
		c->mb_decision=2;
	}
	// some formats want stream headers to be separate
	if(!strcmp(oc->oformat->name, "mp4") || !strcmp(oc->oformat->name, "mov") || !strcmp(oc->oformat->name, "3gp"))
		c->flags |= CODEC_FLAG_GLOBAL_HEADER;

	return st;
}

static AVFrame *alloc_picture(int pix_fmt, int width, int height)
{
	AVFrame *picture;
	uint8_t *picture_buf;
	int size;

	picture = avcodec_alloc_frame();
	if (!picture)
		return NULL;
	size = avpicture_get_size(pix_fmt, width, height);
	picture_buf = (uint8_t *)av_malloc(size);
	if (!picture_buf) {
		av_free(picture);
		return NULL;
	}
	avpicture_fill((AVPicture *)picture, picture_buf,
		pix_fmt, width, height);
	return picture;
}

static void open_video(AVFormatContext *oc, AVStream *st)
{
	AVCodec *codec;
	AVCodecContext *c;

	c = st->codec;

	/* find the video encoder */
	codec = avcodec_find_encoder(c->codec_id);
	if (!codec) {
		fprintf(stderr, "codec not found\n");
		exit(1);
	}

	/* open the codec */
	if (avcodec_open(c, codec) < 0) {
		fprintf(stderr, "could not open codec\n");
		exit(1);
	}

	video_outbuf = NULL;
	if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
		/* allocate output buffer */
		/* XXX: API change will be done */
		/* buffers passed into lav* can be allocated any way you prefer,
		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 = (uint8_t *)av_malloc(video_outbuf_size);
	}

	/* allocate the encoded raw picture */
	picture = alloc_picture(c->pix_fmt, c->width, c->height);
	if (!picture) {
		fprintf(stderr, "Could not allocate picture\n");
		exit(1);
	}

	/* 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;
	if (c->pix_fmt != PIX_FMT_YUV420P) {
		tmp_picture = alloc_picture(PIX_FMT_YUV420P, c->width, c->height);
		if (!tmp_picture) {
			fprintf(stderr, "Could not allocate temporary picture\n");
			exit(1);
		}
	}
}

/* prepare a dummy image */
static void fill_yuv_image(AVFrame *pict, int frame_index, int width, int height)
{
	int x, y, i;

	i = frame_index;

	/* Y */
	for(y=0;y<height;y++) {
		for(x=0;x<width;x++) {
			pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
		}
	}

	/* Cb and Cr */
	for(y=0;y<height/2;y++) {
		for(x=0;x<width/2;x++) {
			pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
			pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
		}
	}
}

static void write_video_frame(AVFormatContext *oc, AVStream *st)
{
	int out_size, ret;
	AVCodecContext *c;
	static struct SwsContext *img_convert_ctx;

	c = st->codec;

	if (frame_count >= STREAM_NB_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 */
	} else {
		if (c->pix_fmt != PIX_FMT_YUV420P) {
			/* as we only generate a YUV420P picture, we must convert it
			to the codec pixel format if needed */
			if (img_convert_ctx == NULL) {
				img_convert_ctx = sws_getContext(c->width, c->height,
					PIX_FMT_YUV420P,
					c->width, c->height,
					c->pix_fmt,
					sws_flags, NULL, NULL, NULL);
				if (img_convert_ctx == NULL) {
					fprintf(stderr, "Cannot initialize the conversion context\n");
					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);
		} else {
			fill_yuv_image(picture, 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 */
		AVPacket pkt;
		av_init_packet(&pkt);

		pkt.flags |= PKT_FLAG_KEY;
		pkt.stream_index= st->index;
		pkt.data= (uint8_t *)picture;
		pkt.size= sizeof(AVPicture);

		ret = av_write_frame(oc, &pkt);
	} else {
		/* encode the image */
		out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, 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*/0x8000000000000000)
				pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);

			if(c->coded_frame->key_frame)
				pkt.flags |= PKT_FLAG_KEY;
			pkt.stream_index= st->index;
			pkt.data= video_outbuf;
			pkt.size= out_size;

			/* write the compressed frame in the media file */
			ret = av_write_frame(oc, &pkt);
		} else {
			ret = 0;
		}
	}
	if (ret != 0) {
		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);
}

/**************************************************************/
/* media file output */

int main()
{
	const char *filename = OUTPUT_FILE;
	AVOutputFormat *fmt;
	AVFormatContext *oc;
	AVStream *audio_st, *video_st;
	double audio_pts, video_pts;
	int i;

	/* initialize libavcodec, and register all codecs and formats */
	av_register_all();


	if (open_input_audio("test.mp3") !=0)
	{
		cout<<"open input file failed!\n";
		return -1;
	}

	/* auto detect the output format from the name. default is
	mpeg. */
	fmt = guess_format(NULL, filename, NULL);
	if (!fmt) {
		printf("Could not deduce output format from file extension: using MPEG.\n");
		fmt = guess_format("mpeg", NULL, NULL);
	}
	if (!fmt) {
		fprintf(stderr, "Could not find suitable output format\n");
		exit(1);
	}

	/* allocate the output media context */
	oc = av_alloc_format_context();
	if (!oc) {
		fprintf(stderr, "Memory error\n");
		exit(1);
	}

	oc->oformat = fmt;
	//    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);
	}

	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);
	if (audio_st)
		open_audio(oc, audio_st);
	/* open the output file, if needed */
	if (!(fmt->flags & AVFMT_NOFILE)) {
		if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
			fprintf(stderr, "Could not open '%s'\n", filename);
			exit(1);
		}
	}

	/* write the stream header, if any */
	av_write_header(oc);

	for(;;) {
		/* compute current audio and video time */
		if (audio_st)
			audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
		else
			audio_pts = 0.0;

		if (video_st)
			video_pts = (double)video_st->pts.val * video_st->time_base.num / video_st->time_base.den;
		else
			video_pts = 0.0;

		if ((!audio_st || audio_pts >= STREAM_DURATION) &&
			(!video_st || video_pts >= STREAM_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);
		} else {
			write_video_frame(oc, video_st);
		}
	}

	/* close each codec */
	if (video_st)
		close_video(oc, video_st);
	if (audio_st)
		close_audio(oc, audio_st);

	/* write the trailer, if any */
	av_write_trailer(oc);

	/* free the streams */
	for(i = 0; i < oc->nb_streams; i++) {
		av_freep(&oc->streams[i]->codec);
		av_freep(&oc->streams[i]);
	}

	if (!(fmt->flags & AVFMT_NOFILE)) {
		/* close the output file */
		url_fclose(oc->pb);
	}

	/* free the stream */
	av_free(oc);

	return 0;
}

[/code]

[wansbest]

顶起来，别沉了！！！

[cxxy328]

建议音频都用fifo缓存来做

[wansbest]

好不容易，终于等到一个人的回答了，fifo没用过，之前在网上有个示例代码我试着用了下，发现它用的那个函数

我的ffmpeg这个版本都没有！！

有这方面的示例代码吗？可不可以参考下，如果我这段代码换成fifo来在做的话需要改动哪些地方！！！

[cxxy328]

AVFifoBuffer fifo;
memset(&fifo,0x0,sizeof(fifo));
av_fifo_init(&fifo, av_fifo_size(&fifo)+samples_size_ptr);
然后把音频数据写到fifo
av_fifo_generic_write(&fifo, buftmp, size_out, NULL);
使用while循环从fifo读数据
while(av_fifo_size(&fifo) > outSampleSize)//(av_fifo_read(&fifo, audio_buf, outSampleSize) == 0)
{
AVPacket pkt;
av_init_packet(&pkt);
av_fifo_read(&fifo, audio_buf, outSampleSize);
int ss = avcodec_encode_audio(outcode_ctx, audio_outbuf, audio_outbuf_size, (short *)audio_buf);//编码
}

[cxxy328]

fifo主要是为了防止帧丢失
因为每次编码的数据长度只有1152个字节
如果你的数据长度不大于这个数据倒是可以不用fifo
大了就要用了
你可以作日志看看
具体实例参考ffmpeg.c源代码中的do_audio_out函数
有详细的fifo

[cxxy328]

既然FLV本身是支持MP3格式的
那你直接把音频编码器换成MP3编码器不就行了吗
干嘛还要再guess_foramt

[cxxy328]

就是find_encoder（这里面参数改成MP3编码器）

[wansbest]

[Quote=引用 8 楼 cxxy328 的回复:]

既然FLV本身是支持MP3格式的
那你直接把音频编码器换成MP3编码器不就行了吗
干嘛还要再guess_foramt
[/Quote]
因为我要做的音视频录制，我能拿到的数据视频数据是h264的，音频数据经过解码之后能拿到PCM格式的，最后将

音频一起输出到一个FLV文件里面，所以用到了guess_format 来取AVOutputFormat。

在find_encoder 之前需要添加一路音频流，是不是在那儿将音频流的code_id设置为MP3就ok了。find_encoder

就是通过音频流的code_id来找的。

[wansbest]

谢谢楼上楼上的回答，现在问题已经解决了！！！

但又由遇到新的问题，我用.FLV后缀得到输出文件的AVOutputFormat，发现里面的音频格式为CODEC_ID_ADPCM_SWF

这种格式的压缩比是1:4相对于MP3来说输出文件要大了很多，这个差距对我要做的东西来说是不可接受的。看了下

FLV的文档，FLV本身是支持MP3格式的，现在的问题就是，用FFMPEG怎么才能将音频文件，以MP3的编码格式存放在

FLV文件里面，输出文件的AVFormatContext AVOutFormat 应该怎么设置。简单点说，就是除了使用

guess_format()之外，还有些什么办法可以设置输出文件的音频格式！！！！

[cxxy328]

..我也刚接触ffmpeg一个月
单独的音视频编解码都可以做了
格式的转换，linux下音视频的实时录制
视频的时间戳没问题，但是音频的时间戳不对
同步不了
都好几天了
在CSDN和ffmpeg工程组发了好几个帖子
没人解决啊
痛苦

[wansbest]

我最终要做的也是linux下面实时音视频录制。

现在还属于预研阶段，主要是决定各个环节怎么来做，还没有做到音视频同步那一块。公司到有几个音视频方

面的高手，到时候问问他们。

你QQ或者MSN是多少，到时候多交流下！！！

我的QQ:337427403

[cxxy328]

是的，它那个是根据文件后缀名来猜编解码器，你既然确定需要哪个，那只要把音频的code_id改MP3就可以了

[wansbest]

这两天太感谢你的回答了，解决了好几个问题！！

先结贴吧！！以后还请多多指教哦！！！

[cxxy328]

603935066,我已经加你了