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