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 //
20 // This Software is an original work of authorship of PacketVideo Corporation.
21 // Portions of the Software were developed in collaboration with NTT DoCoMo,
22 // Inc. or were derived from the public domain or materials licensed from
23 // third parties. Title and ownership, including all intellectual property
24 // rights in and to the Software shall remain with PacketVideo Corporation
25 // and NTT DoCoMo, Inc.
26 //
27 // -----------------------------------------------------------------------
28
29 #include "h223.h"
30 #include "tsc_h324m_config.h"
31 #include "tsc_component.h"
32 #include "tsc_constants.h"
33 #include "tsc_statemanager.h"
34 #include "tsc_capability.h"
35 #include "tsc_lc.h"
36 #include "tsc_blc.h"
37 #include "tsc_clc.h"
38 #include "tsc_channelcontrol.h"
39 #include "tsc_mt.h"
40 #ifdef MEM_TRACK
41 #include "oscl_mem.h"
42 #include "oscl_mem_audit.h"
43 #endif
44
45
46
47 #define PV_2WAY_TSC_WAIT_FOR_OBLC_TIMER_ID "PV_2WAY_TSC_WAIT_FOR_OBLC_TIMER"
48 #define PV_2WAY_TSC_WAIT_FOR_OBLC_TIMER_INTERVAL 1 /* 1 s */
49
50 #define TSC_MAX_OUTSTANDING_PREFMSG_PDUS 32
51
52
TSC_component(TSC_statemanager & aTSCStateManager,TSC_capability & aTSCcapability,TSC_lc & aTSClc,TSC_blc & aTSCblc,TSC_clc & aTSCclc,TSC_mt & aTSCmt)53 TSC_component::TSC_component(TSC_statemanager& aTSCStateManager,
54 TSC_capability& aTSCcapability,
55 TSC_lc& aTSClc,
56 TSC_blc& aTSCblc,
57 TSC_clc& aTSCclc,
58 TSC_mt& aTSCmt):
59 iTSCstatemanager(aTSCStateManager),
60 iTSCcapability(aTSCcapability),
61 iTSClc(aTSClc),
62 iTSCblc(aTSCblc),
63 iTSCclc(aTSCclc),
64 iTSCmt(aTSCmt),
65 iH245(NULL),
66 iH223(NULL),
67 iLocalTcs(NULL),
68 iWaitingForOblcTimer(NULL),
69 iOutgoingChannelConfig(NULL),
70 iIncomingChannelConfig(NULL),
71 iTSCObserver(NULL),
72 iTSCchannelcontrol(iOlcs, aTSCStateManager, aTSCblc,
73 aTSCmt, aTSClc, aTSCcapability, aTSCclc, *this)
74 {
75 iLogger = PVLogger::GetLoggerObject("3g324m.h245user");
76 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
77 (0, "TSC_component::TSC_component"));
78
79 }
80
SetMembers(H245 * aH245,H223 * aH223,TSCObserver * aTSCObserver)81 void TSC_component::SetMembers(H245* aH245, H223* aH223, TSCObserver* aTSCObserver)
82 {
83 iTSCObserver = aTSCObserver;
84 iTSCchannelcontrol.SetMembers(aH223, aTSCObserver);
85 iH245 = aH245;
86 iH223 = aH223;
87 MembersSet();
88 }
89
90
InitVarsSession()91 void TSC_component::InitVarsSession()
92 {
93 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
94 (0, "TSC_component::InitVarsSession"));
95 iRemoteAl1Audio = OFF;
96 iRemoteAl2Audio = OFF;
97 iRemoteAl3Audio = OFF;
98 iRemoteAl1Video = OFF;
99 iRemoteAl2Video = OFF;
100 iRemoteAl3Video = OFF;
101 iVideoLayer = PVT_AL_UNKNOWN;
102 if (iLocalTcs)
103 {
104 Delete_TerminalCapabilitySet(iLocalTcs);
105 OSCL_DEFAULT_FREE(iLocalTcs);
106 iLocalTcs = NULL;
107 }
108 iRemoteTcs.Unbind();
109
110 iOlcs.SetCurrLcn(FIRST_OUTGOING_LCN);
111 }
112
InitVarsLocal()113 void TSC_component::InitVarsLocal()
114 {
115 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
116 (0, "TSC_component::InitVarsLocal"));
117 iAl3ControlFieldOctets = DEFAULT_AL3_CONTROL_FIELD_OCTETS;
118 iAl2WithSn = true;
119
120 iAllowAl1Video = ON;
121 iAllowAl2Video = ON;
122 iAllowAl3Video = ON;
123 iAllowAl1Audio = OFF;
124 iAllowAl2Audio = ON;
125 iAllowAl3Audio = OFF;
126 iUseAl1Video = true;
127 iUseAl2Video = true;
128 iUseAl3Video = true;
129 }
130
InitTsc()131 void TSC_component::InitTsc()
132 {
133 iWaitingForOblcTimer = OSCL_NEW(OsclTimer<OsclMemAllocator>,
134 (PV_2WAY_TSC_WAIT_FOR_OBLC_TIMER_ID, PV_2WAY_TSC_WAIT_FOR_OBLC_TIMER_INTERVAL));
135 iWaitingForOblcTimer->SetObserver(this);
136 }
137
ResetTsc()138 void TSC_component::ResetTsc()
139 {
140 if (iOutgoingChannelConfig)
141 {
142 OSCL_DELETE(iOutgoingChannelConfig);
143 iOutgoingChannelConfig = NULL;
144 }
145
146 if (iIncomingChannelConfig)
147 {
148 OSCL_DELETE(iIncomingChannelConfig);
149 iIncomingChannelConfig = NULL;
150 }
151
152 if (iWaitingForOblcTimer)
153 {
154 iWaitingForOblcTimer->Clear();
155 OSCL_DELETE(iWaitingForOblcTimer);
156 iWaitingForOblcTimer = NULL;
157 }
158 }
159
Disconnect()160 void TSC_component::Disconnect()
161 {
162
163 iWaitingForOblcTimer->Clear();
164 }
165
GenerateSingleDescriptor(uint8 entry_num,TPVChannelId lcn1)166 CPVMultiplexEntryDescriptor* TSC_component::GenerateSingleDescriptor(uint8 entry_num,
167 TPVChannelId lcn1)
168 {
169 PS_MultiplexEntryDescriptor h245_desc =
170 (PS_MultiplexEntryDescriptor)OSCL_DEFAULT_MALLOC(sizeof(S_MultiplexEntryDescriptor));
171 h245_desc->multiplexTableEntryNumber = entry_num;
172 h245_desc->option_of_elementList = true;
173 h245_desc->size_of_elementList = 1;
174 h245_desc->elementList =
175 (PS_MultiplexElement)OSCL_DEFAULT_MALLOC(sizeof(S_MultiplexElement));
176
177 PS_MultiplexElement elem = h245_desc->elementList;
178 elem->muxType.index = 0; // logical channel = 0, 1 = sub-elem list
179 elem->muxType.logicalChannelNumber = (uint16)lcn1;
180 elem->muxType.size = 1; // size of element list
181 elem->repeatCount.index = 1; // ucf
182 elem->repeatCount.finite = 0;
183
184 CPVMultiplexEntryDescriptor* ret =
185 CPVMultiplexEntryDescriptor::NewL(h245_desc, 128);
186 Delete_MultiplexEntryDescriptor(h245_desc);
187 OSCL_DEFAULT_FREE(h245_desc);
188
189 return ret;
190 }
191
192 PS_AdaptationLayerType
GetOutgoingLayer(PV2WayMediaType media_type,uint32 max_sample_size)193 TSC_component::GetOutgoingLayer(PV2WayMediaType media_type, uint32 max_sample_size)
194 {
195 PS_AdaptationLayerType al_type =
196 (PS_AdaptationLayerType)OSCL_DEFAULT_MALLOC(sizeof(S_AdaptationLayerType));
197 int room_for_sn = 0;
198
199 oscl_memset(al_type, 0, sizeof(S_AdaptationLayerType));
200 uint32 max_sdu_size = 0;
201 switch (media_type)
202 {
203 case PV_AUDIO:
204 if (iRemoteAl2Audio)
205 {
206 max_sdu_size = iH223->GetSduSize(OUTGOING, E_EP_MEDIUM);
207 room_for_sn = max_sdu_size - max_sample_size - 1; /* 1 byte for CRC */
208 room_for_sn = (room_for_sn > 1) ? 1 : room_for_sn;
209 if (room_for_sn >= 0)
210 {
211 al_type->index = (uint16)(3 + room_for_sn);
212 return al_type;
213 }
214 }
215 if (iRemoteAl3Audio)
216 {
217 max_sdu_size = iH223->GetSduSize(OUTGOING, E_EP_HIGH);
218 room_for_sn = max_sdu_size - max_sample_size - 2; /* 2 bytes for CRC */
219 if (room_for_sn >= 0)
220 {
221 PS_Al3 al3 = (PS_Al3)OSCL_DEFAULT_MALLOC(sizeof(S_Al3));
222 al3->controlFieldOctets = (int8)((room_for_sn >
223 (int)iAl3ControlFieldOctets) ? iAl3ControlFieldOctets : room_for_sn);
224 al3->sendBufferSize = DEF_AL3_SEND_BUFFER_SIZE;
225 al_type->index = 5;
226 al_type->al3 = al3;
227 return al_type;
228 }
229 }
230 if (iRemoteAl1Audio)
231 {
232 max_sdu_size = iH223->GetSduSize(OUTGOING, E_EP_LOW);
233 room_for_sn = max_sdu_size - max_sample_size;
234 room_for_sn = (room_for_sn > 1) ? 1 : room_for_sn;
235 if (max_sdu_size >= max_sample_size)
236 {
237 al_type->index = 1;
238 return al_type;
239 }
240 }
241 break;
242 case PV_VIDEO:
243 if (iUseAl2Video && iRemoteAl2Video)
244 {
245 al_type->index = (uint16)(iAl2WithSn ? 4 : 3);
246 return al_type;
247 }
248 if (iUseAl3Video && iRemoteAl3Video)
249 {
250 PS_Al3 al3 = (PS_Al3)OSCL_DEFAULT_MALLOC(sizeof(S_Al3));
251 al3->controlFieldOctets = (int8)iAl3ControlFieldOctets;
252 al3->sendBufferSize = DEF_AL3_SEND_BUFFER_SIZE;
253 al_type->index = 5;
254 al_type->al3 = al3;
255 return al_type;
256 }
257 if (iUseAl1Video && iRemoteAl1Video)
258 {
259 al_type->index = 1;
260 return al_type;
261 }
262 break;
263 default:
264 break;
265 }
266 OSCL_DEFAULT_FREE(al_type);
267 return NULL;
268 }
269
SetAlConfig(PV2WayMediaType media_type,TPVAdaptationLayer layer,bool allow)270 void TSC_component::SetAlConfig(PV2WayMediaType media_type,
271 TPVAdaptationLayer layer,
272 bool allow)
273 {
274 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
275 (0, "TSC_component::SetAlConfig"));
276 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
277 (0, "TSC_component::SetAlConfig media type(%d), layer(%d), allow(%d)",
278 media_type, layer, allow));
279
280 switch (media_type)
281 {
282 case PV_AUDIO:
283 if (layer == PVT_AL1)
284 iAllowAl1Audio = allow;
285 else if (layer == PVT_AL2)
286 iAllowAl2Audio = allow;
287 else if (layer == PVT_AL3)
288 iAllowAl3Audio = allow;
289 break;
290 case PV_VIDEO:
291 if (layer == PVT_AL1)
292 iAllowAl1Video = allow;
293 else if (layer == PVT_AL2)
294 iAllowAl2Video = allow;
295 else if (layer == PVT_AL3)
296 iAllowAl3Video = allow;
297 break;
298 case PV_DATA:
299 default:
300 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
301 (0, "TSC_component::SetAlConfig Invalid media type"));
302 }
303 }
304
305 //////////////////////////////////////////////////////////////////////////
306 // Start the CE process by sending this terminals capabilites to the peer terminal
307 //////////////////////////////////////////////////////////////////////////
CEStart()308 bool TSC_component::CEStart()
309 {
310 if (!iIncomingChannelConfig || !iIncomingChannelConfig->size())
311 {
312 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
313 (0, "TSC_component::CEStart- Incoming channel config not set"));
314 return false;
315 }
316
317 iTSCstatemanager.WriteState(TSC_CE_SEND, STARTED);
318
319 MultiplexCapabilityInfo mux_cap_info;
320 mux_cap_info.iAllowAl1Video = iAllowAl1Video;
321 mux_cap_info.iAllowAl2Video = iAllowAl2Video;
322 mux_cap_info.iAllowAl3Video = iAllowAl3Video;
323 mux_cap_info.iAllowAl1Audio = iAllowAl1Audio;
324 mux_cap_info.iAllowAl2Audio = iAllowAl2Audio;
325 mux_cap_info.iAllowAl3Audio = iAllowAl3Audio;
326 mux_cap_info.iMaximumAl2SDUSize = iH223->GetSduSize(INCOMING, E_EP_MEDIUM);
327 mux_cap_info.iMaximumAl3SDUSize = iH223->GetSduSize(INCOMING, E_EP_HIGH);
328 Oscl_Vector<CodecCapabilityInfo*, OsclMemAllocator> outgoing_codecs;
329 Oscl_Vector<CodecCapabilityInfo*, OsclMemAllocator> incoming_codecs;
330 for (unsigned n = 0; n < iIncomingChannelConfig->size(); n++)
331 {
332 Oscl_Vector<FormatCapabilityInfo, OsclMemAllocator>* codecs =
333 (*iIncomingChannelConfig)[n].GetCodecs();
334 if (!codecs)
335 {
336 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
337 (0, "TSC_component::CEStart No codecs specified for format type(%d)",
338 (*iIncomingChannelConfig)[n].GetMediaType()));
339 continue;
340 }
341 for (unsigned m = 0; m < codecs->size(); m++)
342 {
343 CodecCapabilityInfo* info = NULL;
344 PVCodecType_t codec_type = PVMFFormatTypeToPVCodecType((*codecs)[m].format);
345 TPVDirection dir = (*codecs)[m].dir;
346 if (GetMediaType(codec_type) == PV_VIDEO)
347 {
348 info = new VideoCodecCapabilityInfo;
349 ((VideoCodecCapabilityInfo*)info)->resolutions =
350 iTSCcapability.GetResolutions(dir);
351 }
352 else
353 {
354 info = new CodecCapabilityInfo;
355 }
356 info->codec = codec_type;
357 info->dir = dir;
358 incoming_codecs.push_back(info);
359 }
360 }
361 if (iLocalTcs)
362 {
363 Delete_TerminalCapabilitySet(iLocalTcs);
364 OSCL_DEFAULT_FREE(iLocalTcs);
365 iLocalTcs = NULL;
366 }
367 iLocalTcs = GenerateTcs(mux_cap_info, outgoing_codecs, incoming_codecs);
368 CustomGenerateTcs(iLocalTcs);
369
370 CE* Ce = iH245->GetCE();
371 if (Ce) Ce->TransferRequest(iLocalTcs);
372
373 for (unsigned i = 0; i < incoming_codecs.size(); i++)
374 {
375 delete incoming_codecs[i];
376 }
377 return true;
378 }
379
SetTerminalParam(CPVTerminalParam & params)380 TPVStatusCode TSC_component::SetTerminalParam(CPVTerminalParam& params)
381 {
382 CPVH324MParam* h324params = (CPVH324MParam*) & params;
383 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
384 (0, "TSC_component:SetTerminalParam - AL1(%d), AL2(%d), AL3(%d)",
385 h324params->iAllowAl1Video,
386 h324params->iAllowAl2Video,
387 h324params->iAllowAl3Video));
388
389 iAllowAl1Video = h324params->iAllowAl1Video;
390 iAllowAl2Video = h324params->iAllowAl2Video;
391 iAllowAl3Video = h324params->iAllowAl3Video;
392 iUseAl1Video = h324params->iUseAl1Video;
393 iUseAl2Video = h324params->iUseAl2Video;
394 iUseAl3Video = h324params->iUseAl3Video;
395
396 iVideoLayer = h324params->iVideoLayer;
397
398 return EPVT_Success;
399 }
400
GetTerminalParam(CPVH324MParam & ah324param)401 void TSC_component::GetTerminalParam(CPVH324MParam& ah324param)
402 {
403 ah324param.iAllowAl1Video = iAllowAl1Video ? true : false;
404 ah324param.iAllowAl2Video = iAllowAl2Video ? true : false;
405 ah324param.iAllowAl3Video = iAllowAl3Video ? true : false;
406 ah324param.iVideoLayer = iVideoLayer;
407 }
408
IsSupported(TPVDirection dir,PVCodecType_t codec,FormatCapabilityInfo & capability_info)409 bool TSC_component::IsSupported(TPVDirection dir,
410 PVCodecType_t codec,
411 FormatCapabilityInfo& capability_info)
412 {
413 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
414 (0, "TSC_component::IsSupported dir(%d), codec(%d)", dir, codec));
415 if (codec == PV_CODEC_TYPE_NONE)
416 {
417 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
418 (0, "TSC_component::IsSupported No codec is always ok"));
419 return true;
420 }
421 Oscl_Vector<H324ChannelParameters, PVMFTscAlloc>* config = (dir == OUTGOING) ?
422 iOutgoingChannelConfig : iIncomingChannelConfig;
423 if (!config)
424 {
425 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
426 (0, "TSC_component::IsSupported No config available"));
427 return false;
428 }
429 for (unsigned n = 0; n < config->size(); n++)
430 {
431 H324ChannelParameters& param = (*config)[n];
432 if (param.GetMediaType() != GetMediaType(codec))
433 continue;
434 Oscl_Vector<FormatCapabilityInfo, OsclMemAllocator>* codecs = param.GetCodecs();
435 if (!codecs)
436 {
437 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
438 (0, "TSC_component::IsSupported No codecs specified"));
439 return false;
440 }
441 for (unsigned m = 0; m < codecs->size(); m++)
442 {
443 if ((*codecs)[m].format == PVCodecTypeToPVMFFormatType(codec))
444 {
445 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
446 (0, "TSC_component::IsSupported Match found"));
447 capability_info = (*codecs)[m];
448 return true;
449 }
450 }
451 }
452 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
453 (0, "TSC_component::IsSupported No match found"));
454 return false;
455 }
456
IsSupported(TPVDirection dir,PV2WayMediaType media_type,CodecCapabilityInfo & codec_info)457 bool TSC_component::IsSupported(TPVDirection dir,
458 PV2WayMediaType media_type,
459 CodecCapabilityInfo& codec_info)
460 {
461 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
462 (0, "TSC_component::IsSupported dir(%d), media_type(%d)", dir, media_type));
463 if (media_type == PV_MEDIA_NONE)
464 {
465 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
466 (0, "TSC_component::IsSupported No media is always ok"));
467 return true;
468 }
469 Oscl_Vector<H324ChannelParameters, PVMFTscAlloc>* config = (dir == OUTGOING) ?
470 iOutgoingChannelConfig : iIncomingChannelConfig;
471 if (!config)
472 {
473 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
474 (0, "TSC_component::IsSupported No config available"));
475 return false;
476 }
477 for (unsigned n = 0; n < config->size(); n++)
478 {
479 H324ChannelParameters& param = (*config)[n];
480 if (param.GetMediaType() != media_type)
481 continue;
482 Oscl_Vector<FormatCapabilityInfo, OsclMemAllocator>* codecs = param.GetCodecs();
483 if (!codecs)
484 {
485 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
486 (0, "TSC_component::IsSupported No codecs specified"));
487 return false;
488 }
489 codec_info.codec = PVMFFormatTypeToPVCodecType((*codecs)[0].format);
490 codec_info.dir = (*codecs)[0].dir;
491 return true;
492 }
493 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
494 (0, "TSC_component::IsSupported No match found"));
495 return false;
496 }
497 ////////////////////////////////////////////////////////////////////////////
498 // ExtractTcsParameters() (RAN-32K)
499 //
500 // This routine takes the incoming TerminalCapabilitySet
501 // and extracts the following useful parameters:
502 // {h263_qcifMPI, h263_maxBitRate, mpeg4_maxBitRate}
503 // The parameters are stored in globals and may be sent
504 // later to the application.
505 ////////////////////////////////////////////////////////////////////////////
ExtractTcsParameters(PS_TerminalCapabilitySet pTcs)506 void TSC_component::ExtractTcsParameters(PS_TerminalCapabilitySet pTcs)
507 {
508 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
509 (0, "TSC_component::ExtractTcsParameters"));
510
511 if (pTcs->option_of_multiplexCapability)
512 {
513 PS_MultiplexCapability muxcaps = &pTcs->multiplexCapability;
514 if (muxcaps->index == 2)
515 {
516
517 PS_H223Capability h223caps = muxcaps->h223Capability;
518 iRemoteAl1Audio = h223caps->audioWithAL1;
519 iRemoteAl2Audio = h223caps->audioWithAL2;
520 iRemoteAl3Audio = h223caps->audioWithAL3;
521 iRemoteAl1Video = h223caps->videoWithAL1;
522 iRemoteAl2Video = h223caps->videoWithAL2;
523 iRemoteAl3Video = h223caps->videoWithAL3;
524 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
525 (0, "TSC_component::ExtractTcsParameters Remote audio caps AL1(%d), AL2(%d), AL3(%d)",
526 iRemoteAl1Audio, iRemoteAl2Audio, iRemoteAl3Audio));
527 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
528 (0, "TSC_component::ExtractTcsParameters Remote video caps AL1(%d), AL2(%d), AL3(%d)",
529 iRemoteAl1Video, iRemoteAl2Video, iRemoteAl3Video));
530 // -------------------------------------
531 // Decide which Video Layer to use (RAN)
532 // -------------------------------------
533 /* If both terminals support AL2, use AL2 */
534 if (iUseAl2Video && iRemoteAl2Video)
535 {
536 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
537 (0, "TSC_component::ExtractTcsParameters Video Layer Decision is AL2"));
538 iVideoLayer = PVT_AL2;
539 }
540 /* If not, check for mutual AL3 support */
541 else if (iUseAl3Video && iRemoteAl3Video)
542 {
543 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
544 (0, "TSC_component::ExtractTcsParameters Video Layer Decision is AL3"));
545 iVideoLayer = PVT_AL3;
546 }
547 /* If not, check for mutual AL1 support */
548 else if (iUseAl1Video && iRemoteAl1Video)
549 {
550 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
551 (0, "TSC_component::ExtractTcsParameters Video Layer Decision is AL1"));
552 iVideoLayer = PVT_AL1;
553 }
554 }
555 }
556 }
557
558 ////////////////////////////////////////////////////////////////////////
559 // CE User - Transfer.Indication primitive received from H.245
560 ////////////////////////////////////////////////////////////////////////
CETransferIndication(OsclSharedPtr<S_TerminalCapabilitySet> tcs,uint32 aTerminalStatus)561 void TSC_component::CETransferIndication(OsclSharedPtr<S_TerminalCapabilitySet> tcs,
562 uint32 aTerminalStatus)
563 {
564 if (aTerminalStatus == PhaseD_CSUP)
565 {
566 iRemoteTcs = tcs;
567 }
568
569 else if (aTerminalStatus == PhaseE_Comm)
570 {
571 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
572 (0, "TSC_component::CETransferIndication TCS received during PhaseE_Comm"));
573 if (tcs->option_of_multiplexCapability)
574 {
575 /* Save any required CE data */
576 iRemoteAl2Video =
577 tcs->multiplexCapability.h223Capability->videoWithAL2;
578 iRemoteAl3Video =
579 tcs->multiplexCapability.h223Capability->videoWithAL3;
580 }
581 }
582 }
583
584 // ========================================================
585 // SetAl2Al3VideoFlags() (RAN)
586 //
587 // New API from application layer. Sets the flags as follows:
588 // INPUT gAllowAl2Video gAllowAl3Video
589 // 0 ON OFF
590 // 1 OFF ON
591 // 2 ON ON
592 // ========================================================
SetAl2Al3VideoFlags(int32 userInput)593 void TSC_component::SetAl2Al3VideoFlags(int32 userInput)
594 {
595 iAllowAl2Video = iAllowAl3Video = ON;
596 if (userInput == 0)
597 {
598 iAllowAl3Video = OFF;
599 }
600 else if (userInput == 1)
601 {
602 iAllowAl2Video = OFF;
603 }
604 }
605
606 // ========================================================
607 // GetAl2Al3VideoFlags() (RAN)
608 //
609 // Complements SetAl2Al3VideoFlags()
610 // ========================================================
GetAl2Al3VideoFlags(void)611 int32 TSC_component::GetAl2Al3VideoFlags(void)
612 {
613 return(iAllowAl2Video + 2 * iAllowAl3Video - 1);
614 }
615
616 ////////////////////////////////////////////////
617 //
618 ////////////////////////////////////////////////
619 Oscl_Vector < H324ChannelParameters,
GetChannelConfig(TPVDirection dir)620 PVMFTscAlloc > * TSC_component::GetChannelConfig(TPVDirection dir)
621 {
622 if (dir == OUTGOING)
623 {
624 return iOutgoingChannelConfig;
625 }
626 return iIncomingChannelConfig;
627 }
628
SetAl3ControlFieldOctets(unsigned cfo)629 void TSC_component::SetAl3ControlFieldOctets(unsigned cfo)
630 {
631 iAl3ControlFieldOctets = cfo;
632 }
633
SetAl2Sn(int width)634 void TSC_component::SetAl2Sn(int width)
635 {
636 iAl2WithSn = width ? true : false;
637 }
638
639
640 /*****************************************************************************/
641 /* function name : LcEtbIdc E_PtvId_Lc_Etb_Idc */
642 /* function outline : Status04/Event09 procedure */
643 /* function discription : Status04Event09( pReceiveInf ) */
644 /* input data : PS_ControlMsgHeader Receive InfHeader Pointer */
645 /* output data : uint32 Terminal Status */
646 /* draw time : '96.10.09 */
647 /*---------------------------------------------------------------------------*/
648 /* amendment career(x) : */
649 /* */
650 /* Copyright (C) 1996 NTT DoCoMo */
651 /*****************************************************************************/
LcEtbIdc(PS_ControlMsgHeader pReceiveInf)652 uint32 TSC_component::LcEtbIdc(PS_ControlMsgHeader pReceiveInf)
653 {
654 TPVChannelId OpenLcn = (TPVChannelId)pReceiveInf->InfSupplement1 +
655 TSC_INCOMING_CHANNEL_MASK;
656 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
657 (0, "TSC_component::LcEtbIdc lcn(%d)", OpenLcn));
658 PS_ForwardReverseParam pLcParam = (PS_ForwardReverseParam) pReceiveInf->pParameter;
659 /* validate forRevParams */
660 PVMFStatus forRevCheck = iTSCcapability.ValidateForwardReverseParams(pLcParam, INCOMING);
661 if (forRevCheck != PVMFSuccess)
662 {
663 PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_EMERG,
664 (0, "TSC_component::LcEtbIdc ERROR - Incoming forRevParams not supported. Rejecting."));
665 uint16 reason = (uint16)((forRevCheck == PVMFErrNotSupported) ? 2/* dataTypeNotSupported */ : 0/*unspecified*/);
666 TPVDirection dir = iTSClc.LcRlsReq(RELEASE_REJECT, OpenLcn, reason);
667 RemoveOlc(dir, OpenLcn);
668 return PhaseE_Comm;
669 }
670 PS_H223LogicalChannelParameters pH223Lcp =
671 pLcParam->forwardLogicalChannelParameters.multiplexParameters.h223LogicalChannelParameters;
672 PS_DataType pDataType = &pLcParam->forwardLogicalChannelParameters.dataType;
673 PV2WayMediaType media_type = PV_MEDIA_NONE;
674 PVCodecType_t incoming_codec_type = PV_CODEC_TYPE_NONE;
675
676 incoming_codec_type = ::GetCodecType(pDataType);
677 media_type = ::GetMediaType(pDataType);
678 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
679 (0, "TSC_component::LcEtbIdc lcn(%d), media type(%d), codec type(%d)",
680 OpenLcn, media_type, incoming_codec_type));
681
682 OlcKey key(INCOMING, OpenLcn);
683
684 if (iOlcs.count(key))
685 {
686 if (iOlcs[key]->GetState() == OLC_ESTABLISHED)
687 {
688 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
689 (0, "TSC_component::LcEtbIdc Established incoming OLC found for same channel id. Rejecting OLC(%d)",
690 media_type, OpenLcn));
691 TPVDirection dir = iTSClc.LcRlsReq(RELEASE_REJECT, OpenLcn, 0); // unspecified
692 RemoveOlc(dir, OpenLcn);
693 return PhaseE_Comm;
694 }
695 else
696 {
697 ReleasePendingIncomingChannel(OpenLcn);
698 }
699 }
700
701 /* pending incoming OLC for the same media type */
702 Oscl_Vector<OlcParam*, OsclMemAllocator> pending_olc_list;
703 // Search for pending and established channels
704 if (iOlcs.FindOlcs(INCOMING, media_type, OLC_PENDING | OLC_ESTABLISHED,
705 pending_olc_list))
706 {
707 for (unsigned i = 0; i < pending_olc_list.size(); i++)
708 {
709 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
710 (0, "TSC_component::LcEtbIdc Pending incoming OLC found for media type=%d, lcn=%d",
711 media_type, pending_olc_list[i]->GetChannelId()));
712 if (!ReleasedPendingIncomingChannel(pending_olc_list[i]))
713 {
714 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
715 (0, "TSC_component::LcEtbIdc Established incoming OLC found for same media type. Rejecting OLC(%d)",
716 media_type, OpenLcn));
717 TPVDirection dir = iTSClc.LcRlsReq(RELEASE_REJECT, OpenLcn, 0); /* unspecified */
718 RemoveOlc(dir, OpenLcn);
719 return PhaseE_Comm;
720 }
721 }
722 }
723
724 OlcParam* pending_outgoing_olc = NULL;
725 PVCodecType_t to_be_opened_codec = PV_CODEC_TYPE_NONE;
726
727 // Add pending olc to list
728 iOlcs.AppendOlc(INCOMING, OpenLcn, pDataType, pH223Lcp);
729 // is there is a pending outgoing OLC for the same media type ?
730 if (iOlcs.FindOlcs(OUTGOING, media_type, OLC_PENDING, pending_olc_list))
731 {
732 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
733 (0, "TSC_component::LcEtbIdc Pending outgoing OLCs(%d) found for incoming media type(%d).",
734 pending_olc_list.size(), media_type, OpenLcn));
735 OSCL_ASSERT(pending_olc_list.size() == 1);
736 OlcParam* param = pending_outgoing_olc = pending_olc_list[0];
737 if (param->GetDirectionality() == EPVT_BI_DIRECTIONAL)
738 {
739 pending_outgoing_olc = NULL;
740 // There is an OLC/OBLC conflict
741 if (iTSCstatemanager.ReadState(TSC_MSD_DECISION) == MASTER)
742 {
743 // We are master, hence we reject the OLC
744 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
745 (0, "TSC_component::LcEtbIdc BLC Already initiated by local. Rejecting OLC cause we are Master"));
746 TPVDirection dir = iTSClc.LcRlsReq(RELEASE_REJECT, OpenLcn, 10); // Master slave conflict
747 RemoveOlc(dir, OpenLcn);
748 return PhaseE_Comm;
749 }
750 else // We are Slave
751 {
752 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
753 (0, "TSC_component::LcEtbIdc BLC Already initiated by local. Closing BLC cause we are Slave"));
754 to_be_opened_codec = GetCodecType(param->GetForwardParams()->GetDataType());;
755 // Release the pending blc
756 iTSCblc.BlcRlsReq(RELEASE_CLOSE, param->GetChannelId(), 0);
757 ChannelReleased(OUTGOING, param->GetChannelId(), PVMFErrCancelled);
758 // Logical channel will be deleted from the mux when the engine calls ReleasePort
759 }
760 }
761 }
762
763
764 PVMFStatus tscCheck = ValidateOlcsWithTcs();
765 if (tscCheck != PVMFSuccess)
766 {
767 if (pending_outgoing_olc)
768 {
769 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
770 (0, "TSC_component::LcEtbIdc pending olcs."));
771 if (iTSCstatemanager.ReadState(TSC_MSD_DECISION) == MASTER)
772 {
773 // We are master, hence we reject the incoming OLC with code M/S conflict
774 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
775 (0, "TSC_component::LcEtbIdc TCS violated with pending olcs from Master."));
776 TPVDirection dir = iTSClc.LcRlsReq(RELEASE_REJECT, OpenLcn, 10); // Master slave conflict
777 RemoveOlc(dir, OpenLcn);
778 return PhaseE_Comm;
779 }
780 /* We should close the conflicting codec and reopen a replacement. Assumption here is that the
781 conflict is due to the media type of the current incoming channel. This will not work if there
782 are symmetry inter-dependencies between audio and video codecs in the TCS. */
783 pending_outgoing_olc->GetForwardParams()->GetBitrate();
784 iTSClc.LcRlsReq(RELEASE_CLOSE,
785 pending_outgoing_olc->GetChannelId(), 0);
786 ChannelReleased(OUTGOING,
787 pending_outgoing_olc->GetChannelId(), PVMFErrCancelled);
788 FormatCapabilityInfo codec_caps;
789 if (IsSupported(OUTGOING, incoming_codec_type, codec_caps))
790 {
791 /* Verify if the capability sets can support it */
792 TPVChannelId tmp_lcn = iOlcs.GetNextAvailLcn();
793 iOlcs.AppendOlc(OUTGOING, tmp_lcn, pDataType, pH223Lcp);
794 if (ValidateOlcsWithTcs() == PVMFSuccess)
795 {
796 to_be_opened_codec = incoming_codec_type;
797 }
798 else
799 {
800 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
801 (0, "TSC_component::LcEtbIdc Cannot open a replacement channel as incoming codec is not supported"));
802 }
803 RemoveOlc(OUTGOING, tmp_lcn);
804 }
805 else
806 {
807 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
808 (0, "TSC_component::LcEtbIdc Incoming codec not supported for transmit"));
809 }
810 }
811 else
812 {
813 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
814 (0, "TSC_component::LcEtbIdc no pending olcs."));
815 // There were no pending OLCs from the local terminal.
816 TPVDirection dir = iTSClc.LcRlsReq(RELEASE_REJECT, OpenLcn, 3); // dataTypeNotAvailable
817 RemoveOlc(dir, OpenLcn);
818 return PhaseE_Comm;
819 }
820 }
821
822 int leave_status = OpenLogicalChannel(OpenLcn, pDataType, pH223Lcp);
823 if (leave_status != 0)
824 {
825 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
826 (0, "TSC_component::LcEtbIdc - Memory Allocation Failed."));
827 return leave_status;
828 }
829
830 uint8* fsi = NULL;
831 uint32 fsi_len = ::GetFormatSpecificInfo(pDataType, fsi);
832 iTSCObserver->IncomingChannel(OpenLcn, incoming_codec_type, fsi, fsi_len);
833
834 // ESTABLISH.response(LC) Primitive Send
835 iTSClc.LcEtbRps(OpenLcn);
836
837 SetCustomMultiplex(pReceiveInf, media_type);
838 if (to_be_opened_codec == PV_CODEC_TYPE_NONE)
839 return PhaseE_Comm;
840 FormatCapabilityInfo fci;
841 IsSupported(OUTGOING, to_be_opened_codec, fci);
842 PS_AdaptationLayerType al_type = GetOutgoingLayer(media_type, fci.max_sample_size);
843 if (al_type == NULL)
844 {
845 OSCL_LEAVE(PVMFErrNoMemory);
846 }
847 OpenOutgoingChannel(to_be_opened_codec, al_type);
848 Delete_AdaptationLayerType(al_type);
849 OSCL_DEFAULT_FREE(al_type);
850 iTSCmt.MtTrfReq(iOlcs);
851 return PhaseE_Comm;
852 }
853
OpenLogicalChannel(TPVChannelId OpenLcn,PS_DataType pDataType,PS_H223LogicalChannelParameters pH223Lcp)854 uint32 TSC_component::OpenLogicalChannel(TPVChannelId OpenLcn,
855 PS_DataType pDataType,
856 PS_H223LogicalChannelParameters pH223Lcp)
857 {
858 int leave_status = 0;
859 OlcParam* param = NULL;
860 OSCL_TRY(leave_status, param = OpenLogicalChannel(INCOMING,
861 OpenLcn, CHANNEL_ID_UNKNOWN, pDataType, pH223Lcp));
862 OSCL_FIRST_CATCH_ANY(leave_status, void());
863 if (leave_status != 0)
864 {
865 TPVDirection dir = iTSClc.LcRlsReq(RELEASE_REJECT, OpenLcn, 0); // unspecified
866 RemoveOlc(dir, OpenLcn);
867 return PhaseE_Comm;
868 }
869 param->SetState(OLC_ESTABLISHED);
870 return leave_status;
871 }
872
873 /*****************************************************************************/
874 /* function name : Status04Event14 E_PtvId_Blc_Etb_Idc */
875 /* function outline : Status04/Event14 procedure */
876 /* function discription : Status04Event14( pReceiveInf ) */
877 /* input data : PS_ControlMsgHeader Receive InfHeader Pointer */
878 /* output data : uint32 Terminal Status */
879 /* draw time : '96.10.09 */
880 /*---------------------------------------------------------------------------*/
881 /* amendment career(x) : */
882 /* */
883 /* Copyright (C) 1996 NTT DoCoMo */
884 /*****************************************************************************/
BlcEtbIdc(PS_ControlMsgHeader pReceiveInf)885 uint32 TSC_component::BlcEtbIdc(PS_ControlMsgHeader pReceiveInf)
886 {
887 TPVChannelId OpenLcnB = pReceiveInf->InfSupplement1 + TSC_INCOMING_CHANNEL_MASK; /* incoming lcn */
888 TPVChannelId OpenLcnF = CHANNEL_ID_UNKNOWN; /* outgoing lcn */
889 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
890 (0, "TSC_component::BlcEtbIdc lcn(%d)", OpenLcnB));
891 /* Function prototypes */
892 uint8* GetDecoderConfigFromOLC(PS_ForwardReverseParam pPara, uint32 forRev, uint16 *nOctets);
893 PS_ForwardReverseParam forRevParams = (PS_ForwardReverseParam)pReceiveInf->pParameter;
894
895 /* validate forRevParams */
896 PVMFStatus forRevCheck = iTSCcapability.ValidateForwardReverseParams(forRevParams, INCOMING);
897 if (forRevCheck != PVMFSuccess)
898 {
899 PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_EMERG,
900 (0, "TSC_component::BlcEtbIdc ERROR - Incoming forRevParams not supported. Rejecting."));
901 uint16 reason = (uint16)((forRevCheck == PVMFErrNotSupported) ? 2/* dataTypeNotSupported */ : 0/*unspecified*/);
902 TPVDirection dir = iTSClc.LcRlsReq(RELEASE_REJECT, OpenLcnB, reason);
903 RemoveOlc(dir, OpenLcnB);
904 return PhaseE_Comm;
905 }
906
907 PS_ForwardLogicalChannelParameters forwardParams = &forRevParams->forwardLogicalChannelParameters;
908 PS_ReverseLogicalChannelParameters reverseParams = &forRevParams->reverseLogicalChannelParameters;
909 PVCodecType_t in_codec_type = ::GetCodecType(&forwardParams->dataType);
910 PVCodecType_t out_codec_type = ::GetCodecType(&reverseParams->dataType);
911 PV2WayMediaType out_media_type = ::GetMediaType(&reverseParams->dataType);
912 OSCL_UNUSED_ARG(out_media_type);
913 PV2WayMediaType in_media_type = ::GetMediaType(&forwardParams->dataType);
914 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
915 (0, "TSC_component::BlcEtbIdc in media type(%d), in codec type(%d), out media type(%d), out codec type(%d)", in_media_type, in_codec_type, out_media_type, out_codec_type));
916
917 /* Do we support the outgoing codec ? */
918 FormatCapabilityInfo codec_caps;
919 if (!IsSupported(OUTGOING, out_codec_type, codec_caps) ||
920 !IsSupported(INCOMING, in_codec_type, codec_caps))
921 {
922 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
923 (0, "TSC_component::BlcEtbIdc Outgoing/incoming codec not supported for transmit"));
924 TPVDirection dir = iTSCblc.BlcRlsReq(RELEASE_REJECT, OpenLcnB, 2); /* dataTypeNotSupported */
925 RemoveOlc(dir, OpenLcnB);
926 return(PhaseE_Comm);
927 }
928
929 unsigned outgoing_bitrate = 0;
930 if (out_codec_type != PV_CODEC_TYPE_NONE)
931 {
932 outgoing_bitrate = GetOutgoingBitrate(out_codec_type);
933 if (outgoing_bitrate <= 0)
934 {
935 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
936 (0, "TSC_component::BlcEtbIdc No bandwidth allocated for outgoing media type(%d)",
937 out_media_type));
938 TPVDirection dir = iTSCblc.BlcRlsReq(RELEASE_REJECT, OpenLcnB, 3); /* dataTypeNotAvailable */
939 RemoveOlc(dir, OpenLcnB);
940 return PhaseE_Comm ;
941 }
942 }
943
944 /* Cancel waiting for OBLC */
945 if (iWaitingForOblc)
946 {
947 if (out_codec_type != iWaitingForOblcCodec)
948 {
949 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
950 (0, "TSC_component::BlcEtbIdc Reverse codec in BLC(%d) does not match iWaitingForOblcCodec(%d)",
951 out_codec_type, iWaitingForOblcCodec));
952 }
953 }
954 iWaitingForOblc = false;
955 iWaitingForOblcTimer->Clear();
956 iWaitingForOblcCodec = PV_CODEC_TYPE_NONE;
957
958 Oscl_Vector<OlcParam*, OsclMemAllocator> pending_olc_list;
959 /* Pending incoming OLC for the same media type */
960 if (iOlcs.FindOlcs(INCOMING, in_media_type, OLC_PENDING | OLC_ESTABLISHED, pending_olc_list))
961 {
962 for (unsigned i = 0; i < pending_olc_list.size(); i++)
963 {
964 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
965 (0, "TSC_component::BlcEtbIdc Pending incoming OLC found for media type=%d, lcn=%d",
966 in_media_type, pending_olc_list[i]->GetChannelId()));
967 if (!ReleasedPendingIncomingChannel(pending_olc_list[i]))
968 {
969 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
970 (0, "TSC_component::BlcEtbIdc Established incoming OLC found for same media type. Rejecting OLC(%d)", in_media_type, OpenLcnB));
971 TPVDirection dir = iTSCblc.BlcRlsReq(RELEASE_REJECT, OpenLcnB, 0); /* unspecified */
972 RemoveOlc(dir, OpenLcnB);
973 return PhaseE_Comm;
974 }
975
976 }
977 }
978
979 /* if there are established outgoing channels for the same media type, close them */
980 if (out_codec_type != PV_CODEC_TYPE_NONE &&
981 iOlcs.FindOlcs(OUTGOING, in_media_type, OLC_ESTABLISHED, pending_olc_list))
982 {
983 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
984 (0, "TSC_component::BlcEtbIdc Established outgoing OLC found for same media type(%d). Closing down the OLCS", in_media_type));
985 for (unsigned i = 0; i < pending_olc_list.size(); i++)
986 {
987 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
988 (0, "TSC_component::BlcEtbIdc Established outgoing OLC found for media type=%d, lcn=%d",
989 in_media_type, pending_olc_list[i]->GetChannelId()));
990 ChannelReleased(OUTGOING, pending_olc_list[i]->GetChannelId(), PVMFFailure);
991 }
992 }
993
994 PVCodecType_t to_be_opened_codec = PV_CODEC_TYPE_NONE;
995 /* is there is a pending outgoing OLC for the same media type ?*/
996 if (iOlcs.FindOlcs(OUTGOING, in_media_type, OLC_PENDING, pending_olc_list))
997 {
998 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
999 (0, "TSC_component::BlcEtbIdc Pending outgoing OLCs(%d) found for incoming media type(%d).",
1000 pending_olc_list.size(), in_media_type, OpenLcnB));
1001 OSCL_ASSERT(pending_olc_list.size() == 1);
1002 OlcParam* param = pending_olc_list[0];
1003 if (param->GetDirectionality() == EPVT_BI_DIRECTIONAL || /* Bi-dir: always causes conflict*/
1004 out_codec_type != PV_CODEC_TYPE_NONE) /*Uni-dir: no conflict if reverse params are NULL */
1005 {
1006 /* OLCs are conflicting */
1007 if (iTSCstatemanager.ReadState(TSC_MSD_DECISION) == MASTER)
1008 {
1009 /* We are master, hence we reject the incoming OLC */
1010 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1011 (0, "TSC_component::BlcEtbIdc BLC Already initiated by local. Rejecting OBLC cause we are Master"));
1012 TPVDirection dir = iTSCblc.BlcRlsReq(RELEASE_REJECT, OpenLcnB, 10); /* Master slave conflict */
1013 RemoveOlc(dir, OpenLcnB);
1014 return PhaseE_Comm ;
1015 }
1016 /* we are slave */
1017 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1018 (0, "TSC_component::BlcEtbIdc LC Already initiated by local. Closing it cause we are Slave"));
1019 if (out_codec_type == PV_CODEC_TYPE_NONE)
1020 {
1021 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1022 (0, "TSC_component::BlcEtbIdc Reverse DataType==NULL; Need to open replacement OLC/OBLC"));
1023 to_be_opened_codec = GetCodecType(param->GetForwardParams()->GetDataType());
1024 }
1025 ReleaseOlc(param, 0);
1026 ChannelReleased(OUTGOING, param->GetChannelId(), PVMFErrCancelled);
1027 }
1028 }
1029 pending_olc_list.clear();
1030 /* Generate logical channel number */
1031 OpenLcnF = iOlcs.GetNextAvailLcn();
1032 OlcParam* prm = iOlcs.AppendOlc(INCOMING, OpenLcnB,
1033 &forwardParams->dataType,
1034 forwardParams->multiplexParameters.h223LogicalChannelParameters,
1035 OpenLcnF,
1036 &reverseParams->dataType,
1037 reverseParams->rlcMultiplexParameters.h223LogicalChannelParameters);
1038
1039 prm->GetReverseParams()->SetChannelId(OpenLcnF);
1040 /* Validate the TCS's */
1041 PVMFStatus tscCheck = ValidateOlcsWithTcs();
1042 bool transfer_mux_tables = false;
1043 if (tscCheck != PVMFSuccess)
1044 {
1045 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1046 (0, "TSC_component::BlcEtbIdc TCS check failed"));
1047 TPVDirection dir = iTSCblc.BlcRlsReq(RELEASE_REJECT, OpenLcnB, 2); /* dataTypeNotSupported */
1048 RemoveOlc(dir, OpenLcnB);
1049 }
1050 else
1051 {
1052 PVMFStatus RvsParametersOkay = VerifyReverseParameters(forRevParams, iTSCObserver);
1053 if (RvsParametersOkay == PVMFSuccess)
1054 {
1055 AcceptBLCRequest(OpenLcnF, OpenLcnB, forRevParams);
1056 }
1057 else
1058 {
1059 /* RvsParameters are unsuitable; reject the OLC */
1060 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1061 (0, "TSC_component::BlcEtbIdc - Rejecting BLC request (%d). Reverse parameters not ok.",
1062 OpenLcnB));
1063 TPVDirection dir = iTSCblc.BlcRlsReq(RELEASE_REJECT, OpenLcnB, 1); /* unsuitableReverseParameters */
1064 RemoveOlc(dir, OpenLcnB);
1065 /* Fill the data type for the outgoing codec */
1066 PS_DataType pDataType = GetOutgoingDataType(out_codec_type, outgoing_bitrate);
1067 /* Fill the outgoing h223 logical channel parameters */
1068 PS_H223LogicalChannelParameters pH223Params =
1069 GetH223LogicalChannelParameters((uint8)IndexForAdaptationLayer(PVT_AL3),
1070 iTSCcapability.IsSegmentable(OUTGOING, in_media_type),
1071 iAl3ControlFieldOctets);
1072
1073 // Use AL3 for OBLC
1074 PS_AdaptationLayerType al_type = (PS_AdaptationLayerType)OSCL_DEFAULT_MALLOC(sizeof(S_AdaptationLayerType));
1075 if (al_type == NULL)
1076 {
1077 OSCL_LEAVE(PVMFErrNoMemory);
1078 }
1079 PS_Al3 al3 = (PS_Al3)OSCL_DEFAULT_MALLOC(sizeof(S_Al3));
1080 al3->controlFieldOctets = iAl3ControlFieldOctets;
1081 al3->sendBufferSize = DEF_AL3_SEND_BUFFER_SIZE;
1082 al_type->index = 5;
1083 al_type->al3 = al3;
1084
1085 OpenOutgoingChannel(out_codec_type,
1086 al_type,
1087 &forRevParams->forwardLogicalChannelParameters.dataType,
1088 forRevParams->forwardLogicalChannelParameters.multiplexParameters.h223LogicalChannelParameters);
1089
1090 iOlcs.AppendOlc(OUTGOING, OpenLcnF, pDataType, pH223Params,
1091 CHANNEL_ID_UNKNOWN, &forRevParams->forwardLogicalChannelParameters.dataType,
1092 forRevParams->forwardLogicalChannelParameters.multiplexParameters.h223LogicalChannelParameters);
1093 transfer_mux_tables = true;
1094 Delete_AdaptationLayerType(al_type);
1095 OSCL_DEFAULT_FREE(al_type);
1096 Delete_DataType(pDataType);
1097 OSCL_DEFAULT_FREE(pDataType);
1098 Delete_H223LogicalChannelParameters(pH223Params);
1099 OSCL_DEFAULT_FREE(pH223Params);
1100 }
1101 }
1102
1103 if (to_be_opened_codec != PV_CODEC_TYPE_NONE)
1104 {
1105 FormatCapabilityInfo fci;
1106 IsSupported(OUTGOING, to_be_opened_codec, fci);
1107 PS_AdaptationLayerType al_type = GetOutgoingLayer(::GetMediaType(to_be_opened_codec),
1108 fci.max_sample_size);
1109 if (al_type == NULL)
1110 {
1111 OSCL_LEAVE(PVMFErrNoMemory);
1112 }
1113 OpenOutgoingChannel(to_be_opened_codec, al_type);
1114 Delete_AdaptationLayerType(al_type);
1115 OSCL_DEFAULT_FREE(al_type);
1116 transfer_mux_tables = true;
1117 }
1118 if (transfer_mux_tables)
1119 {
1120 iTSCmt.MtTrfReq(iOlcs);
1121 }
1122 return(PhaseE_Comm);
1123 }
1124
VerifyReverseParameters(PS_ForwardReverseParam forRevParams,TSCObserver * aObserver)1125 PVMFStatus TSC_component::VerifyReverseParameters(PS_ForwardReverseParam forRevParams,
1126 TSCObserver* aObserver)
1127 {
1128 OSCL_UNUSED_ARG(aObserver);
1129 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1130 (0, "TSC_capability::VerifyReverseParameters"));
1131 PVMFStatus status;
1132 bool returnNow = iTSCcapability.VerifyReverseParameters(forRevParams, iTSCObserver, status);
1133
1134 if (returnNow)
1135 {
1136 return status;
1137 }
1138 PVCodecType_t codec = GetCodecType(&forRevParams->reverseLogicalChannelParameters.dataType);
1139 PV2WayMediaType media_type = GetMediaType(codec);
1140 uint8* decodeConfigInfoOblc = NULL;
1141 unsigned decodeConfigInfoSzOblc =
1142 ::GetFormatSpecificInfo(&forRevParams->reverseLogicalChannelParameters.dataType,
1143 decodeConfigInfoOblc);
1144 // get the outgoing FSI if any
1145 for (unsigned n = 0; n < iOutgoingChannelConfig->size(); n++)
1146 {
1147 PV2WayMediaType channelMediaType = (*iOutgoingChannelConfig)[n].GetMediaType();
1148 if (channelMediaType != media_type)
1149 {
1150 continue;
1151 }
1152 Oscl_Vector<FormatCapabilityInfo, OsclMemAllocator>* formats =
1153 (*iOutgoingChannelConfig)[n].GetCodecs();
1154 if (!formats)
1155 {
1156 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1157 (0, "TSC_component::VerifyReverseParameters No formats specified for media type(%d)",
1158 channelMediaType));
1159 continue;
1160 }
1161 for (unsigned m = 0; m < formats->size(); m++)
1162 {
1163 PVCodecType_t codec_type_outgoing = PVMFFormatTypeToPVCodecType((*formats)[m].format);
1164 if (codec_type_outgoing != codec)
1165 continue;
1166 if ((*formats)[m].fsi == NULL || (*formats)[m].fsi_len == 0)
1167 {
1168 // There are no FSI restrictions
1169 return PVMFSuccess;
1170 }
1171 if (decodeConfigInfoSzOblc == (*formats)[m].fsi_len &&
1172 oscl_memcmp(decodeConfigInfoOblc, (*formats)[m].fsi, decodeConfigInfoSzOblc) == 0)
1173 {
1174 return PVMFSuccess;
1175 }
1176 }
1177 }
1178
1179 return PVMFFailure;
1180 }
1181
1182
ValidateOlcsWithTcs()1183 PVMFStatus TSC_component::ValidateOlcsWithTcs()
1184 {
1185 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1186 (0, "TSC_component::ValidateOlcsWithTcs"));
1187 /* Verify if local TCS is satisfied */
1188 Oscl_Vector<OlcFormatInfo, OsclMemAllocator> incoming_codecs;
1189 if (!iOlcs.FindCodecs(INCOMING, PV_MEDIA_NONE, OLC_ESTABLISHED,
1190 PV_DIRECTION_BOTH, incoming_codecs))
1191 return PVMFSuccess;
1192 /* Set symmetry info in the codecs */
1193 unsigned n = 0;
1194 for (n = 0; n < incoming_codecs.size(); n++)
1195 {
1196 PV2WayMediaType media_type = GetMediaType(incoming_codecs[n].iCodec);
1197 incoming_codecs[n].isSymmetric = iOlcs.IsSymmetric(media_type,
1198 PV_DIRECTION_BOTH, OLC_PENDING | OLC_ESTABLISHED,
1199 PV_DIRECTION_BOTH, OLC_PENDING | OLC_ESTABLISHED);
1200 }
1201 PVMFStatus status = VerifyCodecs(iLocalTcs, incoming_codecs, iLogger);
1202 if (status != PVMFSuccess)
1203 {
1204 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1205 (0, "TSC_component::ValidateOlcsWithTcs Codecs not compatible with local TCS"));
1206 return status;
1207 }
1208
1209 /* Verify if remote TCS is satisfied */
1210 Oscl_Vector<OlcFormatInfo, OsclMemAllocator> outgoing_codecs;
1211 if (!iOlcs.FindCodecs(OUTGOING, PV_MEDIA_NONE,
1212 OLC_PENDING | OLC_ESTABLISHED, PV_DIRECTION_BOTH, outgoing_codecs))
1213 return PVMFSuccess;
1214 /* Set symmetry info in the codecs */
1215 for (n = 0; n < outgoing_codecs.size(); n++)
1216 {
1217 PV2WayMediaType media_type = GetMediaType(outgoing_codecs[n].iCodec);
1218 outgoing_codecs[n].isSymmetric = iOlcs.IsSymmetric(media_type,
1219 PV_DIRECTION_BOTH,
1220 OLC_PENDING | OLC_ESTABLISHED,
1221 PV_DIRECTION_BOTH,
1222 OLC_PENDING | OLC_ESTABLISHED);
1223 }
1224 status = VerifyCodecs(iRemoteTcs, outgoing_codecs, iLogger);
1225 if (status != PVMFSuccess)
1226 {
1227 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1228 (0, "TSC_component::ValidateOlcsWithTcs Codecs not compatible with remote TCS"));
1229 }
1230 return status;
1231 }
1232
TcsMsdComplete()1233 OsclAny TSC_component::TcsMsdComplete()
1234 {
1235 ClipCodecs(iRemoteTcs);
1236
1237 if (!iOutgoingChannelConfig || iOutgoingChannelConfig->size() == 0)
1238 {
1239 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1240 (0, "TSC_component::TcsMsdComplete No outgoing channels configured(%x)",
1241 iOutgoingChannelConfig));
1242 return;
1243 }
1244
1245 //Oscl_Vector<OlcParam*, OsclMemAllocator> olc_list;
1246 CPVMultiplexEntryDescriptorVector descriptors;
1247
1248 // start OLCs
1249 for (unsigned olcnum = 0; olcnum < iOutgoingChannelConfig->size(); olcnum++)
1250 {
1251 int index = -1;
1252 PV2WayMediaType media_type = (*iOutgoingChannelConfig)[olcnum].GetMediaType();
1253 if (!FindCodecForMediaType(media_type, iOutCodecList, &index))
1254 {
1255 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1256 (0, "TSC_component::TcsMsdComplete No outgoing codec selected for media type=%d",
1257 media_type));
1258 continue;
1259 }
1260 if (AlreadyAssigned(media_type))
1261 {
1262 continue;
1263 }
1264
1265
1266 PVCodecType_t incoming_codec = PV_CODEC_TYPE_NONE;
1267 FormatCapabilityInfo fci;
1268 IsSupported(OUTGOING, iOutCodecList[index]->codec, fci);
1269 PS_AdaptationLayerType al_type = GetOutgoingLayer(media_type, fci.max_sample_size);
1270 if (al_type == NULL)
1271 {
1272 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1273 (0, "TSC_component::TcsMsdComplete Failed to allocate adaptation layer for media type=%d",
1274 media_type));
1275 continue;
1276 }
1277 PS_DataType pDataTypeRvs = NULL;
1278 PS_H223LogicalChannelParameters pH223ParamsRvs = NULL;
1279 if (al_type->index == 5) /* AL3 */
1280 {
1281 incoming_codec = iOutCodecList[index]->codec;
1282 pDataTypeRvs = GetOutgoingDataType(incoming_codec,
1283 GetOutgoingBitrate(incoming_codec));
1284 pH223ParamsRvs = GetH223LogicalChannelParameters((uint8)IndexForAdaptationLayer(PVT_AL3),
1285 iTSCcapability.IsSegmentable(INCOMING, media_type),
1286 iAl3ControlFieldOctets);
1287 }
1288
1289 OlcParam* olc_param = OpenOutgoingChannel(iOutCodecList[index]->codec,
1290 al_type, pDataTypeRvs, pH223ParamsRvs);
1291 if (pH223ParamsRvs)
1292 {
1293 Delete_H223LogicalChannelParameters(pH223ParamsRvs);
1294 OSCL_DEFAULT_FREE(pH223ParamsRvs);
1295 }
1296 if (pDataTypeRvs)
1297 {
1298 Delete_DataType(pDataTypeRvs);
1299 OSCL_DEFAULT_FREE(pDataTypeRvs);
1300 }
1301 Delete_AdaptationLayerType(al_type);
1302 OSCL_DEFAULT_FREE(al_type);
1303 StartOlc(olc_param, media_type, descriptors);
1304 }
1305 if (FinishTcsMsdComplete(descriptors))
1306 {
1307 iTSCmt.MtTrfReq(iOlcs);
1308 }
1309 // Reset flags used to force AL
1310 iUseAl1Video = true;
1311 iUseAl2Video = true;
1312 iUseAl3Video = true;
1313 #ifdef MEM_TRACK
1314 printf("\n Memory Stats After TcsMsdComplete");
1315 MemStats();
1316 #endif
1317 }
1318
SetOutgoingChannelConfig(Oscl_Vector<H324ChannelParameters,PVMFTscAlloc> & out_channel_config)1319 void TSC_component::SetOutgoingChannelConfig(Oscl_Vector<H324ChannelParameters, PVMFTscAlloc>& out_channel_config)
1320 {
1321 if (iOutgoingChannelConfig)
1322 {
1323 OSCL_DELETE(iOutgoingChannelConfig);
1324 iOutgoingChannelConfig = NULL;
1325 }
1326 iOutgoingChannelConfig = new Oscl_Vector<H324ChannelParameters, PVMFTscAlloc>(out_channel_config);
1327
1328 }
1329
SetIncomingChannelConfig(Oscl_Vector<H324ChannelParameters,PVMFTscAlloc> & in_channel_config)1330 void TSC_component::SetIncomingChannelConfig(Oscl_Vector<H324ChannelParameters, PVMFTscAlloc>& in_channel_config)
1331 {
1332 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1333 (0, "TSC_component::SetIncomingChannelConfig size(%d)\n", in_channel_config.size()));
1334 if (iIncomingChannelConfig)
1335 {
1336 OSCL_DELETE(iIncomingChannelConfig);
1337 iIncomingChannelConfig = NULL;
1338 }
1339 iIncomingChannelConfig = new Oscl_Vector<H324ChannelParameters, PVMFTscAlloc>(in_channel_config);
1340 }
1341
1342 /*****************************************************************************/
1343 /* function name : Status04Event10 E_PtvId_Lc_Etb_Cfm */
1344 /* function outline : Status04/Event10 procedure */
1345 /* function discription : Status04Event10( pReceiveInf ) */
1346 /* input data : PS_ControlMsgHeader Receive InfHeader Pointer */
1347 /* output data : uint32 Terminal Status */
1348 /* draw time : '96.10.09 */
1349 /*---------------------------------------------------------------------------*/
1350 /* amendment career(x) : */
1351 /* */
1352 /* Copyright (C) 1996 NTT DoCoMo */
1353 /*****************************************************************************/
LcEtbCfm(PS_ControlMsgHeader pReceiveInf)1354 uint32 TSC_component::LcEtbCfm(PS_ControlMsgHeader pReceiveInf)
1355 {
1356 TPVChannelId lcn = pReceiveInf->InfSupplement1;
1357 /*OlcParam* olc_param = OpenLogicalChannel(OUTGOING, lcn);
1358 }
1359 return PhaseE_Comm;
1360 */
1361 OlcParam* olc_param = iOlcs.FindOlcGivenChannel(OUTGOING, lcn);
1362 if (olc_param == NULL)
1363 {
1364 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1365 (0, "TSC_component::LcEtbCfm ERROR Unable to lookup channel"));
1366 return (PhaseE_Comm);
1367 }
1368 olc_param->SetState(OLC_ESTABLISHED);
1369 CheckOutgoingChannel(olc_param, PVMFSuccess);
1370 return PhaseE_Comm;
1371
1372 }
1373
GetOutgoingBitrate(PVCodecType_t codec_type)1374 unsigned TSC_component::GetOutgoingBitrate(PVCodecType_t codec_type)
1375 {
1376 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1377 (0, "TSC_component::GetOutgoingBitrate codec_type=%d", codec_type));
1378 PV2WayMediaType media_type = GetMediaType(codec_type);
1379 if (!iOutgoingChannelConfig || !iOutgoingChannelConfig->size())
1380 {
1381 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1382 (0, "TSC_component::GetOutgoingBitrate outgoing channel config not found."));
1383 return 0;
1384 }
1385 uint32 bitrate = 0;
1386 for (unsigned n = 0; n < iOutgoingChannelConfig->size(); n++)
1387 {
1388 H324ChannelParameters& params = (*iOutgoingChannelConfig)[n];
1389 if (params.GetMediaType() == media_type)
1390 {
1391 bitrate = params.GetBandwidth();
1392 break;
1393 }
1394 }
1395 if (bitrate == 0)
1396 {
1397 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1398 (0, "TSC_component::GetOutgoingBitrate outgoing channel bitrate=0."));
1399 return bitrate;
1400 }
1401 // lookup the bitrate from remote capabilities
1402 uint32 br = iTSCcapability.GetRemoteBitrate(codec_type);
1403 bitrate = (bitrate > br) ? br : bitrate;
1404 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1405 (0, "TSC_component::GetOutgoingBitrate outgoing channel bitrate=%d.", bitrate));
1406 return bitrate;
1407 }
1408
GetChannelFormatAndCapabilities(TPVDirection dir,Oscl_Vector<FormatCapabilityInfo,OsclMemAllocator> & formats)1409 void TSC_component::GetChannelFormatAndCapabilities(TPVDirection dir,
1410 Oscl_Vector<FormatCapabilityInfo, OsclMemAllocator>& formats)
1411 {
1412 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1413 (0, "TSC_component::GetChannelFormatAndCapabilities"));
1414 OlcList::iterator it = iOlcs.begin();
1415
1416 while (it != iOlcs.end())
1417 {
1418 OlcList::value_type& val = (*it++);
1419 OlcParam* olc = val.second;
1420 H223ChannelParam* param = NULL;
1421 if (olc->GetDirection() == dir)
1422 {
1423 param = olc->GetForwardParams();
1424 }
1425 else if (olc->GetReverseParams())
1426 {
1427 param = olc->GetReverseParams();
1428 }
1429 FormatCapabilityInfo fci;
1430 fci.id = param->GetChannelId();
1431 fci.dir = dir;
1432 fci.format = PVCodecTypeToPVMFFormatType(param->GetMediaParam()->GetCodecType());
1433 fci.bitrate = param->GetBitrate();
1434 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1435 (0, "TSC_component::GetChannelFormatAndCapabilities Adding(%d,%d,%s,%d) to list",
1436 fci.dir, fci.id, fci.format.getMIMEStrPtr(), fci.bitrate));
1437 formats.push_back(fci);
1438 }
1439 }
1440
HasOlc(TPVDirection direction,TPVChannelId id,unsigned state)1441 bool TSC_component::HasOlc(TPVDirection direction,
1442 TPVChannelId id,
1443 unsigned state)
1444 {
1445 if (state)
1446 {
1447 return iOlcs.HasOlc(direction, id, state);
1448 }
1449 else
1450 {
1451 return iOlcs.HasOlc(direction, id);
1452 }
1453 }
1454
FindOlcGivenChannel(TPVDirection direction,TPVChannelId id)1455 OlcParam* TSC_component::FindOlcGivenChannel(TPVDirection direction,
1456 TPVChannelId id)
1457 {
1458 return iOlcs.FindOlcGivenChannel(direction, id);
1459 }
1460
FindOlc(TPVDirection direction,PV2WayMediaType media_type,unsigned state)1461 OlcParam* TSC_component::FindOlc(TPVDirection direction,
1462 PV2WayMediaType media_type,
1463 unsigned state)
1464 {
1465 return iOlcs.FindOlc(direction, media_type, state);
1466 }
1467
LcnDataDetected(TPVChannelId lcn)1468 void TSC_component::LcnDataDetected(TPVChannelId lcn)
1469 {
1470 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1471 (0, "TSC_component::LcnDataDetected - lcn=%d", lcn));
1472 OlcParam* param = iOlcs.FindOlcGivenChannel(INCOMING, lcn);
1473 if (param == NULL)
1474 {
1475 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1476 (0, "TSC_component::LcnDataDetected - Failed to lookup channel, lcn=%d", lcn));
1477 return;
1478 }
1479 if (param->GetReplacementFor() != CHANNEL_ID_UNKNOWN)
1480 {
1481 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1482 (0, "TSC_component::LcnDataDetected - Replaced channel id=%d",
1483 param->GetReplacementFor()));
1484 ChannelReleased(INCOMING, param->GetReplacementFor(), PV2WayErrReplaced);
1485 param->SetReplacementFor((TPVChannelId)NULL);
1486 }
1487 }
1488
1489 // =======================================================
1490 // AcceptBLCRequest()
1491 //
1492 // WWUAPI - New Function
1493 // =======================================================
AcceptBLCRequest(TPVChannelId OpenLcnF,TPVChannelId OpenLcnB,PS_ForwardReverseParam forRevParams)1494 OsclAny TSC_component::AcceptBLCRequest(TPVChannelId OpenLcnF,
1495 TPVChannelId OpenLcnB,
1496 PS_ForwardReverseParam forRevParams)
1497 {
1498 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1499 (0, "TSC: AcceptBLCRequest reverse(%d), forward(%d)\n", OpenLcnB, OpenLcnF));
1500 /* RvsParameters are okay; accept the OLC */
1501 iTSCblc.BlcEtbRps(OpenLcnB - TSC_INCOMING_CHANNEL_MASK, OpenLcnF);
1502 // Open the incoming and outgoing logical channels in the mux
1503 OlcParam* param = OpenLogicalChannel(INCOMING,
1504 OpenLcnB,
1505 OpenLcnF,
1506 &forRevParams->forwardLogicalChannelParameters.dataType,
1507 forRevParams->forwardLogicalChannelParameters.multiplexParameters.h223LogicalChannelParameters,
1508 &forRevParams->reverseLogicalChannelParameters.dataType,
1509 forRevParams->reverseLogicalChannelParameters.rlcMultiplexParameters.h223LogicalChannelParameters);
1510 param->SetState(OLC_ESTABLISHED);
1511 /* Send updated MuxTable for outgoing part of the BLC */
1512 iTSCmt.MtTrfReq(iOlcs);
1513
1514 uint8* fsi = NULL;
1515 uint32 fsi_len = ::GetFormatSpecificInfo(&forRevParams->forwardLogicalChannelParameters.dataType, fsi);
1516 iTSCObserver->IncomingChannel(OpenLcnB,
1517 GetCodecType(&forRevParams->forwardLogicalChannelParameters.dataType),
1518 fsi, fsi_len);
1519
1520 if (OpenLcnF == CHANNEL_ID_UNKNOWN ||
1521 GetCodecType(param->GetReverseParams()->GetDataType()) == PV_CODEC_TYPE_NONE)
1522 return;
1523
1524 // Pause the channel untill OlcAck+MtAck is received
1525 H223OutgoingChannelPtr outgoing_channel;
1526 iH223->GetOutgoingChannel(OpenLcnF, outgoing_channel);
1527 outgoing_channel->Pause();
1528 // Notify outgoing channel
1529 fsi_len = GetFormatSpecificInfo(&forRevParams->reverseLogicalChannelParameters.dataType, fsi);
1530 iTSCObserver->OutgoingChannelEstablished(OpenLcnF,
1531 GetCodecType(&forRevParams->reverseLogicalChannelParameters.dataType),
1532 fsi, fsi_len);
1533 }
1534
1535 // =============================================================
1536 // Status04Event11() E_PtvId_Lc_Rls_Idc
1537 //
1538 // This is LCSE RELEASE.indication.
1539 // =============================================================
LcRlsIdc(PS_ControlMsgHeader pReceiveInf)1540 uint32 TSC_component::LcRlsIdc(PS_ControlMsgHeader pReceiveInf)
1541 {
1542 TPVDirection dir = (pReceiveInf->Dir == S_ControlMsgHeader::INCOMING) ? INCOMING : OUTGOING;
1543 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1544 (0, "TSC_component::LcRlsIdc dir(%d), lcn(%d).",
1545 dir, pReceiveInf->InfSupplement1));
1546 TPVChannelId lcn = (dir == INCOMING) ? (TPVChannelId)(pReceiveInf->InfSupplement1 +
1547 TSC_INCOMING_CHANNEL_MASK) : (TPVChannelId)pReceiveInf->InfSupplement1;
1548 PS_SourceCause_LcBlc sourceCause = (PS_SourceCause_LcBlc)pReceiveInf->pParameter;
1549 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1550 (0, "TSC_component::LcRlsIdc sourceCause(%x), cause index(%d)",
1551 sourceCause, sourceCause->Cause.index));
1552 PVMFStatus status = PVMFSuccess;
1553
1554 OlcParam* olc_param = iOlcs.FindOlcGivenChannel(dir, lcn);
1555 if (olc_param == NULL)
1556 {
1557 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1558 (0, "TSC_component::LcRlsIdc ERROR Unable to lookup channel"));
1559 return (PhaseE_Comm);
1560 }
1561
1562 if (dir == OUTGOING)
1563 {
1564 if (olc_param->GetState() == OLC_PENDING)
1565 {
1566 // only valid rejection code is m/s conflict
1567 if (iTSCstatemanager.ReadState(TSC_MSD_DECISION) == SLAVE &&
1568 sourceCause->Cause.index == 10)
1569 {
1570 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1571 (0, "TSC_component::LcRlsIdc Reject due to M/S conflict"));
1572 }
1573 else
1574 {
1575 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1576 (0, "TSC_component::LcRlsIdc Olc failure"));
1577 status = PVMFFailure;
1578 }
1579 }
1580 }
1581 else if (dir == INCOMING)
1582 {
1583 RemoveMultiplex(olc_param);
1584 }
1585 ChannelReleased(dir, lcn, status);
1586 return(PhaseE_Comm);
1587 }
1588
1589 // =============================================================
1590 // Status04Event16() E_PtvId_Blc_Rls_Idc
1591 //
1592 // This is BLCSE RELEASE.indication. It is called when
1593 // a Bi-Dir OLCReject is received. It could be from an incoming or outgoing SE
1594 // =============================================================
BlcRlsIdc(PS_ControlMsgHeader pReceiveInf)1595 uint32 TSC_component::BlcRlsIdc(PS_ControlMsgHeader pReceiveInf)
1596 {
1597 PS_SourceCause_LcBlc sourceCause = (PS_SourceCause_LcBlc)pReceiveInf->pParameter;
1598 int32 causeIndex = sourceCause->Cause.index;
1599 TPVDirection dir = OUTGOING;
1600 TPVChannelId lcn = (TPVChannelId)pReceiveInf->InfSupplement1;;
1601 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1602 (0, "TSC_component::BlcRlsIdc BLC rejected. dir(%d), forward lcn(%d), reverse lcn(%d), cause index(%d)",
1603 dir, pReceiveInf->InfSupplement1, pReceiveInf->InfSupplement2, causeIndex));
1604
1605 if (pReceiveInf->Dir == S_ControlMsgHeader::INCOMING)
1606 {
1607 dir = INCOMING;
1608 lcn += TSC_INCOMING_CHANNEL_MASK;
1609 }
1610
1611 PVMFStatus status = PVMFSuccess;
1612 PVCodecType_t to_be_opened_codec = PV_CODEC_TYPE_NONE;
1613 PV2WayMediaType media_type = PV_MEDIA_NONE;
1614
1615 if (dir == OUTGOING)
1616 {
1617 OlcParam* olc_param = iOlcs.FindOlcGivenChannel(OUTGOING, lcn);
1618 if (olc_param != NULL)
1619 {
1620 media_type = GetMediaType(olc_param->GetForwardParams()->GetDataType());
1621 if (olc_param->GetState() == OLC_PENDING)
1622 {
1623 if (causeIndex == 1)
1624 {
1625 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1626 (0, "TSC_component::BlcRlsIdc UnsuitableReverseParams. Entering wait state ..."));
1627 /* Cause is unsuitableReverseParameters; Enter wait state */
1628 iWaitingForOblc = true;
1629 iWaitingForOblcCodec = GetCodecType(olc_param->GetForwardParams()->GetDataType());
1630 iWaitingForOblcTimer->Request(PV_TSC_WAITING_FOR_OBLC_TIMER_ID,
1631 PV_TSC_WAITING_FOR_OBLC_TIMER_ID , WAITING_FOR_OBLC_TIMEOUT_SECONDS, this);
1632 }
1633 else if (iTSCstatemanager.ReadState(TSC_MSD_DECISION) == SLAVE &&
1634 causeIndex == 10)
1635 {
1636 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1637 (0, "TSC_component::BlcRlsIdc Master/Slave conflict"));
1638 // is there is a pending outgoing OLC for the same media type ?
1639 Oscl_Vector<OlcParam*, OsclMemAllocator> pending_olc_list;
1640 if (iOlcs.FindOlcs(OUTGOING, media_type, OLC_PENDING, pending_olc_list))
1641 {
1642 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1643 (0, "TSC_component::BlcRlsIdc Pending outgoing OLCs(%d) found for incoming media type(%d).",
1644 pending_olc_list.size(), media_type));
1645 OSCL_ASSERT(pending_olc_list.size() == 1);
1646 OlcParam* param = pending_olc_list[0];
1647 to_be_opened_codec = GetCodecType(param->GetForwardParams()->GetDataType());
1648 }
1649 }
1650 else
1651 {
1652 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1653 (0, "TSC_component::BlcRlsIdc Olc failure"));
1654 status = PVMFFailure;
1655 }
1656 }
1657 }
1658 }
1659 else if (dir == INCOMING)
1660 {
1661 lcn += TSC_INCOMING_CHANNEL_MASK;
1662 }
1663 ChannelReleased(dir, lcn, status);
1664
1665 if (to_be_opened_codec == PV_CODEC_TYPE_NONE)
1666 return PhaseE_Comm;
1667 FormatCapabilityInfo fci;
1668 IsSupported(OUTGOING, to_be_opened_codec, fci);
1669 PS_AdaptationLayerType al_type = GetOutgoingLayer(media_type, fci.max_sample_size);
1670 if (al_type == NULL)
1671 {
1672 OSCL_LEAVE(PVMFErrNoMemory);
1673 }
1674 OpenOutgoingChannel(to_be_opened_codec, al_type);
1675 Delete_AdaptationLayerType(al_type);
1676 OSCL_DEFAULT_FREE(al_type);
1677 iTSCmt.MtTrfReq(iOlcs);
1678 return(PhaseE_Comm);
1679 }
1680
MuxTableSendComplete(uint32 sn,PVMFStatus status)1681 OsclAny TSC_component::MuxTableSendComplete(uint32 sn, PVMFStatus status)
1682 {
1683 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1684 (0, "TSC::MuxTableSendComplete sn(%d), status(%d)", sn, status));
1685 if (!iTSCmt.MuxTableSendComplete(sn))
1686 {
1687 return;
1688 }
1689 Oscl_Vector<OlcParam*, OsclMemAllocator> olc_list;
1690 unsigned num_pending = iOlcs.FindOutgoingOlcsByMtState(MT_PENDING, olc_list);
1691 for (unsigned lcn = 0; lcn < num_pending; lcn++)
1692 {
1693 //OSCL_ASSERT(olc_list[lcn]->GetMtSn()==sn);
1694 olc_list[lcn]->SetMtState(status == PVMFSuccess ? MT_COMPLETE : MT_RELEASED);
1695 if (olc_list[lcn]->GetState() == OLC_ESTABLISHED)
1696 {
1697 CheckOutgoingChannel(olc_list[lcn], status);
1698 }
1699 else
1700 {
1701 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1702 (0, "TSC_component::MuxTableSendComplete Mux table completed, but channel still pending. channel id=(%d)", olc_list[lcn]->GetChannelId()));
1703 }
1704 }
1705 iTSCmt.ReleaseMuxTables();
1706 }
1707
1708 // ===============================================================
1709 // StopData()
1710 //
1711 // Sets flags in the H324 system table which stop data transmission
1712 // for each open, outgoing logical channel.
1713 // ================================================================
StopData()1714 OsclAny TSC_component::StopData()
1715 {
1716 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1717 (0, "TSC_component::StopData"));
1718 OlcList::iterator it = iOlcs.begin();
1719 while (it != iOlcs.end())
1720 {
1721 OlcParam* olc = (*it++).second;
1722 iH223->StopChannel(olc->GetDirection(), olc->GetChannelId());
1723 if (olc->GetReverseParams())
1724 {
1725 iH223->StopChannel(olc->GetReverseParams()->GetDirection(),
1726 olc->GetReverseParams()->GetChannelId());
1727 }
1728 }
1729 }
1730
1731 // bool whether level is unknown
Connect1LevelKnown()1732 bool TSC_component::Connect1LevelKnown()
1733 {
1734 PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_NOTICE,
1735 (0, "TSC_component::Connect"));
1736 bool levelknown = true;
1737 iWaitingForOblc = false;
1738 iWaitingForOblcCodec = PV_CODEC_TYPE_NONE;
1739
1740
1741 if (iOutgoingChannelConfig == NULL)
1742 {
1743 OSCL_LEAVE(PVMFErrNoMemory);
1744 }
1745
1746 if (iIncomingChannelConfig == NULL)
1747 {
1748 OSCL_LEAVE(PVMFErrNoMemory);
1749 }
1750
1751 iWaitingForOblcTimer->Clear();
1752 return levelknown;
1753 }
1754
Connect2()1755 void TSC_component::Connect2()
1756 {
1757 H223PduParcomSharedPtr parcom;
1758 iH223->Start(parcom);
1759 }
1760
1761 // =======================================================
1762 // ClipCodecs() (RAN-32K)
1763 //
1764 // This one reconciles the desired outgoing codecs with the
1765 // capabilities of the remote terminal. The outgoing
1766 // codecs have been specified by the application via calls
1767 // to pH324.SetVideoType(), pH324.SetAudioType(). The
1768 // remote terminal capabilities from the received
1769 // TerminalCapabilitySet are passed in (pTcs).
1770 // If insufficient capabilities are found, the routine will
1771 // modify the outgoing codecs stored in pH324.
1772 // =======================================================
ClipCodecs(PS_TerminalCapabilitySet pTcs)1773 OsclAny TSC_component::ClipCodecs(PS_TerminalCapabilitySet pTcs)
1774 {
1775 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1776 (0, "TSC_component::ClipCodecs(%d,%d)",
1777 pTcs->size_of_capabilityTable,
1778 pTcs->size_of_capabilityDescriptors));
1779 if (!(pTcs->option_of_capabilityTable && pTcs->option_of_capabilityDescriptors))
1780 {
1781 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1782 (0, "TSC_component::ClipCodecs - Remote terminal is incapable of decoding anything"));
1783 return;
1784 }
1785 if (!iOutgoingChannelConfig || iOutgoingChannelConfig->size() == 0)
1786 {
1787 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1788 (0, "TSC_component::ClipCodecs - We dont want to send anything. Skip ClipCodecs."));
1789 return;
1790 }
1791 PS_CapabilityDescriptor pCapDesc = NULL;
1792 PS_AlternativeCapabilitySet pAltCapSet = NULL;
1793 for (unsigned i = 0; i < pTcs->size_of_capabilityDescriptors; ++i)
1794 {
1795 pCapDesc = pTcs->capabilityDescriptors + i;
1796 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1797 (0, "TSC_component::ClipCodecs - descriptor(%d),size_of_simultaneousCapabilities(%d)",
1798 i, pCapDesc->size_of_simultaneousCapabilities));
1799 /* Temporary list of selected codecs. Retain the codecs for descriptor with most matching codecs */
1800 Oscl_Vector<CodecCapabilityInfo*, OsclMemAllocator> codec_list;
1801 /* A changing list of available media for outgoing channels. Once a codec is selected,
1802 the entry for that media is removed from this list */
1803 Oscl_Vector<H324ChannelParameters, PVMFTscAlloc> outgoing_media(*iOutgoingChannelConfig);
1804 if (pCapDesc->size_of_simultaneousCapabilities != iOutgoingChannelConfig->size())
1805 {
1806 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1807 (0, "TSC_component::ClipCodecs - descriptor(%d),size_of_simultaneousCapabilities does not match num channels(%d)", i, iOutgoingChannelConfig->size()));
1808 }
1809
1810 for (unsigned j = 0; j < pCapDesc->size_of_simultaneousCapabilities; ++j)
1811 {
1812 bool txOnly = true;
1813 pAltCapSet = pCapDesc->simultaneousCapabilities + j;
1814 // Get the list of codecs in this ACS
1815 Oscl_Vector<CodecCapabilityInfo*, OsclMemAllocator> codecs_acs;
1816 uint16 num_media_types = GetCodecCapabilityInfo(pTcs, pAltCapSet, codecs_acs);
1817 if (num_media_types != 1)
1818 {
1819 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1820 (0, "TSC_component::ClipCodecs - ERROR: Badly formed AlternativeCapabilitySet j=%d, num media types=%d", j, num_media_types));
1821 Deallocate(codecs_acs);
1822 continue;
1823 }
1824
1825 //Check for tx only capabilities
1826 for (unsigned k = 0; k < codecs_acs.size(); ++k)
1827 {
1828 if (codecs_acs[k]->dir != OUTGOING)
1829 {
1830 txOnly = false;
1831 break;
1832 }
1833 }
1834 if (txOnly)
1835 {
1836 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1837 (0, "TSC_component::ClipCodecs: tx only codecs"));
1838 Deallocate(codecs_acs);
1839 continue;
1840 }
1841
1842 PV2WayMediaType mediaType = GetMediaType(codecs_acs[0]->codec);
1843 if (mediaType != PV_AUDIO && mediaType != PV_VIDEO)
1844 {
1845 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1846 (0, "TSC_component::ClipCodecs: Media type in AlternativeCapabilitySet j=%d is neither audio/video, media type=%d", j, mediaType));
1847 Deallocate(codecs_acs);
1848 continue;
1849 }
1850 // Get the list of our incoming codecs for this media type
1851 Oscl_Vector<CodecCapabilityInfo*, OsclMemAllocator> in_codecs_for_media_type;
1852 iTSCcapability.GetSupportedCodecCapabilityInfo(INCOMING, mediaType, in_codecs_for_media_type);
1853
1854 // Do either side have symmetry constraints ?
1855 bool local_has_symmetry_constraint = iTSCcapability.HasSymmetryConstraint(in_codecs_for_media_type);
1856 bool remote_has_symmetry_constraint = iTSCcapability.HasSymmetryConstraint(codecs_acs);
1857 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1858 (0, "TSC_component::ClipCodecs mediaType=%d, local_has_symmetry_constraint=%d, remote_has_symmetry_constraint=%d", mediaType, local_has_symmetry_constraint, remote_has_symmetry_constraint));
1859 CodecCapabilityInfo* selected_codec_info;
1860 if (local_has_symmetry_constraint || remote_has_symmetry_constraint)
1861 {
1862 selected_codec_info = iTSCcapability.SelectOutgoingCodec(&codecs_acs,
1863 &in_codecs_for_media_type);
1864 }
1865 else
1866 {
1867 selected_codec_info = iTSCcapability.SelectOutgoingCodec(&codecs_acs);
1868 }
1869 if (selected_codec_info)
1870 codec_list.push_back(selected_codec_info->Copy());
1871 Deallocate(codecs_acs);
1872 Deallocate(in_codecs_for_media_type);
1873 }
1874 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1875 (0, "TSC_component::ClipCodecs codec_list size=%d, iOutCodecList size=%d",
1876 codec_list.size(), iOutCodecList.size()));
1877 if (codec_list.size() > iOutCodecList.size())
1878 {
1879 /* found a match */
1880 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1881 (0, "TSC_component::ClipCodecs Match found for descriptor(%d), size(%d)",
1882 i, pCapDesc->size_of_simultaneousCapabilities));
1883 Deallocate(iOutCodecList);
1884 iOutCodecList = codec_list;
1885 for (unsigned num = 0; num < iOutCodecList.size(); num++)
1886 {
1887 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1888 (0, "TSC_component::ClipCodecs Selected codec(%d)=%d",
1889 num, codec_list[num]->codec));
1890 }
1891 }
1892 else
1893 {
1894 Deallocate(codec_list);
1895 }
1896 }
1897 }
1898
Start()1899 void TSC_component::Start()
1900 {
1901 if (iOutgoingChannelConfig == NULL || iIncomingChannelConfig == NULL)
1902 {
1903 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
1904 (0, "TSC_component::Start here"));
1905 }
1906
1907 }
1908
StartDisconnect(bool terminate)1909 void TSC_component::StartDisconnect(bool terminate)
1910 {
1911 if (terminate)
1912 {
1913 StopData();
1914 CloseChannels();
1915 Deallocate(iOutCodecList);
1916 }
1917 }
1918
TimeoutOccurred(int32 timerID,int32 timeoutInfo)1919 void TSC_component::TimeoutOccurred(int32 timerID, int32 timeoutInfo)
1920 {
1921 OSCL_UNUSED_ARG(timeoutInfo);
1922 if (timerID == PV_TSC_WAITING_FOR_OBLC_TIMER_ID)
1923 {
1924 iWaitingForOblc = false;
1925 iWaitingForOblcCodec = PV_CODEC_TYPE_NONE;
1926 }
1927 }
1928
1929 /*****************************************************************************/
1930 /* function name : Status08Event19 E_PtvId_Clc_Cls_Idc */
1931 /* function outline : Status08/Event19 procedure */
1932 /* function discription : Status08Event19( pReceiveInf ) */
1933 /* input data : PS_ControlMsgHeader Receive InfHeader Pointer */
1934 /* output data : uint32 Terminal Status */
1935 /* draw time : '96.10.09 */
1936 /*---------------------------------------------------------------------------*/
1937 /* amendment career(x) : */
1938 /* */
1939 /* Copyright (C) 1996 NTT DoCoMo */
1940 /*****************************************************************************/
Status08Event19(PS_ControlMsgHeader pReceiveInf)1941 uint32 TSC_component::Status08Event19(PS_ControlMsgHeader pReceiveInf)
1942 {
1943 TPVChannelId ClcLcn = CHANNEL_ID_UNKNOWN;
1944 uint32 Directional = 0; /* UNI=1, BI=2 */
1945
1946 /* (RECEIVED AN INCOMING RequestChannelClose) */
1947 /* Input parameters */
1948 ClcLcn = (TPVChannelId)pReceiveInf->InfSupplement1; /* Channel requested to be closed */
1949 Directional = pReceiveInf->InfSupplement2; /* Directionality */
1950 if (Directional != 1 && Directional != 2)
1951 {
1952 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1953 (0, "TSC_component::Status08Event19 Invalid directionality"));
1954 iTSCclc.ClcRjtReq(ClcLcn);
1955 return (PhaseE_Comm);
1956 }
1957
1958 if (!HasOlc(OUTGOING, ClcLcn))
1959 {
1960 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
1961 (0, "TSC_component::Status08Event19 unable to lookup outgoing channel id(%d)",
1962 ClcLcn));
1963 iTSCclc.ClcRjtReq(ClcLcn);
1964 return (PhaseE_Comm);
1965 }
1966
1967 /* Primitive Send */
1968 iTSCclc.ClcClsRps(ClcLcn); /* Send RCCAck Message */
1969
1970 ChannelReleased(OUTGOING, ClcLcn, PVMFSuccess);
1971
1972 /* Send the H.245 CloseLogicalChannel message */
1973 if (Directional == 1) /* UniDirectional */
1974 {
1975 TPVDirection dir = iTSClc.LcRlsReq(RELEASE_CLOSE, ClcLcn, 0);
1976 RemoveOlc(dir, ClcLcn);
1977 }
1978 else if (Directional == 2) /* BiDirectional */
1979 {
1980 TPVDirection dir = iTSCblc.BlcRlsReq(RELEASE_CLOSE, ClcLcn, 0);
1981 RemoveOlc(dir, ClcLcn);
1982 }
1983 return(PhaseE_Comm);
1984 }
1985
1986 /*****************************************************************************/
1987 /* function name : Status04Event15 E_PtvId_Blc_Etb_Cfm */
1988 /* function outline : Status04/Event15 procedure */
1989 /* function discription : Status04Event15( pReceiveInf ) */
1990 /* input data : PS_ControlMsgHeader Receive InfHeader Pointer */
1991 /* output data : uint32 Terminal Status */
1992 /* draw time : '96.10.09 */
1993 /*---------------------------------------------------------------------------*/
1994 /* amendment career(x) : */
1995 /* */
1996 /* Copyright (C) 1996 NTT DoCoMo */
1997 /*****************************************************************************/
BlcEtbCfm(PS_ControlMsgHeader pReceiveInf)1998 uint32 TSC_component::BlcEtbCfm(PS_ControlMsgHeader pReceiveInf)
1999 {
2000 TPVChannelId incoming_lcn = pReceiveInf->InfSupplement2 + TSC_INCOMING_CHANNEL_MASK;
2001 OlcParam* olc_param = iOlcs.FindOlcGivenChannel(OUTGOING, pReceiveInf->InfSupplement1);
2002 if (olc_param == NULL)
2003 {
2004 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2005 (0, "TSC_component::BlcEtbCfm ERROR Unable to lookup channel"));
2006 return PhaseE_Comm;
2007 }
2008 olc_param->SetState(OLC_ESTABLISHED);
2009
2010 // Resume the channel if MT is also complete
2011 CheckOutgoingChannel(olc_param, PVMFSuccess);
2012
2013 if (olc_param->GetReverseParams())
2014 {
2015 // Set the incoming logical channel number
2016 olc_param->GetReverseParams()->SetChannelId(incoming_lcn);
2017 // Open the incoming channel in the mux
2018 OpenPort(INCOMING,
2019 olc_param->GetReverseParams()->GetChannelId(),
2020 olc_param->GetReverseParams());
2021
2022 uint8* fsi = NULL;
2023 uint32 fsi_len = ::GetFormatSpecificInfo(olc_param->GetReverseParams()->GetDataType(), fsi);
2024 iTSCObserver->IncomingChannel(incoming_lcn,
2025 GetCodecType(olc_param->GetReverseParams()->GetDataType()),
2026 fsi, fsi_len);
2027 }
2028 return PhaseE_Comm;
2029 }
2030
2031
2032 // =============================================================
2033 // Status04Event50() E_PtvId_Blc_Etb_Cfm2
2034 //
2035 // This is "BLCSE ESTABLISH.confirm2"
2036 // It is called when SE receives an OLCConfirm (Bi-Dir).
2037 // =============================================================
BlcEtbCfm2(PS_ControlMsgHeader pReceiveInf)2038 uint32 TSC_component::BlcEtbCfm2(PS_ControlMsgHeader pReceiveInf)
2039 {
2040 OSCL_UNUSED_ARG(pReceiveInf);
2041 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2042 (0, "TSC_component::BlcEtbCfm2 forward(%d), reverse(%d))\n",
2043 pReceiveInf->InfSupplement1, pReceiveInf->InfSupplement2));
2044 OlcParam* olc_param = iOlcs.FindOlcGivenChannel(INCOMING,
2045 pReceiveInf->InfSupplement1 + TSC_INCOMING_CHANNEL_MASK);
2046 if (olc_param == NULL)
2047 {
2048 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2049 (0, "TSC_component::BlcEtbCfm ERROR Unable to lookup channel"));
2050 return PhaseE_Comm;
2051 }
2052 olc_param->SetState(OLC_ESTABLISHED);
2053 // Resume the channel if MT is also complete
2054 CheckOutgoingChannel(olc_param, PVMFSuccess);
2055 return PhaseE_Comm;
2056 }
2057
2058
2059 /*****************************************************************************/
2060 /* function name : Status08Event12 E_PtvId_Lc_Rls_Cfm */
2061 /* function outline : Status08/Event12 procedure */
2062 /* function discription : Status08Event12( pReceiveInf ) */
2063 /* input data : PS_ControlMsgHeader Receive InfHeader Pointer */
2064 /* output data : uint32 Terminal Status */
2065 /* draw time : '00.4.13 */
2066 /*---------------------------------------------------------------------------*/
LcRlsCfm(PS_ControlMsgHeader pReceiveInf)2067 uint32 TSC_component::LcRlsCfm(PS_ControlMsgHeader pReceiveInf)
2068 {
2069 TPVChannelId lcn = (TPVChannelId) pReceiveInf->InfSupplement1;
2070 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2071 (0, "TSC_component::LcRlsCfm - lcn(%d)\n", lcn));
2072 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2073 (0, "TSC_component::LcRlsCfm - lcn(%d)\n", lcn));
2074 ChannelReleased(OUTGOING, lcn, PVMFSuccess);
2075 return(PhaseE_Comm);
2076 }
2077
2078 /*****************************************************************************/
2079 /* function name : Status08Event17 E_PtvId_Blc_Rls_Cfm */
2080 /* function outline : Status08/Event17 procedure */
2081 /* function discription : Status08Event17( pReceiveInf ) */
2082 /* input data : PS_ControlMsgHeader Receive InfHeader Pointer */
2083 /* output data : uint32 Terminal Status */
2084 /* draw time : '00.4.13 */
2085 /*---------------------------------------------------------------------------*/
2086 /* RAN - Bi-Dir OLCAck */
BlcRlsCfm(PS_ControlMsgHeader pReceiveInf)2087 uint32 TSC_component::BlcRlsCfm(PS_ControlMsgHeader pReceiveInf)
2088 {
2089 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2090 (0, "TSC_component::BlcRlsCfm - forward(%d), reverse(%d)",
2091 pReceiveInf->InfSupplement1, pReceiveInf->InfSupplement2));
2092 ChannelReleased(OUTGOING,
2093 pReceiveInf->InfSupplement1, PVMFSuccess);
2094 return PhaseE_Comm;
2095 }
2096
GetLogicalChannelInfo(PVMFPortInterface & port)2097 LogicalChannelInfo* TSC_component::GetLogicalChannelInfo(PVMFPortInterface& port)
2098 {
2099 return iTSCchannelcontrol.GetLogicalChannelInfo(port);
2100 }
2101
ReceivedFormatSpecificInfo(TPVChannelId channel_id,uint8 * fsi,uint32 fsi_len)2102 void TSC_component::ReceivedFormatSpecificInfo(TPVChannelId channel_id,
2103 uint8* fsi,
2104 uint32 fsi_len)
2105 {
2106 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2107 (0, "TSC_component::ReceivedFormatSpecificInfo lcn=%d, len=%d",
2108 channel_id, fsi_len));
2109 iTSCchannelcontrol.ReceivedFormatSpecificInfo(channel_id, fsi, fsi_len);
2110 }
2111
IsEstablishedLogicalChannel(TPVDirection aDir,TPVChannelId aChannelId)2112 bool TSC_component::IsEstablishedLogicalChannel(TPVDirection aDir,
2113 TPVChannelId aChannelId)
2114 {
2115 return iTSCchannelcontrol.IsEstablishedLogicalChannel(aDir, aChannelId);
2116 }
2117
2118
RemoveOlc(TPVDirection dir,TPVChannelId lcn)2119 void TSC_component::RemoveOlc(TPVDirection dir, TPVChannelId lcn)
2120 {
2121 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2122 (0, "TSC_component::RemoveOlc lcn(%d), dir(%d)", lcn, dir));
2123 OlcKey key(dir, lcn);
2124 OlcList::iterator iter = iOlcs.find(key);
2125 if (iter == iOlcs.end())
2126 return;
2127 OlcParam* param = (*iter).second;
2128
2129 if ((dir == OUTGOING || param->GetReverseParams()) &&
2130 (param->GetMtNum() && (param->GetMtSn() >= 0)) &&
2131 IsRemovable(lcn))
2132 {
2133 iTSCmt.DeleteMuxEntry(param->GetMtNum());
2134 }
2135
2136 iTSCmt.ReleaseMuxTables();
2137
2138 if (iter != iOlcs.end())
2139 {
2140 delete(*iter).second;
2141 iOlcs.erase(iter);
2142 }
2143 }
2144
ReleaseOlc(OlcParam * olc,uint16 cause)2145 void TSC_component::ReleaseOlc(OlcParam* olc, uint16 cause)
2146 {
2147 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2148 (0, "TSC_channelcontrol::ReleaseOlc olc(%x), reason(%d))", olc, cause));
2149 int release_type = (olc->GetDirection() == OUTGOING) ? RELEASE_CLOSE : RELEASE_REJECT;
2150
2151 if (olc->GetDirectionality() == EPVT_UNI_DIRECTIONAL)
2152 {
2153 iTSClc.LcRlsReq(release_type, olc->GetChannelId(), cause);
2154 }
2155 else
2156 {
2157 iTSCblc.BlcRlsReq(release_type, olc->GetChannelId(), cause);
2158 }
2159 }
2160
2161 /* This function just does the h.245 signalling for closing a logical channel - incoming/outgoing */
SignalChannelClose(TPVDirection dir,TPVChannelId lcn,TPVDirectionality directionality)2162 void TSC_component::SignalChannelClose(TPVDirection dir,
2163 TPVChannelId lcn,
2164 TPVDirectionality directionality)
2165 {
2166 /* Multiplex entries must have failed. Close the channel */
2167 if (dir == OUTGOING)
2168 {
2169 if (directionality == EPVT_BI_DIRECTIONAL)
2170 {
2171 TPVDirection dir = iTSCblc.BlcRlsReq(RELEASE_CLOSE, lcn, 0);
2172 RemoveOlc(dir, lcn);
2173 }
2174 else
2175 {
2176 TPVDirection dir = iTSClc.LcRlsReq(RELEASE_CLOSE, lcn, 0);
2177 RemoveOlc(dir, lcn);
2178 }
2179 }
2180 else
2181 {
2182 iTSCclc.ClcClsReq(lcn);
2183 }
2184 }
2185
CheckOutgoingChannel(OlcParam * olc_param,PVMFStatus status)2186 void TSC_component::CheckOutgoingChannel(OlcParam* olc_param, PVMFStatus status)
2187 {
2188 TPVChannelId id = (olc_param->GetDirection() == OUTGOING) ?
2189 olc_param->GetChannelId() : olc_param->GetReverseParams()->GetChannelId();
2190 PVCodecType_t codec_type = olc_param->GetDirection() == OUTGOING ?
2191 GetCodecType(olc_param->GetForwardParams()->GetDataType()) :
2192 GetCodecType(olc_param->GetReverseParams()->GetDataType());
2193 OSCL_UNUSED_ARG(codec_type);
2194 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2195 (0, "TSC_channelcontrol::CheckOutgoingChannel channel id=%d, codec type=%d, status=%d",
2196 olc_param->GetChannelId(), codec_type, status));
2197 if (status != PVMFSuccess)
2198 {
2199 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2200 (0, "TSC_component::CheckOutgoingChannel Channel open failed"));
2201 ChannelReleased(OUTGOING, olc_param->GetChannelId(), status);
2202 return;
2203 }
2204 if (olc_param->GetMtState() != MT_COMPLETE)
2205 {
2206 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2207 (0, "TSC_component::CheckOutgoingChannel channel id=%d Mux table send not complete",
2208 olc_param->GetChannelId()));
2209 return;
2210 }
2211 // OLC+MT is complete. Resume the channel.
2212 H223OutgoingChannelPtr outgoing_channel;
2213 status = iH223->GetOutgoingChannel(id, outgoing_channel);
2214 if (status != PVMFSuccess)
2215 {
2216 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2217 (0, "TSC_component::CheckOutgoingChannel ERROR Failed to lookup channel."));
2218 return;
2219 }
2220 outgoing_channel->Resume();
2221 // Request fast update from the engine
2222 iTSCObserver->RequestFrameUpdate(outgoing_channel);
2223 }
2224
ChannelReleased(TPVDirection dir,TPVChannelId lcn,PVMFStatus status)2225 OsclAny TSC_component::ChannelReleased(TPVDirection dir, TPVChannelId lcn, PVMFStatus status)
2226 {
2227 OSCL_UNUSED_ARG(status);
2228 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2229 (0, "TSC_channelcontrol::ChannelReleased dir(%d), lcn(%d), status(%d)",
2230 dir, lcn, status));
2231 OlcParam* olc_param = iOlcs.FindOlcGivenChannel(dir, lcn);
2232 if (olc_param == NULL)
2233 {
2234 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2235 (0, "TSC_channelcontrol::ChannelReleased Failed to lookup channel(%d), lcn(%d)\n",
2236 dir, lcn));
2237 return;
2238 }
2239
2240 if (dir == OUTGOING || olc_param->GetState() == OLC_ESTABLISHED)
2241 {
2242 iTSCObserver->ChannelClosed(dir,
2243 lcn,
2244 ::GetCodecType(olc_param->GetForwardParams()->GetDataType()),
2245 status);
2246 }
2247 if (olc_param->GetDirectionality() == EPVT_BI_DIRECTIONAL)
2248 {
2249 TPVChannelId rvs_lcn = olc_param->GetReverseParams()->GetChannelId();
2250 if (rvs_lcn &&
2251 (rvs_lcn != CHANNEL_ID_UNKNOWN) &&
2252 (dir == INCOMING || olc_param->GetState() == OLC_ESTABLISHED))
2253 {
2254 iTSCObserver->ChannelClosed(REVERSE_DIR(dir),
2255 rvs_lcn,
2256 ::GetCodecType(olc_param->GetReverseParams()->GetDataType()),
2257 status);
2258 }
2259 }
2260
2261 RemoveOlc(dir, lcn);
2262 }
2263
CloseChannels()2264 void TSC_component::CloseChannels()
2265 {
2266 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2267 (0, "TSC_channelcontrol::CloseChannels "));
2268 OlcList::iterator it = iOlcs.begin();
2269 while (it != iOlcs.end())
2270 {
2271 OlcParam* olc = (*it++).second;
2272 ChannelReleased(olc->GetDirection(), olc->GetChannelId(), PVMFSuccess);
2273 it = iOlcs.begin();
2274 }
2275 }
2276
2277
OpenLogicalChannel(TPVDirection dir,TPVChannelId lcn,TPVChannelId lcnRvs,PS_DataType dt,PS_H223LogicalChannelParameters lcp,PS_DataType dtRvs,PS_H223LogicalChannelParameters lcpRvs)2278 OlcParam* TSC_component::OpenLogicalChannel(TPVDirection dir,
2279 TPVChannelId lcn,
2280 TPVChannelId lcnRvs,
2281 PS_DataType dt,
2282 PS_H223LogicalChannelParameters lcp,
2283 PS_DataType dtRvs,
2284 PS_H223LogicalChannelParameters lcpRvs)
2285 {
2286
2287 OSCL_UNUSED_ARG(lcpRvs);
2288 OSCL_UNUSED_ARG(dtRvs);
2289 OSCL_UNUSED_ARG(lcp);
2290 OSCL_UNUSED_ARG(dt);
2291
2292 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2293 (0, "TSC_channelcontrol::OpenLogicalChannel dir(%d), lcn(%d), dt(%x), lcp(%x), lcnRvs(%d), dtRvs(%x), lcpRvs(%x)\n", dir, lcn, dt, lcp, lcnRvs, dtRvs, lcpRvs));
2294 // add to list of channels
2295 OlcParam* olc_param = iOlcs.FindOlcGivenChannel(dir, lcn);
2296 if (olc_param == NULL)
2297 {
2298 SignalChannelClose(dir, lcn, lcnRvs == CHANNEL_ID_UNKNOWN ? EPVT_UNI_DIRECTIONAL : EPVT_BI_DIRECTIONAL);
2299 return NULL;
2300 }
2301
2302 /* Is this a replacement channel outgoing channel ? */
2303 if (dir == OUTGOING && olc_param->GetReplacementFor() != CHANNEL_ID_UNKNOWN)
2304 {
2305 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2306 (0, "TSC_channelcontrol::OpenLogicalChannel Replacement for outgoing channel id=%d",
2307 olc_param->GetReplacementFor()));
2308 ChannelReleased(OUTGOING, olc_param->GetReplacementFor(), PV2WayErrReplaced);
2309 olc_param->SetReplacementFor(0);
2310 }
2311
2312 if (olc_param->GetReverseParams())
2313 olc_param->GetReverseParams()->SetChannelId(lcnRvs);
2314
2315 TPVDirection rvs_dir = REVERSE_DIR(dir);
2316 OpenPort(dir, lcn, olc_param->GetForwardParams());
2317 if (olc_param->GetReverseParams() &&
2318 olc_param->GetReverseParams()->GetChannelId() != CHANNEL_ID_UNKNOWN)
2319 {
2320 OpenPort(rvs_dir, olc_param->GetReverseParams()->GetChannelId(),
2321 olc_param->GetReverseParams());
2322 }
2323 return olc_param;
2324 }
OpenPort(TPVDirection dir,TPVChannelId lcn,H223ChannelParam * param)2325 void TSC_component::OpenPort(TPVDirection dir, TPVChannelId lcn, H223ChannelParam* param)
2326 {
2327 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2328 (0, "TSC_channelcontrol::OpenPort dir(%d), lcn(%d), param(%x)\n",
2329 dir, lcn, param));
2330 PVCodecType_t codec_type = ::GetCodecType(param->GetDataType());
2331 if (codec_type == PV_CODEC_TYPE_NONE)
2332 {
2333 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2334 (0, "TSC_channelcontrol::OpenPort codec_type==NONE", codec_type));
2335 return;
2336 }
2337 iH223->OpenChannel(dir, lcn, param);
2338 }
2339
2340
GetOutgoingDataType(PVCodecType_t codecType,uint32 bitrate)2341 PS_DataType TSC_component::GetOutgoingDataType(PVCodecType_t codecType,
2342 uint32 bitrate)
2343 {
2344 uint8* csi = NULL;
2345 uint16 csi_len = 0;
2346 return iTSCcapability.GetOutgoingDataType(codecType, bitrate, csi_len, csi);
2347 }
2348
OpenOutgoingChannel(PVCodecType_t out_codec_type,PS_AdaptationLayerType adaptation_layer,PS_DataType pDataTypeRvs,PS_H223LogicalChannelParameters pH223ParamsRvs)2349 OlcParam* TSC_component::OpenOutgoingChannel(PVCodecType_t out_codec_type,
2350 PS_AdaptationLayerType adaptation_layer,
2351 PS_DataType pDataTypeRvs,
2352 PS_H223LogicalChannelParameters pH223ParamsRvs)
2353 {
2354 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2355 (0, "TSC_component::OpenOutgoingChannel codec(%d), layer(%x)",
2356 out_codec_type, adaptation_layer));
2357 OlcParam* ret = NULL;
2358 // allocate a channel id for this channel
2359 TPVChannelId channel_id = iOlcs.GetNextAvailLcn();
2360 uint32 bitrate = GetOutgoingBitrate(out_codec_type);
2361
2362 /* Fill the data type for the outgoing codec */
2363 PS_DataType pDataType = GetOutgoingDataType(out_codec_type, bitrate);
2364
2365 /* Fill the outgoing h223 logical channel parameters */
2366 PS_H223LogicalChannelParameters pH223Params =
2367 iTSCcapability.GetOutgoingLcnParams(GetMediaType(out_codec_type),
2368 adaptation_layer);
2369 if (adaptation_layer->index == 5)
2370 { /* AL3 */
2371 S_DataType nullDataType;
2372 if (pDataTypeRvs == NULL)
2373 {
2374 nullDataType.index = 1;
2375 pDataTypeRvs = &nullDataType;
2376 }
2377 if (pH223ParamsRvs == NULL)
2378 {
2379 pH223ParamsRvs = pH223Params;
2380 }
2381 PVCodecType_t in_codec_type = GetCodecType(pDataTypeRvs);
2382 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2383 (0, "TSC_component::OpenOutgoingChannel reverse codec(%d)", in_codec_type));
2384 if (in_codec_type != out_codec_type)
2385 {
2386 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
2387 (0, "TSC_component::OpenOutgoingChannel in codec type != out codec type"));
2388 }
2389 if (!CodecRequiresFsi(out_codec_type))
2390 {
2391 iTSCblc.BlcEtbReq(channel_id, pDataType, pH223Params,
2392 pDataTypeRvs, pH223ParamsRvs);
2393 }
2394 ret = iOlcs.AppendOlc(OUTGOING, channel_id, pDataType, pH223Params,
2395 CHANNEL_ID_UNKNOWN, pDataTypeRvs,
2396 pH223ParamsRvs);
2397 }
2398 else
2399 {
2400 if (!CodecRequiresFsi(out_codec_type))
2401 {
2402 iTSClc.LcEtbReq(channel_id, pDataType, pH223Params);
2403 }
2404
2405 ret = iOlcs.AppendOlc(OUTGOING, channel_id, pDataType, pH223Params);
2406 }
2407
2408 // Open the channel in the mux
2409 OpenLogicalChannel(OUTGOING, ret->GetChannelId());
2410 // Pause the channel untill OlcAck+MtAck is received
2411 H223OutgoingChannelPtr outgoing_channel;
2412 iH223->GetOutgoingChannel(ret->GetChannelId(), outgoing_channel);
2413 if (Pausable())
2414 {
2415 outgoing_channel->Pause();
2416 }
2417 // Notify outgoing channel
2418 iTSCObserver->OutgoingChannelEstablished(ret->GetChannelId(), out_codec_type,
2419 NULL, 0); /* FSI will be generated by video source/encoder */
2420
2421 Delete_DataType(pDataType);
2422 OSCL_DEFAULT_FREE(pDataType);
2423 Delete_H223LogicalChannelParameters(pH223Params);
2424 OSCL_DEFAULT_FREE(pH223Params);
2425 return ret;
2426 }
2427
2428
queryInterface(const PVUuid & uuid,PVInterface * & iface)2429 bool TSC_component::queryInterface(const PVUuid& uuid, PVInterface*& iface)
2430 {
2431 // Only returns the component interface
2432 if (uuid == PVUuidH324ComponentInterface)
2433 {
2434 PVMFComponentInterface* myInterface = OSCL_STATIC_CAST(PVMFComponentInterface*, this);
2435 iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
2436 }
2437 else
2438 {
2439 return false;
2440 }
2441
2442 return true;
2443 }
2444
2445 #ifdef MEM_TRACK
MemStats()2446 void TSC_component::MemStats()
2447 {
2448 #if !(OSCL_BYPASS_MEMMGT)
2449
2450 OsclAuditCB auditCB;
2451 OsclMemInit(auditCB);
2452 if (auditCB.pAudit)
2453 {
2454 MM_Stats_t* stats = auditCB.pAudit->MM_GetStats("");
2455 if (stats)
2456 {
2457 printf("\n###################Memory Stats Start#################\n");
2458 printf(" numBytes %d\n", stats->numBytes);
2459 printf(" peakNumBytes %d\n", stats->peakNumBytes);
2460 printf(" numAllocs %d\n", stats->numAllocs);
2461 printf(" peakNumAllocs %d\n", stats->peakNumAllocs);
2462 printf(" numAllocFails %d\n", stats->numAllocFails);
2463 printf(" totalNumAllocs %d\n", stats->totalNumAllocs);
2464 printf(" totalNumBytes %d\n", stats->totalNumBytes);
2465 printf("\n###################Memory Stats End###################\n");
2466 }
2467
2468 }
2469 #endif
2470 }
2471 #endif
2472
2473