624 lines
16 KiB
C
624 lines
16 KiB
C
/**
|
|
* FreeRDP: A Remote Desktop Protocol Implementation
|
|
* Video Redirection Virtual Channel
|
|
*
|
|
* Copyright 2010-2011 Vic Lee
|
|
* Copyright 2015 Thincast Technologies GmbH
|
|
* Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.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.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <winpr/crt.h>
|
|
#include <winpr/stream.h>
|
|
#include <winpr/cmdline.h>
|
|
|
|
#include <freerdp/client/tsmf.h>
|
|
|
|
#include "tsmf_types.h"
|
|
#include "tsmf_constants.h"
|
|
#include "tsmf_ifman.h"
|
|
#include "tsmf_media.h"
|
|
|
|
#include "tsmf_main.h"
|
|
|
|
BOOL tsmf_send_eos_response(IWTSVirtualChannelCallback* pChannelCallback, UINT32 message_id)
|
|
{
|
|
wStream* s = NULL;
|
|
int status = -1;
|
|
TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*)pChannelCallback;
|
|
|
|
if (!callback)
|
|
{
|
|
DEBUG_TSMF("No callback reference - unable to send eos response!");
|
|
return FALSE;
|
|
}
|
|
|
|
if (callback && callback->stream_id && callback->channel && callback->channel->Write)
|
|
{
|
|
s = Stream_New(NULL, 24);
|
|
|
|
if (!s)
|
|
return FALSE;
|
|
|
|
Stream_Write_UINT32(s, TSMF_INTERFACE_CLIENT_NOTIFICATIONS | STREAM_ID_PROXY);
|
|
Stream_Write_UINT32(s, message_id);
|
|
Stream_Write_UINT32(s, CLIENT_EVENT_NOTIFICATION); /* FunctionId */
|
|
Stream_Write_UINT32(s, callback->stream_id); /* StreamId */
|
|
Stream_Write_UINT32(s, TSMM_CLIENT_EVENT_ENDOFSTREAM); /* EventId */
|
|
Stream_Write_UINT32(s, 0); /* cbData */
|
|
DEBUG_TSMF("EOS response size %" PRIuz "", Stream_GetPosition(s));
|
|
status = callback->channel->Write(callback->channel, Stream_GetPosition(s),
|
|
Stream_Buffer(s), NULL);
|
|
|
|
if (status)
|
|
{
|
|
WLog_ERR(TAG, "response error %d", status);
|
|
}
|
|
|
|
Stream_Free(s, TRUE);
|
|
}
|
|
|
|
return (status == 0);
|
|
}
|
|
|
|
BOOL tsmf_playback_ack(IWTSVirtualChannelCallback* pChannelCallback, UINT32 message_id,
|
|
UINT64 duration, UINT32 data_size)
|
|
{
|
|
wStream* s = NULL;
|
|
int status = -1;
|
|
TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*)pChannelCallback;
|
|
|
|
if (!callback)
|
|
return FALSE;
|
|
|
|
s = Stream_New(NULL, 32);
|
|
|
|
if (!s)
|
|
return FALSE;
|
|
|
|
Stream_Write_UINT32(s, TSMF_INTERFACE_CLIENT_NOTIFICATIONS | STREAM_ID_PROXY);
|
|
Stream_Write_UINT32(s, message_id);
|
|
Stream_Write_UINT32(s, PLAYBACK_ACK); /* FunctionId */
|
|
Stream_Write_UINT32(s, callback->stream_id); /* StreamId */
|
|
Stream_Write_UINT64(s, duration); /* DataDuration */
|
|
Stream_Write_UINT64(s, data_size); /* cbData */
|
|
DEBUG_TSMF("ACK response size %" PRIuz "", Stream_GetPosition(s));
|
|
|
|
if (!callback->channel || !callback->channel->Write)
|
|
{
|
|
WLog_ERR(TAG, "callback=%p, channel=%p, write=%p", callback,
|
|
(callback ? callback->channel : NULL),
|
|
(callback && callback->channel ? callback->channel->Write : NULL));
|
|
}
|
|
else
|
|
{
|
|
status = callback->channel->Write(callback->channel, Stream_GetPosition(s),
|
|
Stream_Buffer(s), NULL);
|
|
}
|
|
|
|
if (status)
|
|
{
|
|
WLog_ERR(TAG, "response error %d", status);
|
|
}
|
|
|
|
Stream_Free(s, TRUE);
|
|
return (status == 0);
|
|
}
|
|
|
|
/**
|
|
* Function description
|
|
*
|
|
* @return 0 on success, otherwise a Win32 error code
|
|
*/
|
|
static UINT tsmf_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data)
|
|
{
|
|
size_t length;
|
|
wStream* input;
|
|
wStream* output;
|
|
UINT error = CHANNEL_RC_OK;
|
|
BOOL processed = FALSE;
|
|
TSMF_IFMAN ifman;
|
|
UINT32 MessageId;
|
|
UINT32 FunctionId;
|
|
UINT32 InterfaceId;
|
|
TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*)pChannelCallback;
|
|
UINT32 cbSize = Stream_GetRemainingLength(data);
|
|
|
|
/* 2.2.1 Shared Message Header (SHARED_MSG_HEADER) */
|
|
if (cbSize < 12)
|
|
{
|
|
WLog_ERR(TAG, "invalid size. cbSize=%" PRIu32 "", cbSize);
|
|
return ERROR_INVALID_DATA;
|
|
}
|
|
|
|
input = data;
|
|
output = Stream_New(NULL, 256);
|
|
|
|
if (!output)
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
Stream_Seek(output, 8);
|
|
Stream_Read_UINT32(input, InterfaceId); /* InterfaceId (4 bytes) */
|
|
Stream_Read_UINT32(input, MessageId); /* MessageId (4 bytes) */
|
|
Stream_Read_UINT32(input, FunctionId); /* FunctionId (4 bytes) */
|
|
DEBUG_TSMF("cbSize=%" PRIu32 " InterfaceId=0x%" PRIX32 " MessageId=0x%" PRIX32
|
|
" FunctionId=0x%" PRIX32 "",
|
|
cbSize, InterfaceId, MessageId, FunctionId);
|
|
ZeroMemory(&ifman, sizeof(TSMF_IFMAN));
|
|
ifman.channel_callback = pChannelCallback;
|
|
ifman.decoder_name = ((TSMF_PLUGIN*)callback->plugin)->decoder_name;
|
|
ifman.audio_name = ((TSMF_PLUGIN*)callback->plugin)->audio_name;
|
|
ifman.audio_device = ((TSMF_PLUGIN*)callback->plugin)->audio_device;
|
|
CopyMemory(ifman.presentation_id, callback->presentation_id, GUID_SIZE);
|
|
ifman.stream_id = callback->stream_id;
|
|
ifman.message_id = MessageId;
|
|
ifman.input = input;
|
|
ifman.input_size = cbSize - 12;
|
|
ifman.output = output;
|
|
ifman.output_pending = FALSE;
|
|
ifman.output_interface_id = InterfaceId;
|
|
|
|
// fprintf(stderr, "InterfaceId: 0x%08"PRIX32" MessageId: 0x%08"PRIX32" FunctionId:
|
|
// 0x%08"PRIX32"\n", InterfaceId, MessageId, FunctionId);
|
|
|
|
switch (InterfaceId)
|
|
{
|
|
case TSMF_INTERFACE_CAPABILITIES | STREAM_ID_NONE:
|
|
switch (FunctionId)
|
|
{
|
|
case RIM_EXCHANGE_CAPABILITY_REQUEST:
|
|
error = tsmf_ifman_rim_exchange_capability_request(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case RIMCALL_RELEASE:
|
|
case RIMCALL_QUERYINTERFACE:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case TSMF_INTERFACE_DEFAULT | STREAM_ID_PROXY:
|
|
switch (FunctionId)
|
|
{
|
|
case SET_CHANNEL_PARAMS:
|
|
if (Stream_GetRemainingLength(input) < GUID_SIZE + 4)
|
|
{
|
|
error = ERROR_INVALID_DATA;
|
|
goto out;
|
|
}
|
|
|
|
CopyMemory(callback->presentation_id, Stream_Pointer(input), GUID_SIZE);
|
|
Stream_Seek(input, GUID_SIZE);
|
|
Stream_Read_UINT32(input, callback->stream_id);
|
|
DEBUG_TSMF("SET_CHANNEL_PARAMS StreamId=%" PRIu32 "", callback->stream_id);
|
|
ifman.output_pending = TRUE;
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case EXCHANGE_CAPABILITIES_REQ:
|
|
error = tsmf_ifman_exchange_capability_request(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case CHECK_FORMAT_SUPPORT_REQ:
|
|
error = tsmf_ifman_check_format_support_request(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case ON_NEW_PRESENTATION:
|
|
error = tsmf_ifman_on_new_presentation(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case ADD_STREAM:
|
|
error =
|
|
tsmf_ifman_add_stream(&ifman, ((TSMF_PLUGIN*)callback->plugin)->rdpcontext);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case SET_TOPOLOGY_REQ:
|
|
error = tsmf_ifman_set_topology_request(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case REMOVE_STREAM:
|
|
error = tsmf_ifman_remove_stream(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case SET_SOURCE_VIDEO_RECT:
|
|
error = tsmf_ifman_set_source_video_rect(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case SHUTDOWN_PRESENTATION_REQ:
|
|
error = tsmf_ifman_shutdown_presentation(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case ON_STREAM_VOLUME:
|
|
error = tsmf_ifman_on_stream_volume(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case ON_CHANNEL_VOLUME:
|
|
error = tsmf_ifman_on_channel_volume(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case SET_VIDEO_WINDOW:
|
|
error = tsmf_ifman_set_video_window(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case UPDATE_GEOMETRY_INFO:
|
|
error = tsmf_ifman_update_geometry_info(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case SET_ALLOCATOR:
|
|
error = tsmf_ifman_set_allocator(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case NOTIFY_PREROLL:
|
|
error = tsmf_ifman_notify_preroll(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case ON_SAMPLE:
|
|
error = tsmf_ifman_on_sample(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case ON_FLUSH:
|
|
error = tsmf_ifman_on_flush(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case ON_END_OF_STREAM:
|
|
error = tsmf_ifman_on_end_of_stream(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case ON_PLAYBACK_STARTED:
|
|
error = tsmf_ifman_on_playback_started(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case ON_PLAYBACK_PAUSED:
|
|
error = tsmf_ifman_on_playback_paused(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case ON_PLAYBACK_RESTARTED:
|
|
error = tsmf_ifman_on_playback_restarted(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case ON_PLAYBACK_STOPPED:
|
|
error = tsmf_ifman_on_playback_stopped(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case ON_PLAYBACK_RATE_CHANGED:
|
|
error = tsmf_ifman_on_playback_rate_changed(&ifman);
|
|
processed = TRUE;
|
|
break;
|
|
|
|
case RIMCALL_RELEASE:
|
|
case RIMCALL_QUERYINTERFACE:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
input = NULL;
|
|
ifman.input = NULL;
|
|
|
|
if (error)
|
|
{
|
|
WLog_ERR(TAG, "ifman data received processing error %" PRIu32 "", error);
|
|
}
|
|
|
|
if (!processed)
|
|
{
|
|
switch (FunctionId)
|
|
{
|
|
case RIMCALL_RELEASE:
|
|
/* [MS-RDPEXPS] 2.2.2.2 Interface Release (IFACE_RELEASE)
|
|
This message does not require a reply. */
|
|
processed = TRUE;
|
|
ifman.output_pending = 1;
|
|
break;
|
|
|
|
case RIMCALL_QUERYINTERFACE:
|
|
/* [MS-RDPEXPS] 2.2.2.1.2 Query Interface Response (QI_RSP)
|
|
This message is not supported in this channel. */
|
|
processed = TRUE;
|
|
break;
|
|
}
|
|
|
|
if (!processed)
|
|
{
|
|
WLog_ERR(TAG,
|
|
"Unknown InterfaceId: 0x%08" PRIX32 " MessageId: 0x%08" PRIX32
|
|
" FunctionId: 0x%08" PRIX32 "\n",
|
|
InterfaceId, MessageId, FunctionId);
|
|
/* When a request is not implemented we return empty response indicating error */
|
|
}
|
|
|
|
processed = TRUE;
|
|
}
|
|
|
|
if (processed && !ifman.output_pending)
|
|
{
|
|
/* Response packet does not have FunctionId */
|
|
length = Stream_GetPosition(output);
|
|
Stream_SetPosition(output, 0);
|
|
Stream_Write_UINT32(output, ifman.output_interface_id);
|
|
Stream_Write_UINT32(output, MessageId);
|
|
DEBUG_TSMF("response size %d", length);
|
|
error = callback->channel->Write(callback->channel, length, Stream_Buffer(output), NULL);
|
|
|
|
if (error)
|
|
{
|
|
WLog_ERR(TAG, "response error %" PRIu32 "", error);
|
|
}
|
|
}
|
|
|
|
out:
|
|
Stream_Free(output, TRUE);
|
|
return error;
|
|
}
|
|
|
|
/**
|
|
* Function description
|
|
*
|
|
* @return 0 on success, otherwise a Win32 error code
|
|
*/
|
|
static UINT tsmf_on_close(IWTSVirtualChannelCallback* pChannelCallback)
|
|
{
|
|
TSMF_STREAM* stream;
|
|
TSMF_PRESENTATION* presentation;
|
|
TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*)pChannelCallback;
|
|
DEBUG_TSMF("");
|
|
|
|
if (callback->stream_id)
|
|
{
|
|
presentation = tsmf_presentation_find_by_id(callback->presentation_id);
|
|
|
|
if (presentation)
|
|
{
|
|
stream = tsmf_stream_find_by_id(presentation, callback->stream_id);
|
|
|
|
if (stream)
|
|
tsmf_stream_free(stream);
|
|
}
|
|
}
|
|
|
|
free(pChannelCallback);
|
|
return CHANNEL_RC_OK;
|
|
}
|
|
|
|
/**
|
|
* Function description
|
|
*
|
|
* @return 0 on success, otherwise a Win32 error code
|
|
*/
|
|
static UINT tsmf_on_new_channel_connection(IWTSListenerCallback* pListenerCallback,
|
|
IWTSVirtualChannel* pChannel, BYTE* Data, BOOL* pbAccept,
|
|
IWTSVirtualChannelCallback** ppCallback)
|
|
{
|
|
TSMF_CHANNEL_CALLBACK* callback;
|
|
TSMF_LISTENER_CALLBACK* listener_callback = (TSMF_LISTENER_CALLBACK*)pListenerCallback;
|
|
DEBUG_TSMF("");
|
|
callback = (TSMF_CHANNEL_CALLBACK*)calloc(1, sizeof(TSMF_CHANNEL_CALLBACK));
|
|
|
|
if (!callback)
|
|
return CHANNEL_RC_NO_MEMORY;
|
|
|
|
callback->iface.OnDataReceived = tsmf_on_data_received;
|
|
callback->iface.OnClose = tsmf_on_close;
|
|
callback->iface.OnOpen = NULL;
|
|
callback->plugin = listener_callback->plugin;
|
|
callback->channel_mgr = listener_callback->channel_mgr;
|
|
callback->channel = pChannel;
|
|
*ppCallback = (IWTSVirtualChannelCallback*)callback;
|
|
return CHANNEL_RC_OK;
|
|
}
|
|
|
|
/**
|
|
* Function description
|
|
*
|
|
* @return 0 on success, otherwise a Win32 error code
|
|
*/
|
|
static UINT tsmf_plugin_initialize(IWTSPlugin* pPlugin, IWTSVirtualChannelManager* pChannelMgr)
|
|
{
|
|
UINT status;
|
|
TSMF_PLUGIN* tsmf = (TSMF_PLUGIN*)pPlugin;
|
|
DEBUG_TSMF("");
|
|
tsmf->listener_callback = (TSMF_LISTENER_CALLBACK*)calloc(1, sizeof(TSMF_LISTENER_CALLBACK));
|
|
|
|
if (!tsmf->listener_callback)
|
|
return CHANNEL_RC_NO_MEMORY;
|
|
|
|
tsmf->listener_callback->iface.OnNewChannelConnection = tsmf_on_new_channel_connection;
|
|
tsmf->listener_callback->plugin = pPlugin;
|
|
tsmf->listener_callback->channel_mgr = pChannelMgr;
|
|
status = pChannelMgr->CreateListener(
|
|
pChannelMgr, "TSMF", 0, (IWTSListenerCallback*)tsmf->listener_callback, &(tsmf->listener));
|
|
tsmf->listener->pInterface = tsmf->iface.pInterface;
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* Function description
|
|
*
|
|
* @return 0 on success, otherwise a Win32 error code
|
|
*/
|
|
static UINT tsmf_plugin_terminated(IWTSPlugin* pPlugin)
|
|
{
|
|
TSMF_PLUGIN* tsmf = (TSMF_PLUGIN*)pPlugin;
|
|
DEBUG_TSMF("");
|
|
free(tsmf->listener_callback);
|
|
free(tsmf);
|
|
return CHANNEL_RC_OK;
|
|
}
|
|
|
|
/**
|
|
* Function description
|
|
*
|
|
* @return 0 on success, otherwise a Win32 error code
|
|
*/
|
|
static UINT tsmf_process_addin_args(IWTSPlugin* pPlugin, const ADDIN_ARGV* args)
|
|
{
|
|
int status;
|
|
DWORD flags;
|
|
COMMAND_LINE_ARGUMENT_A* arg;
|
|
TSMF_PLUGIN* tsmf = (TSMF_PLUGIN*)pPlugin;
|
|
COMMAND_LINE_ARGUMENT_A tsmf_args[] = { { "sys", COMMAND_LINE_VALUE_REQUIRED, "<subsystem>",
|
|
NULL, NULL, -1, NULL, "audio subsystem" },
|
|
{ "dev", COMMAND_LINE_VALUE_REQUIRED, "<device>", NULL,
|
|
NULL, -1, NULL, "audio device name" },
|
|
{ "decoder", COMMAND_LINE_VALUE_REQUIRED, "<subsystem>",
|
|
NULL, NULL, -1, NULL, "decoder subsystem" },
|
|
{ NULL, 0, NULL, NULL, NULL, -1, NULL, NULL } };
|
|
flags = COMMAND_LINE_SIGIL_NONE | COMMAND_LINE_SEPARATOR_COLON;
|
|
status = CommandLineParseArgumentsA(args->argc, args->argv, tsmf_args, flags, tsmf, NULL, NULL);
|
|
|
|
if (status != 0)
|
|
return ERROR_INVALID_DATA;
|
|
|
|
arg = tsmf_args;
|
|
|
|
do
|
|
{
|
|
if (!(arg->Flags & COMMAND_LINE_VALUE_PRESENT))
|
|
continue;
|
|
|
|
CommandLineSwitchStart(arg) CommandLineSwitchCase(arg, "sys")
|
|
{
|
|
tsmf->audio_name = _strdup(arg->Value);
|
|
|
|
if (!tsmf->audio_name)
|
|
return ERROR_OUTOFMEMORY;
|
|
}
|
|
CommandLineSwitchCase(arg, "dev")
|
|
{
|
|
tsmf->audio_device = _strdup(arg->Value);
|
|
|
|
if (!tsmf->audio_device)
|
|
return ERROR_OUTOFMEMORY;
|
|
}
|
|
CommandLineSwitchCase(arg, "decoder")
|
|
{
|
|
tsmf->decoder_name = _strdup(arg->Value);
|
|
|
|
if (!tsmf->decoder_name)
|
|
return ERROR_OUTOFMEMORY;
|
|
}
|
|
CommandLineSwitchDefault(arg)
|
|
{
|
|
}
|
|
CommandLineSwitchEnd(arg)
|
|
} while ((arg = CommandLineFindNextArgumentA(arg)) != NULL);
|
|
|
|
return CHANNEL_RC_OK;
|
|
}
|
|
|
|
#ifdef BUILTIN_CHANNELS
|
|
#define DVCPluginEntry tsmf_DVCPluginEntry
|
|
#else
|
|
#define DVCPluginEntry FREERDP_API DVCPluginEntry
|
|
#endif
|
|
|
|
/**
|
|
* Function description
|
|
*
|
|
* @return 0 on success, otherwise a Win32 error code
|
|
*/
|
|
UINT DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
|
|
{
|
|
UINT status = 0;
|
|
TSMF_PLUGIN* tsmf;
|
|
TsmfClientContext* context;
|
|
UINT error = CHANNEL_RC_NO_MEMORY;
|
|
tsmf = (TSMF_PLUGIN*)pEntryPoints->GetPlugin(pEntryPoints, "tsmf");
|
|
|
|
if (!tsmf)
|
|
{
|
|
tsmf = (TSMF_PLUGIN*)calloc(1, sizeof(TSMF_PLUGIN));
|
|
|
|
if (!tsmf)
|
|
{
|
|
WLog_ERR(TAG, "calloc failed!");
|
|
return CHANNEL_RC_NO_MEMORY;
|
|
}
|
|
|
|
tsmf->iface.Initialize = tsmf_plugin_initialize;
|
|
tsmf->iface.Connected = NULL;
|
|
tsmf->iface.Disconnected = NULL;
|
|
tsmf->iface.Terminated = tsmf_plugin_terminated;
|
|
tsmf->rdpcontext =
|
|
((freerdp*)((rdpSettings*)pEntryPoints->GetRdpSettings(pEntryPoints))->instance)
|
|
->context;
|
|
context = (TsmfClientContext*)calloc(1, sizeof(TsmfClientContext));
|
|
|
|
if (!context)
|
|
{
|
|
WLog_ERR(TAG, "calloc failed!");
|
|
goto error_context;
|
|
}
|
|
|
|
context->handle = (void*)tsmf;
|
|
tsmf->iface.pInterface = (void*)context;
|
|
|
|
if (!tsmf_media_init())
|
|
{
|
|
error = ERROR_INVALID_OPERATION;
|
|
goto error_init;
|
|
}
|
|
|
|
status = pEntryPoints->RegisterPlugin(pEntryPoints, "tsmf", &tsmf->iface);
|
|
}
|
|
|
|
if (status == CHANNEL_RC_OK)
|
|
{
|
|
status = tsmf_process_addin_args(&tsmf->iface, pEntryPoints->GetPluginData(pEntryPoints));
|
|
}
|
|
|
|
return status;
|
|
error_init:
|
|
free(context);
|
|
error_context:
|
|
free(tsmf);
|
|
return error;
|
|
}
|