25 #include "ipcallstream.h" |
25 #include "ipcallstream.h" |
26 |
26 |
27 using namespace TMS; |
27 using namespace TMS; |
28 |
28 |
29 // ----------------------------------------------------------------------------- |
29 // ----------------------------------------------------------------------------- |
30 // TMSVoIPUplink::TMSVoIPUplink |
30 // TMSIPUplink::TMSIPUplink |
31 // Standard Constructor |
31 // Standard Constructor |
32 // ----------------------------------------------------------------------------- |
32 // ----------------------------------------------------------------------------- |
33 // |
33 // |
34 TMSVoIPUplink::TMSVoIPUplink() |
34 TMSIPUplink::TMSIPUplink() |
35 { |
35 { |
36 } |
36 } |
37 |
37 |
38 // ----------------------------------------------------------------------------- |
38 // ----------------------------------------------------------------------------- |
39 // TMSVoIPUplink::~TMSVoIPUplink |
39 // TMSIPUplink::~TMSIPUplink |
40 // Standard Constructor |
40 // Standard Constructor |
41 // ----------------------------------------------------------------------------- |
41 // ----------------------------------------------------------------------------- |
42 // |
42 // |
43 TMSVoIPUplink::~TMSVoIPUplink() |
43 TMSIPUplink::~TMSIPUplink() |
44 { |
44 { |
45 TRACE_PRN_FN_ENT; |
45 TRACE_PRN_FN_ENT; |
46 |
46 |
47 Stop(); |
47 Stop(); |
48 |
48 |
53 |
53 |
54 TRACE_PRN_FN_EXT; |
54 TRACE_PRN_FN_EXT; |
55 } |
55 } |
56 |
56 |
57 // ----------------------------------------------------------------------------- |
57 // ----------------------------------------------------------------------------- |
58 // TMSVoIPUplink::NewL |
58 // TMSIPUplink::NewL |
59 // Symbian two-phase constructor |
59 // Symbian two-phase constructor |
60 // ----------------------------------------------------------------------------- |
60 // ----------------------------------------------------------------------------- |
61 // |
61 // |
62 TMSVoIPUplink* TMSVoIPUplink::NewL(const guint32 codecID, |
62 TMSIPUplink* TMSIPUplink::NewL(const guint32 codecID, |
63 const TMMFPrioritySettings priority) |
63 const TMMFPrioritySettings priority) |
64 { |
64 { |
65 TMSVoIPUplink* self = new (ELeave) TMSVoIPUplink(); |
65 TMSIPUplink* self = new (ELeave) TMSIPUplink(); |
66 CleanupStack::PushL(self); |
66 CleanupStack::PushL(self); |
67 self->ConstructL(codecID, priority); |
67 self->ConstructL(codecID, priority); |
68 CleanupStack::Pop(self); |
68 CleanupStack::Pop(self); |
69 return self; |
69 return self; |
70 } |
70 } |
71 |
71 |
72 // ----------------------------------------------------------------------------- |
72 // ----------------------------------------------------------------------------- |
73 // TMSVoIPUplink::ConstructL |
73 // TMSIPUplink::ConstructL |
74 // Part two of Symbian two phase construction |
74 // Part two of Symbian two phase construction |
75 // ----------------------------------------------------------------------------- |
75 // ----------------------------------------------------------------------------- |
76 // |
76 // |
77 void TMSVoIPUplink::ConstructL(const guint32 codecID, |
77 void TMSIPUplink::ConstructL(const guint32 codecID, |
78 const TMMFPrioritySettings priority) |
78 const TMMFPrioritySettings priority) |
79 { |
79 { |
80 TRACE_PRN_FN_ENT; |
80 TRACE_PRN_FN_ENT; |
81 |
81 |
82 iCodecID = codecID; |
82 iCodecID = codecID; |
96 |
96 |
97 TRACE_PRN_FN_EXT; |
97 TRACE_PRN_FN_EXT; |
98 } |
98 } |
99 |
99 |
100 // ----------------------------------------------------------------------------- |
100 // ----------------------------------------------------------------------------- |
101 // TMSVoIPUplink::Start |
101 // TMSIPUplink::Start |
102 // |
102 // |
103 // ----------------------------------------------------------------------------- |
103 // ----------------------------------------------------------------------------- |
104 // |
104 // |
105 void TMSVoIPUplink::Start() |
105 void TMSIPUplink::Start() |
106 { |
106 { |
107 TRACE_PRN_FN_ENT; |
107 TRACE_PRN_FN_ENT; |
108 |
108 |
109 gint err = TMS_RESULT_ILLEGAL_OPERATION; |
109 gint err = TMS_RESULT_ILLEGAL_OPERATION; |
110 iWriteDataXferHndlToClient = FALSE; |
110 iWriteDataXferHndlToClient = FALSE; |
129 |
129 |
130 TRACE_PRN_FN_EXT; |
130 TRACE_PRN_FN_EXT; |
131 } |
131 } |
132 |
132 |
133 // ----------------------------------------------------------------------------- |
133 // ----------------------------------------------------------------------------- |
134 // TMSVoIPUplink::Stop |
134 // TMSIPUplink::Stop |
135 // |
135 // |
136 // ----------------------------------------------------------------------------- |
136 // ----------------------------------------------------------------------------- |
137 // |
137 // |
138 void TMSVoIPUplink::Stop() |
138 void TMSIPUplink::Stop() |
139 { |
139 { |
140 TRACE_PRN_FN_ENT; |
140 TRACE_PRN_FN_ENT; |
141 |
141 |
142 if (iStatus == EStreaming && iDevSound) |
142 if (iStatus == EStreaming && iDevSound) |
143 { |
143 { |
150 } |
150 } |
151 TRACE_PRN_FN_EXT; |
151 TRACE_PRN_FN_EXT; |
152 } |
152 } |
153 |
153 |
154 // ----------------------------------------------------------------------------- |
154 // ----------------------------------------------------------------------------- |
155 // TMSVoIPUplink::BufferToBeEmptied |
155 // TMSIPUplink::BufferToBeEmptied |
156 // From MDevSoundObserver |
156 // From MDevSoundObserver |
157 // ----------------------------------------------------------------------------- |
157 // ----------------------------------------------------------------------------- |
158 // |
158 // |
159 void TMSVoIPUplink::BufferToBeEmptied(CMMFBuffer* aBuffer) |
159 void TMSIPUplink::BufferToBeEmptied(CMMFBuffer* aBuffer) |
160 { |
160 { |
161 iDevSoundBufPtr = static_cast<CMMFDataBuffer*> (aBuffer); |
161 iDevSoundBufPtr = static_cast<CMMFDataBuffer*> (aBuffer); |
162 TDes8& data = iDevSoundBufPtr->Data(); |
162 TDes8& data = iDevSoundBufPtr->Data(); |
163 |
163 |
164 iBufLen = iDevSoundBufPtr->BufferSize(); |
164 iBufLen = iDevSoundBufPtr->BufferSize(); |
199 err = iMsgQueue.Send(iMsgBuffer); |
199 err = iMsgQueue.Send(iMsgBuffer); |
200 TRACE_PRN_IF_ERR(err); |
200 TRACE_PRN_IF_ERR(err); |
201 } |
201 } |
202 |
202 |
203 // ----------------------------------------------------------------------------- |
203 // ----------------------------------------------------------------------------- |
204 // TMSVoIPUplink::BufferEmptied |
204 // TMSIPUplink::BufferEmptied |
205 // |
205 // |
206 // ----------------------------------------------------------------------------- |
206 // ----------------------------------------------------------------------------- |
207 // |
207 // |
208 void TMSVoIPUplink::BufferEmptied() |
208 void TMSIPUplink::BufferEmptied() |
209 { |
209 { |
210 //TRACE_PRN_N(_L("TMS->UPL->BE")); |
210 //TRACE_PRN_N(_L("TMS->UPL->BE")); |
211 if (iDevSound) |
211 if (iDevSound) |
212 { |
212 { |
213 iDevSound->RecordData(); |
213 iDevSound->RecordData(); |
214 } |
214 } |
215 } |
215 } |
216 |
216 |
217 // ----------------------------------------------------------------------------- |
217 // ----------------------------------------------------------------------------- |
218 // TMSVoIPUplink::SetCodecCi |
218 // TMSIPUplink::SetCodecCi |
219 // |
219 // |
220 // ----------------------------------------------------------------------------- |
220 // ----------------------------------------------------------------------------- |
221 // |
221 // |
222 gint TMSVoIPUplink::SetCodecCi() |
222 gint TMSIPUplink::SetCodecCi() |
223 { |
223 { |
224 TRAPD(err, SetCodecCiL()); |
224 TRAPD(err, SetCodecCiL()); |
225 return err; |
225 return err; |
226 } |
226 } |
227 |
227 |
228 // ----------------------------------------------------------------------------- |
228 // ----------------------------------------------------------------------------- |
229 // TMSVoIPUplink::SetCodecCiL |
229 // TMSIPUplink::SetCodecCiL |
230 // |
230 // |
231 // ----------------------------------------------------------------------------- |
231 // ----------------------------------------------------------------------------- |
232 // |
232 // |
233 void TMSVoIPUplink::SetCodecCiL() |
233 void TMSIPUplink::SetCodecCiL() |
234 { |
234 { |
235 TRACE_PRN_FN_ENT; |
235 TRACE_PRN_FN_ENT; |
236 |
236 |
237 switch (iCodecID) |
237 switch (iCodecID) |
238 { |
238 { |
279 |
279 |
280 TRACE_PRN_FN_EXT; |
280 TRACE_PRN_FN_EXT; |
281 } |
281 } |
282 |
282 |
283 // ----------------------------------------------------------------------------- |
283 // ----------------------------------------------------------------------------- |
284 // TMSVoIPUplink::SetGain |
284 // TMSIPUplink::SetGain |
285 // |
285 // |
286 // ----------------------------------------------------------------------------- |
286 // ----------------------------------------------------------------------------- |
287 // |
287 // |
288 gint TMSVoIPUplink::SetGain(const guint gain) |
288 gint TMSIPUplink::SetGain(const guint gain) |
289 { |
289 { |
290 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
290 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
291 if (iDevSound) |
291 if (iDevSound) |
292 { |
292 { |
293 iDevSound->SetGain(gain); |
293 iDevSound->SetGain(gain); |
296 TRACE_PRN_N1(_L("TMS->UPL: SetGain [%d]"), gain); |
296 TRACE_PRN_N1(_L("TMS->UPL: SetGain [%d]"), gain); |
297 return status; |
297 return status; |
298 } |
298 } |
299 |
299 |
300 // ----------------------------------------------------------------------------- |
300 // ----------------------------------------------------------------------------- |
301 // TMSVoIPUplink::GetGain |
301 // TMSIPUplink::GetGain |
302 // |
302 // |
303 // ----------------------------------------------------------------------------- |
303 // ----------------------------------------------------------------------------- |
304 // |
304 // |
305 gint TMSVoIPUplink::GetGain(guint& gain) |
305 gint TMSIPUplink::GetGain(guint& gain) |
306 { |
306 { |
307 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
307 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
308 if (iDevSound) |
308 if (iDevSound) |
309 { |
309 { |
310 gain = iDevSound->Gain(); |
310 gain = iDevSound->Gain(); |
313 TRACE_PRN_N1(_L("TMS->UPL: GetGain [%d]"), gain); |
313 TRACE_PRN_N1(_L("TMS->UPL: GetGain [%d]"), gain); |
314 return status; |
314 return status; |
315 } |
315 } |
316 |
316 |
317 // ----------------------------------------------------------------------------- |
317 // ----------------------------------------------------------------------------- |
318 // TMSVoIPUplink::GetMaxGain |
318 // TMSIPUplink::GetMaxGain |
319 // |
319 // |
320 // ----------------------------------------------------------------------------- |
320 // ----------------------------------------------------------------------------- |
321 // |
321 // |
322 gint TMSVoIPUplink::GetMaxGain(guint& gain) |
322 gint TMSIPUplink::GetMaxGain(guint& gain) |
323 { |
323 { |
324 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
324 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
325 if (iDevSound) |
325 if (iDevSound) |
326 { |
326 { |
327 gain = iDevSound->MaxGain(); |
327 gain = iDevSound->MaxGain(); |
330 TRACE_PRN_N1(_L("TMS->UPL: MaxGain [%d]"), gain); |
330 TRACE_PRN_N1(_L("TMS->UPL: MaxGain [%d]"), gain); |
331 return status; |
331 return status; |
332 } |
332 } |
333 |
333 |
334 // ----------------------------------------------------------------------------- |
334 // ----------------------------------------------------------------------------- |
335 // TMSVoIPUplink::GetDataXferChunkHndl |
335 // TMSIPUplink::GetDataXferChunkHndl |
336 // |
336 // |
337 // ----------------------------------------------------------------------------- |
337 // ----------------------------------------------------------------------------- |
338 // |
338 // |
339 gint TMSVoIPUplink::GetDataXferChunkHndl(const TUint32 key, RChunk& chunk) |
339 gint TMSIPUplink::GetDataXferChunkHndl(const TUint32 key, RChunk& chunk) |
340 { |
340 { |
341 gint status = TMS_RESULT_SUCCESS; |
341 gint status = TMS_RESULT_SUCCESS; |
342 |
342 |
343 if (iChunk.Handle()) |
343 if (iChunk.Handle()) |
344 { |
344 { |
356 |
356 |
357 return status; |
357 return status; |
358 } |
358 } |
359 |
359 |
360 // ----------------------------------------------------------------------------- |
360 // ----------------------------------------------------------------------------- |
361 // TMSVoIPUplink::SetIlbcCodecMode |
361 // TMSIPUplink::SetIlbcCodecMode |
362 // |
362 // |
363 // ----------------------------------------------------------------------------- |
363 // ----------------------------------------------------------------------------- |
364 // |
364 // |
365 gint TMSVoIPUplink::SetIlbcCodecMode(const gint mode) |
365 gint TMSIPUplink::SetIlbcCodecMode(const gint mode) |
366 { |
366 { |
367 gint err = TMS_RESULT_DOES_NOT_EXIST; |
367 gint err = TMS_RESULT_DOES_NOT_EXIST; |
368 |
368 |
369 if (iStatus == EReady) |
369 if (iStatus == EReady) |
370 { |
370 { |
390 TRACE_PRN_IF_ERR(err); |
390 TRACE_PRN_IF_ERR(err); |
391 return err; |
391 return err; |
392 } |
392 } |
393 |
393 |
394 // ----------------------------------------------------------------------------- |
394 // ----------------------------------------------------------------------------- |
395 // TMSVoIPUplink::GetIlbcCodecMode |
395 // TMSIPUplink::GetIlbcCodecMode |
396 // |
396 // |
397 // ----------------------------------------------------------------------------- |
397 // ----------------------------------------------------------------------------- |
398 // |
398 // |
399 gint TMSVoIPUplink::GetIlbcCodecMode(gint& mode) |
399 gint TMSIPUplink::GetIlbcCodecMode(gint& mode) |
400 { |
400 { |
401 // not available through CIs -> return cached value |
401 // not available through CIs -> return cached value |
402 mode = iILBCEncodeMode; |
402 mode = iILBCEncodeMode; |
403 TRACE_PRN_N1(_L("TMS->UPL: GetIlbcCodecMode [%d]"), mode); |
403 TRACE_PRN_N1(_L("TMS->UPL: GetIlbcCodecMode [%d]"), mode); |
404 return TMS_RESULT_SUCCESS; |
404 return TMS_RESULT_SUCCESS; |
405 } |
405 } |
406 |
406 |
407 // ----------------------------------------------------------------------------- |
407 // ----------------------------------------------------------------------------- |
408 // TMSVoIPUplink::SetG711CodecMode |
408 // TMSIPUplink::SetG711CodecMode |
409 // |
409 // |
410 // ----------------------------------------------------------------------------- |
410 // ----------------------------------------------------------------------------- |
411 // |
411 // |
412 gint TMSVoIPUplink::SetG711CodecMode(const gint mode) |
412 gint TMSIPUplink::SetG711CodecMode(const gint mode) |
413 { |
413 { |
414 gint err = TMS_RESULT_DOES_NOT_EXIST; |
414 gint err = TMS_RESULT_DOES_NOT_EXIST; |
415 |
415 |
416 if (iStatus == EReady) |
416 if (iStatus == EReady) |
417 { |
417 { |
437 TRACE_PRN_IF_ERR(err); |
437 TRACE_PRN_IF_ERR(err); |
438 return err; |
438 return err; |
439 } |
439 } |
440 |
440 |
441 // ----------------------------------------------------------------------------- |
441 // ----------------------------------------------------------------------------- |
442 // TMSVoIPUplink::GetG711CodecMode |
442 // TMSIPUplink::GetG711CodecMode |
443 // |
443 // |
444 // ----------------------------------------------------------------------------- |
444 // ----------------------------------------------------------------------------- |
445 // |
445 // |
446 gint TMSVoIPUplink::GetG711CodecMode(gint& mode) |
446 gint TMSIPUplink::GetG711CodecMode(gint& mode) |
447 { |
447 { |
448 // not available through CIs -> return cached value |
448 // not available through CIs -> return cached value |
449 mode = iG711EncodeMode; |
449 mode = iG711EncodeMode; |
450 TRACE_PRN_N1(_L("TMS->UPL: GetG711CodecMode [%d]"), mode); |
450 TRACE_PRN_N1(_L("TMS->UPL: GetG711CodecMode [%d]"), mode); |
451 return TMS_RESULT_SUCCESS; |
451 return TMS_RESULT_SUCCESS; |
452 } |
452 } |
453 |
453 |
454 // ----------------------------------------------------------------------------- |
454 // ----------------------------------------------------------------------------- |
455 // TMSVoIPUplink::GetSupportedBitrates |
455 // TMSIPUplink::GetSupportedBitrates |
456 // |
456 // |
457 // ----------------------------------------------------------------------------- |
457 // ----------------------------------------------------------------------------- |
458 // |
458 // |
459 gint TMSVoIPUplink::GetSupportedBitrates(RArray<guint>& bitrates) |
459 gint TMSIPUplink::GetSupportedBitrates(RArray<guint>& bitrates) |
460 { |
460 { |
461 gint err = TMS_RESULT_DOES_NOT_EXIST; |
461 gint err = TMS_RESULT_DOES_NOT_EXIST; |
462 bitrates.Reset(); |
462 bitrates.Reset(); |
463 |
463 |
464 if (iSpeechEncoderConfig) |
464 if (iSpeechEncoderConfig) |
469 TRACE_PRN_IF_ERR(err); |
469 TRACE_PRN_IF_ERR(err); |
470 return err; |
470 return err; |
471 } |
471 } |
472 |
472 |
473 // ----------------------------------------------------------------------------- |
473 // ----------------------------------------------------------------------------- |
474 // TMSVoIPUplink::SetBitrate |
474 // TMSIPUplink::SetBitrate |
475 // |
475 // |
476 // ----------------------------------------------------------------------------- |
476 // ----------------------------------------------------------------------------- |
477 // |
477 // |
478 gint TMSVoIPUplink::SetBitrate(guint bitrate) |
478 gint TMSIPUplink::SetBitrate(guint bitrate) |
479 { |
479 { |
480 gint err = TMS_RESULT_DOES_NOT_EXIST; |
480 gint err = TMS_RESULT_DOES_NOT_EXIST; |
481 |
481 |
482 if (iSpeechEncoderConfig) |
482 if (iSpeechEncoderConfig) |
483 { |
483 { |
488 TRACE_PRN_IF_ERR(err); |
488 TRACE_PRN_IF_ERR(err); |
489 return err; |
489 return err; |
490 } |
490 } |
491 |
491 |
492 // ----------------------------------------------------------------------------- |
492 // ----------------------------------------------------------------------------- |
493 // TMSVoIPUplink::GetBitrate |
493 // TMSIPUplink::GetBitrate |
494 // |
494 // |
495 // ----------------------------------------------------------------------------- |
495 // ----------------------------------------------------------------------------- |
496 // |
496 // |
497 gint TMSVoIPUplink::GetBitrate(guint& bitrate) |
497 gint TMSIPUplink::GetBitrate(guint& bitrate) |
498 { |
498 { |
499 gint err = TMS_RESULT_DOES_NOT_EXIST; |
499 gint err = TMS_RESULT_DOES_NOT_EXIST; |
500 |
500 |
501 if (iSpeechEncoderConfig) |
501 if (iSpeechEncoderConfig) |
502 { |
502 { |
507 TRACE_PRN_IF_ERR(err); |
507 TRACE_PRN_IF_ERR(err); |
508 return err; |
508 return err; |
509 } |
509 } |
510 |
510 |
511 // ----------------------------------------------------------------------------- |
511 // ----------------------------------------------------------------------------- |
512 // TMSVoIPUplink::SetVad |
512 // TMSIPUplink::SetVad |
513 // |
513 // |
514 // ----------------------------------------------------------------------------- |
514 // ----------------------------------------------------------------------------- |
515 // |
515 // |
516 gint TMSVoIPUplink::SetVad(const TMSFormatType fmttype, const gboolean vad) |
516 gint TMSIPUplink::SetVad(const TMSFormatType fmttype, const gboolean vad) |
517 { |
517 { |
518 gint err = TMS_RESULT_DOES_NOT_EXIST; |
518 gint err = TMS_RESULT_DOES_NOT_EXIST; |
519 |
519 |
520 switch (fmttype) |
520 switch (fmttype) |
521 { |
521 { |
564 TRACE_PRN_IF_ERR(err); |
564 TRACE_PRN_IF_ERR(err); |
565 return err; |
565 return err; |
566 } |
566 } |
567 |
567 |
568 // ----------------------------------------------------------------------------- |
568 // ----------------------------------------------------------------------------- |
569 // TMSVoIPUplink::GetVad |
569 // TMSIPUplink::GetVad |
570 // |
570 // |
571 // ----------------------------------------------------------------------------- |
571 // ----------------------------------------------------------------------------- |
572 // |
572 // |
573 gint TMSVoIPUplink::GetVad(const TMSFormatType fmttype, gboolean& vad) |
573 gint TMSIPUplink::GetVad(const TMSFormatType fmttype, gboolean& vad) |
574 { |
574 { |
575 gint err = TMS_RESULT_DOES_NOT_EXIST; |
575 gint err = TMS_RESULT_DOES_NOT_EXIST; |
576 |
576 |
577 switch (fmttype) |
577 switch (fmttype) |
578 { |
578 { |
621 TRACE_PRN_IF_ERR(err); |
621 TRACE_PRN_IF_ERR(err); |
622 return err; |
622 return err; |
623 } |
623 } |
624 |
624 |
625 // ----------------------------------------------------------------------------- |
625 // ----------------------------------------------------------------------------- |
626 // TMSVoIPUplink::InitializeComplete |
626 // TMSIPUplink::InitializeComplete |
627 // A callback from the DevSound indicating completion of the initialization. |
627 // A callback from the DevSound indicating completion of the initialization. |
628 // It will send config data to the D/S and configure the encoder via CI. |
628 // It will send config data to the D/S and configure the encoder via CI. |
629 // If everything goes well, the state of the thread is set EReady. |
629 // If everything goes well, the state of the thread is set EReady. |
630 // The initialization completion message is sent back to the main thread. |
630 // The initialization completion message is sent back to the main thread. |
631 // ----------------------------------------------------------------------------- |
631 // ----------------------------------------------------------------------------- |
632 // |
632 // |
633 void TMSVoIPUplink::InitializeComplete(TInt aError) |
633 void TMSIPUplink::InitializeComplete(TInt aError) |
634 { |
634 { |
635 TRACE_PRN_FN_ENT; |
635 TRACE_PRN_FN_ENT; |
636 |
636 |
637 gint err = aError; |
637 gint err = aError; |
638 |
638 |
666 TRACE_PRN_IF_ERR(err); |
666 TRACE_PRN_IF_ERR(err); |
667 TRACE_PRN_FN_EXT; |
667 TRACE_PRN_FN_EXT; |
668 } |
668 } |
669 |
669 |
670 // ----------------------------------------------------------------------------- |
670 // ----------------------------------------------------------------------------- |
671 // TMSVoIPUplink::RecordError |
671 // TMSIPUplink::RecordError |
672 // From MDevSoundObserver |
672 // From MDevSoundObserver |
673 // Recording error is send to the main thread. |
673 // Recording error is send to the main thread. |
674 // The state of recorder is rolled back to EReady. |
674 // The state of recorder is rolled back to EReady. |
675 // ----------------------------------------------------------------------------- |
675 // ----------------------------------------------------------------------------- |
676 // |
676 // |
677 void TMSVoIPUplink::RecordError(TInt /*aError*/) |
677 void TMSIPUplink::RecordError(TInt /*aError*/) |
678 { |
678 { |
679 //TRACE_PRN_IF_ERR(aError); |
679 //TRACE_PRN_IF_ERR(aError); |
680 |
680 |
681 #ifdef _DEBUG |
681 #ifdef _DEBUG |
682 iSamplesRecCount = 0; |
682 iSamplesRecCount = 0; |