path: root/mm_sound_pa_client.c

/*
 * libmm-sound
 *
 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * Contact: Seungbae Shin <seungbae.shin@samsung.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <mm_error.h>
#include <mm_debug.h>

#include <mm_sound_pa_client.h>

#include <glib.h>

#define MM_SOUND_CHANNEL_MIN                1
#define MM_SOUND_CHANNEL_MAX                6

typedef struct _mm_sound_handle_t {
	uint32_t handle;

	int mode;
	int volume_type;
	int gain_type;
	int rate;
	int channels;
	pa_simple *s;

	int period;	/* open api retrun value. */

	int source_type;
} mm_sound_handle_t;

static struct {
	uint32_t handle_count;	/* use amotic operations */
	GList *handles;
	pthread_mutex_t lock;

	int state;
	pa_threaded_mainloop *mainloop;
	pa_context *context;
} mm_sound_handle_mgr;

#define CHECK_HANDLE_RANGE(x) \
	do { \
		if (x == 0) { \
			debug_msg("invalid handle(%d)", x); \
			return MM_ERROR_INVALID_ARGUMENT; \
		} \
	} while (0);

#define ATOMIC_INC(l, x) \
	do { \
		pthread_mutex_lock(l); \
		x = x + 1; \
		if (x == 0) \
		x = x + 1; \
		pthread_mutex_unlock(l); \
	} while (0);

// phandle(ret), GList, userdata, coimpare func
#define GET_HANDLE_DATA(p, l, u, func) \
	do { \
		GList* list = 0; \
		list = g_list_find_custom(l, u, func); \
		if (list != 0) \
			p = (mm_sound_handle_t*)list->data; \
		else \
			p = NULL; \
	} while (0);

#define PA_SIMPLE_SAMPLES_PER_PERIOD_DEFAULT				1536	/* frames */
#define PA_SIMPLE_PERIODS_PER_BUFFER_FASTMODE				4
#define PA_SIMPLE_PERIODS_PER_BUFFER_DEFAULT				6
#define PA_SIMPLE_PERIODS_PER_BUFFER_VOIP					2
#define PA_SIMPLE_PERIODS_PER_BUFFER_PLAYBACK				8
#define PA_SIMPLE_PERIODS_PER_BUFFER_CAPTURE				12
#define PA_SIMPLE_PERIODS_PER_BUFFER_VIDEO					10

#define PA_SIMPLE_PERIOD_TIME_FOR_ULOW_LATENCY_MSEC			20
#define PA_SIMPLE_PERIOD_TIME_FOR_LOW_LATENCY_MSEC			25
#define PA_SIMPLE_PERIOD_TIME_FOR_MID_LATENCY_MSEC			50
#define PA_SIMPLE_PERIOD_TIME_FOR_HIGH_LATENCY_MSEC			75
#define PA_SIMPLE_PERIOD_TIME_FOR_VOIP_LATENCY_MSEC			20

__attribute__ ((constructor))
void __mm_sound_pa_init(void)
{
	memset(&mm_sound_handle_mgr, 0, sizeof(mm_sound_handle_mgr));
	mm_sound_handle_mgr.state = FALSE;

	mm_sound_handle_mgr.handles = g_list_alloc();
	mm_sound_handle_mgr.handle_count = 1;
	pthread_mutex_init(&mm_sound_handle_mgr.lock, NULL);
}

__attribute__ ((destructor))
void __mm_sound_pa_deinit(void)
{
	g_list_free(mm_sound_handle_mgr.handles);
	pthread_mutex_destroy(&mm_sound_handle_mgr.lock);
	mm_sound_handle_mgr.handle_count = 0;

	if (mm_sound_handle_mgr.state) {
		debug_msg("mainloop(%p),  context(%p)", mm_sound_handle_mgr.mainloop, mm_sound_handle_mgr.context);
		pa_threaded_mainloop_stop(mm_sound_handle_mgr.mainloop);
		pa_context_disconnect(mm_sound_handle_mgr.context);
		pa_context_unref(mm_sound_handle_mgr.context);
		pa_threaded_mainloop_free(mm_sound_handle_mgr.mainloop);
	}
}

gint __mm_sound_handle_comparefunc(gconstpointer a, gconstpointer b)
{
	mm_sound_handle_t *phandle = (mm_sound_handle_t *) a;
	int *handle = (int *)b;

	if (phandle == NULL)
		return -1;

	if (phandle->handle == *handle)
		return 0;
	else
		return -1;
}

EXPORT_API
int mm_sound_pa_open(MMSoundHandleMode mode, int volume_config, pa_sample_spec * ss, pa_channel_map * channel_map,
					int *size, char *stream_type, int stream_index)
{
	pa_simple *s = NULL;
	pa_channel_map maps;
	pa_buffer_attr attr;

	int prop_vol_type = 0;
	int prop_gain_type = VOLUME_GAIN_DEFAULT;

	int err = MM_ERROR_SOUND_INTERNAL;
	int period_time = PA_SIMPLE_PERIOD_TIME_FOR_MID_LATENCY_MSEC;
	int samples_per_period = PA_SIMPLE_SAMPLES_PER_PERIOD_DEFAULT;

	int handle_mode = mode;
	int sample_size = 0;
	pa_proplist *proplist = NULL;

	mm_sound_handle_t *handle = NULL;

	if (ss->channels < MM_SOUND_CHANNEL_MIN || ss->channels > MM_SOUND_CHANNEL_MAX)
		return MM_ERROR_INVALID_ARGUMENT;

	proplist = pa_proplist_new();

	if (channel_map == NULL) {
		pa_channel_map_init_auto(&maps, ss->channels, PA_CHANNEL_MAP_ALSA);
		channel_map = &maps;
	}

	switch (ss->format) {
	case PA_SAMPLE_U8:
		sample_size = 1 * ss->channels;
		break;
	case PA_SAMPLE_S16LE:
		sample_size = 2 * ss->channels;
		break;
	default:
		sample_size = 0;
		debug_error("Invalid sample size (%d)", sample_size);
		break;
	}

	if (stream_index != -1) {
		char stream_index_s[11];
		debug_msg("Set stream index [%d]", stream_index);

		snprintf(stream_index_s, sizeof(stream_index_s) - 1, "%d", stream_index);
		debug_msg("stream_index[%d] converted to string[%s]", stream_index, stream_index_s);
		pa_proplist_sets(proplist, PA_PROP_MEDIA_PARENT_ID, stream_index_s);
	}
	/* Set stream type */
	pa_proplist_sets(proplist, PA_PROP_MEDIA_ROLE, stream_type);

	memset(&attr, '\0', sizeof(attr));

	switch (handle_mode) {
	case HANDLE_MODE_OUTPUT:
		period_time = PA_SIMPLE_PERIOD_TIME_FOR_MID_LATENCY_MSEC;
		samples_per_period = (ss->rate * period_time) / 1000;
		attr.prebuf = -1;
		attr.minreq = -1;
		attr.tlength = (uint32_t)((ss->rate / 10) * pa_frame_size(ss));
		attr.maxlength = -1;
		attr.fragsize = 0;

		s = pa_simple_new_proplist(NULL, "MM_SOUND_PA_CLIENT", PA_STREAM_PLAYBACK, NULL, "PLAYBACK", ss, channel_map, &attr,
								   proplist, &err);
		break;

	default:
		err = MM_ERROR_SOUND_INTERNAL;
		goto fail;
	}

	if (!s) {
		debug_error("Open pulseaudio handle has failed - %s", pa_strerror(err));
		if (!strncmp(pa_strerror(err), "Access denied by security check", strlen(pa_strerror(err))))
			err = MM_ERROR_SOUND_PERMISSION_DENIED;
		else
			err = MM_ERROR_SOUND_INTERNAL;
		goto fail;
	}

	handle = (mm_sound_handle_t *) malloc(sizeof(mm_sound_handle_t));
	if (!handle) {
		debug_error("Failed to alloc handle");
		err = MM_ERROR_OUT_OF_MEMORY;
		goto fail;
	}
	memset(handle, 0, sizeof(mm_sound_handle_t));
	handle->mode = mode;
	handle->volume_type = prop_vol_type;
	handle->gain_type = prop_gain_type;
	handle->rate = ss->rate;
	handle->channels = ss->channels;
	handle->s = s;
	handle->period = samples_per_period * sample_size;
	*size = handle->period;
	handle->handle = mm_sound_handle_mgr.handle_count;
	ATOMIC_INC(&mm_sound_handle_mgr.lock, mm_sound_handle_mgr.handle_count);	// 0 is not used

	mm_sound_handle_mgr.handles = g_list_append(mm_sound_handle_mgr.handles, handle);

	if (handle->handle == 0) {
		debug_msg("out of range. handle(%d)", handle->handle);
		goto fail;
	}

	debug_msg
		("created handle[%d]. mode(%d), volumetype(%d), gain(%d), rate(%d), channels(%d), format(%d), s(%p), source_type(%d)",
		 handle->handle, handle->mode, handle->volume_type, handle->gain_type, handle->rate, handle->channels, ss->format,
		 handle->s, handle->source_type);

	if (proplist)
		pa_proplist_free(proplist);

	return handle->handle;

 fail:
	if (proplist)
		pa_proplist_free(proplist);

	if (handle)
		free(handle);

	return err;

}

EXPORT_API
int mm_sound_pa_write(const int handle, void *buf, const int size)
{
	mm_sound_handle_t *phandle = NULL;
	int err = MM_ERROR_NONE;

	if (buf == NULL)
		return MM_ERROR_INVALID_ARGUMENT;

	if (size < 0)
		return MM_ERROR_INVALID_ARGUMENT;
	else if (size == 0)
		return MM_ERROR_NONE;

	CHECK_HANDLE_RANGE(handle);
	GET_HANDLE_DATA(phandle, mm_sound_handle_mgr.handles, &handle, __mm_sound_handle_comparefunc);

	if (phandle == NULL) {
		debug_msg("phandle is null");
		return MM_ERROR_SOUND_INTERNAL;
	}

	if (0 > pa_simple_write(phandle->s, buf, size, &err)) {
		debug_error("pa_simple_write() failed with %s", pa_strerror(err));
		return MM_ERROR_SOUND_INTERNAL;
	}

	return size;

}

EXPORT_API
int mm_sound_pa_close(const int handle)
{
	mm_sound_handle_t *phandle = NULL;
	int err = MM_ERROR_NONE;

	CHECK_HANDLE_RANGE(handle);
	GET_HANDLE_DATA(phandle, mm_sound_handle_mgr.handles, &handle, __mm_sound_handle_comparefunc);
	if (phandle == NULL) {
		debug_msg("phandle is null");
		return MM_ERROR_SOUND_INTERNAL;
	}

	debug_msg("phandle(%p) s(%p), handle(%d), rate(%d), ch(%d)",
			  phandle, phandle->s, phandle->handle, phandle->rate, phandle->channels);

	switch (phandle->mode) {
	case HANDLE_MODE_OUTPUT:
		if (0 > pa_simple_flush(phandle->s, &err)) {
			err = MM_ERROR_SOUND_INTERNAL;
			debug_msg("pa_simple_flush() failed with %s", pa_strerror(err));
		}
		break;
	default:
		break;
	}

	pa_simple_free(phandle->s);
	phandle->s = NULL;

	debug_msg("leave: handle[%d]", handle);

	mm_sound_handle_mgr.handles = g_list_remove(mm_sound_handle_mgr.handles, phandle);
	if (phandle != NULL) {
		free(phandle);
		phandle = NULL;
	}

	return err;

}

EXPORT_API
int mm_sound_pa_drain(const int handle)
{
	mm_sound_handle_t *phandle = NULL;
	int err = MM_ERROR_NONE;

	CHECK_HANDLE_RANGE(handle);
	GET_HANDLE_DATA(phandle, mm_sound_handle_mgr.handles, &handle, __mm_sound_handle_comparefunc);
	if (phandle == NULL)
		return MM_ERROR_SOUND_INTERNAL;

	if (0 > pa_simple_drain(phandle->s, &err)) {
		debug_error("pa_simple_drain() failed with %s", pa_strerror(err));
		err = MM_ERROR_SOUND_INTERNAL;
	}

	return err;
}