From a6be7610736293774b11f9a172d156ab444811c9 Mon Sep 17 00:00:00 2001 From: tkummermehr Date: Thu, 13 Jul 2017 22:05:10 +0200 Subject: New XML Parser implementation, supports splitter and combiner --- ucs2-interface/ucs-xml/UcsXml_Private.c | 510 ++++++++++++++++++++++++++++++++ 1 file changed, 510 insertions(+) create mode 100644 ucs2-interface/ucs-xml/UcsXml_Private.c (limited to 'ucs2-interface/ucs-xml/UcsXml_Private.c') diff --git a/ucs2-interface/ucs-xml/UcsXml_Private.c b/ucs2-interface/ucs-xml/UcsXml_Private.c new file mode 100644 index 0000000..b447bce --- /dev/null +++ b/ucs2-interface/ucs-xml/UcsXml_Private.c @@ -0,0 +1,510 @@ +/*------------------------------------------------------------------------------------------------*/ +/* Unicens XML Parser */ +/* Copyright 2017, Microchip Technology Inc. and its subsidiaries. */ +/* */ +/* Redistribution and use in source and binary forms, with or without */ +/* modification, are permitted provided that the following conditions are met: */ +/* */ +/* 1. Redistributions of source code must retain the above copyright notice, this */ +/* list of conditions and the following disclaimer. */ +/* */ +/* 2. Redistributions in binary form must reproduce the above copyright notice, */ +/* this list of conditions and the following disclaimer in the documentation */ +/* and/or other materials provided with the distribution. */ +/* */ +/* 3. Neither the name of the copyright holder nor the names of its */ +/* contributors may be used to endorse or promote products derived from */ +/* this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" */ +/* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE */ +/* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE */ +/* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE */ +/* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL */ +/* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR */ +/* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER */ +/* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, */ +/* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */ +/* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/*------------------------------------------------------------------------------------------------*/ + +#include +#include +#include +#include "UcsXml_Private.h" + +static const char* USB_PHY_STANDARD = "Standard"; +static const char* USB_PHY_HSIC = "HSIC"; + +static const char* CLOCK_8FS = "8Fs"; +static const char* CLOCK_16FS = "16Fs"; +static const char* CLOCK_32FS = "32Fs"; +static const char* CLOCK_64FS = "64Fs"; +static const char* CLOCK_128FS = "128Fs"; +static const char* CLOCK_256FS = "256Fs"; +static const char* CLOCK_512FS = "512Fs"; +static const char* CLOCK_1024FS = "1024Fs"; +static const char* CLOCK_2048FS = "2048Fs"; +static const char* CLOCK_3072FS = "3072Fs"; +static const char* CLOCK_4096FS = "4096Fs"; +static const char* CLOCK_6144FS = "6144Fs"; +static const char* CLOCK_8192FS = "8192Fs"; +static const char* CLOCK_WILDCARD = "Wildcard"; + +static const char* STRM_ALIGN_L16 = "Left16Bit"; +static const char* STRM_ALIGN_L24 = "Left24Bit"; +static const char* STRM_ALIGN_R16 = "Right16Bit"; +static const char* STRM_ALIGN_R24 = "Right24Bit"; +static const char* STRM_ALIGN_SEQUENTIAL = "Seq"; + +static const char* I2S_PIN_SRXA0 = "SRXA0"; +static const char* I2S_PIN_SRXA1 = "SRXA1"; +static const char* I2S_PIN_SRXB0 = "SRXB0"; +static const char* I2S_PIN_SRXB1 = "SRXB1"; + +static const char* MUTE_OFF = "NoMuting"; +static const char* MUTE_SIGNAL = "MuteSignal"; +/* +static const char* VAL_TRUE = "true"; +static const char* VAL_FALSE = "false"; + */ + +#define ASSERT_FALSE() { assert(false); return false; } +#define CHECK_POINTER(PTR) if (NULL == PTR) { ASSERT_FALSE(); } + +static int32_t Str2Int(const char *val) +{ + return strtol( val, NULL, 0 ); +} + +void *MCalloc(struct UcsXmlObjectList *list, uint32_t nElem, uint32_t elemSize) +{ + void *obj; + struct UcsXmlObjectList *tail = list; + if (NULL == list || 0 == nElem || 0 == elemSize) return NULL; + + obj = calloc(nElem, elemSize); + if (NULL == obj) + { + assert(false); + return NULL; + } + if (NULL == list->obj) + { + list->obj = obj; + return obj; + } + while(tail->next) tail = tail->next; + tail->next = calloc(1, sizeof(struct UcsXmlObjectList)); + if (NULL == tail->next) + { + assert(false); + free(obj); + return NULL; + } + tail->next->obj = obj; + return obj; +} + +void FreeObjList(struct UcsXmlObjectList *cur) +{ + struct UcsXmlObjectList *root = cur; + while(cur) + { + struct UcsXmlObjectList *next = cur->next; + assert(NULL != cur->obj); + if (cur->obj) + free(cur->obj); + if (cur != root) + free(cur); + cur = next; + } +} + +bool GetMostSocket(Ucs_Xrm_MostSocket_t **mostSoc, struct MostSocketParameters *param) +{ + Ucs_Xrm_MostSocket_t *soc = NULL; + CHECK_POINTER(mostSoc); + CHECK_POINTER(param); + CHECK_POINTER(param->list); + soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_MostSocket_t)); + CHECK_POINTER(soc); + *mostSoc = soc; + soc->resource_type = UCS_XRM_RC_TYPE_MOST_SOCKET; + soc->most_port_handle = 0x0D00; + soc->bandwidth = param->bandwidth; + soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT; + switch(param->dataType) + { + case SYNC_DATA: + soc->data_type = UCS_MOST_SCKT_SYNC_DATA; + break; + case AV_PACKETIZED: + soc->data_type = UCS_MOST_SCKT_AV_PACKETIZED; + break; + case QOS_IP: + soc->data_type = UCS_MOST_SCKT_QOS_IP; + break; + case DISC_FRAME_PHASE: + soc->data_type = UCS_MOST_SCKT_DISC_FRAME_PHASE; + break; + default: + ASSERT_FALSE(); + } + return true; +} + +bool GetUsbPort(Ucs_Xrm_UsbPort_t **usbPort, struct UsbPortParameters *param) +{ + Ucs_Xrm_UsbPort_t *port = NULL; + CHECK_POINTER(usbPort); + CHECK_POINTER(param); + CHECK_POINTER(param->list); + CHECK_POINTER(param->deviceInterfaces); + CHECK_POINTER(param->streamInCount); + CHECK_POINTER(param->streamOutCount); + CHECK_POINTER(param->physicalLayer); + port = MCalloc(param->list, 1, sizeof(Ucs_Xrm_UsbPort_t)); + CHECK_POINTER(port); + *usbPort = port; + port->resource_type = UCS_XRM_RC_TYPE_USB_PORT; + port->index = 0; + port->devices_interfaces = (uint16_t)Str2Int(param->deviceInterfaces); + port->streaming_if_ep_in_count = (uint8_t)Str2Int(param->streamInCount); + port->streaming_if_ep_out_count = (uint8_t)Str2Int(param->streamOutCount); + if (0 == strcmp(USB_PHY_STANDARD, param->physicalLayer)) + port->physical_layer = UCS_USB_PHY_LAYER_STANDARD; + else if (0 == strcmp(USB_PHY_HSIC, param->physicalLayer)) + port->physical_layer = UCS_USB_PHY_LAYER_HSCI; + else ASSERT_FALSE(); + return true; +} + +bool GetUsbPortDefaultCreated(Ucs_Xrm_ResObject_t **usbPort, struct UcsXmlObjectList *list) +{ + Ucs_Xrm_DefaultCreatedPort_t *p; + CHECK_POINTER(usbPort); + CHECK_POINTER(list); + p = MCalloc(list, 1, sizeof(Ucs_Xrm_DefaultCreatedPort_t)); + CHECK_POINTER(p); + p->resource_type = UCS_XRM_RC_TYPE_DC_PORT; + p->port_type = UCS_XRM_PORT_TYPE_USB; + p->index = 0; + *usbPort = (Ucs_Xrm_ResObject_t *)p; + return true; +} + +bool GetUsbSocket(Ucs_Xrm_UsbSocket_t **usbSoc, struct UsbSocketParameters *param) +{ + Ucs_Xrm_UsbSocket_t *soc = NULL; + CHECK_POINTER(usbSoc); + CHECK_POINTER(param); + CHECK_POINTER(param->list); + CHECK_POINTER(param->endpointAddress); + CHECK_POINTER(param->framesPerTrans); + CHECK_POINTER(param->usbPort); + soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_UsbSocket_t)); + CHECK_POINTER(soc); + *usbSoc = soc; + soc->resource_type = UCS_XRM_RC_TYPE_USB_SOCKET; + soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT; + switch(param->dataType) + { + case SYNC_DATA: + soc->data_type = UCS_USB_SCKT_SYNC_DATA; + break; + case AV_PACKETIZED: + soc->data_type = UCS_USB_SCKT_AV_PACKETIZED; + break; + case IPC_PACKET: + soc->data_type = UCS_USB_SCKT_IPC_PACKET; + break; + default: + ASSERT_FALSE(); + } + soc->end_point_addr = (uint8_t)Str2Int(param->endpointAddress); + soc->frames_per_transfer = (uint16_t)Str2Int(param->framesPerTrans); + soc->usb_port_obj_ptr = param->usbPort; + return true; +} + +bool GetMlbPort(Ucs_Xrm_MlbPort_t **mlbPort, struct MlbPortParameters *param) +{ + Ucs_Xrm_MlbPort_t *port = NULL; + CHECK_POINTER(mlbPort); + CHECK_POINTER(param); + CHECK_POINTER(param->list); + CHECK_POINTER(param->clockConfig); + port = MCalloc(param->list, 1, sizeof(Ucs_Xrm_MlbPort_t)); + CHECK_POINTER(port); + *mlbPort = port; + port->resource_type = UCS_XRM_RC_TYPE_MLB_PORT; + port->index = 0; + if (0 == strcmp(param->clockConfig, CLOCK_256FS)) + port->clock_config = UCS_MLB_CLK_CFG_256_FS; + else if (0 == strcmp(param->clockConfig, CLOCK_512FS)) + port->clock_config = UCS_MLB_CLK_CFG_512_FS; + else if (0 == strcmp(param->clockConfig, CLOCK_1024FS)) + port->clock_config = UCS_MLB_CLK_CFG_1024_FS; + else if (0 == strcmp(param->clockConfig, CLOCK_2048FS)) + port->clock_config = UCS_MLB_CLK_CFG_2048_FS; + else if (0 == strcmp(param->clockConfig, CLOCK_3072FS)) + port->clock_config = UCS_MLB_CLK_CFG_3072_FS; + else if (0 == strcmp(param->clockConfig, CLOCK_4096FS)) + port->clock_config = UCS_MLB_CLK_CFG_4096_FS; + else if (0 == strcmp(param->clockConfig, CLOCK_6144FS)) + port->clock_config = UCS_MLB_CLK_CFG_6144_FS; + else if (0 == strcmp(param->clockConfig, CLOCK_8192FS)) + port->clock_config = UCS_MLB_CLK_CFG_8192_FS; + else ASSERT_FALSE(); + return true; +} + +bool GetMlbPortDefaultCreated(Ucs_Xrm_ResObject_t **mlbPort, struct UcsXmlObjectList *list) +{ + Ucs_Xrm_DefaultCreatedPort_t *p; + CHECK_POINTER(mlbPort); + CHECK_POINTER(list) + p = MCalloc(list, 1, sizeof(Ucs_Xrm_DefaultCreatedPort_t)); + CHECK_POINTER(p); + p->resource_type = UCS_XRM_RC_TYPE_DC_PORT; + p->port_type = UCS_XRM_PORT_TYPE_MLB; + p->index = 0; + *mlbPort = (Ucs_Xrm_ResObject_t *)p; + return true; +} + +bool GetMlbSocket(Ucs_Xrm_MlbSocket_t **mlbSoc, struct MlbSocketParameters *param) +{ + Ucs_Xrm_MlbSocket_t *soc = NULL; + CHECK_POINTER(mlbSoc); + CHECK_POINTER(param); + CHECK_POINTER(param->list); + CHECK_POINTER(param->channelAddress); + CHECK_POINTER(param->mlbPort); + soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_MlbSocket_t)); + CHECK_POINTER(soc); + *mlbSoc = soc; + soc->resource_type = UCS_XRM_RC_TYPE_MLB_SOCKET; + soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT; + soc->bandwidth = param->bandwidth; + switch(param->dataType) + { + case SYNC_DATA: + soc->data_type = UCS_MLB_SCKT_SYNC_DATA; + break; + case AV_PACKETIZED: + soc->data_type = UCS_MLB_SCKT_AV_PACKETIZED; + break; + case QOS_IP: + soc->data_type = UCS_MLB_SCKT_QOS_IP; + break; + case DISC_FRAME_PHASE: + soc->data_type = UCS_MLB_SCKT_DISC_FRAME_PHASE; + break; + case IPC_PACKET: + soc->data_type = UCS_MLB_SCKT_IPC_PACKET; + break; + default: + ASSERT_FALSE(); + } + soc->channel_address = (uint16_t)Str2Int(param->channelAddress); + soc->mlb_port_obj_ptr = param->mlbPort; + return true; +} + +bool GetStrmPort(Ucs_Xrm_StrmPort_t **strmPort, struct StrmPortParameters *param) +{ + Ucs_Xrm_StrmPort_t *port = NULL; + CHECK_POINTER(strmPort); + CHECK_POINTER(param); + CHECK_POINTER(param->list); + CHECK_POINTER(param->clockConfig); + port = MCalloc(param->list, 1, sizeof(Ucs_Xrm_StrmPort_t)); + CHECK_POINTER(port); + *strmPort = port; + port->resource_type = UCS_XRM_RC_TYPE_STRM_PORT; + port->index = param->index; + if (0 == port->index) + { + if (0 == strcmp(param->clockConfig, CLOCK_8FS)) + port->clock_config = UCS_STREAM_PORT_CLK_CFG_8FS; + else if (0 == strcmp(param->clockConfig, CLOCK_16FS)) + port->clock_config = UCS_STREAM_PORT_CLK_CFG_16FS; + else if (0 == strcmp(param->clockConfig, CLOCK_32FS)) + port->clock_config = UCS_STREAM_PORT_CLK_CFG_32FS; + else if (0 == strcmp(param->clockConfig, CLOCK_64FS)) + port->clock_config = UCS_STREAM_PORT_CLK_CFG_64FS; + else if (0 == strcmp(param->clockConfig, CLOCK_128FS)) + port->clock_config = UCS_STREAM_PORT_CLK_CFG_128FS; + else if (0 == strcmp(param->clockConfig, CLOCK_256FS)) + port->clock_config = UCS_STREAM_PORT_CLK_CFG_256FS; + else if (0 == strcmp(param->clockConfig, CLOCK_512FS)) + port->clock_config = UCS_STREAM_PORT_CLK_CFG_512FS; + else if (0 == strcmp(param->clockConfig, CLOCK_WILDCARD)) + port->clock_config = UCS_STREAM_PORT_CLK_CFG_WILD; + else ASSERT_FALSE(); + } else { + port->clock_config = UCS_STREAM_PORT_CLK_CFG_WILD; + } + + if (0 == strcmp(param->dataAlignment, STRM_ALIGN_L16)) + port->data_alignment = UCS_STREAM_PORT_ALGN_LEFT16BIT; + else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_L24)) + port->data_alignment = UCS_STREAM_PORT_ALGN_LEFT24BIT; + else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_R16)) + port->data_alignment = UCS_STREAM_PORT_ALGN_RIGHT16BIT; + else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_R24)) + port->data_alignment = UCS_STREAM_PORT_ALGN_RIGHT24BIT; + else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_SEQUENTIAL)) + port->data_alignment = UCS_STREAM_PORT_ALGN_SEQ; + else ASSERT_FALSE(); + return true; +} + +bool GetStrmSocket(Ucs_Xrm_StrmSocket_t **strmSoc, struct StrmSocketParameters *param) +{ + Ucs_Xrm_StrmSocket_t *soc = NULL; + CHECK_POINTER(strmSoc); + CHECK_POINTER(param); + CHECK_POINTER(param->list); + CHECK_POINTER(param->streamPin); + CHECK_POINTER(param->streamPortA); + CHECK_POINTER(param->streamPortB); + soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_StrmSocket_t)); + CHECK_POINTER(soc); + *strmSoc = soc; + soc->resource_type = UCS_XRM_RC_TYPE_STRM_SOCKET; + soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT; + switch(param->dataType) + { + case SYNC_DATA: + soc->data_type = UCS_STREAM_PORT_SCKT_SYNC_DATA; + break; + default: + ASSERT_FALSE(); + } + soc->bandwidth = param->bandwidth; + if (0 == strcmp(param->streamPin, I2S_PIN_SRXA0)) + { + soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXA0; + soc->stream_port_obj_ptr = param->streamPortA; + return true; + } + else if (0 == strcmp(param->streamPin, I2S_PIN_SRXA1)) + { + soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXA1; + soc->stream_port_obj_ptr = param->streamPortA; + return true; + } + else if (0 == strcmp(param->streamPin, I2S_PIN_SRXB0)) + { + soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXB0; + soc->stream_port_obj_ptr = param->streamPortB; + return true; + } + else if (0 == strcmp(param->streamPin, I2S_PIN_SRXB1)) + { + soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXB1; + soc->stream_port_obj_ptr = param->streamPortB; + return true; + } + else ASSERT_FALSE(); + return true; +} + +bool GetSplitter(Ucs_Xrm_Splitter_t **splitter, struct SplitterParameters *param) +{ + Ucs_Xrm_Splitter_t *split = NULL; + CHECK_POINTER(splitter); + CHECK_POINTER(param); + CHECK_POINTER(param->list); + split = MCalloc(param->list, 1, sizeof(Ucs_Xrm_Splitter_t)); + CHECK_POINTER(split); + *splitter = split; + split->most_port_handle = 0x0D00; + split->resource_type = UCS_XRM_RC_TYPE_SPLITTER; + split->bytes_per_frame = param->bytesPerFrame; + split->socket_in_obj_ptr = param->inSoc; + return true; +} + +bool GetCombiner(Ucs_Xrm_Combiner_t **combiner, struct CombinerParameters *param) +{ + Ucs_Xrm_Combiner_t *comb = NULL; + CHECK_POINTER(combiner); + CHECK_POINTER(param); + CHECK_POINTER(param->list); + comb = MCalloc(param->list, 1, sizeof(Ucs_Xrm_Combiner_t)); + CHECK_POINTER(comb); + *combiner = comb; + comb->most_port_handle = 0x0D00; + comb->resource_type = UCS_XRM_RC_TYPE_COMBINER; + comb->bytes_per_frame = param->bytesPerFrame; + comb->port_socket_obj_ptr = param->outSoc; + return true; +} + +bool GetSyncCon(Ucs_Xrm_SyncCon_t **syncCon, struct SyncConParameters *param) +{ + Ucs_Xrm_SyncCon_t *con = NULL; + CHECK_POINTER(syncCon); + CHECK_POINTER(param); + CHECK_POINTER(param->list); + CHECK_POINTER(param->muteMode); + CHECK_POINTER(param->inSoc); + CHECK_POINTER(param->outSoc); + con = MCalloc(param->list, 1, sizeof(Ucs_Xrm_SyncCon_t)); + CHECK_POINTER(con); + *syncCon = con; + con->resource_type = UCS_XRM_RC_TYPE_SYNC_CON; + if (0 == strcmp(param->muteMode, MUTE_OFF)) + con->mute_mode = UCS_SYNC_MUTE_MODE_NO_MUTING; + else if (0 == strcmp(param->muteMode, MUTE_SIGNAL)) + con->mute_mode = UCS_SYNC_MUTE_MODE_MUTE_SIGNAL; + else ASSERT_FALSE(); + if (param->optional_offset) + con->offset = (uint16_t)Str2Int(param->optional_offset); + else + con->offset = 0; + con->socket_in_obj_ptr = param->inSoc; + con->socket_out_obj_ptr = param->outSoc; + return true; +} + +bool GetAvpCon(Ucs_Xrm_AvpCon_t **avpCon, struct AvpConParameters *param) +{ + Ucs_Xrm_AvpCon_t *con = NULL; + CHECK_POINTER(avpCon); + CHECK_POINTER(param); + CHECK_POINTER(param->list); + CHECK_POINTER(param->inSoc); + CHECK_POINTER(param->outSoc); + con = MCalloc(param->list, 1, sizeof(Ucs_Xrm_AvpCon_t)); + CHECK_POINTER(con); + *avpCon = con; + con->resource_type = UCS_XRM_RC_TYPE_AVP_CON; + con->socket_in_obj_ptr = param->inSoc; + con->socket_out_obj_ptr = param->outSoc; + if (param->optional_isocPacketSize) + { + int32_t pSize = Str2Int(param->optional_isocPacketSize); + switch(pSize) + { + case 188: + con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_188; + break; + case 196: + con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_196; + break; + case 206: + con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_206; + break; + default: + ASSERT_FALSE(); + } + } else { + con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_188; + } + return true; +} \ No newline at end of file -- cgit 1.2.3-korg