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_Private.h"\r
  35 \r
  36 static const char* USB_PHY_STANDARD =       "Standard";\r
  37 static const char* USB_PHY_HSIC =           "HSIC";\r
  38 \r
  39 static const char* CLOCK_8FS =              "8Fs";\r
  40 static const char* CLOCK_16FS =             "16Fs";\r
  41 static const char* CLOCK_32FS =             "32Fs";\r
  42 static const char* CLOCK_64FS =             "64Fs";\r
  43 static const char* CLOCK_128FS =            "128Fs";\r
  44 static const char* CLOCK_256FS =            "256Fs";\r
  45 static const char* CLOCK_512FS =            "512Fs";\r
  46 static const char* CLOCK_1024FS =           "1024Fs";\r
  47 static const char* CLOCK_2048FS =           "2048Fs";\r
  48 static const char* CLOCK_3072FS =           "3072Fs";\r
  49 static const char* CLOCK_4096FS =           "4096Fs";\r
  50 static const char* CLOCK_6144FS =           "6144Fs";\r
  51 static const char* CLOCK_8192FS =           "8192Fs";\r
  52 static const char* CLOCK_WILDCARD =         "Wildcard";\r
  53 \r
  54 static const char* STRM_ALIGN_L16 =         "Left16Bit";\r
  55 static const char* STRM_ALIGN_L24 =         "Left24Bit";\r
  56 static const char* STRM_ALIGN_R16 =         "Right16Bit";\r
  57 static const char* STRM_ALIGN_R24 =         "Right24Bit";\r
  58 static const char* STRM_ALIGN_SEQUENTIAL =  "Seq";\r
  59 \r
  60 static const char* I2S_PIN_SRXA0 =          "SRXA0";\r
  61 static const char* I2S_PIN_SRXA1 =          "SRXA1";\r
  62 static const char* I2S_PIN_SRXB0 =          "SRXB0";\r
  63 static const char* I2S_PIN_SRXB1 =          "SRXB1";\r
  64 \r
  65 static const char* MUTE_OFF =               "NoMuting";\r
  66 static const char* MUTE_SIGNAL =            "MuteSignal";\r
  67 /*\r
  68 static const char* VAL_TRUE =               "true";\r
  69 static const char* VAL_FALSE =              "false";\r
  70  */\r
  71 \r
  72 #define ASSERT_FALSE() { assert(false); return false; }\r
  73 #define CHECK_POINTER(PTR) if (NULL == PTR) { ASSERT_FALSE(); }\r
  74 \r
  75 static int32_t Str2Int(const char *val)\r
  76 {\r
  77     return strtol( val, NULL, 0 );\r
  78 }\r
  79 \r
  80 void *MCalloc(struct UcsXmlObjectList *list, uint32_t nElem, uint32_t elemSize)\r
  81 {\r
  82     void *obj;\r
  83     struct UcsXmlObjectList *tail = list;\r
  84     if (NULL == list || 0 == nElem || 0 == elemSize) return NULL;\r
  85 \r
  86     obj = calloc(nElem, elemSize);\r
  87     if (NULL == obj)\r
  88     {\r
  89         assert(false);\r
  90         return NULL;\r
  91     }\r
  92     if (NULL == list->obj)\r
  93     {\r
  94         list->obj = obj;\r
  95         return obj;\r
  96     }\r
  97     while(tail->next) tail = tail->next;\r
  98     tail->next = calloc(1, sizeof(struct UcsXmlObjectList));\r
  99     if (NULL == tail->next)\r
 100     {\r
 101         assert(false);\r
 102         free(obj);\r
 103         return NULL;\r
 104     }\r
 105     tail->next->obj = obj;\r
 106     return obj;\r
 107 }\r
 108 \r
 109 void FreeObjList(struct UcsXmlObjectList *cur)\r
 110 {\r
 111     struct UcsXmlObjectList *root = cur;\r
 112     while(cur)\r
 113     {\r
 114         struct UcsXmlObjectList *next = cur->next;\r
 115         assert(NULL != cur->obj);\r
 116         if (cur->obj)\r
 117             free(cur->obj);\r
 118         if (cur != root)\r
 119             free(cur);\r
 120         cur = next;\r
 121     }\r
 122 }\r
 123 \r
 124 bool GetMostSocket(Ucs_Xrm_MostSocket_t **mostSoc, struct MostSocketParameters *param)\r
 125 {\r
 126     Ucs_Xrm_MostSocket_t *soc = NULL;\r
 127     CHECK_POINTER(mostSoc);\r
 128     CHECK_POINTER(param);\r
 129     CHECK_POINTER(param->list);\r
 130     soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_MostSocket_t));\r
 131     CHECK_POINTER(soc);\r
 132     *mostSoc = soc;\r
 133     soc->resource_type = UCS_XRM_RC_TYPE_MOST_SOCKET;\r
 134     soc->most_port_handle = 0x0D00;\r
 135     soc->bandwidth = param->bandwidth;\r
 136     soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT;\r
 137     switch(param->dataType)\r
 138     {\r
 139     case SYNC_DATA:\r
 140         soc->data_type = UCS_MOST_SCKT_SYNC_DATA;\r
 141         break;\r
 142     case AV_PACKETIZED:\r
 143         soc->data_type = UCS_MOST_SCKT_AV_PACKETIZED;\r
 144         break;\r
 145     case QOS_IP:\r
 146         soc->data_type = UCS_MOST_SCKT_QOS_IP;\r
 147         break;\r
 148     case DISC_FRAME_PHASE:\r
 149         soc->data_type = UCS_MOST_SCKT_DISC_FRAME_PHASE;\r
 150         break;\r
 151     default:\r
 152         ASSERT_FALSE();\r
 153     }\r
 154     return true;\r
 155 }\r
 156 \r
 157 bool GetUsbPort(Ucs_Xrm_UsbPort_t **usbPort, struct UsbPortParameters *param)\r
 158 {\r
 159     Ucs_Xrm_UsbPort_t *port = NULL;\r
 160     CHECK_POINTER(usbPort);\r
 161     CHECK_POINTER(param);\r
 162     CHECK_POINTER(param->list);\r
 163     CHECK_POINTER(param->deviceInterfaces);\r
 164     CHECK_POINTER(param->streamInCount);\r
 165     CHECK_POINTER(param->streamOutCount);\r
 166     CHECK_POINTER(param->physicalLayer);\r
 167     port = MCalloc(param->list, 1, sizeof(Ucs_Xrm_UsbPort_t));\r
 168     CHECK_POINTER(port);\r
 169     *usbPort = port;\r
 170     port->resource_type = UCS_XRM_RC_TYPE_USB_PORT;\r
 171     port->index = 0;\r
 172     port->devices_interfaces = (uint16_t)Str2Int(param->deviceInterfaces);\r
 173     port->streaming_if_ep_in_count = (uint8_t)Str2Int(param->streamInCount);\r
 174     port->streaming_if_ep_out_count = (uint8_t)Str2Int(param->streamOutCount);\r
 175     if (0 == strcmp(USB_PHY_STANDARD, param->physicalLayer))\r
 176         port->physical_layer = UCS_USB_PHY_LAYER_STANDARD;\r
 177     else if (0 == strcmp(USB_PHY_HSIC, param->physicalLayer))\r
 178         port->physical_layer = UCS_USB_PHY_LAYER_HSCI;\r
 179     else ASSERT_FALSE();\r
 180     return true;\r
 181 }\r
 182 \r
 183 bool GetUsbPortDefaultCreated(Ucs_Xrm_ResObject_t **usbPort, struct UcsXmlObjectList *list)\r
 184 {\r
 185     Ucs_Xrm_DefaultCreatedPort_t *p;\r
 186     CHECK_POINTER(usbPort);\r
 187     CHECK_POINTER(list);\r
 188     p = MCalloc(list, 1, sizeof(Ucs_Xrm_DefaultCreatedPort_t));\r
 189     CHECK_POINTER(p);\r
 190     p->resource_type = UCS_XRM_RC_TYPE_DC_PORT;\r
 191     p->port_type = UCS_XRM_PORT_TYPE_USB;\r
 192     p->index = 0;\r
 193     *usbPort = (Ucs_Xrm_ResObject_t *)p;\r
 194     return true;\r
 195 }\r
 196 \r
 197 bool GetUsbSocket(Ucs_Xrm_UsbSocket_t **usbSoc, struct UsbSocketParameters *param)\r
 198 {\r
 199     Ucs_Xrm_UsbSocket_t *soc = NULL;\r
 200     CHECK_POINTER(usbSoc);\r
 201     CHECK_POINTER(param);\r
 202     CHECK_POINTER(param->list);\r
 203     CHECK_POINTER(param->endpointAddress);\r
 204     CHECK_POINTER(param->framesPerTrans);\r
 205     CHECK_POINTER(param->usbPort);\r
 206     soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_UsbSocket_t));\r
 207     CHECK_POINTER(soc);\r
 208     *usbSoc = soc;\r
 209     soc->resource_type = UCS_XRM_RC_TYPE_USB_SOCKET;\r
 210     soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT;\r
 211     switch(param->dataType)\r
 212     {\r
 213     case SYNC_DATA:\r
 214         soc->data_type = UCS_USB_SCKT_SYNC_DATA;\r
 215         break;\r
 216     case AV_PACKETIZED:\r
 217         soc->data_type = UCS_USB_SCKT_AV_PACKETIZED;\r
 218         break;\r
 219     case IPC_PACKET:\r
 220         soc->data_type = UCS_USB_SCKT_IPC_PACKET;\r
 221         break;\r
 222     default:\r
 223         ASSERT_FALSE();\r
 224     }\r
 225     soc->end_point_addr = (uint8_t)Str2Int(param->endpointAddress);\r
 226     soc->frames_per_transfer = (uint16_t)Str2Int(param->framesPerTrans);\r
 227     soc->usb_port_obj_ptr = param->usbPort;\r
 228     return true;\r
 229 }\r
 230 \r
 231 bool GetMlbPort(Ucs_Xrm_MlbPort_t **mlbPort, struct MlbPortParameters *param)\r
 232 {\r
 233     Ucs_Xrm_MlbPort_t *port = NULL;\r
 234     CHECK_POINTER(mlbPort);\r
 235     CHECK_POINTER(param);\r
 236     CHECK_POINTER(param->list);\r
 237     CHECK_POINTER(param->clockConfig);\r
 238     port = MCalloc(param->list, 1, sizeof(Ucs_Xrm_MlbPort_t));\r
 239     CHECK_POINTER(port);\r
 240     *mlbPort = port;\r
 241     port->resource_type = UCS_XRM_RC_TYPE_MLB_PORT;\r
 242     port->index = 0;\r
 243     if (0 == strcmp(param->clockConfig, CLOCK_256FS))\r
 244         port->clock_config = UCS_MLB_CLK_CFG_256_FS;\r
 245     else if (0 == strcmp(param->clockConfig, CLOCK_512FS))\r
 246         port->clock_config = UCS_MLB_CLK_CFG_512_FS;\r
 247     else if (0 == strcmp(param->clockConfig, CLOCK_1024FS))\r
 248         port->clock_config = UCS_MLB_CLK_CFG_1024_FS;\r
 249     else if (0 == strcmp(param->clockConfig, CLOCK_2048FS))\r
 250         port->clock_config = UCS_MLB_CLK_CFG_2048_FS;\r
 251     else if (0 == strcmp(param->clockConfig, CLOCK_3072FS))\r
 252         port->clock_config = UCS_MLB_CLK_CFG_3072_FS;\r
 253     else if (0 == strcmp(param->clockConfig, CLOCK_4096FS))\r
 254         port->clock_config = UCS_MLB_CLK_CFG_4096_FS;\r
 255     else if (0 == strcmp(param->clockConfig, CLOCK_6144FS))\r
 256         port->clock_config = UCS_MLB_CLK_CFG_6144_FS;\r
 257     else if (0 == strcmp(param->clockConfig, CLOCK_8192FS))\r
 258         port->clock_config = UCS_MLB_CLK_CFG_8192_FS;\r
 259     else ASSERT_FALSE();\r
 260     return true;\r
 261 }\r
 262 \r
 263 bool GetMlbPortDefaultCreated(Ucs_Xrm_ResObject_t **mlbPort, struct UcsXmlObjectList *list)\r
 264 {\r
 265     Ucs_Xrm_DefaultCreatedPort_t *p;\r
 266     CHECK_POINTER(mlbPort);\r
 267     CHECK_POINTER(list)\r
 268     p = MCalloc(list, 1, sizeof(Ucs_Xrm_DefaultCreatedPort_t));\r
 269     CHECK_POINTER(p);\r
 270     p->resource_type = UCS_XRM_RC_TYPE_DC_PORT;\r
 271     p->port_type = UCS_XRM_PORT_TYPE_MLB;\r
 272     p->index = 0;\r
 273     *mlbPort = (Ucs_Xrm_ResObject_t *)p;\r
 274     return true;\r
 275 }\r
 276 \r
 277 bool GetMlbSocket(Ucs_Xrm_MlbSocket_t **mlbSoc, struct MlbSocketParameters *param)\r
 278 {\r
 279     Ucs_Xrm_MlbSocket_t *soc = NULL;\r
 280     CHECK_POINTER(mlbSoc);\r
 281     CHECK_POINTER(param);\r
 282     CHECK_POINTER(param->list);\r
 283     CHECK_POINTER(param->channelAddress);\r
 284     CHECK_POINTER(param->mlbPort);\r
 285     soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_MlbSocket_t));\r
 286     CHECK_POINTER(soc);\r
 287     *mlbSoc = soc;\r
 288     soc->resource_type = UCS_XRM_RC_TYPE_MLB_SOCKET;\r
 289     soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT;\r
 290     soc->bandwidth = param->bandwidth;\r
 291     switch(param->dataType)\r
 292     {\r
 293     case SYNC_DATA:\r
 294         soc->data_type = UCS_MLB_SCKT_SYNC_DATA;\r
 295         break;\r
 296     case AV_PACKETIZED:\r
 297         soc->data_type = UCS_MLB_SCKT_AV_PACKETIZED;\r
 298         break;\r
 299     case QOS_IP:\r
 300         soc->data_type = UCS_MLB_SCKT_QOS_IP;\r
 301         break;\r
 302     case DISC_FRAME_PHASE:\r
 303         soc->data_type = UCS_MLB_SCKT_DISC_FRAME_PHASE;\r
 304         break;\r
 305     case IPC_PACKET:\r
 306         soc->data_type = UCS_MLB_SCKT_IPC_PACKET;\r
 307         break;\r
 308     default:\r
 309         ASSERT_FALSE();\r
 310     }\r
 311     soc->channel_address = (uint16_t)Str2Int(param->channelAddress);\r
 312     soc->mlb_port_obj_ptr = param->mlbPort;\r
 313     return true;\r
 314 }\r
 315 \r
 316 bool GetStrmPort(Ucs_Xrm_StrmPort_t **strmPort, struct StrmPortParameters *param)\r
 317 {\r
 318     Ucs_Xrm_StrmPort_t *port = NULL;\r
 319     CHECK_POINTER(strmPort);\r
 320     CHECK_POINTER(param);\r
 321     CHECK_POINTER(param->list);\r
 322     CHECK_POINTER(param->clockConfig);\r
 323     port = MCalloc(param->list, 1, sizeof(Ucs_Xrm_StrmPort_t));\r
 324     CHECK_POINTER(port);\r
 325     *strmPort = port;\r
 326     port->resource_type = UCS_XRM_RC_TYPE_STRM_PORT;\r
 327     port->index = param->index;\r
 328     if (0 == port->index)\r
 329     {\r
 330         if (0 == strcmp(param->clockConfig, CLOCK_8FS))\r
 331             port->clock_config = UCS_STREAM_PORT_CLK_CFG_8FS;\r
 332         else if (0 == strcmp(param->clockConfig, CLOCK_16FS))\r
 333             port->clock_config = UCS_STREAM_PORT_CLK_CFG_16FS;\r
 334         else if (0 == strcmp(param->clockConfig, CLOCK_32FS))\r
 335             port->clock_config = UCS_STREAM_PORT_CLK_CFG_32FS;\r
 336         else if (0 == strcmp(param->clockConfig, CLOCK_64FS))\r
 337             port->clock_config = UCS_STREAM_PORT_CLK_CFG_64FS;\r
 338         else if (0 == strcmp(param->clockConfig, CLOCK_128FS))\r
 339             port->clock_config = UCS_STREAM_PORT_CLK_CFG_128FS;\r
 340         else if (0 == strcmp(param->clockConfig, CLOCK_256FS))\r
 341             port->clock_config = UCS_STREAM_PORT_CLK_CFG_256FS;\r
 342         else if (0 == strcmp(param->clockConfig, CLOCK_512FS))\r
 343             port->clock_config = UCS_STREAM_PORT_CLK_CFG_512FS;\r
 344         else if (0 == strcmp(param->clockConfig, CLOCK_WILDCARD))\r
 345             port->clock_config = UCS_STREAM_PORT_CLK_CFG_WILD;\r
 346         else ASSERT_FALSE();\r
 347     } else {\r
 348         port->clock_config = UCS_STREAM_PORT_CLK_CFG_WILD;\r
 349     }\r
 350 \r
 351     if (0 == strcmp(param->dataAlignment, STRM_ALIGN_L16))\r
 352         port->data_alignment = UCS_STREAM_PORT_ALGN_LEFT16BIT;\r
 353     else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_L24))\r
 354         port->data_alignment = UCS_STREAM_PORT_ALGN_LEFT24BIT;\r
 355     else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_R16))\r
 356         port->data_alignment = UCS_STREAM_PORT_ALGN_RIGHT16BIT;\r
 357     else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_R24))\r
 358         port->data_alignment = UCS_STREAM_PORT_ALGN_RIGHT24BIT;\r
 359     else if (0 == strcmp(param->dataAlignment, STRM_ALIGN_SEQUENTIAL))\r
 360         port->data_alignment = UCS_STREAM_PORT_ALGN_SEQ;\r
 361     else ASSERT_FALSE();\r
 362     return true;\r
 363 }\r
 364 \r
 365 bool GetStrmSocket(Ucs_Xrm_StrmSocket_t **strmSoc, struct StrmSocketParameters *param)\r
 366 {\r
 367     Ucs_Xrm_StrmSocket_t *soc = NULL;\r
 368     CHECK_POINTER(strmSoc);\r
 369     CHECK_POINTER(param);\r
 370     CHECK_POINTER(param->list);\r
 371     CHECK_POINTER(param->streamPin);\r
 372     CHECK_POINTER(param->streamPortA);\r
 373     CHECK_POINTER(param->streamPortB);\r
 374     soc = MCalloc(param->list, 1, sizeof(Ucs_Xrm_StrmSocket_t));\r
 375     CHECK_POINTER(soc);\r
 376     *strmSoc = soc;\r
 377     soc->resource_type = UCS_XRM_RC_TYPE_STRM_SOCKET;\r
 378     soc->direction = param->isSource ? UCS_SOCKET_DIR_INPUT : UCS_SOCKET_DIR_OUTPUT;\r
 379     switch(param->dataType)\r
 380     {\r
 381     case SYNC_DATA:\r
 382         soc->data_type = UCS_STREAM_PORT_SCKT_SYNC_DATA;\r
 383         break;\r
 384     default:\r
 385         ASSERT_FALSE();\r
 386     }\r
 387     soc->bandwidth = param->bandwidth;\r
 388     if (0 == strcmp(param->streamPin, I2S_PIN_SRXA0))\r
 389     {\r
 390         soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXA0;\r
 391         soc->stream_port_obj_ptr = param->streamPortA;\r
 392         return true;\r
 393     }\r
 394     else if (0 == strcmp(param->streamPin, I2S_PIN_SRXA1))\r
 395     {\r
 396         soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXA1;\r
 397         soc->stream_port_obj_ptr = param->streamPortA;\r
 398         return true;\r
 399     }\r
 400     else if (0 == strcmp(param->streamPin, I2S_PIN_SRXB0))\r
 401     {\r
 402         soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXB0;\r
 403         soc->stream_port_obj_ptr = param->streamPortB;\r
 404         return true;\r
 405     }\r
 406     else if (0 == strcmp(param->streamPin, I2S_PIN_SRXB1))\r
 407     {\r
 408         soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXB1;\r
 409         soc->stream_port_obj_ptr = param->streamPortB;\r
 410         return true;\r
 411     }\r
 412     else ASSERT_FALSE();\r
 413     return true;\r
 414 }\r
 415 \r
 416 bool GetSplitter(Ucs_Xrm_Splitter_t **splitter, struct SplitterParameters *param)\r
 417 {\r
 418     Ucs_Xrm_Splitter_t *split = NULL;\r
 419     CHECK_POINTER(splitter);\r
 420     CHECK_POINTER(param);\r
 421     CHECK_POINTER(param->list);\r
 422     split = MCalloc(param->list, 1, sizeof(Ucs_Xrm_Splitter_t));\r
 423     CHECK_POINTER(split);\r
 424     *splitter = split;\r
 425     split->most_port_handle = 0x0D00;\r
 426     split->resource_type = UCS_XRM_RC_TYPE_SPLITTER;\r
 427     split->bytes_per_frame = param->bytesPerFrame;\r
 428     split->socket_in_obj_ptr = param->inSoc;\r
 429     return true;\r
 430 }\r
 431 \r
 432 bool GetCombiner(Ucs_Xrm_Combiner_t **combiner, struct CombinerParameters *param)\r
 433 {\r
 434     Ucs_Xrm_Combiner_t *comb = NULL;\r
 435     CHECK_POINTER(combiner);\r
 436     CHECK_POINTER(param);\r
 437     CHECK_POINTER(param->list);\r
 438     comb = MCalloc(param->list, 1, sizeof(Ucs_Xrm_Combiner_t));\r
 439     CHECK_POINTER(comb);\r
 440     *combiner = comb;\r
 441     comb->most_port_handle = 0x0D00;\r
 442     comb->resource_type = UCS_XRM_RC_TYPE_COMBINER;\r
 443     comb->bytes_per_frame = param->bytesPerFrame;\r
 444     comb->port_socket_obj_ptr = param->outSoc;\r
 445     return true;\r
 446 }\r
 447 \r
 448 bool GetSyncCon(Ucs_Xrm_SyncCon_t **syncCon, struct SyncConParameters *param)\r
 449 {\r
 450     Ucs_Xrm_SyncCon_t *con = NULL;\r
 451     CHECK_POINTER(syncCon);\r
 452     CHECK_POINTER(param);\r
 453     CHECK_POINTER(param->list);\r
 454     CHECK_POINTER(param->muteMode);\r
 455     CHECK_POINTER(param->inSoc);\r
 456     CHECK_POINTER(param->outSoc);\r
 457     con = MCalloc(param->list, 1, sizeof(Ucs_Xrm_SyncCon_t));\r
 458     CHECK_POINTER(con);\r
 459     *syncCon = con;\r
 460     con->resource_type = UCS_XRM_RC_TYPE_SYNC_CON;\r
 461     if (0 == strcmp(param->muteMode, MUTE_OFF))\r
 462         con->mute_mode = UCS_SYNC_MUTE_MODE_NO_MUTING;\r
 463     else if (0 == strcmp(param->muteMode, MUTE_SIGNAL))\r
 464         con->mute_mode = UCS_SYNC_MUTE_MODE_MUTE_SIGNAL;\r
 465     else ASSERT_FALSE();\r
 466     if (param->optional_offset)\r
 467         con->offset = (uint16_t)Str2Int(param->optional_offset);\r
 468     else\r
 469         con->offset = 0;\r
 470     con->socket_in_obj_ptr = param->inSoc;\r
 471     con->socket_out_obj_ptr = param->outSoc;\r
 472     return true;\r
 473 }\r
 474 \r
 475 bool GetAvpCon(Ucs_Xrm_AvpCon_t **avpCon, struct AvpConParameters *param)\r
 476 {\r
 477     Ucs_Xrm_AvpCon_t *con = NULL;\r
 478     CHECK_POINTER(avpCon);\r
 479     CHECK_POINTER(param);\r
 480     CHECK_POINTER(param->list);\r
 481     CHECK_POINTER(param->inSoc);\r
 482     CHECK_POINTER(param->outSoc);\r
 483     con = MCalloc(param->list, 1, sizeof(Ucs_Xrm_AvpCon_t));\r
 484     CHECK_POINTER(con);\r
 485     *avpCon = con;\r
 486     con->resource_type = UCS_XRM_RC_TYPE_AVP_CON;\r
 487     con->socket_in_obj_ptr = param->inSoc;\r
 488     con->socket_out_obj_ptr = param->outSoc;\r
 489     if (param->optional_isocPacketSize)\r
 490     {\r
 491         int32_t pSize = Str2Int(param->optional_isocPacketSize);\r
 492         switch(pSize)\r
 493         {\r
 494         case 188:\r
 495             con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_188;\r
 496             break;\r
 497         case 196:\r
 498             con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_196;\r
 499             break;\r
 500         case 206:\r
 501             con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_206;\r
 502             break;\r
 503         default:\r
 504             ASSERT_FALSE();\r
 505         }\r
 506     } else {\r
 507         con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_188;\r
 508     }\r
 509     return true;\r
 510 }