1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Telephony Multimedia Service |
|
15 * |
|
16 */ |
|
17 |
|
18 #include <AudioPreference.h> |
|
19 #include "tmsutility.h" |
|
20 #include "tmsclientserver.h" |
|
21 #include "tmsshared.h" |
|
22 #include "ipcallstream.h" |
|
23 #include "callipadpt.h" |
|
24 |
|
25 using namespace TMS; |
|
26 |
|
27 // ----------------------------------------------------------------------------- |
|
28 // TMSCallIPAdpt::NewL |
|
29 // Symbian constructor. |
|
30 // ----------------------------------------------------------------------------- |
|
31 // |
|
32 TMSCallIPAdpt* TMSCallIPAdpt::NewL() |
|
33 { |
|
34 TMSCallIPAdpt* self = new (ELeave) TMSCallIPAdpt(); |
|
35 CleanupStack::PushL(self); |
|
36 self->ConstructL(); |
|
37 CleanupStack::Pop(self); |
|
38 return self; |
|
39 } |
|
40 |
|
41 // ----------------------------------------------------------------------------- |
|
42 // TMSCallIPAdpt::ConstructL |
|
43 // 2-nd phase constructor. |
|
44 // ----------------------------------------------------------------------------- |
|
45 // |
|
46 void TMSCallIPAdpt::ConstructL() |
|
47 { |
|
48 TRACE_PRN_FN_ENT; |
|
49 iIPUplink = NULL; |
|
50 iIPDownlink = NULL; |
|
51 iDTMFDnlinkPlayer = NULL; |
|
52 iDTMFUplinkPlayer = NULL; |
|
53 iDTMFNotifier = NULL; |
|
54 TRACE_PRN_FN_EXT; |
|
55 } |
|
56 |
|
57 // ----------------------------------------------------------------------------- |
|
58 // TMSCallIPAdpt::TMSCallIPAdpt |
|
59 // |
|
60 // ----------------------------------------------------------------------------- |
|
61 // |
|
62 TMSCallIPAdpt::TMSCallIPAdpt() |
|
63 { |
|
64 } |
|
65 |
|
66 // ----------------------------------------------------------------------------- |
|
67 // TMSCallIPAdpt::~TMSCallIPAdpt |
|
68 // |
|
69 // ----------------------------------------------------------------------------- |
|
70 // |
|
71 TMSCallIPAdpt::~TMSCallIPAdpt() |
|
72 { |
|
73 TRACE_PRN_FN_ENT; |
|
74 |
|
75 iCodecs.Reset(); |
|
76 iCodecs.Close(); |
|
77 iArrBitrates.Reset(); |
|
78 delete iDTMFUplinkPlayer; |
|
79 delete iDTMFDnlinkPlayer; |
|
80 delete iDTMFNotifier; |
|
81 delete iIPUplink; |
|
82 delete iIPDownlink; |
|
83 |
|
84 if (iMsgQueueUp.Handle() > 0) |
|
85 { |
|
86 iMsgQueueUp.Close(); |
|
87 } |
|
88 if (iMsgQueueDn.Handle() > 0) |
|
89 { |
|
90 iMsgQueueDn.Close(); |
|
91 } |
|
92 |
|
93 TRACE_PRN_FN_EXT; |
|
94 } |
|
95 |
|
96 // ----------------------------------------------------------------------------- |
|
97 // TMSCallIPAdpt::PostConstruct |
|
98 // |
|
99 // ----------------------------------------------------------------------------- |
|
100 // |
|
101 gint TMSCallIPAdpt::PostConstruct() |
|
102 { |
|
103 TRACE_PRN_FN_ENT; |
|
104 gint status(TMS_RESULT_SUCCESS); |
|
105 iNextStreamId = 1; |
|
106 iUplinkInitialized = FALSE; |
|
107 iDnlinkInitialized = FALSE; |
|
108 |
|
109 TRACE_PRN_FN_EXT; |
|
110 return status; |
|
111 } |
|
112 |
|
113 // ----------------------------------------------------------------------------- |
|
114 // TMSCallIPAdpt::CreateStream |
|
115 // |
|
116 // ----------------------------------------------------------------------------- |
|
117 // |
|
118 gint TMSCallIPAdpt::CreateStream(TMSCallType /*callType*/, |
|
119 TMSStreamType strmType, gint& outStrmId) |
|
120 { |
|
121 TRACE_PRN_FN_ENT; |
|
122 gint status(TMS_RESULT_SUCCESS); |
|
123 switch (strmType) |
|
124 { |
|
125 case TMS_STREAM_UPLINK: |
|
126 { |
|
127 status = TMS_RESULT_ALREADY_EXIST; |
|
128 if (!iUplinkInitialized) |
|
129 { |
|
130 iUplinkInitialized = TRUE; |
|
131 iUplinkStreamId = iNextStreamId; |
|
132 outStrmId = iUplinkStreamId; |
|
133 iNextStreamId++; |
|
134 status = TMS_RESULT_SUCCESS; |
|
135 } |
|
136 break; |
|
137 } |
|
138 case TMS_STREAM_DOWNLINK: |
|
139 { |
|
140 status = TMS_RESULT_ALREADY_EXIST; |
|
141 if (!iDnlinkInitialized) |
|
142 { |
|
143 iDnlinkInitialized = TRUE; |
|
144 iDnlinkStreamId = iNextStreamId; |
|
145 outStrmId = iDnlinkStreamId; |
|
146 iNextStreamId++; |
|
147 status = TMS_RESULT_SUCCESS; |
|
148 } |
|
149 break; |
|
150 } |
|
151 default: |
|
152 { |
|
153 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
|
154 break; |
|
155 } |
|
156 } |
|
157 TRACE_PRN_FN_EXT; |
|
158 return status; |
|
159 } |
|
160 |
|
161 // ----------------------------------------------------------------------------- |
|
162 // TMSCallIPAdpt::InitStream |
|
163 // |
|
164 // ----------------------------------------------------------------------------- |
|
165 // |
|
166 gint TMSCallIPAdpt::InitStreamL(TMSCallType /*callType*/, |
|
167 TMSStreamType strmType, gint strmId, TMSFormatType frmtType, |
|
168 const RMessage2& aMessage) |
|
169 { |
|
170 TRACE_PRN_FN_ENT; |
|
171 gint status(TMS_RESULT_SUCCESS); |
|
172 |
|
173 TUint32 fourCC = TOFOURCC(frmtType); |
|
174 if (fourCC == NULL) |
|
175 { |
|
176 return TMS_RESULT_INVALID_ARGUMENT; |
|
177 } |
|
178 |
|
179 switch (strmType) |
|
180 { |
|
181 case TMS_STREAM_UPLINK: |
|
182 { |
|
183 status = TMS_RESULT_DOES_NOT_EXIST; |
|
184 if (strmId == iUplinkStreamId) |
|
185 { |
|
186 SetFormat(iUplinkStreamId, fourCC); |
|
187 status = OpenUplinkL(aMessage); |
|
188 |
|
189 iDTMFUplinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this, |
|
190 KAudioPrefUnknownVoipAudioUplink, |
|
191 KAudioPriorityUnknownVoipAudioUplink); |
|
192 |
|
193 if(!iDTMFNotifier) |
|
194 { |
|
195 iDTMFNotifier = TMSDtmfNotifier::NewL(); |
|
196 } |
|
197 |
|
198 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
|
199 } |
|
200 break; |
|
201 } |
|
202 case TMS_STREAM_DOWNLINK: |
|
203 { |
|
204 status = TMS_RESULT_DOES_NOT_EXIST; |
|
205 if (strmId == iDnlinkStreamId) |
|
206 { |
|
207 SetFormat(iDnlinkStreamId, fourCC); |
|
208 status = OpenDownlinkL(aMessage); |
|
209 |
|
210 iDTMFDnlinkPlayer = TMSAudioDtmfTonePlayer::NewL(*this, |
|
211 KAudioPrefUnknownVoipAudioDownlink, |
|
212 KAudioPriorityUnknownVoipAudioDownlink); |
|
213 |
|
214 if(!iDTMFNotifier) |
|
215 { |
|
216 iDTMFNotifier = TMSDtmfNotifier::NewL(); |
|
217 } |
|
218 |
|
219 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
|
220 } |
|
221 break; |
|
222 } |
|
223 default: |
|
224 { |
|
225 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
|
226 break; |
|
227 } |
|
228 } |
|
229 |
|
230 TRACE_PRN_IF_ERR(status); |
|
231 TRACE_PRN_FN_EXT; |
|
232 return status; |
|
233 } |
|
234 |
|
235 // ----------------------------------------------------------------------------- |
|
236 // TMSCallIPAdpt::StartStream |
|
237 // |
|
238 // ----------------------------------------------------------------------------- |
|
239 // |
|
240 gint TMSCallIPAdpt::StartStream(TMSCallType /*callType*/, |
|
241 TMSStreamType strmType, gint strmId) |
|
242 { |
|
243 TRACE_PRN_FN_ENT; |
|
244 gint status(TMS_RESULT_INVALID_STATE); |
|
245 switch (strmType) |
|
246 { |
|
247 case TMS_STREAM_UPLINK: |
|
248 { |
|
249 if (strmId == iUplinkStreamId && iIPUplink) |
|
250 { |
|
251 iIPUplink->Start(); |
|
252 status = TMS_RESULT_SUCCESS; |
|
253 NotifyClient(iUplinkStreamId, ECmdUplinkStarted, status); |
|
254 } |
|
255 break; |
|
256 } |
|
257 case TMS_STREAM_DOWNLINK: |
|
258 { |
|
259 if (strmId == iDnlinkStreamId && iIPDownlink) |
|
260 { |
|
261 iIPDownlink->Start(); |
|
262 status = TMS_RESULT_SUCCESS; |
|
263 NotifyClient(iDnlinkStreamId, ECmdDownlinkStarted, status); |
|
264 } |
|
265 break; |
|
266 } |
|
267 default: |
|
268 { |
|
269 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
|
270 break; |
|
271 } |
|
272 } |
|
273 TRACE_PRN_FN_EXT; |
|
274 return status; |
|
275 } |
|
276 |
|
277 // ----------------------------------------------------------------------------- |
|
278 // TMSCallIPAdpt::PauseStream |
|
279 // |
|
280 // ----------------------------------------------------------------------------- |
|
281 // |
|
282 gint TMSCallIPAdpt::PauseStream(TMSCallType /*callType*/, |
|
283 TMSStreamType strmType, gint strmId) |
|
284 { |
|
285 TRACE_PRN_FN_ENT; |
|
286 gint status(TMS_RESULT_INVALID_STATE); |
|
287 switch (strmType) |
|
288 { |
|
289 case TMS_STREAM_UPLINK: |
|
290 { |
|
291 if (strmId == iUplinkStreamId && iIPUplink) |
|
292 { |
|
293 iIPUplink->Stop(); |
|
294 status = TMS_RESULT_SUCCESS; |
|
295 NotifyClient(iUplinkStreamId, ECmdUplinkPaused, status); |
|
296 } |
|
297 break; |
|
298 } |
|
299 case TMS_STREAM_DOWNLINK: |
|
300 { |
|
301 if (strmId == iDnlinkStreamId && iIPDownlink) |
|
302 { |
|
303 iIPDownlink->Stop(); |
|
304 status = TMS_RESULT_SUCCESS; |
|
305 NotifyClient(iDnlinkStreamId, ECmdDownlinkPaused, status); |
|
306 } |
|
307 break; |
|
308 } |
|
309 default: |
|
310 { |
|
311 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
|
312 break; |
|
313 } |
|
314 } |
|
315 TRACE_PRN_FN_EXT; |
|
316 return status; |
|
317 } |
|
318 |
|
319 // ----------------------------------------------------------------------------- |
|
320 // TMSCallIPAdpt::StopStream |
|
321 // |
|
322 // ----------------------------------------------------------------------------- |
|
323 // |
|
324 gint TMSCallIPAdpt::StopStream(TMSCallType /*callType*/, TMSStreamType strmType, |
|
325 gint strmId) |
|
326 { |
|
327 TRACE_PRN_FN_ENT; |
|
328 gint status(TMS_RESULT_INVALID_STATE); |
|
329 |
|
330 switch (strmType) |
|
331 { |
|
332 case TMS_STREAM_UPLINK: |
|
333 { |
|
334 if (strmId == iUplinkStreamId && iIPUplink) |
|
335 { |
|
336 iIPUplink->Stop(); |
|
337 status = TMS_RESULT_SUCCESS; |
|
338 NotifyClient(iUplinkStreamId, ECmdUplinkInitComplete, status); |
|
339 } |
|
340 break; |
|
341 } |
|
342 case TMS_STREAM_DOWNLINK: |
|
343 { |
|
344 if (strmId == iDnlinkStreamId && iIPDownlink) |
|
345 { |
|
346 iIPDownlink->Stop(); |
|
347 status = TMS_RESULT_SUCCESS; |
|
348 NotifyClient(iDnlinkStreamId, ECmdDownlinkInitComplete, status); |
|
349 } |
|
350 break; |
|
351 } |
|
352 default: |
|
353 { |
|
354 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
|
355 break; |
|
356 } |
|
357 } |
|
358 TRACE_PRN_FN_EXT; |
|
359 return status; |
|
360 } |
|
361 |
|
362 // ----------------------------------------------------------------------------- |
|
363 // TMSCallIPAdpt::DeinitStream |
|
364 // |
|
365 // ----------------------------------------------------------------------------- |
|
366 // |
|
367 gint TMSCallIPAdpt::DeinitStream(TMSCallType /*callType*/, |
|
368 TMSStreamType strmType, gint strmId) |
|
369 { |
|
370 TRACE_PRN_FN_ENT; |
|
371 gint status(TMS_RESULT_INVALID_STATE); |
|
372 |
|
373 switch (strmType) |
|
374 { |
|
375 case TMS_STREAM_UPLINK: |
|
376 { |
|
377 if (strmId == iUplinkStreamId && iIPUplink) |
|
378 { |
|
379 iIPUplink->Stop(); |
|
380 //iUplinkStreamId = -1; |
|
381 iUplinkInitialized = FALSE; |
|
382 status = TMS_RESULT_SUCCESS; |
|
383 NotifyClient(iUplinkStreamId, ECmdDownlinkDeInitComplete, |
|
384 status); |
|
385 } |
|
386 break; |
|
387 } |
|
388 case TMS_STREAM_DOWNLINK: |
|
389 { |
|
390 if (strmId == iDnlinkStreamId && iIPDownlink) |
|
391 { |
|
392 iIPDownlink->Stop(); |
|
393 //iDnlinkStreamId = -1; |
|
394 iDnlinkInitialized = FALSE; |
|
395 status = TMS_RESULT_SUCCESS; |
|
396 NotifyClient(iDnlinkStreamId, ECmdDownlinkDeInitComplete, |
|
397 status); |
|
398 } |
|
399 break; |
|
400 } |
|
401 default: |
|
402 { |
|
403 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
|
404 break; |
|
405 } |
|
406 } |
|
407 |
|
408 TRACE_PRN_FN_EXT; |
|
409 return status; |
|
410 } |
|
411 |
|
412 // ----------------------------------------------------------------------------- |
|
413 // TMSCallIPAdpt::DeleteStream |
|
414 // |
|
415 // ----------------------------------------------------------------------------- |
|
416 // |
|
417 gint TMSCallIPAdpt::DeleteStream(TMSCallType /*callType*/, |
|
418 TMSStreamType strmType, gint strmId) |
|
419 { |
|
420 TRACE_PRN_FN_ENT; |
|
421 gint status(TMS_RESULT_SUCCESS); |
|
422 switch (strmType) |
|
423 { |
|
424 case TMS_STREAM_UPLINK: |
|
425 { |
|
426 // This is additional error checking |
|
427 if (strmId == iUplinkStreamId) |
|
428 { |
|
429 iUplinkStreamId = -1; |
|
430 iUplinkInitialized = FALSE; |
|
431 } |
|
432 break; |
|
433 } |
|
434 case TMS_STREAM_DOWNLINK: |
|
435 { |
|
436 // This is additional error checking |
|
437 if (strmId == iDnlinkStreamId) |
|
438 { |
|
439 iDnlinkStreamId = -1; |
|
440 iDnlinkInitialized = FALSE; |
|
441 } |
|
442 break; |
|
443 } |
|
444 default: |
|
445 { |
|
446 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
|
447 break; |
|
448 } |
|
449 } |
|
450 TRACE_PRN_FN_EXT; |
|
451 return status; |
|
452 } |
|
453 |
|
454 // ----------------------------------------------------------------------------- |
|
455 // TMSCallIPAdpt::DataXferBufferEmptied |
|
456 // |
|
457 // ----------------------------------------------------------------------------- |
|
458 // |
|
459 gint TMSCallIPAdpt::DataXferBufferEmptied(TMSCallType /*callType*/, |
|
460 TMSStreamType strmType, gint strmId) |
|
461 { |
|
462 TRACE_PRN_FN_ENT; |
|
463 gint status(TMS_RESULT_SUCCESS); |
|
464 switch (strmType) |
|
465 { |
|
466 case TMS_STREAM_UPLINK: |
|
467 { |
|
468 if (strmId == iUplinkStreamId) |
|
469 { |
|
470 TRAP(status, BufferEmptiedL()); |
|
471 } |
|
472 break; |
|
473 } |
|
474 case TMS_STREAM_DOWNLINK: |
|
475 status = TMS_RESULT_ILLEGAL_OPERATION; |
|
476 break; |
|
477 default: |
|
478 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
|
479 break; |
|
480 } |
|
481 TRACE_PRN_FN_EXT; |
|
482 return status; |
|
483 } |
|
484 |
|
485 // ----------------------------------------------------------------------------- |
|
486 // TMSCallIPAdpt::DataXferBufferFilled |
|
487 // |
|
488 // ----------------------------------------------------------------------------- |
|
489 // |
|
490 gint TMSCallIPAdpt::DataXferBufferFilled(TMSCallType /*callType*/, |
|
491 TMSStreamType strmType, gint strmId, guint datasize) |
|
492 { |
|
493 TRACE_PRN_FN_ENT; |
|
494 gint status(TMS_RESULT_SUCCESS); |
|
495 switch (strmType) |
|
496 { |
|
497 case TMS_STREAM_DOWNLINK: |
|
498 if (strmId == iDnlinkStreamId) |
|
499 { |
|
500 TRAP(status, BufferFilledL(datasize)); |
|
501 } |
|
502 break; |
|
503 case TMS_STREAM_UPLINK: |
|
504 status = TMS_RESULT_ILLEGAL_OPERATION; |
|
505 break; |
|
506 default: |
|
507 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
|
508 break; |
|
509 } |
|
510 TRACE_PRN_FN_EXT; |
|
511 return status; |
|
512 } |
|
513 |
|
514 // ----------------------------------------------------------------------------- |
|
515 // TMSCallIPAdpt::GetDataXferBufferHndl |
|
516 // |
|
517 // ----------------------------------------------------------------------------- |
|
518 // |
|
519 gint TMSCallIPAdpt::GetDataXferBufferHndl(const TMSCallType /*callType*/, |
|
520 const TMSStreamType strmType, const gint strmId, const guint32 key, |
|
521 RChunk& chunk) |
|
522 { |
|
523 TRACE_PRN_FN_ENT; |
|
524 gint status(TMS_RESULT_SUCCESS); |
|
525 switch (strmType) |
|
526 { |
|
527 case TMS_STREAM_DOWNLINK: |
|
528 { |
|
529 if (strmId == iDnlinkStreamId) |
|
530 { |
|
531 TRAP(status, GetDataXferChunkHndl(strmType, key, chunk)); |
|
532 } |
|
533 break; |
|
534 } |
|
535 case TMS_STREAM_UPLINK: |
|
536 { |
|
537 if (strmId == iUplinkStreamId) |
|
538 { |
|
539 TRAP(status, GetDataXferChunkHndl(strmType, key, chunk)); |
|
540 } |
|
541 break; |
|
542 } |
|
543 default: |
|
544 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
|
545 break; |
|
546 } |
|
547 TRACE_PRN_FN_EXT; |
|
548 return status; |
|
549 } |
|
550 |
|
551 // ----------------------------------------------------------------------------- |
|
552 // TMSCallIPAdpt::GetMaxVolume |
|
553 // |
|
554 // ----------------------------------------------------------------------------- |
|
555 // |
|
556 gint TMSCallIPAdpt::GetMaxVolume(guint& volume) |
|
557 { |
|
558 TRACE_PRN_FN_ENT; |
|
559 gint status(TMS_RESULT_INVALID_STATE); |
|
560 |
|
561 if (iDnlinkInitialized && iIPDownlink) |
|
562 { |
|
563 status = iIPDownlink->GetMaxVolume(volume); |
|
564 iMaxVolume = volume; |
|
565 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume); |
|
566 } |
|
567 |
|
568 TRACE_PRN_FN_EXT; |
|
569 return status; |
|
570 } |
|
571 |
|
572 // ----------------------------------------------------------------------------- |
|
573 // TMSCallIPAdpt::SetVolume |
|
574 // |
|
575 // ----------------------------------------------------------------------------- |
|
576 // |
|
577 gint TMSCallIPAdpt::SetVolume(const guint volume) |
|
578 { |
|
579 TRACE_PRN_FN_ENT; |
|
580 gint status(TMS_RESULT_INVALID_STATE); |
|
581 if (iDnlinkInitialized && iIPDownlink) |
|
582 { |
|
583 status = iIPDownlink->SetVolume(volume); |
|
584 NotifyClient(iDnlinkStreamId, ECmdSetVolume, status); |
|
585 } |
|
586 TRACE_PRN_FN_EXT; |
|
587 return status; |
|
588 } |
|
589 |
|
590 // ----------------------------------------------------------------------------- |
|
591 // TMSCallIPAdpt::GetVolume |
|
592 // |
|
593 // ----------------------------------------------------------------------------- |
|
594 // |
|
595 gint TMSCallIPAdpt::GetVolume(guint& volume) |
|
596 { |
|
597 TRACE_PRN_FN_ENT; |
|
598 gint status(TMS_RESULT_INVALID_STATE); |
|
599 if (iDnlinkInitialized && iIPDownlink) |
|
600 { |
|
601 status = iIPDownlink->GetVolume(volume); |
|
602 } |
|
603 TRACE_PRN_FN_EXT; |
|
604 return status; |
|
605 } |
|
606 |
|
607 // ----------------------------------------------------------------------------- |
|
608 // TMSCallIPAdpt::GetMaxGain |
|
609 // |
|
610 // ----------------------------------------------------------------------------- |
|
611 // |
|
612 gint TMSCallIPAdpt::GetMaxGain(guint& gain) |
|
613 { |
|
614 TRACE_PRN_FN_ENT; |
|
615 gint status(TMS_RESULT_INVALID_STATE); |
|
616 if (iUplinkInitialized && iIPUplink) |
|
617 { |
|
618 status = iIPUplink->GetMaxGain(gain); |
|
619 iMaxGain = gain; |
|
620 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetMaxGain [%d]"), iMaxGain); |
|
621 } |
|
622 TRACE_PRN_FN_EXT; |
|
623 return status; |
|
624 } |
|
625 |
|
626 // ----------------------------------------------------------------------------- |
|
627 // TMSCallIPAdpt::SetGain |
|
628 // |
|
629 // ----------------------------------------------------------------------------- |
|
630 // |
|
631 gint TMSCallIPAdpt::SetGain(const guint gain) |
|
632 { |
|
633 TRACE_PRN_FN_ENT; |
|
634 gint status(TMS_RESULT_INVALID_STATE); |
|
635 if (iUplinkInitialized && iIPUplink) |
|
636 { |
|
637 status = iIPUplink->SetGain(gain); |
|
638 NotifyClient(iUplinkStreamId, ECmdSetGain, status); |
|
639 } |
|
640 TRACE_PRN_FN_EXT; |
|
641 return status; |
|
642 } |
|
643 |
|
644 // ----------------------------------------------------------------------------- |
|
645 // TMSCallIPAdpt::GetGain |
|
646 // |
|
647 // ----------------------------------------------------------------------------- |
|
648 // |
|
649 gint TMSCallIPAdpt::GetGain(guint& gain) |
|
650 { |
|
651 TRACE_PRN_FN_ENT; |
|
652 gint status(TMS_RESULT_INVALID_STATE); |
|
653 if (iUplinkInitialized && iIPUplink) |
|
654 { |
|
655 status = iIPUplink->GetGain(gain); |
|
656 } |
|
657 TRACE_PRN_FN_EXT; |
|
658 return status; |
|
659 } |
|
660 |
|
661 // ----------------------------------------------------------------------------- |
|
662 // TMSCallIPAdpt::GetGlobalMaxVolume |
|
663 // |
|
664 // ----------------------------------------------------------------------------- |
|
665 // |
|
666 gint TMSCallIPAdpt::GetGlobalMaxVolume(guint& volume) |
|
667 { |
|
668 TRACE_PRN_FN_ENT; |
|
669 gint status(TMS_RESULT_INVALID_STATE); |
|
670 if (iDnlinkInitialized && iIPDownlink) |
|
671 { |
|
672 status = iIPDownlink->GetMaxVolume(volume); |
|
673 iMaxVolume = volume; |
|
674 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume); |
|
675 } |
|
676 TRACE_PRN_FN_EXT; |
|
677 return status; |
|
678 } |
|
679 |
|
680 // ----------------------------------------------------------------------------- |
|
681 // TMSCallIPAdpt::SetGlobalVolume |
|
682 // |
|
683 // ----------------------------------------------------------------------------- |
|
684 // |
|
685 gint TMSCallIPAdpt::SetGlobalVolume(const guint volume) |
|
686 { |
|
687 TRACE_PRN_FN_ENT; |
|
688 gint status(TMS_RESULT_INVALID_STATE); |
|
689 if (iDnlinkInitialized && iIPDownlink) |
|
690 { |
|
691 status = iIPDownlink->SetVolume(volume); |
|
692 } |
|
693 TRACE_PRN_FN_EXT; |
|
694 return status; |
|
695 } |
|
696 |
|
697 // ----------------------------------------------------------------------------- |
|
698 // TMSCallIPAdpt::GetGlobalVolume |
|
699 // |
|
700 // ----------------------------------------------------------------------------- |
|
701 // |
|
702 gint TMSCallIPAdpt::GetGlobalVolume(guint& volume) |
|
703 { |
|
704 TRACE_PRN_FN_ENT; |
|
705 gint status(TMS_RESULT_INVALID_STATE); |
|
706 if (iDnlinkInitialized && iIPDownlink) |
|
707 { |
|
708 status = iIPDownlink->GetVolume(volume); |
|
709 } |
|
710 TRACE_PRN_FN_EXT; |
|
711 return status; |
|
712 } |
|
713 |
|
714 // ----------------------------------------------------------------------------- |
|
715 // TMSCallIPAdpt::GetGlobalMaxGain |
|
716 // |
|
717 // ----------------------------------------------------------------------------- |
|
718 // |
|
719 gint TMSCallIPAdpt::GetGlobalMaxGain(guint& gain) |
|
720 { |
|
721 TRACE_PRN_FN_ENT; |
|
722 gint status(TMS_RESULT_INVALID_STATE); |
|
723 if (iUplinkInitialized && iIPUplink) |
|
724 { |
|
725 status = iIPUplink->GetMaxGain(gain); |
|
726 iMaxGain = gain; |
|
727 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetMaxGain [%d]"), iMaxGain); |
|
728 } |
|
729 TRACE_PRN_FN_EXT; |
|
730 return status; |
|
731 } |
|
732 |
|
733 // ----------------------------------------------------------------------------- |
|
734 // TMSCallIPAdpt::SetGlobalGain |
|
735 // |
|
736 // ----------------------------------------------------------------------------- |
|
737 // |
|
738 gint TMSCallIPAdpt::SetGlobalGain(const guint gain) |
|
739 { |
|
740 TRACE_PRN_FN_ENT; |
|
741 gint status(TMS_RESULT_INVALID_STATE); |
|
742 if (iUplinkInitialized && iIPUplink) |
|
743 { |
|
744 status = iIPUplink->SetGain(gain); |
|
745 } |
|
746 TRACE_PRN_FN_EXT; |
|
747 return status; |
|
748 } |
|
749 |
|
750 // ----------------------------------------------------------------------------- |
|
751 // TMSCallIPAdpt::GetGlobalGain |
|
752 // |
|
753 // ----------------------------------------------------------------------------- |
|
754 // |
|
755 gint TMSCallIPAdpt::GetGlobalGain(guint& gain) |
|
756 { |
|
757 TRACE_PRN_FN_ENT; |
|
758 gint status(TMS_RESULT_INVALID_STATE); |
|
759 if (iUplinkInitialized && iIPUplink) |
|
760 { |
|
761 status = iIPUplink->GetGain(gain); |
|
762 } |
|
763 TRACE_PRN_FN_EXT; |
|
764 return status; |
|
765 } |
|
766 |
|
767 // ----------------------------------------------------------------------------- |
|
768 // TMSCallIPAdpt::GetCodecMode |
|
769 // |
|
770 // ----------------------------------------------------------------------------- |
|
771 // |
|
772 gint TMSCallIPAdpt::GetCodecMode(const TMSFormatType fmttype, |
|
773 const TMSStreamType strmtype, gint& mode) |
|
774 { |
|
775 TRACE_PRN_FN_ENT; |
|
776 gint status(TMS_RESULT_SUCCESS); |
|
777 switch (fmttype) |
|
778 { |
|
779 case TMS_FORMAT_ILBC: |
|
780 status = GetIlbcCodecMode(mode, strmtype); |
|
781 break; |
|
782 case TMS_FORMAT_G711: |
|
783 status = GetG711CodecMode(mode, strmtype); |
|
784 break; |
|
785 default: |
|
786 status = TMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED; |
|
787 break; |
|
788 } |
|
789 TRACE_PRN_FN_EXT; |
|
790 return status; |
|
791 } |
|
792 |
|
793 // ----------------------------------------------------------------------------- |
|
794 // TMSCallIPAdpt::SetCodecMode |
|
795 // |
|
796 // ----------------------------------------------------------------------------- |
|
797 // |
|
798 gint TMSCallIPAdpt::SetCodecMode(const TMSFormatType fmttype, |
|
799 const TMSStreamType strmtype, const gint mode) |
|
800 { |
|
801 TRACE_PRN_FN_ENT; |
|
802 gint status(TMS_RESULT_SUCCESS); |
|
803 switch (fmttype) |
|
804 { |
|
805 case TMS_FORMAT_ILBC: |
|
806 status = SetIlbcCodecMode(mode, strmtype); |
|
807 break; |
|
808 case TMS_FORMAT_G711: |
|
809 status = SetG711CodecMode(mode, strmtype); |
|
810 break; |
|
811 default: |
|
812 status = TMS_RESULT_FORMAT_TYPE_NOT_SUPPORTED; |
|
813 break; |
|
814 } |
|
815 TRACE_PRN_FN_EXT; |
|
816 return status; |
|
817 } |
|
818 |
|
819 // ----------------------------------------------------------------------------- |
|
820 // TMSCallIPAdpt::GetSupportedBitRatesCount |
|
821 // |
|
822 // ----------------------------------------------------------------------------- |
|
823 // |
|
824 gint TMSCallIPAdpt::GetSupportedBitRatesCount(guint& count) |
|
825 { |
|
826 TRACE_PRN_FN_ENT; |
|
827 gint status(TMS_RESULT_INVALID_STATE); |
|
828 if (iIPUplink) |
|
829 { |
|
830 status = iIPUplink->GetSupportedBitrates(iArrBitrates); |
|
831 count = iArrBitrates.Count(); |
|
832 } |
|
833 TRACE_PRN_FN_EXT; |
|
834 return status; |
|
835 } |
|
836 |
|
837 // ----------------------------------------------------------------------------- |
|
838 // TMSCallIPAdpt::GetSupportedBitRates |
|
839 // |
|
840 // Bitrates are already returned from the codec as a result of call to |
|
841 // GetSupportedBitratesCount(). Just pack them into a descriptor and return |
|
842 // back to the client. |
|
843 // ----------------------------------------------------------------------------- |
|
844 // |
|
845 gint TMSCallIPAdpt::GetSupportedBitRates(CBufFlat*& brbuffer) |
|
846 { |
|
847 TRAPD(status, GetSupportedBitRatesL(brbuffer)); |
|
848 return status; |
|
849 } |
|
850 |
|
851 // ----------------------------------------------------------------------------- |
|
852 // TMSCallIPAdpt::GetSupportedBitRatesL |
|
853 // |
|
854 // GetSupportedBitRates implementation which can leave. |
|
855 // ----------------------------------------------------------------------------- |
|
856 // |
|
857 void TMSCallIPAdpt::GetSupportedBitRatesL(CBufFlat*& brbuffer) |
|
858 { |
|
859 TRACE_PRN_FN_ENT; |
|
860 RBufWriteStream stream; |
|
861 stream.Open(*brbuffer); |
|
862 CleanupClosePushL(stream); |
|
863 guint numOfItems = iArrBitrates.Count(); |
|
864 |
|
865 for (guint i = 0; i < numOfItems; i++) |
|
866 { |
|
867 stream.WriteUint32L(iArrBitrates[i]); |
|
868 //TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: BR: [%d]"), iArrBitrates[i]); |
|
869 } |
|
870 |
|
871 CleanupStack::PopAndDestroy(&stream); |
|
872 TRACE_PRN_FN_EXT; |
|
873 } |
|
874 |
|
875 // ----------------------------------------------------------------------------- |
|
876 // TMSCallIPAdpt::GetBitRate |
|
877 // |
|
878 // ----------------------------------------------------------------------------- |
|
879 // |
|
880 gint TMSCallIPAdpt::GetBitRate(guint& bitrate) |
|
881 { |
|
882 TRACE_PRN_FN_ENT; |
|
883 gint status(TMS_RESULT_INVALID_STATE); |
|
884 if (iIPUplink) |
|
885 { |
|
886 status = iIPUplink->GetBitrate(bitrate); |
|
887 } |
|
888 TRACE_PRN_FN_EXT; |
|
889 return status; |
|
890 } |
|
891 |
|
892 // ----------------------------------------------------------------------------- |
|
893 // TMSCallIPAdpt::SetBitRate |
|
894 // |
|
895 // ----------------------------------------------------------------------------- |
|
896 // |
|
897 gint TMSCallIPAdpt::SetBitRate(const guint bitrate) |
|
898 { |
|
899 TRACE_PRN_FN_ENT; |
|
900 gint status(TMS_RESULT_INVALID_STATE); |
|
901 if (iIPUplink) |
|
902 { |
|
903 status = iIPUplink->SetBitrate(bitrate); |
|
904 } |
|
905 TRACE_PRN_FN_EXT; |
|
906 return status; |
|
907 } |
|
908 |
|
909 // ----------------------------------------------------------------------------- |
|
910 // TMSCallIPAdpt::GetVAD |
|
911 // |
|
912 // ----------------------------------------------------------------------------- |
|
913 // |
|
914 gint TMSCallIPAdpt::GetVAD(const TMSFormatType fmttype, gboolean& vad) |
|
915 { |
|
916 TRACE_PRN_FN_ENT; |
|
917 gint status(TMS_RESULT_INVALID_STATE); |
|
918 if (iIPUplink) |
|
919 { |
|
920 status = iIPUplink->GetVad(fmttype, vad); |
|
921 } |
|
922 TRACE_PRN_FN_EXT; |
|
923 return status; |
|
924 } |
|
925 |
|
926 // ----------------------------------------------------------------------------- |
|
927 // TMSCallIPAdpt::SetVAD |
|
928 // |
|
929 // ----------------------------------------------------------------------------- |
|
930 // |
|
931 gint TMSCallIPAdpt::SetVAD(const TMSFormatType fmttype, const gboolean vad) |
|
932 { |
|
933 TRACE_PRN_FN_ENT; |
|
934 gint status(TMS_RESULT_INVALID_STATE); |
|
935 if (iIPUplink) |
|
936 { |
|
937 status = iIPUplink->SetVad(fmttype, vad); |
|
938 } |
|
939 TRACE_PRN_FN_EXT; |
|
940 return status; |
|
941 } |
|
942 |
|
943 // ----------------------------------------------------------------------------- |
|
944 // TMSCallIPAdpt::GetCNG |
|
945 // |
|
946 // ----------------------------------------------------------------------------- |
|
947 // |
|
948 gint TMSCallIPAdpt::GetCNG(const TMSFormatType fmttype, gboolean& cng) |
|
949 { |
|
950 TRACE_PRN_FN_ENT; |
|
951 gint status(TMS_RESULT_INVALID_STATE); |
|
952 if (iIPDownlink) |
|
953 { |
|
954 status = iIPDownlink->GetCng(fmttype, cng); |
|
955 } |
|
956 TRACE_PRN_FN_EXT; |
|
957 return status; |
|
958 } |
|
959 |
|
960 // ----------------------------------------------------------------------------- |
|
961 // TMSCallIPAdpt::SetCNG |
|
962 // |
|
963 // ----------------------------------------------------------------------------- |
|
964 // |
|
965 gint TMSCallIPAdpt::SetCNG(const TMSFormatType fmttype, const gboolean cng) |
|
966 { |
|
967 TRACE_PRN_FN_ENT; |
|
968 gint status(TMS_RESULT_INVALID_STATE); |
|
969 if (iIPDownlink) |
|
970 { |
|
971 status = iIPDownlink->SetCng(fmttype, cng); |
|
972 } |
|
973 TRACE_PRN_FN_EXT; |
|
974 return status; |
|
975 } |
|
976 |
|
977 // ----------------------------------------------------------------------------- |
|
978 // TMSCallIPAdpt::GetPlc |
|
979 // |
|
980 // ----------------------------------------------------------------------------- |
|
981 // |
|
982 gint TMSCallIPAdpt::GetPlc(const TMSFormatType fmttype, gboolean& plc) |
|
983 { |
|
984 TRACE_PRN_FN_ENT; |
|
985 gint status(TMS_RESULT_INVALID_STATE); |
|
986 if (iIPDownlink) |
|
987 { |
|
988 status = iIPDownlink->GetPlc(fmttype, plc); |
|
989 } |
|
990 TRACE_PRN_FN_EXT; |
|
991 return status; |
|
992 } |
|
993 |
|
994 // ----------------------------------------------------------------------------- |
|
995 // TMSCallIPAdpt::SetPlc |
|
996 // |
|
997 // ----------------------------------------------------------------------------- |
|
998 // |
|
999 gint TMSCallIPAdpt::SetPlc(const TMSFormatType fmttype, const gboolean plc) |
|
1000 { |
|
1001 TRACE_PRN_FN_ENT; |
|
1002 gint status(TMS_RESULT_INVALID_STATE); |
|
1003 if (iIPDownlink) |
|
1004 { |
|
1005 status = iIPDownlink->SetPlc(fmttype, plc); |
|
1006 } |
|
1007 TRACE_PRN_FN_EXT; |
|
1008 return status; |
|
1009 } |
|
1010 |
|
1011 // ----------------------------------------------------------------------------- |
|
1012 // TMSCallIPAdpt::OpenDownlinkL |
|
1013 // Method for player initialization. |
|
1014 // ----------------------------------------------------------------------------- |
|
1015 // |
|
1016 gint TMSCallIPAdpt::OpenDownlinkL(const RMessage2& aMessage) |
|
1017 { |
|
1018 TRACE_PRN_FN_ENT; |
|
1019 gint status(TMS_RESULT_SUCCESS); |
|
1020 |
|
1021 // Clients must have MultimediaDD capability to use this priority/pref. |
|
1022 // TODO: Also, TMS will monitor for emergency call and if detected it |
|
1023 // will deny access to audio resources. |
|
1024 iPriority.iPref = KAudioPrefVoipAudioDownlink; |
|
1025 iPriority.iPriority = KAudioPriorityVoipAudioDownlink; |
|
1026 |
|
1027 if (!iIPDownlink) |
|
1028 { |
|
1029 iIPDownlink = TMSIPDownlink::NewL(iDnFourCC, iPriority); |
|
1030 } |
|
1031 |
|
1032 if (iIPDownlink) |
|
1033 { |
|
1034 // Open message queue for handling server notifications to the client |
|
1035 if (iMsgQueueDn.Handle() <= 0) |
|
1036 { |
|
1037 // Second argument in TMSCallProxy::InitStream |
|
1038 status = iMsgQueueDn.Open(aMessage, 1); |
|
1039 } |
|
1040 |
|
1041 if (status == TMS_RESULT_SUCCESS) |
|
1042 { |
|
1043 // For transfer data buffer processing |
|
1044 iIPDownlink->SetMsgQueue(iMsgQueueDn); |
|
1045 } |
|
1046 } |
|
1047 |
|
1048 TRACE_PRN_IF_ERR(status); |
|
1049 TRACE_PRN_FN_EXT; |
|
1050 return status; |
|
1051 } |
|
1052 |
|
1053 // ----------------------------------------------------------------------------- |
|
1054 // TMSCallIPAdpt::OpenUplinkL |
|
1055 // Method for recorder initialization. |
|
1056 // ----------------------------------------------------------------------------- |
|
1057 // |
|
1058 gint TMSCallIPAdpt::OpenUplinkL(const RMessage2& aMessage) |
|
1059 { |
|
1060 TRACE_PRN_FN_ENT; |
|
1061 gint status(TMS_RESULT_SUCCESS); |
|
1062 |
|
1063 // Ensure clients have MultimediaDD capability to use this priority/pref |
|
1064 iPriority.iPref = KAudioPrefVoipAudioUplink; |
|
1065 iPriority.iPriority = KAudioPriorityVoipAudioUplink; |
|
1066 |
|
1067 if (!iIPUplink) |
|
1068 { |
|
1069 iIPUplink = TMSIPUplink::NewL(iUpFourCC, iPriority); |
|
1070 } |
|
1071 |
|
1072 if (iIPUplink) |
|
1073 { |
|
1074 // Open message queue for handling server notifications to the client |
|
1075 if (iMsgQueueUp.Handle() <= 0) |
|
1076 { |
|
1077 // Second argument in TMSCallProxy::InitStream |
|
1078 status = iMsgQueueUp.Open(aMessage, 1); |
|
1079 } |
|
1080 |
|
1081 if (status == TMS_RESULT_SUCCESS) |
|
1082 { |
|
1083 // For transfer data buffer processing |
|
1084 iIPUplink->SetMsgQueue(iMsgQueueUp); |
|
1085 } |
|
1086 } |
|
1087 |
|
1088 TRACE_PRN_IF_ERR(status); |
|
1089 TRACE_PRN_FN_EXT; |
|
1090 return status; |
|
1091 } |
|
1092 |
|
1093 // ----------------------------------------------------------------------------- |
|
1094 // TMSCallIPAdpt::SetFormat |
|
1095 // |
|
1096 // ----------------------------------------------------------------------------- |
|
1097 // |
|
1098 void TMSCallIPAdpt::SetFormat(const gint strmId, const TUint32 aFormat) |
|
1099 { |
|
1100 if (strmId == iUplinkStreamId) |
|
1101 { |
|
1102 iUpFourCC = aFormat; |
|
1103 } |
|
1104 else if (strmId == iDnlinkStreamId) |
|
1105 { |
|
1106 iDnFourCC = aFormat; |
|
1107 } |
|
1108 } |
|
1109 |
|
1110 // ----------------------------------------------------------------------------- |
|
1111 // TMSCallIPAdpt::BufferFilled |
|
1112 // |
|
1113 // ----------------------------------------------------------------------------- |
|
1114 // |
|
1115 void TMSCallIPAdpt::BufferFilledL(TUint dataSize) |
|
1116 { |
|
1117 if (iIPDownlink) |
|
1118 { |
|
1119 iIPDownlink->BufferFilled(dataSize); |
|
1120 } |
|
1121 } |
|
1122 |
|
1123 // ----------------------------------------------------------------------------- |
|
1124 // TMSCallIPAdpt::BufferEmptied |
|
1125 // |
|
1126 // ----------------------------------------------------------------------------- |
|
1127 // |
|
1128 void TMSCallIPAdpt::BufferEmptiedL() |
|
1129 { |
|
1130 if (iIPUplink) |
|
1131 { |
|
1132 iIPUplink->BufferEmptied(); |
|
1133 } |
|
1134 } |
|
1135 |
|
1136 // ----------------------------------------------------------------------------- |
|
1137 // TMSCallIPAdpt::GetDataXferChunkHndl |
|
1138 // |
|
1139 // ----------------------------------------------------------------------------- |
|
1140 // |
|
1141 gint TMSCallIPAdpt::GetDataXferChunkHndl(const TMSStreamType strmType, |
|
1142 const TUint32 key, RChunk& chunk) |
|
1143 { |
|
1144 TRACE_PRN_FN_ENT; |
|
1145 |
|
1146 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
|
1147 switch (strmType) |
|
1148 { |
|
1149 case TMS_STREAM_DOWNLINK: |
|
1150 { |
|
1151 if (iIPDownlink) |
|
1152 { |
|
1153 status = iIPDownlink->GetDataXferChunkHndl(key, chunk); |
|
1154 } |
|
1155 break; |
|
1156 } |
|
1157 case TMS_STREAM_UPLINK: |
|
1158 { |
|
1159 if (iIPUplink) |
|
1160 { |
|
1161 status = iIPUplink->GetDataXferChunkHndl(key, chunk); |
|
1162 } |
|
1163 break; |
|
1164 } |
|
1165 default: |
|
1166 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
|
1167 break; |
|
1168 } |
|
1169 |
|
1170 TRACE_PRN_FN_EXT; |
|
1171 return status; |
|
1172 } |
|
1173 |
|
1174 // ----------------------------------------------------------------------------- |
|
1175 // TMSCallIPAdpt::SetIlbcCodecMode |
|
1176 // |
|
1177 // ----------------------------------------------------------------------------- |
|
1178 // |
|
1179 gint TMSCallIPAdpt::SetIlbcCodecMode(const gint mode, |
|
1180 const TMSStreamType strmtype) |
|
1181 { |
|
1182 gint status(TMS_RESULT_INVALID_ARGUMENT); |
|
1183 |
|
1184 if (strmtype == TMS_STREAM_DOWNLINK) |
|
1185 { |
|
1186 if (iDnlinkInitialized && iIPDownlink) |
|
1187 { |
|
1188 status = iIPDownlink->SetIlbcCodecMode(mode); |
|
1189 } |
|
1190 } |
|
1191 else if (strmtype == TMS_STREAM_UPLINK) |
|
1192 { |
|
1193 if (iUplinkInitialized && iIPUplink) |
|
1194 { |
|
1195 status = iIPUplink->SetIlbcCodecMode(mode); |
|
1196 } |
|
1197 } |
|
1198 |
|
1199 return status; |
|
1200 } |
|
1201 |
|
1202 // ----------------------------------------------------------------------------- |
|
1203 // TMSCallIPAdpt::GetIlbcCodecMode |
|
1204 // |
|
1205 // ----------------------------------------------------------------------------- |
|
1206 // |
|
1207 gint TMSCallIPAdpt::GetIlbcCodecMode(gint& mode, const TMSStreamType strmtype) |
|
1208 { |
|
1209 gint status(TMS_RESULT_INVALID_ARGUMENT); |
|
1210 |
|
1211 if (strmtype == TMS_STREAM_DOWNLINK) |
|
1212 { |
|
1213 if (iDnlinkInitialized && iIPDownlink) |
|
1214 { |
|
1215 status = iIPDownlink->GetIlbcCodecMode(mode); |
|
1216 } |
|
1217 } |
|
1218 else if (strmtype == TMS_STREAM_UPLINK) |
|
1219 { |
|
1220 if (iUplinkInitialized && iIPUplink) |
|
1221 { |
|
1222 status = iIPUplink->GetIlbcCodecMode(mode); |
|
1223 } |
|
1224 } |
|
1225 |
|
1226 return status; |
|
1227 } |
|
1228 |
|
1229 // ----------------------------------------------------------------------------- |
|
1230 // TMSCallIPAdpt::SetG711CodecMode |
|
1231 // |
|
1232 // ----------------------------------------------------------------------------- |
|
1233 // |
|
1234 gint TMSCallIPAdpt::SetG711CodecMode(const gint mode, |
|
1235 const TMSStreamType strmtype) |
|
1236 { |
|
1237 gint status(TMS_RESULT_INVALID_ARGUMENT); |
|
1238 |
|
1239 if (strmtype == TMS_STREAM_DOWNLINK) |
|
1240 { |
|
1241 if (iDnlinkInitialized && iIPDownlink) |
|
1242 { |
|
1243 status = iIPDownlink->SetG711CodecMode(mode); |
|
1244 } |
|
1245 } |
|
1246 else if (strmtype == TMS_STREAM_UPLINK) |
|
1247 { |
|
1248 if (iUplinkInitialized && iIPUplink) |
|
1249 { |
|
1250 status = iIPUplink->SetG711CodecMode(mode); |
|
1251 } |
|
1252 } |
|
1253 |
|
1254 return status; |
|
1255 } |
|
1256 |
|
1257 // ----------------------------------------------------------------------------- |
|
1258 // TMSCallIPAdpt::GetG711CodecMode |
|
1259 // |
|
1260 // ----------------------------------------------------------------------------- |
|
1261 // |
|
1262 gint TMSCallIPAdpt::GetG711CodecMode(gint& mode, const TMSStreamType strmtype) |
|
1263 { |
|
1264 gint status(TMS_RESULT_INVALID_ARGUMENT); |
|
1265 |
|
1266 if (strmtype == TMS_STREAM_DOWNLINK) |
|
1267 { |
|
1268 if (iDnlinkInitialized && iIPDownlink) |
|
1269 { |
|
1270 status = iIPDownlink->GetG711CodecMode(mode); |
|
1271 } |
|
1272 } |
|
1273 else if (strmtype == TMS_STREAM_UPLINK) |
|
1274 { |
|
1275 if (iUplinkInitialized && iIPUplink) |
|
1276 { |
|
1277 status = iIPUplink->GetG711CodecMode(mode); |
|
1278 } |
|
1279 } |
|
1280 |
|
1281 return status; |
|
1282 } |
|
1283 |
|
1284 // ----------------------------------------------------------------------------- |
|
1285 // TMSCallIPAdpt::FrameModeRequiredForEC |
|
1286 // |
|
1287 // ----------------------------------------------------------------------------- |
|
1288 // |
|
1289 gint TMSCallIPAdpt::FrameModeRqrdForEC(gboolean& frmodereq) |
|
1290 { |
|
1291 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
|
1292 if (iIPDownlink) |
|
1293 { |
|
1294 status = iIPDownlink->FrameModeRqrdForEC(frmodereq); |
|
1295 } |
|
1296 return status; |
|
1297 } |
|
1298 |
|
1299 // ----------------------------------------------------------------------------- |
|
1300 // TMSCallIPAdpt::SetFrameMode |
|
1301 // |
|
1302 // ----------------------------------------------------------------------------- |
|
1303 // |
|
1304 gint TMSCallIPAdpt::SetFrameMode(const gboolean frmode) |
|
1305 { |
|
1306 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
|
1307 if (iIPDownlink) |
|
1308 { |
|
1309 status = iIPDownlink->SetFrameMode(frmode); |
|
1310 } |
|
1311 return status; |
|
1312 } |
|
1313 |
|
1314 // ----------------------------------------------------------------------------- |
|
1315 // TMSCallIPAdpt::GetFrameMode |
|
1316 // |
|
1317 // ----------------------------------------------------------------------------- |
|
1318 // |
|
1319 gint TMSCallIPAdpt::GetFrameMode(gboolean& frmode) |
|
1320 { |
|
1321 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
|
1322 if (iIPDownlink) |
|
1323 { |
|
1324 status = iIPDownlink->GetFrameMode(frmode); |
|
1325 } |
|
1326 return status; |
|
1327 } |
|
1328 |
|
1329 // ----------------------------------------------------------------------------- |
|
1330 // TMSCallIPAdpt::ConcealErrorForNextBuffer |
|
1331 // ----------------------------------------------------------------------------- |
|
1332 // |
|
1333 gint TMSCallIPAdpt::ConcealErrorForNextBuffer() |
|
1334 { |
|
1335 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
|
1336 if (iIPDownlink) |
|
1337 { |
|
1338 status = iIPDownlink->ConcealErrorForNextBuffer(); |
|
1339 } |
|
1340 return status; |
|
1341 } |
|
1342 |
|
1343 // ----------------------------------------------------------------------------- |
|
1344 // TMSCallIPAdpt::BadLsfNextBuffer |
|
1345 // |
|
1346 // ----------------------------------------------------------------------------- |
|
1347 // |
|
1348 gint TMSCallIPAdpt::BadLsfNextBuffer() |
|
1349 { |
|
1350 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
|
1351 if (iIPDownlink) |
|
1352 { |
|
1353 status = iIPDownlink->BadLsfNextBuffer(); |
|
1354 } |
|
1355 return status; |
|
1356 } |
|
1357 |
|
1358 // ----------------------------------------------------------------------------- |
|
1359 // TMSCallIPAdpt::SetOutput |
|
1360 // |
|
1361 // ----------------------------------------------------------------------------- |
|
1362 // |
|
1363 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output) |
|
1364 { |
|
1365 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
|
1366 if (iDnlinkInitialized && iIPDownlink) |
|
1367 { |
|
1368 TRAP(status, iIPDownlink->SetAudioDeviceL(output)); |
|
1369 } |
|
1370 return status; |
|
1371 } |
|
1372 // ----------------------------------------------------------------------------- |
|
1373 // TMSCallIPAdpt::GetOutput |
|
1374 // |
|
1375 // ----------------------------------------------------------------------------- |
|
1376 // |
|
1377 gint TMSCallIPAdpt::GetOutput(TMSAudioOutput& output) |
|
1378 { |
|
1379 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
|
1380 if (iDnlinkInitialized && iIPDownlink) |
|
1381 { |
|
1382 TRAP(status, iIPDownlink->GetAudioDeviceL(output)); |
|
1383 } |
|
1384 return status; |
|
1385 } |
|
1386 // ----------------------------------------------------------------------------- |
|
1387 // TMSCallIPAdpt::GetPreviousOutput |
|
1388 // |
|
1389 // ----------------------------------------------------------------------------- |
|
1390 // |
|
1391 gint TMSCallIPAdpt::GetPreviousOutput(TMSAudioOutput& /*output*/) |
|
1392 { |
|
1393 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
|
1394 } |
|
1395 |
|
1396 // ----------------------------------------------------------------------------- |
|
1397 // TMSCallIPAdpt::GetAvailableOutputsL |
|
1398 // |
|
1399 // ----------------------------------------------------------------------------- |
|
1400 // |
|
1401 gint TMSCallIPAdpt::GetAvailableOutputsL(gint& /*count*/, |
|
1402 CBufFlat*& /*outputsbuffer*/) |
|
1403 { |
|
1404 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
|
1405 } |
|
1406 |
|
1407 // ----------------------------------------------------------------------------- |
|
1408 // TMSCallIPAdpt::StartDTMF |
|
1409 // |
|
1410 // ----------------------------------------------------------------------------- |
|
1411 // |
|
1412 gint TMSCallIPAdpt::StartDTMF(TMSStreamType strmtype, TDes& dtmfstring) |
|
1413 { |
|
1414 TRACE_PRN_FN_ENT; |
|
1415 TmsMsgBufPckg dtmfpckg; |
|
1416 if (strmtype == TMS_STREAM_DOWNLINK) |
|
1417 { |
|
1418 if (iDTMFDnlinkPlayer /*&& iDTMFDnlinkStatus*/) |
|
1419 { |
|
1420 iDTMFDnlinkPlayer->PlayDtmfTone(dtmfstring); |
|
1421 dtmfpckg().iStatus = TMS_RESULT_SUCCESS; |
|
1422 //TMS_EVENT_DTMF_TONE_STARTED |
|
1423 dtmfpckg().iRequest = ECmdDTMFOpenDnlinkComplete; |
|
1424 } |
|
1425 } |
|
1426 else if (strmtype == TMS_STREAM_UPLINK) |
|
1427 { |
|
1428 if (iDTMFUplinkPlayer /*&& iDTMFUplinkStatus*/) |
|
1429 { |
|
1430 iDTMFUplinkPlayer->PlayDtmfTone(dtmfstring); |
|
1431 dtmfpckg().iStatus = TMS_RESULT_SUCCESS; |
|
1432 //TMS_EVENT_DTMF_TONE_STARTED |
|
1433 dtmfpckg().iRequest = ECmdDTMFOpenUplinkComplete; |
|
1434 } |
|
1435 } |
|
1436 |
|
1437 if (iDTMFNotifier) |
|
1438 { |
|
1439 iDTMFNotifier->SetDtmf(dtmfpckg, TRUE); |
|
1440 } |
|
1441 TRACE_PRN_FN_EXT; |
|
1442 return TMS_RESULT_SUCCESS; |
|
1443 } |
|
1444 // ----------------------------------------------------------------------------- |
|
1445 // TMSCallIPAdpt::StopDTMF |
|
1446 // |
|
1447 // ----------------------------------------------------------------------------- |
|
1448 // |
|
1449 gint TMSCallIPAdpt::StopDTMF(TMSStreamType streamtype) |
|
1450 { |
|
1451 TRACE_PRN_FN_ENT; |
|
1452 |
|
1453 if (streamtype == TMS_STREAM_DOWNLINK) |
|
1454 { |
|
1455 iDTMFDnlinkPlayer->Cancel(); |
|
1456 } |
|
1457 else |
|
1458 { |
|
1459 iDTMFUplinkPlayer->Cancel(); |
|
1460 } |
|
1461 |
|
1462 TRACE_PRN_FN_EXT; |
|
1463 return TMS_RESULT_SUCCESS; |
|
1464 } |
|
1465 |
|
1466 // ----------------------------------------------------------------------------- |
|
1467 // TMSCallIPAdpt::ContinueDTMF |
|
1468 // |
|
1469 // ----------------------------------------------------------------------------- |
|
1470 // |
|
1471 gint TMSCallIPAdpt::ContinueDTMF(TBool /*continuesending*/) |
|
1472 { |
|
1473 TRACE_PRN_FN_ENT; |
|
1474 TRACE_PRN_FN_EXT; |
|
1475 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
|
1476 } |
|
1477 |
|
1478 //From DTMFTonePlayerObserver |
|
1479 // ----------------------------------------------------------------------------- |
|
1480 // TMSCallIPAdpt::DTMFInitCompleted |
|
1481 // |
|
1482 // ----------------------------------------------------------------------------- |
|
1483 // |
|
1484 void TMSCallIPAdpt::DTMFInitCompleted(TInt /*error*/) |
|
1485 { |
|
1486 //DTMF init status |
|
1487 TRACE_PRN_FN_ENT; |
|
1488 TRACE_PRN_FN_EXT; |
|
1489 } |
|
1490 |
|
1491 // ----------------------------------------------------------------------------- |
|
1492 // TMSCallIPAdpt::DTMFToneFinished |
|
1493 // |
|
1494 // ----------------------------------------------------------------------------- |
|
1495 // |
|
1496 void TMSCallIPAdpt::DTMFToneFinished(TInt error) |
|
1497 { |
|
1498 TRACE_PRN_FN_ENT; |
|
1499 TmsMsgBufPckg dtmfpckg; |
|
1500 |
|
1501 if(error == KErrUnderflow || error == KErrInUse) |
|
1502 { |
|
1503 error = TMS_RESULT_SUCCESS; |
|
1504 } |
|
1505 |
|
1506 dtmfpckg().iStatus = error; |
|
1507 //TMS_EVENT_DTMF_TONE_STOPPED |
|
1508 dtmfpckg().iRequest = ECmdDTMFTonePlayFinished; |
|
1509 if (iDTMFNotifier) |
|
1510 { |
|
1511 iDTMFNotifier->SetDtmf(dtmfpckg, TRUE); |
|
1512 } |
|
1513 TRACE_PRN_FN_EXT; |
|
1514 } |
|
1515 |
|
1516 // ----------------------------------------------------------------------------- |
|
1517 // TMSCallIPAdpt::NotifyClient |
|
1518 // ----------------------------------------------------------------------------- |
|
1519 // |
|
1520 void TMSCallIPAdpt::NotifyClient(const gint strmId, const TInt aCommand, |
|
1521 const TInt aStatus, const TInt64 /*aInt64*/) |
|
1522 { |
|
1523 iMsgBuffer.iRequest = aCommand; |
|
1524 iMsgBuffer.iStatus = aStatus; |
|
1525 |
|
1526 if (strmId == iUplinkStreamId) |
|
1527 { |
|
1528 iMsgQueueUp.Send(iMsgBuffer); |
|
1529 } |
|
1530 else if (strmId == iDnlinkStreamId) |
|
1531 { |
|
1532 iMsgQueueDn.Send(iMsgBuffer); |
|
1533 } |
|
1534 } |
|
1535 |
|
1536 // End of file |
|