FreeRDP/channels/rdpsnd/mac_audio/rdpsnd_audio_q.c

/**
 * FreeRDP: A Remote Desktop Protocol client.
 * Audio Output Virtual Channel
 *
 * Copyright 2012 Laxmikant Rashinkar <LK.Rashinkar@gmail.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.
 */

/**
 * Use AudioQueue to implement audio redirection
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <freerdp/types.h>
#include <freerdp/utils/memory.h>
#include <freerdp/utils/dsp.h>
#include <freerdp/utils/svc_plugin.h>
#include <AudioToolbox/AudioToolbox.h>
#include <AudioToolbox/AudioQueue.h>

#include "rdpsnd_main.h"

#define AQ_NUM_BUFFERS  10
#define AQ_BUF_SIZE     (32 * 1024)

static void aq_playback_cb(void *user_data,
                           AudioQueueRef aq_ref,
                           AudioQueueBufferRef aq_buf_ref
                          );

struct rdpsnd_audio_q_plugin
{
	rdpsndDevicePlugin device;

	/* audio queue player state */
	int     is_open;        // true when audio_q has been inited
	char *  device_name;
	int     is_playing;
	int     buf_index;
    
	AudioStreamBasicDescription  data_format;
	AudioQueueRef                aq_ref;
	AudioQueueBufferRef          buffers[AQ_NUM_BUFFERS];
};
typedef struct rdpsnd_audio_q_plugin rdpsndAudioQPlugin;

static void rdpsnd_audio_close(rdpsndDevicePlugin* device)
{
	rdpsndAudioQPlugin* aq_plugin_p = (rdpsndAudioQPlugin*) device;
    
	AudioQueueStop(aq_plugin_p->aq_ref, 0);
	aq_plugin_p->is_open = 0;
}

static void rdpsnd_audio_open(rdpsndDevicePlugin* device, rdpsndFormat* format, int latency)
{
	int rv;
	int i;
    
	rdpsndAudioQPlugin* aq_plugin_p = (rdpsndAudioQPlugin *) device;
	if (aq_plugin_p->is_open) {
		return;
	}
    
	aq_plugin_p->buf_index = 0;
    
	// setup AudioStreamBasicDescription
	aq_plugin_p->data_format.mSampleRate = 44100;
	aq_plugin_p->data_format.mFormatID = kAudioFormatLinearPCM;
	aq_plugin_p->data_format.mFormatFlags = kAudioFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked;
    
	// until we know better, assume that one packet = one frame
	// one frame = bytes_per_sample x number_of_channels
	aq_plugin_p->data_format.mBytesPerPacket = 4;
	aq_plugin_p->data_format.mFramesPerPacket = 1;
	aq_plugin_p->data_format.mBytesPerFrame = 4;
	aq_plugin_p->data_format.mChannelsPerFrame = 2;
	aq_plugin_p->data_format.mBitsPerChannel = 16;
    
	rv = AudioQueueNewOutput(&aq_plugin_p->data_format, // audio stream basic desc
				 aq_playback_cb,            // callback when more data is required
				 aq_plugin_p,               // data to pass to callback
				 CFRunLoopGetCurrent(),     // The current run loop, and the one on 
							    // which the audio queue playback callback 
							    // will be invoked
				 kCFRunLoopCommonModes,     // run loop modes in which callbacks can 
							    // be invoked
				 0,                         // flags - reserved
				 &aq_plugin_p->aq_ref
				);
	if (rv != 0) {
		printf("rdpsnd_audio_open: AudioQueueNewOutput() failed with error %d\n", rv);
		aq_plugin_p->is_open = 1;
		return;
	}
    
	for (i = 0; i < AQ_NUM_BUFFERS; i++)
	{
		rv = AudioQueueAllocateBuffer(aq_plugin_p->aq_ref, AQ_BUF_SIZE, &aq_plugin_p->buffers[i]);
	}
    
	aq_plugin_p->is_open = 1;
}

static void rdpsnd_audio_free(rdpsndDevicePlugin* device)
{
}

static boolean rdpsnd_audio_format_supported(rdpsndDevicePlugin* device, rdpsndFormat* format)
{
	switch (format->wFormatTag)
	{
		case 1: /* PCM */
			if (format->cbSize == 0 &&
			   (format->nSamplesPerSec <= 48000) &&
			   (format->wBitsPerSample == 8 || format->wBitsPerSample == 16) &&
			   (format->nChannels == 1 || format->nChannels == 2))
		{
			return 1;
		}
		break;
	}
	return 0;
}

static void rdpsnd_audio_set_format(rdpsndDevicePlugin* device, rdpsndFormat* format, int latency)
{
}

static void rdpsnd_audio_set_volume(rdpsndDevicePlugin* device, uint32 value)
{
}

static void rdpsnd_audio_play(rdpsndDevicePlugin* device, uint8* data, int size)
{
	rdpsndAudioQPlugin* aq_plugin_p = (rdpsndAudioQPlugin *) device;
	AudioQueueBufferRef aq_buf_ref;
	int                 len;
    
	if (!aq_plugin_p->is_open) {
		return;
	}

	/* get next empty buffer */
	aq_buf_ref = aq_plugin_p->buffers[aq_plugin_p->buf_index];
    
	// fill aq_buf_ref with audio data
	len = size > AQ_BUF_SIZE ? AQ_BUF_SIZE : size;
    
	memcpy(aq_buf_ref->mAudioData, (char *) data, len);
	aq_buf_ref->mAudioDataByteSize = len;
    
	// add buffer to audioqueue
	AudioQueueEnqueueBuffer(aq_plugin_p->aq_ref, aq_buf_ref, 0, 0);
    
	// update buf_index
	aq_plugin_p->buf_index++;
	if (aq_plugin_p->buf_index >= AQ_NUM_BUFFERS) {
		aq_plugin_p->buf_index = 0;
	}
}

static void rdpsnd_audio_start(rdpsndDevicePlugin* device)
{
	rdpsndAudioQPlugin* aq_plugin_p = (rdpsndAudioQPlugin *) device;

	AudioQueueStart(aq_plugin_p->aq_ref, NULL);
}

/**
 * AudioQueue Playback callback
 *
 * our job here is to fill aq_buf_ref with audio data and enqueue it
 */

static void aq_playback_cb(void *user_data,
			   AudioQueueRef aq_ref,
			   AudioQueueBufferRef aq_buf_ref
			  )
{
}

int FreeRDPRdpsndDeviceEntry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS pEntryPoints)
{
	rdpsndAudioQPlugin* aqPlugin;
	RDP_PLUGIN_DATA* data;
    
	aqPlugin = xnew(rdpsndAudioQPlugin);

	aqPlugin->device.Open = rdpsnd_audio_open;
	aqPlugin->device.FormatSupported = rdpsnd_audio_format_supported;
	aqPlugin->device.SetFormat = rdpsnd_audio_set_format;
	aqPlugin->device.SetVolume = rdpsnd_audio_set_volume;
	aqPlugin->device.Play = rdpsnd_audio_play;
	aqPlugin->device.Start = rdpsnd_audio_start;
	aqPlugin->device.Close = rdpsnd_audio_close;
	aqPlugin->device.Free = rdpsnd_audio_free;

	data = pEntryPoints->plugin_data;
    
	if (data && strcmp((char *)data->data[0], "macaudio") == 0) {
		if(strlen((char *)data->data[1]) > 0)
			aqPlugin->device_name = strdup((char *)data->data[1]);
		else
			aqPlugin->device_name = NULL;
	}
	pEntryPoints->pRegisterRdpsndDevice(pEntryPoints->rdpsnd, (rdpsndDevicePlugin*)aqPlugin);
	return 0;
}