Simple sound playback using ALSA API and libasound

sound_playback.c

/*
 * Simple sound playback using ALSA API and libasound.
 *
 * Compile:
 * $ cc -o play sound_playback.c -lasound
 * 
 * Usage:
 * $ ./play <sample_rate> <channels> <seconds> < <file>
 * 
 * Examples:
 * $ ./play 44100 2 5 < /dev/urandom
 * $ ./play 22050 1 8 < /path/to/file.wav
 *
 * Copyright (C) 2009 Alessandro Ghedini <[email protected]>
 * --------------------------------------------------------------
 * "THE BEER-WARE LICENSE" (Revision 42):
 * Alessandro Ghedini wrote this file. As long as you retain this
 * notice you can do whatever you want with this stuff. If we
 * meet some day, and you think this stuff is worth it, you can
 * buy me a beer in return.
 * --------------------------------------------------------------
 */

#include <alsa/asoundlib.h>
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libswresample/swresample.h>
#include <stdio.h>
#include <stdlib.h>

#define PCM_DEVICE "default"

int main(int argc, char **argv) {
	unsigned int pcm, tmp, dir;
	int rate, channels, seconds;
	snd_pcm_t *pcm_handle;
	snd_pcm_hw_params_t *params;
	snd_pcm_uframes_t frames;
	char *buff;
	int buff_size;

	if (argc < 4) {
		printf("Usage: %s <sample_rate> <channels> <seconds>\n", argv[0]);
		return -1;
	}

	rate = atoi(argv[1]);
	channels = atoi(argv[2]);
	seconds = atoi(argv[3]);

	/* Initialize FFmpeg */
	av_register_all();

	AVFormatContext *fmt_ctx = NULL;
	AVCodecContext *codec_ctx = NULL;
	AVCodec *codec = NULL;
	AVPacket *packet = av_packet_alloc();
	AVFrame *frame = av_frame_alloc();
	struct SwrContext *swr_ctx = NULL;

	/* Open the M4A file */
	if (avformat_open_input(&fmt_ctx, "input.m4a", NULL, NULL) < 0) {
		printf("ERROR: Could not open input file.\n");
		return -1;
	}

	if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
		printf("ERROR: Could not find stream information.\n");
		return -1;
	}

	AVStream *audio_stream = fmt_ctx->streams[0];
	codec = avcodec_find_decoder(audio_stream->codecpar->codec_id);
	codec_ctx = avcodec_alloc_context3(codec);

	if (avcodec_parameters_to_context(codec_ctx, audio_stream->codecpar) < 0) {
		printf("ERROR: Could not fill codec context.\n");
		return -1;
	}

	if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
		printf("ERROR: Could not open codec.\n");
		return -1;
	}

	swr_ctx = swr_alloc();
	av_opt_set_int(swr_ctx, "in_channel_layout", codec_ctx->channel_layout, 0);
	av_opt_set_int(swr_ctx, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0);
	av_opt_set_int(swr_ctx, "in_sample_rate", codec_ctx->sample_rate, 0);
	av_opt_set_int(swr_ctx, "out_sample_rate", rate, 0);
	av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", codec_ctx->sample_fmt, 0);
	av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);
	swr_init(swr_ctx);

	/* Open the PCM device in playback mode */
	if (pcm = snd_pcm_open(&pcm_handle, PCM_DEVICE, SND_PCM_STREAM_PLAYBACK, 0) < 0) 
		printf("ERROR: Can't open \"%s\" PCM device. %s\n", PCM_DEVICE, snd_strerror(pcm));

	/* Allocate parameters object and fill it with default values */
	snd_pcm_hw_params_alloca(&params);
	snd_pcm_hw_params_any(pcm_handle, params);

	/* Set parameters */
	if (pcm = snd_pcm_hw_params_set_access(pcm_handle, params, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) 
		printf("ERROR: Can't set interleaved mode. %s\n", snd_strerror(pcm));

	if (pcm = snd_pcm_hw_params_set_format(pcm_handle, params, SND_PCM_FORMAT_S16_LE) < 0) 
		printf("ERROR: Can't set format. %s\n", snd_strerror(pcm));

	if (pcm = snd_pcm_hw_params_set_channels(pcm_handle, params, channels) < 0) 
		printf("ERROR: Can't set channels number. %s\n", snd_strerror(pcm));

	if (pcm = snd_pcm_hw_params_set_rate_near(pcm_handle, params, &rate, 0) < 0) 
		printf("ERROR: Can't set rate. %s\n", snd_strerror(pcm));

	/* Write parameters */
	if (pcm = snd_pcm_hw_params(pcm_handle, params) < 0)
		printf("ERROR: Can't set hardware parameters. %s\n", snd_strerror(pcm));

	/* Resume information */
	printf("PCM name: '%s'\n", snd_pcm_name(pcm_handle));
	printf("PCM state: %s\n", snd_pcm_state_name(snd_pcm_state(pcm_handle)));

	snd_pcm_hw_params_get_channels(params, &tmp);
	printf("channels: %i ", tmp);
	if (tmp == 1)
		printf("(mono)\n");
	else if (tmp == 2)
		printf("(stereo)\n");

	snd_pcm_hw_params_get_rate(params, &tmp, 0);
	printf("rate: %d bps\n", tmp);

	printf("seconds: %d\n", seconds);    

	/* Allocate buffer to hold single period */
	snd_pcm_hw_params_get_period_size(params, &frames, 0);
	buff_size = frames * channels * 2 /* 2 -> sample size */;
	buff = (char *) malloc(buff_size);

	/* PCM playback loop */
	while (av_read_frame(fmt_ctx, packet) >= 0) {
		if (packet->stream_index == audio_stream->index) {
			if (avcodec_send_packet(codec_ctx, packet) >= 0) {
				while (avcodec_receive_frame(codec_ctx, frame) >= 0) {
					int out_linesize;
					int out_samples = swr_convert(swr_ctx, (uint8_t **)&buff, buff_size / (channels * 2), 
												  (const uint8_t **)frame->data, frame->nb_samples);

					int data_size = av_samples_get_buffer_size(&out_linesize, channels, out_samples, AV_SAMPLE_FMT_S16, 1);

					if (snd_pcm_writei(pcm_handle, buff, out_samples) == -EPIPE) {
						snd_pcm_prepare(pcm_handle);
					}
				}
			}
		}
		av_packet_unref(packet);
	}

	/* Cleanup */
	swr_free(&swr_ctx);
	avcodec_free_context(&codec_ctx);
	avformat_close_input(&fmt_ctx);
	av_packet_free(&packet);
	av_frame_free(&frame);

	snd_pcm_drain(pcm_handle);
	snd_pcm_close(pcm_handle);
	free(buff);

	return 0;
}