1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18 /**
19 * @file pvmf_medialayer_port.cpp
20 * @brief PVMF MediaLayer Port implementation
21 */
22 #ifndef PVMF_MEDIALAYER_PORT_H_INCLUDED
23 #include "pvmf_medialayer_port.h"
24 #endif
25 #ifndef OSCL_MEM_BASIC_FUNCTIONS_H
26 #include "oscl_mem_basic_functions.h"
27 #endif
28 #ifndef OSCL_MIME_STRING_UTILS_H
29 #include "pv_mime_string_utils.h"
30 #endif
31 #ifndef PVMF_NODE_INTERFACE_H_INCLUDED
32 #include "pvmf_node_interface.h"
33 #endif
34 #ifndef PVMF_MEDIALAYER_NODE_H_INCLUDED
35 #include "pvmf_medialayer_node.h"
36 #endif
37 #ifndef PVMF_MEDIA_MSG_FORMAT_IDS_H_INCLUDED
38 #include "pvmf_media_msg_format_ids.h"
39 #endif
40 #ifndef PVMI_KVP_INCLUDED
41 #include "pvmi_kvp.h"
42 #endif
43 #ifndef PVMF_SM_TUNABLES_H_INCLUDED
44 #include "pvmf_sm_tunables.h"
45 #endif
46
47 #define PVMF_ML_PORT_OVERRIDE 1
48
49 ////////////////////////////////////////////////////////////////////////////
PVMFMediaLayerPort(int32 aTag,PVMFNodeInterface * aNode,const char * name)50 PVMFMediaLayerPort::PVMFMediaLayerPort(int32 aTag, PVMFNodeInterface* aNode, const char*name)
51 : PvmfPortBaseImpl(aTag, aNode, name)
52 {
53 iMLNode = (PVMFMediaLayerNode*)aNode;
54 Construct();
55 }
56
57 ////////////////////////////////////////////////////////////////////////////
PVMFMediaLayerPort(int32 aTag,PVMFNodeInterface * aNode,uint32 aInCapacity,uint32 aInReserve,uint32 aInThreshold,uint32 aOutCapacity,uint32 aOutReserve,uint32 aOutThreshold,const char * name)58 PVMFMediaLayerPort::PVMFMediaLayerPort(int32 aTag, PVMFNodeInterface* aNode
59 , uint32 aInCapacity
60 , uint32 aInReserve
61 , uint32 aInThreshold
62 , uint32 aOutCapacity
63 , uint32 aOutReserve
64 , uint32 aOutThreshold
65 , const char*name)
66 : PvmfPortBaseImpl(aTag, aNode, aInCapacity, aInReserve, aInThreshold, aOutCapacity, aOutReserve, aOutThreshold, name)
67 {
68 iMLNode = (PVMFMediaLayerNode*)aNode;
69 Construct();
70 }
71
72 ////////////////////////////////////////////////////////////////////////////
Construct()73 void PVMFMediaLayerPort::Construct()
74 {
75 iLogger = PVLogger::GetLoggerObject("PVMFMediaLayerPort");
76 oscl_memset(&iStats, 0, sizeof(PvmfPortBaseImplStats));
77 /*
78 * Odd numbered ports are output
79 */
80 if (iTag % 2)
81 {
82 iPortType = PVMF_MEDIALAYER_PORT_TYPE_OUTPUT;
83 }
84 /*
85 * Even numbered ports are input
86 */
87 else
88 {
89 iPortType = PVMF_MEDIALAYER_PORT_TYPE_INPUT;
90
91 }
92 }
93
94 ////////////////////////////////////////////////////////////////////////////
~PVMFMediaLayerPort()95 PVMFMediaLayerPort::~PVMFMediaLayerPort()
96 {
97 Disconnect();
98 ClearMsgQueues();
99
100 }
101
102 ////////////////////////////////////////////////////////////////////////////
Connect(PVMFPortInterface * aPort)103 PVMFStatus PVMFMediaLayerPort::Connect(PVMFPortInterface* aPort)
104 {
105 PVMF_MLNODE_LOGINFO((0, "PVMFMediaLayerPort::Connect: aPort=0x%x", aPort));
106
107 if (!aPort)
108 {
109 PVMF_MLNODE_LOGERROR((0, "PVMFMediaLayerPort::Connect: Error - Connecting to invalid port"));
110 return PVMFErrArgument;
111 }
112
113 if (iConnectedPort)
114 {
115 PVMF_MLNODE_LOGERROR((0, "PVMFMediaLayerPort::Connect: Error - Already connected"));
116 return PVMFFailure;
117 }
118
119 if (iPortType == PVMF_MEDIALAYER_PORT_TYPE_OUTPUT)
120 {
121 OsclAny* temp = NULL;
122 aPort->QueryInterface(PVMI_CAPABILITY_AND_CONFIG_PVUUID, temp);
123 PvmiCapabilityAndConfig *config = OSCL_STATIC_CAST(PvmiCapabilityAndConfig*, temp);
124
125 if (config != NULL)
126 {
127 if (!(pvmiSetPortFormatSpecificInfoSync(config, PVMF_FORMAT_SPECIFIC_INFO_KEY)))
128 {
129 PVMF_MLNODE_LOGERROR((0, "PVMFMediaLayerPort::Connect: Error - Unable To Send Format Specific Info To Peer"));
130 return PVMFFailure;
131 }
132 if (!(pvmiSetPortFormatSpecificInfoSync(config, PVMF_DATAPATH_PORT_MAX_NUM_MEDIA_MSGS_KEY)))
133 {
134 PVMF_MLNODE_LOGERROR((0, "PVMFMediaLayerPort::Connect: Error - Unable To Send Max Num Media Msg Key To Peer"));
135 return PVMFFailure;
136 }
137 }
138 }
139
140 /*
141 * Automatically connect the peer.
142 */
143 if (aPort->PeerConnect(this) != PVMFSuccess)
144 {
145 PVMF_MLNODE_LOGERROR((0, "PVMFMediaLayerPort::Connect: Error - Peer Connect failed"));
146 return PVMFFailure;
147 }
148
149 iConnectedPort = aPort;
150
151 PortActivity(PVMF_PORT_ACTIVITY_CONNECT);
152 return PVMFSuccess;
153 }
154
155 ////////////////////////////////////////////////////////////////////////////
getParametersSync(PvmiMIOSession aSession,PvmiKeyType aIdentifier,PvmiKvp * & aParameters,int & num_parameter_elements,PvmiCapabilityContext aContext)156 PVMFStatus PVMFMediaLayerPort::getParametersSync(PvmiMIOSession aSession,
157 PvmiKeyType aIdentifier,
158 PvmiKvp*& aParameters,
159 int& num_parameter_elements,
160 PvmiCapabilityContext aContext)
161 {
162 OSCL_UNUSED_ARG(aSession);
163 OSCL_UNUSED_ARG(aContext);
164
165 PVMF_MLNODE_LOGINFO((0, "PVMFMediaLayerPort::getParametersSync: aSession=0x%x, aIdentifier=%s, aParameters=0x%x, num_parameters_elements=%d, aContext=0x%x",
166 aSession, aIdentifier, aParameters, num_parameter_elements, aContext));
167
168 num_parameter_elements = 0;
169 if (pv_mime_strcmp(aIdentifier, PVMF_FORMAT_SPECIFIC_INFO_KEY) == 0)
170 {
171 if (!pvmiGetPortFormatSpecificInfoSync(PVMF_FORMAT_SPECIFIC_INFO_KEY, aParameters))
172 {
173 return PVMFFailure;
174 }
175 }
176 else if (pv_mime_strcmp(aIdentifier, PVMF_DATAPATH_PORT_MAX_NUM_MEDIA_MSGS_KEY) == 0)
177 {
178 if (!pvmiGetPortFormatSpecificInfoSync(PVMF_DATAPATH_PORT_MAX_NUM_MEDIA_MSGS_KEY, aParameters))
179 {
180 return PVMFFailure;
181 }
182 }
183 num_parameter_elements = 1;
184 return PVMFSuccess;
185 }
186
187
188 ////////////////////////////////////////////////////////////////////////////
releaseParameters(PvmiMIOSession aSession,PvmiKvp * aParameters,int num_elements)189 PVMFStatus PVMFMediaLayerPort::releaseParameters(PvmiMIOSession aSession, PvmiKvp* aParameters, int num_elements)
190 {
191 OSCL_UNUSED_ARG(aSession);
192 OSCL_UNUSED_ARG(num_elements);
193
194 PVMF_MLNODE_LOGINFO((0, "PVMFMediaLayerPort::releaseParameters: aSession=0x%x, aParameters=0x%x, num_elements=%d",
195 aSession, aParameters, num_elements));
196
197 if (pv_mime_strcmp(aParameters->key, PVMF_FORMAT_SPECIFIC_INFO_KEY) == 0)
198 {
199 OsclMemAllocator alloc;
200 alloc.deallocate((OsclAny*)(aParameters->key));
201 return PVMFSuccess;
202 }
203 return PVMFErrNotSupported;
204 }
205
206 ////////////////////////////////////////////////////////////////////////////
setParametersSync(PvmiMIOSession aSession,PvmiKvp * aParameters,int num_elements,PvmiKvp * & aRet_kvp)207 void PVMFMediaLayerPort::setParametersSync(PvmiMIOSession aSession,
208 PvmiKvp* aParameters,
209 int num_elements,
210 PvmiKvp * & aRet_kvp)
211 {
212 OSCL_UNUSED_ARG(aSession);
213 OSCL_UNUSED_ARG(aParameters);
214 OSCL_UNUSED_ARG(num_elements);
215 OSCL_UNUSED_ARG(aRet_kvp);
216
217
218 PVMF_MLNODE_LOGINFO((0, "PVMFMediaLayerPort::getParametersSync: aSession=0x%x, aParameters=0x%x, num_elements=%d, aRet_kvp=0x%x",
219 aSession, aParameters, num_elements, aRet_kvp));
220
221 //OSCL_LEAVE(OsclErrNotSupported);
222 }
223
224 ////////////////////////////////////////////////////////////////////////////
verifyParametersSync(PvmiMIOSession aSession,PvmiKvp * aParameters,int num_elements)225 PVMFStatus PVMFMediaLayerPort::verifyParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters, int num_elements)
226 {
227 OSCL_UNUSED_ARG(aSession);
228 OSCL_UNUSED_ARG(aParameters);
229 OSCL_UNUSED_ARG(num_elements);
230
231
232 PVMF_MLNODE_LOGINFO((0, "PVMFMediaLayerPort::verifyParametersSync: aSession=0x%x, aParameters=0x%x, num_elements=%d",
233 aSession, aParameters, num_elements));
234
235 return PVMFErrNotSupported;
236 }
237
238 ////////////////////////////////////////////////////////////////////////////
freechunkavailable(OsclAny *)239 void PVMFMediaLayerPort::freechunkavailable(OsclAny*)
240 {
241 iMLNode->freechunkavailable(this);
242 }
243
244 ////////////////////////////////////////////////////////////////////////////
245 bool
pvmiSetPortFormatSpecificInfoSync(PvmiCapabilityAndConfig * aPort,const char * aFormatValType)246 PVMFMediaLayerPort::pvmiSetPortFormatSpecificInfoSync(PvmiCapabilityAndConfig *aPort,
247 const char* aFormatValType)
248 {
249 /*
250 * Create PvmiKvp for capability settings
251 */
252 PVMFMediaLayerPortContainer* portContainerPtr = NULL;
253 if (!(iMLNode->GetPortContainer((OSCL_STATIC_CAST(PVMFPortInterface*, this)), portContainerPtr)))
254 {
255 return false;
256 }
257 if (pv_mime_strcmp(aFormatValType, PVMF_FORMAT_SPECIFIC_INFO_KEY) == 0)
258 {
259 OsclMemAllocator alloc;
260 PvmiKvp kvp;
261 kvp.key = NULL;
262 kvp.length = oscl_strlen(aFormatValType) + 1; // +1 for \0
263 kvp.key = (PvmiKeyType)alloc.ALLOCATE(kvp.length);
264 if (kvp.key == NULL)
265 {
266 return false;
267 }
268 oscl_strncpy(kvp.key, aFormatValType, kvp.length);
269 if (portContainerPtr->iTrackConfig.getMemFragSize() == 0)
270 {
271 kvp.value.key_specific_value = 0;
272 kvp.capacity = 0;
273 }
274 else
275 {
276 kvp.value.key_specific_value = (OsclAny*)(portContainerPtr->iTrackConfig.getMemFragPtr());
277 kvp.capacity = portContainerPtr->iTrackConfig.getMemFragSize();
278 }
279 PvmiKvp* retKvp = NULL; // for return value
280 int32 err;
281 OSCL_TRY(err, aPort->setParametersSync(NULL, &kvp, 1, retKvp););
282 /* ignore the error for now */
283 alloc.deallocate((OsclAny*)(kvp.key));
284 return true;
285 }
286 else if (pv_mime_strcmp(aFormatValType, PVMF_DATAPATH_PORT_MAX_NUM_MEDIA_MSGS_KEY) == 0)
287 {
288 OsclMemAllocator alloc;
289 PvmiKvp kvp;
290 kvp.key = NULL;
291 kvp.length = oscl_strlen(aFormatValType) + 1; // +1 for \0
292 kvp.key = (PvmiKeyType)alloc.ALLOCATE(kvp.length);
293 if (kvp.key == NULL)
294 {
295 return false;
296 }
297 oscl_strncpy(kvp.key, aFormatValType, kvp.length);
298
299 kvp.value.uint32_value = MEDIALAYERNODE_MAXNUM_MEDIA_DATA;
300 PvmiKvp* retKvp = NULL; // for return value
301 int32 err;
302 OSCL_TRY(err, aPort->setParametersSync(NULL, &kvp, 1, retKvp););
303 /* ignore the error for now */
304 alloc.deallocate((OsclAny*)(kvp.key));
305 return true;
306 }
307 return false;
308 }
309
310 ////////////////////////////////////////////////////////////////////////////
311 PVMFStatus
pvmiVerifyPortFormatSpecificInfoSync(const char * aFormatValType,OsclAny * aConfig)312 PVMFMediaLayerPort::pvmiVerifyPortFormatSpecificInfoSync(const char* aFormatValType,
313 OsclAny* aConfig)
314 {
315 /*
316 * Create PvmiKvp for capability settings
317 */
318 PVMFStatus status = PVMFErrNotSupported;
319 OsclAny* temp = NULL;
320 iConnectedPort->QueryInterface(PVMI_CAPABILITY_AND_CONFIG_PVUUID, temp);
321 PvmiCapabilityAndConfig *capConfig = OSCL_STATIC_CAST(PvmiCapabilityAndConfig*, temp);
322
323 if (capConfig != NULL)
324 {
325 if (pv_mime_strcmp(aFormatValType, PVMF_FORMAT_SPECIFIC_INFO_KEY) == 0)
326 {
327 OsclRefCounterMemFrag* aFormatValue = (OsclRefCounterMemFrag*)aConfig;
328 if (aFormatValue->getMemFragSize() > 0)
329 {
330 OsclMemAllocator alloc;
331 PvmiKvp kvp;
332 kvp.key = NULL;
333 kvp.length = oscl_strlen(aFormatValType) + 1; // +1 for \0
334 kvp.key = (PvmiKeyType)alloc.ALLOCATE(kvp.length);
335 if (kvp.key == NULL)
336 {
337 return PVMFErrNoMemory;
338 }
339 oscl_strncpy(kvp.key, aFormatValType, kvp.length);
340
341 kvp.value.key_specific_value = (OsclAny*)(aFormatValue->getMemFragPtr());
342 kvp.capacity = aFormatValue->getMemFragSize();
343 int32 err;
344 OSCL_TRY(err, status = capConfig->verifyParametersSync(NULL, &kvp, 1););
345 /* ignore the error for now */
346 alloc.deallocate((OsclAny*)(kvp.key));
347 return status;
348 }
349 }
350 else if (pv_mime_strcmp(aFormatValType, PVMF_BITRATE_VALUE_KEY) == 0 ||
351 pv_mime_strcmp(aFormatValType, PVMF_FRAMERATE_VALUE_KEY) == 0)
352 {
353 if (aConfig != NULL)
354 {
355 OsclMemAllocator alloc;
356 PvmiKvp kvp;
357 kvp.key = NULL;
358 kvp.length = oscl_strlen(aFormatValType) + 1; // +1 for \0
359 kvp.key = (PvmiKeyType)alloc.ALLOCATE(kvp.length);
360 if (kvp.key == NULL)
361 {
362 return PVMFErrNoMemory;
363 }
364 oscl_strncpy(kvp.key, aFormatValType, kvp.length);
365
366 uint32* bitrate = (uint32*)aConfig;
367 kvp.value.uint32_value = *bitrate;
368 int32 err;
369 OSCL_TRY(err, status = capConfig->verifyParametersSync(NULL, &kvp, 1););
370
371 alloc.deallocate((OsclAny*)(kvp.key));
372
373 return status;
374 }
375 }
376 return PVMFErrArgument;
377 }
378 return PVMFFailure;
379 }
380
381 ////////////////////////////////////////////////////////////////////////////
382 bool
pvmiGetPortFormatSpecificInfoSync(const char * aFormatValType,PvmiKvp * & aKvp)383 PVMFMediaLayerPort::pvmiGetPortFormatSpecificInfoSync(const char* aFormatValType,
384 PvmiKvp*& aKvp)
385 {
386 /*
387 * Create PvmiKvp for capability settings
388 */
389 PVMFMediaLayerPortContainer* portContainerPtr = NULL;
390 if (!(iMLNode->GetPortContainer((OSCL_STATIC_CAST(PVMFPortInterface*, this)), portContainerPtr)))
391 {
392 return false;
393 }
394 if (pv_mime_strcmp(aFormatValType, PVMF_FORMAT_SPECIFIC_INFO_KEY) == 0)
395 {
396 OsclMemAllocator alloc;
397 aKvp->key = NULL;
398 aKvp->length = oscl_strlen(aFormatValType) + 1; // +1 for \0
399 aKvp->key = (PvmiKeyType)alloc.ALLOCATE(aKvp->length);
400 if (aKvp->key == NULL)
401 {
402 return false;
403 }
404 oscl_strncpy(aKvp->key, aFormatValType, aKvp->length);
405 if (portContainerPtr->iTrackConfig.getMemFragSize() == 0)
406 {
407 aKvp->value.key_specific_value = 0;
408 aKvp->capacity = 0;
409 }
410 else
411 {
412 aKvp->value.key_specific_value = (OsclAny*)(portContainerPtr->iTrackConfig.getMemFragPtr());
413 aKvp->capacity = portContainerPtr->iTrackConfig.getMemFragSize();
414 }
415 return true;
416 }
417 else if (pv_mime_strcmp(aFormatValType, PVMF_DATAPATH_PORT_MAX_NUM_MEDIA_MSGS_KEY) == 0)
418 {
419 OsclMemAllocator alloc;
420 aKvp->key = NULL;
421 aKvp->length = oscl_strlen(aFormatValType) + 1; // +1 for \0
422 aKvp->key = (PvmiKeyType)alloc.ALLOCATE(aKvp->length);
423 if (aKvp->key == NULL)
424 {
425 return false;
426 }
427 oscl_strncpy(aKvp->key, aFormatValType, aKvp->length);
428 aKvp->value.uint32_value = MEDIALAYERNODE_MAXNUM_MEDIA_DATA;
429 return true;
430 }
431 return false;
432 }
433
434 ////////////////////////////////////////////////////////////////////////////
peekHead(PVMFSharedMediaDataPtr & dataPtr,bool & bEos)435 bool PVMFMediaLayerPort::peekHead(PVMFSharedMediaDataPtr& dataPtr, bool& bEos)
436 {
437 if (iIncomingQueue.iQ.empty())
438 {
439 return false;
440 }
441
442 // get a pointer to the queue head
443 PVMFSharedMediaMsgPtr msg = iIncomingQueue.iQ.front();
444
445 // check the format id first - treat EOS special
446
447 if (msg->getFormatID() == PVMF_MEDIA_CMD_EOS_FORMAT_ID)
448 {
449 bEos = true;
450 }
451 else
452 {
453 convertToPVMFMediaData(dataPtr, msg);
454 bEos = false;
455 }
456
457 return true;
458 }
459
460 ////////////////////////////////////////////////////////////////////////////
QueueOutgoingMsg(PVMFSharedMediaMsgPtr aMsg)461 PVMFStatus PVMFMediaLayerPort::QueueOutgoingMsg(PVMFSharedMediaMsgPtr aMsg)
462 {
463 #if PVMF_ML_PORT_OVERRIDE
464 PVMF_MLNODE_LOGINFO((0, "PVMFMediaLayerPort::QueueOutgoingMsg"));
465
466 //If port is not connected, don't accept data on the
467 //outgoing queue.
468 if (!iConnectedPort)
469 {
470 PVMF_MLNODE_LOGERROR((0, "PVMFMediaLayerPort::QueueOutgoingMsg: Error - Port not connected"));
471 return PVMFFailure;
472 }
473
474 PvmfPortBaseImpl* cpPort = OSCL_STATIC_CAST(PvmfPortBaseImpl*, iConnectedPort);
475
476 // Connected Port incoming Queue is in busy / flushing state. Do not accept more outgoing messages
477 // until the queue is not busy, i.e. queue size drops below specified threshold or FlushComplete
478 // is called.
479 if (cpPort->iIncomingQueue.iBusy)
480 {
481 PVMF_MLNODE_LOGINFO((0, "PVMFMediaLayerPort::QueueOutgoingMsg: Connected Port Incoming queue in busy / flushing state - Attempting to Q in output port's outgoing msg q"));
482 return (PvmfPortBaseImpl::QueueOutgoingMsg(aMsg));
483 }
484 // In case there are data pending in iOutgoingQueue, we should try sending them first.
485 if (!iOutgoingQueue.iQ.empty())
486 {
487 PVMF_MLNODE_LOGINFO((0, "PVMFMediaLayerPort::QueueOutgoingMsg: send pending data first"));
488 PVMFStatus status = PvmfPortBaseImpl::Send();
489 if (status != PVMFSuccess)
490 {
491 PVMF_MLNODE_LOGINFO((0, "PVMFMediaLayerPort::QueueOutgoingMsg: send pending data not success status = %d:", status));
492 return status;
493 }
494 else if (cpPort->iIncomingQueue.iBusy)
495 {
496 PVMF_MLNODE_LOGINFO((0, "PVMFMediaLayerPort::QueueOutgoingMsg: Connected Port Incoming queue in busy / flushing state after sending pending data - Attempting to Q in output port's outgoing msg q"));
497 return (PvmfPortBaseImpl::QueueOutgoingMsg(aMsg));
498 }
499 }
500
501
502 // Add message to outgoing queue and notify the node of the activity
503 // There is no need to trap the push_back, since it cannot leave in this usage
504 // Reason being that we do a reserve in the constructor and we do not let the
505 // port queues grow indefinitely (we either a connected port busy or outgoing Q busy
506 // before we reach the reserved limit
507 PVMFStatus status = cpPort->Receive(aMsg);
508
509 if (status != PVMFSuccess)
510 {
511 return PVMFFailure;
512 }
513
514 // Outgoing queue size is at capacity and goes into busy state. The owner node is
515 // notified of this transition into busy state.
516 if (cpPort->isIncomingFull())
517 {
518 PVMF_MLNODE_LOGINFO((0, "PVMFMediaLayerPort::QueueOutgoingMsg: Connected Port incoming queue is full. Goes into busy state"));
519 cpPort->iIncomingQueue.iBusy = true;
520 PvmfPortBaseImpl::PortActivity(PVMF_PORT_ACTIVITY_CONNECTED_PORT_BUSY);
521 }
522
523 return PVMFSuccess;
524 #else
525 return (PvmfPortBaseImpl::QueueOutgoingMsg(aMsg));
526 #endif
527 }
528
IsOutgoingQueueBusy()529 bool PVMFMediaLayerPort::IsOutgoingQueueBusy()
530 {
531 #if PVMF_ML_PORT_OVERRIDE
532 if (iPortType == PVMF_MEDIALAYER_PORT_TYPE_OUTPUT)
533 {
534 if (iConnectedPort != NULL)
535 {
536 PvmfPortBaseImpl* cpPort = OSCL_STATIC_CAST(PvmfPortBaseImpl*, iConnectedPort);
537 return (cpPort->iIncomingQueue.iBusy);
538 }
539 }
540 return (PvmfPortBaseImpl::IsOutgoingQueueBusy());;
541 #else
542 return (PvmfPortBaseImpl::IsOutgoingQueueBusy());
543 #endif
544 }
545
546
547