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