[Libav-user] Audio file is not getting created.

[Prakash Rokade]

I am trying to record audio from speaker.
I am using below code to create audio file.
The audio file is created but there is no audio data in file.
Or some time only 2-3 sec of audio  data is recorded.

I have gone through the ffmpeg examples.

can some one help me by seeing the below code.
Thanks.


ref struct WriterData
{
	public:
		Ffmpeg::AVFormatContext*		FormatContext;
		
		Ffmpeg::AVStream*				AudioStream;
		Ffmpeg::AVFrame*				AudioFrame;
		Ffmpeg::AVCodec				*Audio_Codec;

		int AudioBitRate;
		int SampleRate;
		int Channels;
		
		int AudioReceived;
		int AudioWritten;

		Ffmpeg::int64_t next_pts;
		int samples_count;

		Ffmpeg::AVFrame *tmp_frame;

		float t, tincr, tincr2;
		struct Ffmpeg::SwsContext *sws_ctx;
		struct Ffmpeg::SwrContext *swr_ctx;

		double PreviousAudioDts;

		AudioWriterData()
		{
			FormatContext = NULL;
				
			AudioStream = NULL;

			Audio_Codec = NULL;

			AudioFrame = NULL;
			
			AudioReceived = 0;
			AudioWritten = 0;
		}
};

void Encoder::Open(String^ fileName, AudioCodec audioCodec, int
audioBitrate, int sampleRate, int channels)
{
	CheckIfDisposed();

	Close();

	data = gcnew WriterData();
	bool success = false;
		
	if (((int)audioCodec < -1) || ((int)audioCodec >= AUDIO_CODECS_COUNT))
		throw gcnew ArgumentException("Invalid audio codec is specified.");

	m_acodec = audioCodec;
	m_audioBitrate = audioBitrate;
	m_sampleRate = sampleRate;
	m_channels = channels;
		
	data->AudioBitRate = audioBitrate;
	data->SampleRate = sampleRate;
	data->Channels = channels;

	char* nativeFileName =
(char*)System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(fileName).ToPointer();

	try
	{
		Ffmpeg::AVOutputFormat* outputFormat = Ffmpeg::av_guess_format(NULL,
nativeFileName, NULL);

		if (!outputFormat)
		{
			outputFormat = Ffmpeg::av_guess_format("mp3", NULL, NULL);

			if (!outputFormat)
				throw gcnew Exception("Cannot find suitable output format.");
		}

		data->FormatContext = Ffmpeg::avformat_alloc_context();

		if (!data->FormatContext)
			throw gcnew Exception("Cannot allocate format context.");

		data->FormatContext->oformat = outputFormat;
		strcpy_s(data->FormatContext->filename, nativeFileName);

		Ffmpeg::AVCodecID codecId = (audioCodec == AudioCodec::Default) ?
outputFormat->audio_codec : (Ffmpeg::AVCodecID)
audio_codecs[(int)audioCodec];

		data->FormatContext->oformat->audio_codec = codecId;

		add_audio_stream(data, codecId);
				
		open_audio(data);

		Ffmpeg::av_dump_format(data->FormatContext, 0, nativeFileName, 1);

		if (!(outputFormat->flags & AVFMT_NOFILE))
		{
			if (Ffmpeg::avio_open(&data->FormatContext->pb, nativeFileName,
AVIO_FLAG_WRITE) < 0)
				throw gcnew System::IO::IOException("Cannot open the video file.");
		}

		Ffmpeg::avformat_write_header(data->FormatContext, NULL);

		success = true;
	}
	finally
	{
		nativeFileName = NULL;
		delete[] nativeFileName;

		if (!success)
			Close();
	}
}

void add_audio_stream(WriterData^ data, enum Ffmpeg::AVCodecID codecId)
{
	data->AudioStream = Ffmpeg::avformat_new_stream(data->FormatContext,
data->FormatContext->audio_codec);

	if (!data->AudioStream)
		throw gcnew Exception("Could not alloc audio stream");

	Ffmpeg::AVCodecContext *codecContext = data->AudioStream->codec;

	codecContext->codec_id = codecId;
	codecContext->codec_type = Ffmpeg::AVMEDIA_TYPE_AUDIO;
	codecContext->sample_fmt = Ffmpeg::AV_SAMPLE_FMT_S16;
	codecContext->channels = data->Channels;
	codecContext->delay = 0;
	codecContext->bit_rate = data->AudioBitRate;

	if (codecContext->bit_rate == 0)
		codecContext->bit_rate = data->SampleRate * data->Channels * 16;

	codecContext->bit_rate = codecContext->bit_rate;
	codecContext->bit_rate_tolerance = codecContext->bit_rate;
	codecContext->rc_min_rate = 0;
	codecContext->rc_max_rate = 0;
	codecContext->frame_size = 0;
	codecContext->channel_layout = (codecContext->channels == 2 ?
AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO);

	codecContext->sample_rate = data->SampleRate;

	codecContext->time_base.den = data->SampleRate;
	codecContext->time_base.num = 1;

	//data->AudioStream->time_base.den = codecContext->time_base.den;
	//data->AudioStream->time_base.num = codecContext->time_base.num;
						
	if (data->FormatContext->oformat->flags & AVFMT_GLOBALHEADER)
		codecContext->flags |= CODEC_FLAG_GLOBAL_HEADER;
}

void open_audio(WriterData^ data)
{
	Ffmpeg::AVCodecContext* codecContext = data->AudioStream->codec;
	Ffmpeg::AVCodec* codec = avcodec_find_encoder(codecContext->codec_id);

	if (!codec)
		throw gcnew Exception("Cannot find audio codec.");

	codecContext->codec_id = codec->id;
	codecContext->codec_type = Ffmpeg::AVMEDIA_TYPE_AUDIO;
	codecContext->sample_fmt = codec->sample_fmts[0];
	codecContext->sample_rate = data->SampleRate;
	codecContext->channel_layout = AV_CH_LAYOUT_STEREO;
	codecContext->channels =
Ffmpeg::av_get_channel_layout_nb_channels(codecContext->channel_layout);
	codecContext->bit_rate = data->AudioBitRate;

	int ret = Ffmpeg::avcodec_open2(codecContext, codec, NULL);
	if (ret < 0)
		throw gcnew Exception("Cannot open audio codec.");
}


void Encoder::WriteAudioChunk(IntPtr chunk, int lenght, TimeSpan timestamp)
{
	CheckIfDisposed();

	if (data == nullptr)
		throw gcnew System::IO::IOException("A video file was not opened yet.");

	int bufferSize = lenght;
			
	data->AudioFrame = Ffmpeg::av_frame_alloc();

	Ffmpeg::av_frame_unref(data->AudioFrame);
	data->AudioFrame->pts = AV_NOPTS_VALUE;
	data->AudioFrame->format = data->AudioStream->codec->sample_fmt;

	int bytePerSample =
Ffmpeg::av_get_bytes_per_sample(data->AudioStream->codec->sample_fmt);
	int dataSize = data->Channels * bytePerSample;			
	data->AudioStream->codec->frame_size = data->Channels *
data->SampleRate * bytePerSample;
	data->AudioFrame->nb_samples = data->AudioStream->codec->frame_size;

	Ffmpeg::uint8_t *buf =
reinterpret_cast<Ffmpeg::uint8_t*>(static_cast<void*>(chunk));

	int ret = Ffmpeg::avcodec_fill_audio_frame(data->AudioFrame,
data->Channels, data->AudioStream->codec->sample_fmt, buf, bufferSize,
1);

	if (!ret)
		throw gcnew System::IO::IOException("A video file was not opened yet.");
			
	data->AudioReceived++;
	
	write_audio_chunk(data, buf, ret,timestamp.TotalMilliseconds);
}

void write_audio_chunk(WriterData^ data, Ffmpeg::uint8_t *ut, int
size,double timeStamp)
{
	Ffmpeg::AVCodecContext* codecContext = data->AudioStream->codec;
	int out_size, ret = 0;

	Ffmpeg::AVPacket packet;

	int64_t dts = timeStamp;
	dts = dts * data->FrameRate;

	if (data->PreviousAudioDts < 0)
		data->PreviousAudioDts = dts;

	int got_packet;
	Ffmpeg::av_init_packet(&packet);
	packet.data = ut;
	packet.size = size;

	out_size = Ffmpeg::avcodec_send_frame(codecContext, data->AudioFrame);
	got_packet = Ffmpeg::avcodec_receive_packet(codecContext, &packet);

	

	if (got_packet)
	{
		if (codecContext->coded_frame->pts != AV_NOPTS_VALUE)
		{
			packet.pts = Ffmpeg::av_rescale_q(packet.pts,
codecContext->time_base, data->AudioStream->time_base);
			packet.dts = Ffmpeg::av_rescale_q(packet.dts,
codecContext->time_base, data->AudioStream->time_base);
			packet.duration = Ffmpeg::av_rescale_q(packet.duration,
codecContext->time_base, data->AudioStream->time_base);
		}

		packet.stream_index = data->AudioStream->index;

		ret = Ffmpeg::av_interleaved_write_frame(data->FormatContext, &packet);
		//ret = Ffmpeg::av_write_frame(data->FormatContext, &packet);
		data->AudioWritten++;
	}
			

	av_packet_unref(&packet);
	got_packet = 0;

	if (ret != 0)
		throw gcnew Exception("Error while writing audio frame.");
}