1 /*------------------------------------------------------------------------------------------------*/
\r
2 /* UNICENS XML Parser */
\r
3 /* Copyright 2017, Microchip Technology Inc. and its subsidiaries. */
\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
8 /* 1. Redistributions of source code must retain the above copyright notice, this */
\r
9 /* list of conditions and the following disclaimer. */
\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
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
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
35 #include "UcsXml_Private.h"
\r
37 static const char* USB_PHY_STANDARD = "Standard";
\r
38 static const char* USB_PHY_HSIC = "HSIC";
\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
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
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
66 static const char* MUTE_OFF = "NoMuting";
\r
67 static const char* MUTE_SIGNAL = "MuteSignal";
\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
72 static int32_t Str2Int(const char *val)
\r
74 return strtol( val, NULL, 0 );
\r
77 void *MCalloc(struct UcsXmlObjectList *list, uint32_t nElem, uint32_t elemSize)
\r
80 struct UcsXmlObjectList *tail = list;
\r
81 if (NULL == list || 0 == nElem || 0 == elemSize) return NULL;
\r
83 obj = calloc(nElem, elemSize);
\r
89 if (NULL == list->obj)
\r
94 while(tail->next) tail = tail->next;
\r
95 tail->next = calloc(1, sizeof(struct UcsXmlObjectList));
\r
96 if (NULL == tail->next)
\r
102 tail->next->obj = obj;
\r
106 void FreeObjList(struct UcsXmlObjectList *cur)
\r
108 struct UcsXmlObjectList *root = cur;
\r
111 struct UcsXmlObjectList *next = cur->next;
\r
112 assert(NULL != cur->obj);
\r
121 bool GetMostSocket(Ucs_Xrm_MostSocket_t **mostSoc, struct MostSocketParameters *param)
\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
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
137 soc->data_type = UCS_MOST_SCKT_SYNC_DATA;
\r
139 case AV_PACKETIZED:
\r
140 soc->data_type = UCS_MOST_SCKT_AV_PACKETIZED;
\r
143 soc->data_type = UCS_MOST_SCKT_QOS_IP;
\r
145 case DISC_FRAME_PHASE:
\r
146 soc->data_type = UCS_MOST_SCKT_DISC_FRAME_PHASE;
\r
149 ASSERT_FALSE("GetMostSocket->dataType", "");
\r
154 bool GetUsbPort(Ucs_Xrm_UsbPort_t **usbPort, struct UsbPortParameters *param)
\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
167 port->resource_type = UCS_XRM_RC_TYPE_USB_PORT;
\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
180 bool GetUsbPortDefaultCreated(Ucs_Xrm_ResObject_t **usbPort, struct UcsXmlObjectList *list)
\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
187 p->resource_type = UCS_XRM_RC_TYPE_DC_PORT;
\r
188 p->port_type = UCS_XRM_PORT_TYPE_USB;
\r
190 *usbPort = (Ucs_Xrm_ResObject_t *)p;
\r
194 bool GetUsbSocket(Ucs_Xrm_UsbSocket_t **usbSoc, struct UsbSocketParameters *param)
\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
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
211 soc->data_type = UCS_USB_SCKT_SYNC_DATA;
\r
213 case AV_PACKETIZED:
\r
214 soc->data_type = UCS_USB_SCKT_AV_PACKETIZED;
\r
217 soc->data_type = UCS_USB_SCKT_IPC_PACKET;
\r
220 ASSERT_FALSE("GetUsbSocket->dataType", "");
\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
228 bool GetMlbPort(Ucs_Xrm_MlbPort_t **mlbPort, struct MlbPortParameters *param)
\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
238 port->resource_type = UCS_XRM_RC_TYPE_MLB_PORT;
\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
260 bool GetMlbPortDefaultCreated(Ucs_Xrm_ResObject_t **mlbPort, struct UcsXmlObjectList *list)
\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
267 p->resource_type = UCS_XRM_RC_TYPE_DC_PORT;
\r
268 p->port_type = UCS_XRM_PORT_TYPE_MLB;
\r
270 *mlbPort = (Ucs_Xrm_ResObject_t *)p;
\r
274 bool GetMlbSocket(Ucs_Xrm_MlbSocket_t **mlbSoc, struct MlbSocketParameters *param)
\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
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
291 soc->data_type = UCS_MLB_SCKT_SYNC_DATA;
\r
293 case AV_PACKETIZED:
\r
294 soc->data_type = UCS_MLB_SCKT_AV_PACKETIZED;
\r
297 soc->data_type = UCS_MLB_SCKT_QOS_IP;
\r
299 case DISC_FRAME_PHASE:
\r
300 soc->data_type = UCS_MLB_SCKT_DISC_FRAME_PHASE;
\r
303 soc->data_type = UCS_MLB_SCKT_IPC_PACKET;
\r
306 ASSERT_FALSE("GetMlbSocket->dataType", "");
\r
308 soc->channel_address = (uint16_t)Str2Int(param->channelAddress);
\r
309 soc->mlb_port_obj_ptr = param->mlbPort;
\r
313 bool GetStrmPort(Ucs_Xrm_StrmPort_t **strmPort, struct StrmPortParameters *param)
\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
323 port->resource_type = UCS_XRM_RC_TYPE_STRM_PORT;
\r
324 port->index = param->index;
\r
325 if (0 == port->index)
\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
345 port->clock_config = UCS_STREAM_PORT_CLK_CFG_WILD;
\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
362 bool GetStrmSocket(Ucs_Xrm_StrmSocket_t **strmSoc, struct StrmSocketParameters *param)
\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
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
379 soc->data_type = UCS_STREAM_PORT_SCKT_SYNC_DATA;
\r
382 ASSERT_FALSE("GetStrmSocket->dataType", "");
\r
384 soc->bandwidth = param->bandwidth;
\r
385 if (0 == strcmp(param->streamPin, I2S_PIN_SRXA0))
\r
387 soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXA0;
\r
388 soc->stream_port_obj_ptr = param->streamPortA;
\r
391 else if (0 == strcmp(param->streamPin, I2S_PIN_SRXA1))
\r
393 soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXA1;
\r
394 soc->stream_port_obj_ptr = param->streamPortA;
\r
397 else if (0 == strcmp(param->streamPin, I2S_PIN_SRXB0))
\r
399 soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXB0;
\r
400 soc->stream_port_obj_ptr = param->streamPortB;
\r
403 else if (0 == strcmp(param->streamPin, I2S_PIN_SRXB1))
\r
405 soc->stream_pin_id = UCS_STREAM_PORT_PIN_ID_SRXB1;
\r
406 soc->stream_port_obj_ptr = param->streamPortB;
\r
409 else ASSERT_FALSE("GetStrmSocket->streamPin", param->streamPin);
\r
413 bool GetSplitter(Ucs_Xrm_Splitter_t **splitter, struct SplitterParameters *param)
\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
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
429 bool GetCombiner(Ucs_Xrm_Combiner_t **combiner, struct CombinerParameters *param)
\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
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
445 bool GetSyncCon(Ucs_Xrm_SyncCon_t **syncCon, struct SyncConParameters *param)
\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
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
467 con->socket_in_obj_ptr = param->inSoc;
\r
468 con->socket_out_obj_ptr = param->outSoc;
\r
472 bool GetAvpCon(Ucs_Xrm_AvpCon_t **avpCon, struct AvpConParameters *param)
\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
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
488 int32_t pSize = Str2Int(param->optional_isocPacketSize);
\r
492 con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_188;
\r
495 con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_196;
\r
498 con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_206;
\r
501 ASSERT_FALSE("GetAvpCon->isoc_packet_size", "");
\r
504 con->isoc_packet_size = UCS_ISOC_PCKT_SIZE_188;
\r