mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Audin channel use dynamic logger where possible.

Browse Source
This commit is contained in:
Armin Novak 2018-02-09 13:49:58 +01:00
parent a42f6d6aa1
commit c53d72211a
1 changed files with 135 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

228
channels/audin/client/audin_main.c
View File

@ -32,10 +32,10 @@
#include <winpr/crt.h> #include <winpr/crt.h>
#include <winpr/cmdline.h> #include <winpr/cmdline.h>
#include <winpr/stream.h>
#include <winpr/wlog.h>
#include <freerdp/addin.h> #include <freerdp/addin.h>
#include <winpr/stream.h>
#include <freerdp/freerdp.h> #include <freerdp/freerdp.h>
#include "audin_main.h" #include "audin_main.h"
@ -93,28 +93,39 @@ struct _AUDIN_PLUGIN
rdpContext* rdpcontext; rdpContext* rdpcontext;
BOOL attached; BOOL attached;
wLog* log;
}; };
static BOOL audin_process_addin_args(AUDIN_PLUGIN* audin, ADDIN_ARGV* args); static BOOL audin_process_addin_args(AUDIN_PLUGIN* audin, ADDIN_ARGV* args);
static UINT audin_write_and_free_stream(AUDIN_CHANNEL_CALLBACK* callback, wStream* s)
{
UINT error = ERROR_INTERNAL_ERROR;
if (callback && callback->channel && callback->channel->Write)
error = callback->channel->Write(callback->channel, (UINT32) Stream_GetPosition(s),
Stream_Buffer(s), NULL);
Stream_Free(s, TRUE);
return error;
}
/** /**
* Function description * Function description
* *
* @return 0 on success, otherwise a Win32 error code * @return 0 on success, otherwise a Win32 error code
*/ */
static UINT audin_process_version(IWTSVirtualChannelCallback* pChannelCallback, wStream* s) static UINT audin_process_version(AUDIN_PLUGIN* audin, AUDIN_CHANNEL_CALLBACK* callback, wStream* s)
{ {
UINT error; UINT error;
wStream* out; wStream* out;
UINT32 Version; UINT32 Version;
AUDIN_CHANNEL_CALLBACK* callback = (AUDIN_CHANNEL_CALLBACK*) pChannelCallback;
Stream_Read_UINT32(s, Version); Stream_Read_UINT32(s, Version);
DEBUG_DVC("Version=%"PRIu32"", Version); DEBUG_DVC("Version=%"PRIu32"", Version);
out = Stream_New(NULL, 5); out = Stream_New(NULL, 5);
if (!out) if (!out)
{ {
WLog_ERR(TAG, "Stream_New failed!"); WLog_Print(audin->log, WLOG_ERROR, "Stream_New failed!");
return ERROR_OUTOFMEMORY; return ERROR_OUTOFMEMORY;
} }
@ -131,11 +142,13 @@ static UINT audin_process_version(IWTSVirtualChannelCallback* pChannelCallback,
* *
* @return 0 on success, otherwise a Win32 error code * @return 0 on success, otherwise a Win32 error code
*/ */
static UINT audin_send_incoming_data_pdu(IWTSVirtualChannelCallback* pChannelCallback) static UINT audin_send_incoming_data_pdu(AUDIN_CHANNEL_CALLBACK* callback)
{ {
BYTE out_data[1]; BYTE out_data[1] = { MSG_SNDIN_DATA_INCOMING };
AUDIN_CHANNEL_CALLBACK* callback = (AUDIN_CHANNEL_CALLBACK*) pChannelCallback;
out_data[0] = MSG_SNDIN_DATA_INCOMING; if (!callback || !callback->channel || !callback->channel->Write)
return ERROR_INTERNAL_ERROR;
return callback->channel->Write(callback->channel, 1, out_data, NULL); return callback->channel->Write(callback->channel, 1, out_data, NULL);
} }
@ -144,10 +157,8 @@ static UINT audin_send_incoming_data_pdu(IWTSVirtualChannelCallback* pChannelCal
* *
* @return 0 on success, otherwise a Win32 error code * @return 0 on success, otherwise a Win32 error code
*/ */
static UINT audin_process_formats(IWTSVirtualChannelCallback* pChannelCallback, wStream* s) static UINT audin_process_formats(AUDIN_PLUGIN* audin, AUDIN_CHANNEL_CALLBACK* callback, wStream* s)
{ {
AUDIN_CHANNEL_CALLBACK* callback = (AUDIN_CHANNEL_CALLBACK*) pChannelCallback;
AUDIN_PLUGIN* audin = (AUDIN_PLUGIN*) callback->plugin;
UINT32 i; UINT32 i;
BYTE* fm; BYTE* fm;
UINT error; UINT error;
@ -155,12 +166,16 @@ static UINT audin_process_formats(IWTSVirtualChannelCallback* pChannelCallback,
UINT32 NumFormats; UINT32 NumFormats;
audinFormat format; audinFormat format;
UINT32 cbSizeFormatsPacket; UINT32 cbSizeFormatsPacket;
if (Stream_GetRemainingLength(s) < 8)
return ERROR_NO_DATA;
Stream_Read_UINT32(s, NumFormats); Stream_Read_UINT32(s, NumFormats);
DEBUG_DVC("NumFormats %"PRIu32"", NumFormats); DEBUG_DVC("NumFormats %"PRIu32"", NumFormats);
if ((NumFormats < 1) || (NumFormats > 1000)) if ((NumFormats < 1) || (NumFormats > 1000))
{ {
WLog_ERR(TAG, "bad NumFormats %"PRIu32"", NumFormats); WLog_Print(audin->log, WLOG_ERROR, "bad NumFormats %"PRIu32"", NumFormats);
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
@ -169,7 +184,7 @@ static UINT audin_process_formats(IWTSVirtualChannelCallback* pChannelCallback,
if (!callback->formats) if (!callback->formats)
{ {
WLog_ERR(TAG, "calloc failed!"); WLog_Print(audin->log, WLOG_ERROR, "calloc failed!");
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
@ -178,7 +193,7 @@ static UINT audin_process_formats(IWTSVirtualChannelCallback* pChannelCallback,
if (!out) if (!out)
{ {
error = CHANNEL_RC_NO_MEMORY; error = CHANNEL_RC_NO_MEMORY;
WLog_ERR(TAG, "Stream_New failed!"); WLog_Print(audin->log, WLOG_ERROR, "Stream_New failed!");
goto out; goto out;
} }
@ -187,6 +202,9 @@ static UINT audin_process_formats(IWTSVirtualChannelCallback* pChannelCallback,
/* SoundFormats (variable) */ /* SoundFormats (variable) */
for (i = 0; i < NumFormats; i++) for (i = 0; i < NumFormats; i++)
{ {
if (Stream_GetRemainingLength(s) < 18)
return ERROR_NO_DATA;
Stream_GetPointer(s, fm); Stream_GetPointer(s, fm);
Stream_Read_UINT16(s, format.wFormatTag); Stream_Read_UINT16(s, format.wFormatTag);
Stream_Read_UINT16(s, format.nChannels); Stream_Read_UINT16(s, format.nChannels);
@ -196,6 +214,10 @@ static UINT audin_process_formats(IWTSVirtualChannelCallback* pChannelCallback,
Stream_Read_UINT16(s, format.wBitsPerSample); Stream_Read_UINT16(s, format.wBitsPerSample);
Stream_Read_UINT16(s, format.cbSize); Stream_Read_UINT16(s, format.cbSize);
format.data = Stream_Pointer(s); format.data = Stream_Pointer(s);
if (Stream_GetRemainingLength(s) < format.cbSize)
return ERROR_NO_DATA;
Stream_Seek(s, format.cbSize); Stream_Seek(s, format.cbSize);
DEBUG_DVC("wFormatTag=%"PRIu16" nChannels=%"PRIu16" nSamplesPerSec=%"PRIu32" " DEBUG_DVC("wFormatTag=%"PRIu16" nChannels=%"PRIu16" nSamplesPerSec=%"PRIu32" "
"nBlockAlign=%"PRIu16" wBitsPerSample=%"PRIu16" cbSize=%"PRIu16"", "nBlockAlign=%"PRIu16" wBitsPerSample=%"PRIu16" cbSize=%"PRIu16"",
@ -221,7 +243,7 @@ static UINT audin_process_formats(IWTSVirtualChannelCallback* pChannelCallback,
if (!Stream_EnsureRemainingCapacity(out, 18 + format.cbSize)) if (!Stream_EnsureRemainingCapacity(out, 18 + format.cbSize))
{ {
error = CHANNEL_RC_NO_MEMORY; error = CHANNEL_RC_NO_MEMORY;
WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!"); WLog_Print(audin->log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
goto out; goto out;
} }
@ -229,9 +251,9 @@ static UINT audin_process_formats(IWTSVirtualChannelCallback* pChannelCallback,
} }
} }
if ((error = audin_send_incoming_data_pdu(pChannelCallback))) if ((error = audin_send_incoming_data_pdu(callback)))
{ {
WLog_ERR(TAG, "audin_send_incoming_data_pdu failed!"); WLog_Print(audin->log, WLOG_ERROR, "audin_send_incoming_data_pdu failed!");
goto out; goto out;
} }
@ -240,7 +262,7 @@ static UINT audin_process_formats(IWTSVirtualChannelCallback* pChannelCallback,
Stream_Write_UINT8(out, MSG_SNDIN_FORMATS); /* Header (1 byte) */ Stream_Write_UINT8(out, MSG_SNDIN_FORMATS); /* Header (1 byte) */
Stream_Write_UINT32(out, callback->formats_count); /* NumFormats (4 bytes) */ Stream_Write_UINT32(out, callback->formats_count); /* NumFormats (4 bytes) */
Stream_Write_UINT32(out, cbSizeFormatsPacket); /* cbSizeFormatsPacket (4 bytes) */ Stream_Write_UINT32(out, cbSizeFormatsPacket); /* cbSizeFormatsPacket (4 bytes) */
error = callback->channel->Write(callback->channel, cbSizeFormatsPacket, Stream_Buffer(out), NULL); error = audin_write_and_free_stream(callback, out);
out: out:
if (error != CHANNEL_RC_OK) if (error != CHANNEL_RC_OK)
@ -249,7 +271,6 @@ out:
callback->formats = NULL; callback->formats = NULL;
} }
Stream_Free(out, TRUE);
return error; return error;
} }
@ -258,25 +279,20 @@ out:
* *
* @return 0 on success, otherwise a Win32 error code * @return 0 on success, otherwise a Win32 error code
*/ */
static UINT audin_send_format_change_pdu(IWTSVirtualChannelCallback* pChannelCallback, static UINT audin_send_format_change_pdu(AUDIN_PLUGIN* audin, AUDIN_CHANNEL_CALLBACK* callback,
UINT32 NewFormat) UINT32 NewFormat)
{ {
UINT error; wStream* out = Stream_New(NULL, 5);
wStream* out;
AUDIN_CHANNEL_CALLBACK* callback = (AUDIN_CHANNEL_CALLBACK*) pChannelCallback;
out = Stream_New(NULL, 5);
if (!out) if (!out)
{ {
WLog_ERR(TAG, "Stream_New failed!"); WLog_Print(audin->log, WLOG_ERROR, "Stream_New failed!");
return CHANNEL_RC_OK; return CHANNEL_RC_OK;
} }
Stream_Write_UINT8(out, MSG_SNDIN_FORMATCHANGE); Stream_Write_UINT8(out, MSG_SNDIN_FORMATCHANGE);
Stream_Write_UINT32(out, NewFormat); Stream_Write_UINT32(out, NewFormat);
error = callback->channel->Write(callback->channel, 5, Stream_Buffer(out), NULL); return audin_write_and_free_stream(callback, out);
Stream_Free(out, TRUE);
return error;
} }
/** /**
@ -284,24 +300,20 @@ static UINT audin_send_format_change_pdu(IWTSVirtualChannelCallback* pChannelCal
* *
* @return 0 on success, otherwise a Win32 error code * @return 0 on success, otherwise a Win32 error code
*/ */
static UINT audin_send_open_reply_pdu(IWTSVirtualChannelCallback* pChannelCallback, UINT32 Result) static UINT audin_send_open_reply_pdu(AUDIN_PLUGIN* audin, AUDIN_CHANNEL_CALLBACK* callback,
UINT32 Result)
{ {
UINT error; wStream* out = Stream_New(NULL, 5);
wStream* out;
AUDIN_CHANNEL_CALLBACK* callback = (AUDIN_CHANNEL_CALLBACK*) pChannelCallback;
out = Stream_New(NULL, 5);
if (!out) if (!out)
{ {
WLog_ERR(TAG, "Stream_New failed!"); WLog_Print(audin->log, WLOG_ERROR, "Stream_New failed!");
return CHANNEL_RC_NO_MEMORY; return CHANNEL_RC_NO_MEMORY;
} }
Stream_Write_UINT8(out, MSG_SNDIN_OPEN_REPLY); Stream_Write_UINT8(out, MSG_SNDIN_OPEN_REPLY);
Stream_Write_UINT32(out, Result); Stream_Write_UINT32(out, Result);
error = callback->channel->Write(callback->channel, 5, Stream_Buffer(out), NULL); return audin_write_and_free_stream(callback, out);
Stream_Free(out, TRUE);
return error;
} }
/** /**
@ -327,9 +339,9 @@ static UINT audin_receive_wave_data(const BYTE* data, int size, void* user_data)
if (!audin->attached) if (!audin->attached)
return CHANNEL_RC_OK; return CHANNEL_RC_OK;
if ((error = audin_send_incoming_data_pdu((IWTSVirtualChannelCallback*) callback))) if ((error = audin_send_incoming_data_pdu(callback)))
{ {
WLog_ERR(TAG, "audin_send_incoming_data_pdu failed!"); WLog_Print(audin->log, WLOG_ERROR, "audin_send_incoming_data_pdu failed!");
return error; return error;
} }
@ -337,16 +349,13 @@ static UINT audin_receive_wave_data(const BYTE* data, int size, void* user_data)
if (!out) if (!out)
{ {
WLog_ERR(TAG, "Stream_New failed!"); WLog_Print(audin->log, WLOG_ERROR, "Stream_New failed!");
return ERROR_NOT_ENOUGH_MEMORY; return ERROR_NOT_ENOUGH_MEMORY;
} }
Stream_Write_UINT8(out, MSG_SNDIN_DATA); Stream_Write_UINT8(out, MSG_SNDIN_DATA);
Stream_Write(out, data, size); Stream_Write(out, data, size);
error = callback->channel->Write(callback->channel, (UINT32) Stream_GetPosition(out), return audin_write_and_free_stream(callback, out);
Stream_Buffer(out), NULL);
Stream_Free(out, TRUE);
return error;
} }
/** /**
@ -354,14 +363,19 @@ static UINT audin_receive_wave_data(const BYTE* data, int size, void* user_data)
* *
* @return 0 on success, otherwise a Win32 error code * @return 0 on success, otherwise a Win32 error code
*/ */
static UINT audin_process_open(IWTSVirtualChannelCallback* pChannelCallback, wStream* s) static UINT audin_process_open(AUDIN_PLUGIN* audin, AUDIN_CHANNEL_CALLBACK* callback, wStream* s)
{ {
AUDIN_CHANNEL_CALLBACK* callback = (AUDIN_CHANNEL_CALLBACK*) pChannelCallback;
AUDIN_PLUGIN* audin = (AUDIN_PLUGIN*) callback->plugin;
audinFormat* format; audinFormat* format;
UINT32 initialFormat; UINT32 initialFormat;
UINT32 FramesPerPacket; UINT32 FramesPerPacket;
UINT error = CHANNEL_RC_OK; UINT error = CHANNEL_RC_OK;
if (!audin || !callback || !s)
return ERROR_INTERNAL_ERROR;
if (Stream_GetRemainingLength(s) < 8)
return ERROR_NO_DATA;
Stream_Read_UINT32(s, FramesPerPacket); Stream_Read_UINT32(s, FramesPerPacket);
Stream_Read_UINT32(s, initialFormat); Stream_Read_UINT32(s, initialFormat);
DEBUG_DVC("FramesPerPacket=%"PRIu32" initialFormat=%"PRIu32"", DEBUG_DVC("FramesPerPacket=%"PRIu32" initialFormat=%"PRIu32"",
@ -369,8 +383,8 @@ static UINT audin_process_open(IWTSVirtualChannelCallback* pChannelCallback, wSt
if (initialFormat >= (UINT32) callback->formats_count) if (initialFormat >= (UINT32) callback->formats_count)
{ {
WLog_ERR(TAG, "invalid format index %"PRIu32" (total %d)", WLog_Print(audin->log, WLOG_ERROR, "invalid format index %"PRIu32" (total %d)",
initialFormat, callback->formats_count); initialFormat, callback->formats_count);
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
@ -382,7 +396,7 @@ static UINT audin_process_open(IWTSVirtualChannelCallback* pChannelCallback, wSt
if (error != CHANNEL_RC_OK) if (error != CHANNEL_RC_OK)
{ {
WLog_ERR(TAG, "SetFormat failed with errorcode %"PRIu32"", error); WLog_Print(audin->log, WLOG_ERROR, "SetFormat failed with errorcode %"PRIu32"", error);
return error; return error;
} }
@ -390,19 +404,19 @@ static UINT audin_process_open(IWTSVirtualChannelCallback* pChannelCallback, wSt
if (error != CHANNEL_RC_OK) if (error != CHANNEL_RC_OK)
{ {
WLog_ERR(TAG, "Open failed with errorcode %"PRIu32"", error); WLog_Print(audin->log, WLOG_ERROR, "Open failed with errorcode %"PRIu32"", error);
return error; return error;
} }
} }
if ((error = audin_send_format_change_pdu(pChannelCallback, initialFormat))) if ((error = audin_send_format_change_pdu(audin, callback, initialFormat)))
{ {
WLog_ERR(TAG, "audin_send_format_change_pdu failed!"); WLog_Print(audin->log, WLOG_ERROR, "audin_send_format_change_pdu failed!");
return error; return error;
} }
if ((error = audin_send_open_reply_pdu(pChannelCallback, 0))) if ((error = audin_send_open_reply_pdu(audin, callback, 0)))
WLog_ERR(TAG, "audin_send_open_reply_pdu failed!"); WLog_Print(audin->log, WLOG_ERROR, "audin_send_open_reply_pdu failed!");
return error; return error;
} }
@ -412,20 +426,26 @@ static UINT audin_process_open(IWTSVirtualChannelCallback* pChannelCallback, wSt
* *
* @return 0 on success, otherwise a Win32 error code * @return 0 on success, otherwise a Win32 error code
*/ */
static UINT audin_process_format_change(IWTSVirtualChannelCallback* pChannelCallback, wStream* s) static UINT audin_process_format_change(AUDIN_PLUGIN* audin, AUDIN_CHANNEL_CALLBACK* callback,
wStream* s)
{ {
AUDIN_CHANNEL_CALLBACK* callback = (AUDIN_CHANNEL_CALLBACK*) pChannelCallback;
AUDIN_PLUGIN* audin = (AUDIN_PLUGIN*) callback->plugin;
UINT32 NewFormat; UINT32 NewFormat;
audinFormat* format; audinFormat* format;
UINT error = CHANNEL_RC_OK; UINT error = CHANNEL_RC_OK;
if (!audin || !callback || !s)
return ERROR_INTERNAL_ERROR;
if (Stream_GetRemainingLength(s) < 4)
return ERROR_NO_DATA;
Stream_Read_UINT32(s, NewFormat); Stream_Read_UINT32(s, NewFormat);
DEBUG_DVC("NewFormat=%"PRIu32"", NewFormat); DEBUG_DVC("NewFormat=%"PRIu32"", NewFormat);
if (NewFormat >= (UINT32) callback->formats_count) if (NewFormat >= (UINT32) callback->formats_count)
{ {
WLog_ERR(TAG, "invalid format index %"PRIu32" (total %d)", WLog_Print(audin->log, WLOG_ERROR, "invalid format index %"PRIu32" (total %d)",
NewFormat, callback->formats_count); NewFormat, callback->formats_count);
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
} }
@ -437,7 +457,7 @@ static UINT audin_process_format_change(IWTSVirtualChannelCallback* pChannelCall
if (error != CHANNEL_RC_OK) if (error != CHANNEL_RC_OK)
{ {
WLog_ERR(TAG, "Close failed with errorcode %"PRIu32"", error); WLog_Print(audin->log, WLOG_ERROR, "Close failed with errorcode %"PRIu32"", error);
return error; return error;
} }
@ -445,7 +465,7 @@ static UINT audin_process_format_change(IWTSVirtualChannelCallback* pChannelCall
if (error != CHANNEL_RC_OK) if (error != CHANNEL_RC_OK)
{ {
WLog_ERR(TAG, "SetFormat failed with errorcode %"PRIu32"", error); WLog_Print(audin->log, WLOG_ERROR, "SetFormat failed with errorcode %"PRIu32"", error);
return error; return error;
} }
@ -453,13 +473,13 @@ static UINT audin_process_format_change(IWTSVirtualChannelCallback* pChannelCall
if (error != CHANNEL_RC_OK) if (error != CHANNEL_RC_OK)
{ {
WLog_ERR(TAG, "Open failed with errorcode %"PRIu32"", error); WLog_Print(audin->log, WLOG_ERROR, "Open failed with errorcode %"PRIu32"", error);
return error; return error;
} }
} }
if ((error = audin_send_format_change_pdu(pChannelCallback, NewFormat))) if ((error = audin_send_format_change_pdu(audin, callback, NewFormat)))
WLog_ERR(TAG, "audin_send_format_change_pdu failed!"); WLog_Print(audin->log, WLOG_ERROR, "audin_send_format_change_pdu failed!");
return error; return error;
} }
@ -473,29 +493,43 @@ static UINT audin_on_data_received(IWTSVirtualChannelCallback* pChannelCallback,
{ {
UINT error; UINT error;
BYTE MessageId; BYTE MessageId;
AUDIN_PLUGIN* audin;
AUDIN_CHANNEL_CALLBACK* callback = (AUDIN_CHANNEL_CALLBACK*) pChannelCallback;
if (!callback || !data)
return ERROR_INVALID_PARAMETER;
audin = (AUDIN_PLUGIN*) callback->plugin;
if (!audin)
return ERROR_INTERNAL_ERROR;
if (Stream_GetRemainingCapacity(data) < 1)
return ERROR_NO_DATA;
Stream_Read_UINT8(data, MessageId); Stream_Read_UINT8(data, MessageId);
DEBUG_DVC("MessageId=0x%02"PRIx8"", MessageId); DEBUG_DVC("MessageId=0x%02"PRIx8"", MessageId);
switch (MessageId) switch (MessageId)
{ {
case MSG_SNDIN_VERSION: case MSG_SNDIN_VERSION:
error = audin_process_version(pChannelCallback, data); error = audin_process_version(audin, callback, data);
break; break;
case MSG_SNDIN_FORMATS: case MSG_SNDIN_FORMATS:
error = audin_process_formats(pChannelCallback, data); error = audin_process_formats(audin, callback, data);
break; break;
case MSG_SNDIN_OPEN: case MSG_SNDIN_OPEN:
error = audin_process_open(pChannelCallback, data); error = audin_process_open(audin, callback, data);
break; break;
case MSG_SNDIN_FORMATCHANGE: case MSG_SNDIN_FORMATCHANGE:
error = audin_process_format_change(pChannelCallback, data); error = audin_process_format_change(audin, callback, data);
break; break;
default: default:
WLog_ERR(TAG, "unknown MessageId=0x%02"PRIx8"", MessageId); WLog_Print(audin->log, WLOG_ERROR, "unknown MessageId=0x%02"PRIx8"", MessageId);
error = ERROR_INVALID_DATA; error = ERROR_INVALID_DATA;
break; break;
} }
@ -520,7 +554,7 @@ static UINT audin_on_close(IWTSVirtualChannelCallback* pChannelCallback)
IFCALLRET(audin->device->Close, error, audin->device); IFCALLRET(audin->device->Close, error, audin->device);
if (error != CHANNEL_RC_OK) if (error != CHANNEL_RC_OK)
WLog_ERR(TAG, "Close failed with errorcode %"PRIu32"", error); WLog_Print(audin->log, WLOG_ERROR, "Close failed with errorcode %"PRIu32"", error);
} }
free(callback->formats); free(callback->formats);
@ -538,13 +572,19 @@ static UINT audin_on_new_channel_connection(IWTSListenerCallback* pListenerCallb
IWTSVirtualChannelCallback** ppCallback) IWTSVirtualChannelCallback** ppCallback)
{ {
AUDIN_CHANNEL_CALLBACK* callback; AUDIN_CHANNEL_CALLBACK* callback;
AUDIN_PLUGIN* audin;
AUDIN_LISTENER_CALLBACK* listener_callback = (AUDIN_LISTENER_CALLBACK*) pListenerCallback; AUDIN_LISTENER_CALLBACK* listener_callback = (AUDIN_LISTENER_CALLBACK*) pListenerCallback;
if (!listener_callback || !listener_callback->plugin)
return ERROR_INTERNAL_ERROR;
audin = (AUDIN_PLUGIN*) listener_callback->plugin;
DEBUG_DVC("..."); DEBUG_DVC("...");
callback = (AUDIN_CHANNEL_CALLBACK*) calloc(1, sizeof(AUDIN_CHANNEL_CALLBACK)); callback = (AUDIN_CHANNEL_CALLBACK*) calloc(1, sizeof(AUDIN_CHANNEL_CALLBACK));
if (!callback) if (!callback)
{ {
WLog_ERR(TAG, "calloc failed!"); WLog_Print(audin->log, WLOG_ERROR, "calloc failed!");
return CHANNEL_RC_NO_MEMORY; return CHANNEL_RC_NO_MEMORY;
} }
@ -570,7 +610,7 @@ static UINT audin_plugin_initialize(IWTSPlugin* pPlugin, IWTSVirtualChannelManag
if (!audin->listener_callback) if (!audin->listener_callback)
{ {
WLog_ERR(TAG, "calloc failed!"); WLog_Print(audin->log, WLOG_ERROR, "calloc failed!");
return CHANNEL_RC_NO_MEMORY; return CHANNEL_RC_NO_MEMORY;
} }
@ -598,7 +638,7 @@ static UINT audin_plugin_terminated(IWTSPlugin* pPlugin)
if (error != CHANNEL_RC_OK) if (error != CHANNEL_RC_OK)
{ {
WLog_ERR(TAG, "Free failed with errorcode %"PRIu32"", error); WLog_Print(audin->log, WLOG_ERROR, "Free failed with errorcode %"PRIu32"", error);
// dont stop on error // dont stop on error
} }
@ -649,7 +689,7 @@ static UINT audin_register_device_plugin(IWTSPlugin* pPlugin, IAudinDevice* devi
if (audin->device) if (audin->device)
{ {
WLog_ERR(TAG, "existing device, abort."); WLog_Print(audin->log, WLOG_ERROR, "existing device, abort.");
return ERROR_ALREADY_EXISTS; return ERROR_ALREADY_EXISTS;
} }
@ -678,8 +718,9 @@ static UINT audin_load_device_plugin(IWTSPlugin* pPlugin, const char* name, ADDI
if (entry == NULL) if (entry == NULL)
{ {
WLog_ERR(TAG, "freerdp_load_channel_addin_entry did not return any function pointers for %s ", WLog_Print(audin->log, WLOG_ERROR,
name); "freerdp_load_channel_addin_entry did not return any function pointers for %s ",
name);
return ERROR_INVALID_FUNCTION; return ERROR_INVALID_FUNCTION;
} }
@ -690,11 +731,11 @@ static UINT audin_load_device_plugin(IWTSPlugin* pPlugin, const char* name, ADDI
if ((error = entry(&entryPoints))) if ((error = entry(&entryPoints)))
{ {
WLog_ERR(TAG, "%s entry returned error %"PRIu32".", name, error); WLog_Print(audin->log, WLOG_ERROR, "%s entry returned error %"PRIu32".", name, error);
return error; return error;
} }
WLog_INFO(TAG, "Loaded %s backend for audin", name); WLog_Print(audin->log, WLOG_INFO, "Loaded %s backend for audin", name);
return CHANNEL_RC_OK; return CHANNEL_RC_OK;
} }
@ -710,7 +751,7 @@ static UINT audin_set_subsystem(AUDIN_PLUGIN* audin, char* subsystem)
if (!audin->subsystem) if (!audin->subsystem)
{ {
WLog_ERR(TAG, "_strdup failed!"); WLog_Print(audin->log, WLOG_ERROR, "_strdup failed!");
return ERROR_NOT_ENOUGH_MEMORY; return ERROR_NOT_ENOUGH_MEMORY;
} }
@ -729,7 +770,7 @@ static UINT audin_set_device_name(AUDIN_PLUGIN* audin, char* device_name)
if (!audin->device_name) if (!audin->device_name)
{ {
WLog_ERR(TAG, "_strdup failed!"); WLog_Print(audin->log, WLOG_ERROR, "_strdup failed!");
return ERROR_NOT_ENOUGH_MEMORY; return ERROR_NOT_ENOUGH_MEMORY;
} }
@ -776,7 +817,7 @@ BOOL audin_process_addin_args(AUDIN_PLUGIN* audin, ADDIN_ARGV* args)
{ {
if ((error = audin_set_subsystem(audin, arg->Value))) if ((error = audin_set_subsystem(audin, arg->Value)))
{ {
WLog_ERR(TAG, "audin_set_subsystem failed with error %"PRIu32"!", error); WLog_Print(audin->log, WLOG_ERROR, "audin_set_subsystem failed with error %"PRIu32"!", error);
return FALSE; return FALSE;
} }
} }
@ -784,7 +825,7 @@ BOOL audin_process_addin_args(AUDIN_PLUGIN* audin, ADDIN_ARGV* args)
{ {
if ((error = audin_set_device_name(audin, arg->Value))) if ((error = audin_set_device_name(audin, arg->Value)))
{ {
WLog_ERR(TAG, "audin_set_device_name failed with error %"PRIu32"!", error); WLog_Print(audin->log, WLOG_ERROR, "audin_set_device_name failed with error %"PRIu32"!", error);
return FALSE; return FALSE;
} }
} }
@ -882,6 +923,7 @@ UINT DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
return CHANNEL_RC_NO_MEMORY; return CHANNEL_RC_NO_MEMORY;
} }
audin->log = WLog_Get(TAG);
audin->attached = TRUE; audin->attached = TRUE;
audin->iface.Initialize = audin_plugin_initialize; audin->iface.Initialize = audin_plugin_initialize;
audin->iface.Connected = NULL; audin->iface.Connected = NULL;
@ -903,8 +945,8 @@ UINT DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
{ {
if ((error = audin_load_device_plugin((IWTSPlugin*) audin, audin->subsystem, args))) if ((error = audin_load_device_plugin((IWTSPlugin*) audin, audin->subsystem, args)))
{ {
WLog_ERR(TAG, "audin_load_device_plugin %s failed with error %"PRIu32"!", WLog_Print(audin->log, WLOG_ERROR, "audin_load_device_plugin %s failed with error %"PRIu32"!",
audin->subsystem, error); audin->subsystem, error);
goto out; goto out;
} }
} }
@ -914,18 +956,18 @@ UINT DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
{ {
if ((error = audin_set_subsystem(audin, entry->subsystem))) if ((error = audin_set_subsystem(audin, entry->subsystem)))
{ {
WLog_ERR(TAG, "audin_set_subsystem for %s failed with error %"PRIu32"!", WLog_Print(audin->log, WLOG_ERROR, "audin_set_subsystem for %s failed with error %"PRIu32"!",
entry->subsystem, error); entry->subsystem, error);
} }
else if ((error = audin_set_device_name(audin, entry->device))) else if ((error = audin_set_device_name(audin, entry->device)))
{ {
WLog_ERR(TAG, "audin_set_device_name for %s failed with error %"PRIu32"!", WLog_Print(audin->log, WLOG_ERROR, "audin_set_device_name for %s failed with error %"PRIu32"!",
entry->subsystem, error); entry->subsystem, error);
} }
else if ((error = audin_load_device_plugin((IWTSPlugin*) audin, audin->subsystem, args))) else if ((error = audin_load_device_plugin((IWTSPlugin*) audin, audin->subsystem, args)))
{ {
WLog_ERR(TAG, "audin_load_device_plugin %s failed with error %"PRIu32"!", WLog_Print(audin->log, WLOG_ERROR, "audin_load_device_plugin %s failed with error %"PRIu32"!",
entry->subsystem, error); entry->subsystem, error);
} }
entry++; entry++;
@ -933,7 +975,7 @@ UINT DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
} }
if (audin->device == NULL) if (audin->device == NULL)
WLog_ERR(TAG, "no sound device."); WLog_Print(audin->log, WLOG_ERROR, "no sound device.");
error = pEntryPoints->RegisterPlugin(pEntryPoints, "audin", (IWTSPlugin*) audin); error = pEntryPoints->RegisterPlugin(pEntryPoints, "audin", (IWTSPlugin*) audin);
out: out: