ucs2-interface/ucs-xml/UcsXml_Private.c

   1 /*------------------------------------------------------------------------------------------------*/\r
   2 /* UNICENS XML Parser                                                                             */\r
   3 /* Copyright 2017, Microchip Technology Inc. and its subsidiaries.                                */\r
   4 /*                                                                                                */\r
   5 /* Redistribution and use in source and binary forms, with or without                             */\r
   6 /* modification, are permitted provided that the following conditions are met:                    */\r
   7 /*                                                                                                */\r
   8 /* 1. Redistributions of source code must retain the above copyright notice, this                 */\r
   9 /*    list of conditions and the following disclaimer.                                            */\r
  10 /*                                                                                                */\r
  11 /* 2. Redistributions in binary form must reproduce the above copyright notice,                   */\r
  12 /*    this list of conditions and the following disclaimer in the documentation                   */\r
  13 /*    and/or other materials provided with the distribution.                                      */\r
  14 /*                                                                                                */\r
  15 /* 3. Neither the name of the copyright holder nor the names of its                               */\r
  16 /*    contributors may be used to endorse or promote products derived from                        */\r
  17 /*    this software without specific prior written permission.                                    */\r
  18 /*                                                                                                */\r
  19 /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"                    */\r
  20 /* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE                      */\r
  21 /* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE                 */\r
  22 /* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE                   */\r
  23 /* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL                     */\r
  24 /* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR                     */\r
  25 /* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER                     */\r
  26 /* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,                  */\r
  27 /* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE                  */\r
  28 /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                           */\r
  29 /*------------------------------------------------------------------------------------------------*/\r
  30 \r
  31 #include <stdlib.h>\r
  32 #include <string.h>\r
  33 #include <assert.h>\r
  34 #include "UcsXml.h"\r
  35 #include "UcsXml_Private.h"\r
  36 \r
  37 static const char* USB_PHY_STANDARD =       "Standard";\r
  38 static const char* USB_PHY_HSIC =           "HSIC";\r
  39 \r
  40 static const char* CLOCK_8FS =              "8Fs";\r
  41 static const char* CLOCK_16FS =             "16Fs";\r
  42 static const char* CLOCK_32FS =             "32Fs";\r
  43 static const char* CLOCK_64FS =             "64Fs";\r
  44 static const char* CLOCK_128FS =            "128Fs";\r
  45 static const char* CLOCK_256FS =            "256Fs";\r
  46 static const char* CLOCK_512FS =            "512Fs";\r
  47 static const char* CLOCK_1024FS =           "1024Fs";\r
  48 static const char* CLOCK_2048FS =           "2048Fs";\r
  49 static const char* CLOCK_3072FS =           "3072Fs";\r
  50 static const char* CLOCK_4096FS =           "4096Fs";\r
  51 static const char* CLOCK_6144FS =           "6144Fs";\r
  52 static const char* CLOCK_8192FS =           "8192Fs";\r
  53 static const char* CLOCK_WILDCARD =         "Wildcard";\r
  54 \r
  55 static const char* STRM_ALIGN_L16 =         "Left16Bit";\r
  56 static const char* STRM_ALIGN_L24 =         "Left24Bit";\r
  57 static const char* STRM_ALIGN_R16 =         "Right16Bit";\r
  58 static const char* STRM_ALIGN_R24 =         "Right24Bit";\r
  59 static const char* STRM_ALIGN_SEQUENTIAL =  "Seq";\r
  60 \r
  61 static const char* I2S_PIN_SRXA0 =          "SRXA0";\r
  62 static const char* I2S_PIN_SRXA1 =          "SRXA1";\r
  63 static const char* I2S_PIN_SRXB0 =          "SRXB0";\r
  64 static const char* I2S_PIN_SRXB1 =          "SRXB1";\r
  65 \r
  66 static const char* MUTE_OFF =               "NoMuting";\r
  67 static const char* MUTE_SIGNAL =            "MuteSignal";\r
  68 \r
  69 #define ASSERT_FALSE(func, par) { UcsXml_CB_OnError("Parameter error in attribute=%s value=%s, file=%s, line=%d", 4, func, par,  __FILE__, __LINE__); return false; }\r
  70 #define CHECK_POINTER(PTR) if (NULL == PTR) { ASSERT_FALSE(PTR, "NULL pointer"); }\r
  71 \r
  72 static int32_t Str2Int(const char *val)\r
  73 {\r
  74     return strtol( val, NULL, 0 );\r
  75 }\r
  76 \r
  77 void *MCalloc(struct UcsXmlObjectList *list, uint32_t nElem, uint32_t elemSize)\r
  78 {\r
  79     void *obj;\r
  80     struct UcsXmlObjectList *tail = list;\r
  81     if (NULL == list || 0 == nElem || 0 == elemSize) return NULL;\r
  82 \r
  83     obj = calloc(nElem, elemSize);\r
  84     if (NULL == obj)\r
  85     {\r
  86         assert(false);\r
  87         return NULL;\r
  88     }\r
  89     if (NULL == list->obj)\r
  90     {\r
  91         list->obj = obj;\r
  92         return obj;\r
  93     }\r
  94     while(tail->next) tail = tail->next;\r
  95     tail->next = calloc(1, sizeof(struct UcsXmlObjectList));\r
  96     if (NULL == tail->next)\r
  97     {\r
  98         assert(false);\r
  99         free(obj);\r
 100         return NULL;\r
 101     }\r
 102     tail->next->obj = obj;\r
 103     return obj;\r
 104 }\r
 105 \r
 106 void FreeObjList(struct UcsXmlObjectList *cur)\r
 107 {\r
 108     struct UcsXmlObjectList *root = cur;\r
 109     while(cur)\r
 110     {\r
 111         struct UcsXmlObjectList *next = cur->next;\r
 112         assert(NULL != cur->obj);\r
 113         if (cur->obj)\r
 114             free(cur->obj);\r
 115         if (cur != root)\r
 116             free(cur);\r
 117         cur = next;\r
 118     }\r
 119 }\r
 120 \r
 121 bool GetMostSocket(Ucs_Xrm_MostSocket_t **mostSoc, struct MostSocketParameters *param)\r
 122 {\r
 123     Ucs_Xrm_MostSocket_t *soc = NULL;\r
 124     CHECK_POINTER(mostSoc);\r
 125     CHECK_POINTER(param);\r
 126     CHECK_POINTER(param->list);\r
 127     soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_MostSocket_t));\r
 128     CHECK_POINTER(soc);\r
 129     *mostSoc = soc;\r
 130     soc->resource_type = UCS_XRM_RC_TYPE_MOST_SOCKET;\r
 131     soc->most_port_handle = 0x0D00;\r
 132     soc->bandwidth = param->bandwidth;\r
 133     soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT;\r
 134     switch(param->dataType)\r
 135     {\r
 136     case SYNC_DATA:\r
 137         soc->data_type = UCS_MOST_SCKT_SYNC_DATA;\r
 138         break;\r
 139     case AV_PACKETIZED:\r
 140         soc->data_type = UCS_MOST_SCKT_AV_PACKETIZED;\r
 141         break;\r
 142     case QOS_IP:\r
 143         soc->data_type = UCS_MOST_SCKT_QOS_IP;\r
 144         break;\r
 145     case DISC_FRAME_PHASE:\r
 146         soc->data_type = UCS_MOST_SCKT_DISC_FRAME_PHASE;\r
 147         break;\r
 148     default:\r
 149         ASSERT_FALSE("GetMostSocket->dataType", "");\r
 150     }\r
 151     return true;\r
 152 }\r
 153 \r
 154 bool GetUsbPort(Ucs_Xrm_UsbPort_t **usbPort, struct UsbPortParameters *param)\r
 155 {\r
 156     Ucs_Xrm_UsbPort_t *port = NULL;\r
 157     CHECK_POINTER(usbPort);\r
 158     CHECK_POINTER(param);\r
 159     CHECK_POINTER(param->list);\r
 160     CHECK_POINTER(param->deviceInterfaces);\r
 161     CHECK_POINTER(param->streamInCount);\r
 162     CHECK_POINTER(param->streamOutCount);\r
 163     CHECK_POINTER(param->physicalLayer);\r
 164     port = MCalloc(param->list, 1, sizeof(Ucs_Xrm_UsbPort_t));\r
 165     CHECK_POINTER(port);\r
 166     *usbPort = port;\r
 167     port->resource_type = UCS_XRM_RC_TYPE_USB_PORT;\r
 168     port->index = 0;\r
 169     port->devices_interfaces = (uint16_t)Str2Int(param->deviceInterfaces);\r
 170     port->streaming_if_ep_in_count = (uint8_t)Str2Int(param->streamInCount);\r
 171     port->streaming_if_ep_out_count = (uint8_t)Str2Int(param->streamOutCount);\r
 172     if (0 == strcmp(USB_PHY_STANDARD, param->physicalLayer))\r
 173         port->physical_layer = UCS_USB_PHY_LAYER_STANDARD;\r
 174     else if (0 == strcmp(USB_PHY_HSIC, param->physicalLayer))\r
 175         port->physical_layer = UCS_USB_PHY_LAYER_HSCI;\r
 176     else ASSERT_FALSE("GetUsbPort->physical_layer", param->physicalLayer);\r
 177     return true;\r
 178 }\r
 179 \r
 180 bool GetUsbPortDefaultCreated(Ucs_Xrm_ResObject_t **usbPort, struct UcsXmlObjectList *list)\r
 181 {\r
 182     Ucs_Xrm_DefaultCreatedPort_t *p;\r
 183     CHECK_POINTER(usbPort);\r
 184     CHECK_POINTER(list);\r
 185     p = MCalloc(list, 1, sizeof(Ucs_Xrm_DefaultCreatedPort_t));\r
 186     CHECK_POINTER(p);\r
 187     p->resource_type = UCS_XRM_RC_TYPE_DC_PORT;\r
 188     p->port_type = UCS_XRM_PORT_TYPE_USB;\r
 189     p->index = 0;\r
 190     *usbPort = (Ucs_Xrm_ResObject_t *)p;\r
 191     return true;\r
 192 }\r
 193 \r
 194 bool GetUsbSocket(Ucs_Xrm_UsbSocket_t **usbSoc, struct UsbSocketParameters *param)\r
 195 {\r
 196     Ucs_Xrm_UsbSocket_t *soc = NULL;\r
 197     CHECK_POINTER(usbSoc);\r
 198     CHECK_POINTER(param);\r
 199     CHECK_POINTER(param->list);\r
 200     CHECK_POINTER(param->endpointAddress);\r
 201     CHECK_POINTER(param->framesPerTrans);\r
 202     CHECK_POINTER(param->usbPort);\r
 203     soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_UsbSocket_t));\r
 204     CHECK_POINTER(soc);\r
 205     *usbSoc = soc;\r
 206     soc->resource_type = UCS_XRM_RC_TYPE_USB_SOCKET;\r
 207     soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT;\r
 208     switch(param->dataType)\r
 209     {\r
 210     case SYNC_DATA:\r
 211         soc->data_type = UCS_USB_SCKT_SYNC_DATA;\r
 212         break;\r
 213     case AV_PACKETIZED:\r
 214         soc->data_type = UCS_USB_SCKT_AV_PACKETIZED;\r
 215         break;\r
 216     case IPC_PACKET:\r
 217         soc->data_type = UCS_USB_SCKT_IPC_PACKET;\r
 218         break;\r
 219     default:\r
 220         ASSERT_FALSE("GetUsbSocket->dataType", "");\r
 221     }\r
 222     soc->end_point_addr = (uint8_t)Str2Int(param->endpointAddress);\r
 223     soc->frames_per_transfer = (uint16_t)Str2Int(param->framesPerTrans);\r
 224     soc->usb_port_obj_ptr = param->usbPort;\r
 225     return true;\r
 226 }\r
 227 \r
 228 bool GetMlbPort(Ucs_Xrm_MlbPort_t **mlbPort, struct MlbPortParameters *param)\r
 229 {\r
 230     Ucs_Xrm_MlbPort_t *port = NULL;\r
 231     CHECK_POINTER(mlbPort);\r
 232     CHECK_POINTER(param);\r
 233     CHECK_POINTER(param->list);\r
 234     CHECK_POINTER(param->clockConfig);\r
 235     port = MCalloc(param->list, 1, sizeof(Ucs_Xrm_MlbPort_t));\r
 236     CHECK_POINTER(port);\r
 237     *mlbPort = port;\r
 238     port->resource_type = UCS_XRM_RC_TYPE_MLB_PORT;\r
 239     port->index = 0;\r
 240     if (0 == strcmp(param->clockConfig, CLOCK_256FS))\r
 241         port->clock_config = UCS_MLB_CLK_CFG_256_FS;\r
 242     else if (0 == strcmp(param->clockConfig, CLOCK_512FS))\r
 243         port->clock_config = UCS_MLB_CLK_CFG_512_FS;\r
 244     else if (0 == strcmp(param->clockConfig, CLOCK_1024FS))\r
 245         port->clock_config = UCS_MLB_CLK_CFG_1024_FS;\r
 246     else if (0 == strcmp(param->clockConfig, CLOCK_2048FS))\r
 247         port->clock_config = UCS_MLB_CLK_CFG_2048_FS;\r
 248     else if (0 == strcmp(param->clockConfig, CLOCK_3072FS))\r
 249         port->clock_config = UCS_MLB_CLK_CFG_3072_FS;\r
 250     else if (0 == strcmp(param->clockConfig, CLOCK_4096FS))\r
 251         port->clock_config = UCS_MLB_CLK_CFG_4096_FS;\r
 252     else if (0 == strcmp(param->clockConfig, CLOCK_6144FS))\r
 253         port->clock_config = UCS_MLB_CLK_CFG_6144_FS;\r
 254     else if (0 == strcmp(param->clockConfig, CLOCK_8192FS))\r
 255         port->clock_config = UCS_MLB_CLK_CFG_8192_FS;\r
 256     else ASSERT_FALSE("GetMlbPort->clockConfig", param->clockConfig);\r
 257     return true;\r
 258 }\r
 259 \r
 260 bool GetMlbPortDefaultCreated(Ucs_Xrm_ResObject_t **mlbPort, struct UcsXmlObjectList *list)\r
 261 {\r
 262     Ucs_Xrm_DefaultCreatedPort_t *p;\r
 263     CHECK_POINTER(mlbPort);\r
 264     CHECK_POINTER(list)\r
 265     p = MCalloc(list, 1, sizeof(Ucs_Xrm_DefaultCreatedPort_t));\r
 266     CHECK_POINTER(p);\r
 267     p->resource_type = UCS_XRM_RC_TYPE_DC_PORT;\r
 268     p->port_type = UCS_XRM_PORT_TYPE_MLB;\r
 269     p->index = 0;\r
 270     *mlbPort = (Ucs_Xrm_ResObject_t *)p;\r
 271     return true;\r
 272 }\r
 273 \r
 274 bool GetMlbSocket(Ucs_Xrm_MlbSocket_t **mlbSoc, struct MlbSocketParameters *param)\r
 275 {\r
 276     Ucs_Xrm_MlbSocket_t *soc = NULL;\r
 277     CHECK_POINTER(mlbSoc);\r
 278     CHECK_POINTER(param);\r
 279     CHECK_POINTER(param->list);\r
 280     CHECK_POINTER(param->channelAddress);\r
 281     CHECK_POINTER(param->mlbPort);\r
 282     soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_MlbSocket_t));\r
 283     CHECK_POINTER(soc);\r
 284     *mlbSoc = soc;\r
 285     soc->resource_type = UCS_XRM_RC_TYPE_MLB_SOCKET;\r
 286     soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT;\r
 287     soc->bandwidth = param->bandwidth;\r
 288     switch(param->dataType)\r
 289     {\r
 290     case SYNC_DATA:\r
 291         soc->data_type = UCS_MLB_SCKT_SYNC_DATA;\r
 292         break;\r
 293     case AV_PACKETIZED:\r
 294         soc->data_type = UCS_MLB_SCKT_AV_PACKETIZED;\r
 295         break;\r
 296     case QOS_IP:\r
 297         soc->data_type = UCS_MLB_SCKT_QOS_IP;\r
 298         break;\r
 299     case DISC_FRAME_PHASE:\r
 300         soc->data_type = UCS_MLB_SCKT_DISC_FRAME_PHASE;\r
 301         break;\r
 302     case IPC_PACKET:\r
 303         soc->data_type = UCS_MLB_SCKT_IPC_PACKET;\r
 304         break;\r
 305     default:\r
 306         ASSERT_FALSE("GetMlbSocket->dataType", "");\r
 307     }\r
 308     soc->channel_address = (uint16_t)Str2Int(param->channelAddress);\r
 309     soc->mlb_port_obj_ptr = param->mlbPort;\r
 310     return true;\r
 311 }\r
 312 \r
 313 bool GetStrmPort(Ucs_Xrm_StrmPort_t **strmPort, struct StrmPortParameters *param)\r
 314 {\r
 315     Ucs_Xrm_StrmPort_t *port = NULL;\r
 316     CHECK_POINTER(strmPort);\r
 317     CHECK_POINTER(param);\r
 318     CHECK_POINTER(param->list);\r
 319     CHECK_POINTER(param->clockConfig);\r
 320     port = MCalloc(param->list, 1, sizeof(Ucs_Xrm_StrmPort_t));\r
 321     CHECK_POINTER(port);\r
 322     *strmPort = port;\r
 323     port->resource_type = UCS_XRM_RC_TYPE_STRM_PORT;\r
 324     port->index = param->index;\r
 325     if (0 == port->index)\r
 326     {\r
 327         if (0 == strcmp(param->clockConfig, CLOCK_8FS))\r
 328             port->clock_config = UCS_STREAM_PORT_CLK_CFG_8FS;\r
 329         else if (0 == strcmp(param->clockConfig, CLOCK_16FS))\r
 330             port->clock_config = UCS_STREAM_PORT_CLK_CFG_16FS;\r
 331         else if (0 == strcmp(param->clockConfig, CLOCK_32FS))\r
 332             port->clock_config = UCS_STREAM_PORT_CLK_CFG_32FS;\r
 333         else if (0 == strcmp(param->clockConfig, CLOCK_64FS))\r
 334             port->clock_config = UCS_STREAM_PORT_CLK_CFG_64FS;\r
 335         else if (0 == strcmp(param->clockConfig, CLOCK_128FS))\r
 336             port->clock_config = UCS_STREAM_PORT_CLK_CFG_128FS;\r
 337         else if (0 == strcmp(param->clockConfig, CLOCK_256FS))\r
 338             port->clock_config = UCS_STREAM_PORT_CLK_CFG_256FS;\r
 339         else if (0 == strcmp(param->clockConfig, CLOCK_512FS))\r
 340             port->clock_config = UCS_STREAM_PORT_CLK_CFG_512FS;\r
 341         else if (0 == strcmp(param->clockConfig, CLOCK_WILDCARD))\r
 342             port->clock_config = UCS_STREAM_PORT_CLK_CFG_WILD;\r
 343         else ASSERT_FALSE("GetStrmPort->clockConfig", param->clockConfig);\r
 344     } else {\r
 345         port->clock_config = UCS_STREAM_PORT_CLK_CFG_WILD;\r
 346     }\r
 347 \r
 348     if (0 == strcmp(param->dataAlignment, STRM_ALIGN_L16))\r
 349         port->data_alignment = UCS_STREAM_PORT_ALGN_LEFT16BIT;\r
 350     else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_L24))\r
 351         port->data_alignment = UCS_STREAM_PORT_ALGN_LEFT24BIT;\r
 352     else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_R16))\r
 353         port->data_alignment = UCS_STREAM_PORT_ALGN_RIGHT16BIT;\r
 354     else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_R24))\r
 355         port->data_alignment = UCS_STREAM_PORT_ALGN_RIGHT24BIT;\r
 356     else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_SEQUENTIAL))\r
 357         port->data_alignment = UCS_STREAM_PORT_ALGN_SEQ;\r
 358     else ASSERT_FALSE("GetStrmPort->dataAlignment", param->dataAlignment);\r
 359     return true;\r
 360 }\r
 361 \r
 362 bool GetStrmSocket(Ucs_Xrm_StrmSocket_t **strmSoc, struct StrmSocketParameters *param)\r
 363 {\r
 364     Ucs_Xrm_StrmSocket_t *soc = NULL;\r
 365     CHECK_POINTER(strmSoc);\r
 366     CHECK_POINTER(param);\r
 367     CHECK_POINTER(param->list);\r
 368     CHECK_POINTER(param->streamPin);\r
 369     CHECK_POINTER(param->streamPortA);\r
 370     CHECK_POINTER(param->streamPortB);\r
 371     soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_StrmSocket_t));\r
 372     CHECK_POINTER(soc);\r
 373     *strmSoc = soc;\r
 374     soc->resource_type = UCS_XRM_RC_TYPE_STRM_SOCKET;\r
 375     soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT;\r
 376     switch(param->dataType)\r
 377     {\r
 378     case SYNC_DATA:\r
 379         soc->data_type = UCS_STREAM_PORT_SCKT_SYNC_DATA;\r
 380         break;\r
 381     default:\r
 382         ASSERT_FALSE("GetStrmSocket->dataType", "");\r
 383     }\r
 384     soc->bandwidth = param->bandwidth;\r
 385     if (0 == strcmp(param->streamPin, I2S_PIN_SRXA0))\r
 386     {\r
 387         soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXA0;\r
 388         soc->stream_port_obj_ptr = param->streamPortA;\r
 389         return true;\r
 390     }\r
 391     else if (0 == strcmp(param->streamPin, I2S_PIN_SRXA1))\r
 392     {\r
 393         soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXA1;\r
 394         soc->stream_port_obj_ptr = param->streamPortA;\r
 395         return true;\r
 396     }\r
 397     else if (0 == strcmp(param->streamPin, I2S_PIN_SRXB0))\r
 398     {\r
 399         soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXB0;\r
 400         soc->stream_port_obj_ptr = param->streamPortB;\r
 401         return true;\r
 402     }\r
 403     else if (0 == strcmp(param->streamPin, I2S_PIN_SRXB1))\r
 404     {\r
 405         soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXB1;\r
 406         soc->stream_port_obj_ptr = param->streamPortB;\r
 407         return true;\r
 408     }\r
 409     else ASSERT_FALSE("GetStrmSocket->streamPin", param->streamPin);\r
 410     return true;\r
 411 }\r
 412 \r
 413 bool GetSplitter(Ucs_Xrm_Splitter_t **splitter, struct SplitterParameters *param)\r
 414 {\r
 415     Ucs_Xrm_Splitter_t *split = NULL;\r
 416     CHECK_POINTER(splitter);\r
 417     CHECK_POINTER(param);\r
 418     CHECK_POINTER(param->list);\r
 419     split = MCalloc(param->list, 1, sizeof(Ucs_Xrm_Splitter_t));\r
 420     CHECK_POINTER(split);\r
 421     *splitter = split;\r
 422     split->most_port_handle = 0x0D00;\r
 423     split->resource_type = UCS_XRM_RC_TYPE_SPLITTER;\r
 424     split->bytes_per_frame = param->bytesPerFrame;\r
 425     split->socket_in_obj_ptr = param->inSoc;\r
 426     return true;\r
 427 }\r
 428 \r
 429 bool GetCombiner(Ucs_Xrm_Combiner_t **combiner, struct CombinerParameters *param)\r
 430 {\r
 431     Ucs_Xrm_Combiner_t *comb = NULL;\r
 432     CHECK_POINTER(combiner);\r
 433     CHECK_POINTER(param);\r
 434     CHECK_POINTER(param->list);\r
 435     comb = MCalloc(param->list, 1, sizeof(Ucs_Xrm_Combiner_t));\r
 436     CHECK_POINTER(comb);\r
 437     *combiner = comb;\r
 438     comb->most_port_handle = 0x0D00;\r
 439     comb->resource_type = UCS_XRM_RC_TYPE_COMBINER;\r
 440     comb->bytes_per_frame = param->bytesPerFrame;\r
 441     comb->port_socket_obj_ptr = param->outSoc;\r
 442     return true;\r
 443 }\r
 444 \r
 445 bool GetSyncCon(Ucs_Xrm_SyncCon_t **syncCon, struct SyncConParameters *param)\r
 446 {\r
 447     Ucs_Xrm_SyncCon_t *con = NULL;\r
 448     CHECK_POINTER(syncCon);\r
 449     CHECK_POINTER(param);\r
 450     CHECK_POINTER(param->list);\r
 451     CHECK_POINTER(param->muteMode);\r
 452     CHECK_POINTER(param->inSoc);\r
 453     CHECK_POINTER(param->outSoc);\r
 454     con = MCalloc(param->list, 1, sizeof(Ucs_Xrm_SyncCon_t));\r
 455     CHECK_POINTER(con);\r
 456     *syncCon = con;\r
 457     con->resource_type = UCS_XRM_RC_TYPE_SYNC_CON;\r
 458     if (0 == strcmp(param->muteMode, MUTE_OFF))\r
 459         con->mute_mode = UCS_SYNC_MUTE_MODE_NO_MUTING;\r
 460     else if (0 == strcmp(param->muteMode, MUTE_SIGNAL))\r
 461         con->mute_mode = UCS_SYNC_MUTE_MODE_MUTE_SIGNAL;\r
 462     else ASSERT_FALSE("GetSyncCon->mute_mode", param->muteMode);\r
 463     if (param->optional_offset)\r
 464         con->offset = (uint16_t)Str2Int(param->optional_offset);\r
 465     else\r
 466         con->offset = 0;\r
 467     con->socket_in_obj_ptr = param->inSoc;\r
 468     con->socket_out_obj_ptr = param->outSoc;\r
 469     return true;\r
 470 }\r
 471 \r
 472 bool GetAvpCon(Ucs_Xrm_AvpCon_t **avpCon, struct AvpConParameters *param)\r
 473 {\r
 474     Ucs_Xrm_AvpCon_t *con = NULL;\r
 475     CHECK_POINTER(avpCon);\r
 476     CHECK_POINTER(param);\r
 477     CHECK_POINTER(param->list);\r
 478     CHECK_POINTER(param->inSoc);\r
 479     CHECK_POINTER(param->outSoc);\r
 480     con = MCalloc(param->list, 1, sizeof(Ucs_Xrm_AvpCon_t));\r
 481     CHECK_POINTER(con);\r
 482     *avpCon = con;\r
 483     con->resource_type = UCS_XRM_RC_TYPE_AVP_CON;\r
 484     con->socket_in_obj_ptr = param->inSoc;\r
 485     con->socket_out_obj_ptr = param->outSoc;\r
 486     if (param->optional_isocPacketSize)\r
 487     {\r
 488         int32_t pSize = Str2Int(param->optional_isocPacketSize);\r
 489         switch(pSize)\r
 490         {\r
 491         case 188:\r
 492             con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_188;\r
 493             break;\r
 494         case 196:\r
 495             con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_196;\r
 496             break;\r
 497         case 206:\r
 498             con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_206;\r
 499             break;\r
 500         default:\r
 501             ASSERT_FALSE("GetAvpCon->isoc_packet_size", "");\r
 502         }\r
 503     } else {\r
 504         con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_188;\r
 505     }\r
 506     return true;\r
 507 }\r