23 #include "callipadpt.h" |
23 #include "callipadpt.h" |
24 |
24 |
25 using namespace TMS; |
25 using namespace TMS; |
26 |
26 |
27 // ----------------------------------------------------------------------------- |
27 // ----------------------------------------------------------------------------- |
28 // CallIPAdpt::NewL |
28 // TMSCallIPAdpt::NewL |
29 // Symbian constructor. |
29 // Symbian constructor. |
30 // ----------------------------------------------------------------------------- |
30 // ----------------------------------------------------------------------------- |
31 // |
31 // |
32 CallIPAdpt* CallIPAdpt::NewL() |
32 TMSCallIPAdpt* TMSCallIPAdpt::NewL() |
33 { |
33 { |
34 CallIPAdpt* self = new (ELeave) CallIPAdpt(); |
34 TMSCallIPAdpt* self = new (ELeave) TMSCallIPAdpt(); |
35 CleanupStack::PushL(self); |
35 CleanupStack::PushL(self); |
36 self->ConstructL(); |
36 self->ConstructL(); |
37 CleanupStack::Pop(self); |
37 CleanupStack::Pop(self); |
38 return self; |
38 return self; |
39 } |
39 } |
40 |
40 |
41 // ----------------------------------------------------------------------------- |
41 // ----------------------------------------------------------------------------- |
42 // CallIPAdpt::ConstructL |
42 // TMSCallIPAdpt::ConstructL |
43 // 2-nd phase constructor. |
43 // 2-nd phase constructor. |
44 // ----------------------------------------------------------------------------- |
44 // ----------------------------------------------------------------------------- |
45 // |
45 // |
46 void CallIPAdpt::ConstructL() |
46 void TMSCallIPAdpt::ConstructL() |
47 { |
47 { |
48 TRACE_PRN_FN_ENT; |
48 TRACE_PRN_FN_ENT; |
49 iVoIPUplink = NULL; |
49 iIPUplink = NULL; |
50 iVoIPDownlink = NULL; |
50 iIPDownlink = NULL; |
51 TRACE_PRN_FN_EXT; |
51 TRACE_PRN_FN_EXT; |
52 } |
52 } |
53 |
53 |
54 // ----------------------------------------------------------------------------- |
54 // ----------------------------------------------------------------------------- |
55 // CallIPAdpt::CallIPAdpt |
55 // TMSCallIPAdpt::TMSCallIPAdpt |
56 // |
56 // |
57 // ----------------------------------------------------------------------------- |
57 // ----------------------------------------------------------------------------- |
58 // |
58 // |
59 CallIPAdpt::CallIPAdpt() |
59 TMSCallIPAdpt::TMSCallIPAdpt() |
60 { |
60 { |
61 } |
61 } |
62 |
62 |
63 // ----------------------------------------------------------------------------- |
63 // ----------------------------------------------------------------------------- |
64 // CallIPAdpt::~CallIPAdpt |
64 // TMSCallIPAdpt::~TMSCallIPAdpt |
65 // |
65 // |
66 // ----------------------------------------------------------------------------- |
66 // ----------------------------------------------------------------------------- |
67 // |
67 // |
68 CallIPAdpt::~CallIPAdpt() |
68 TMSCallIPAdpt::~TMSCallIPAdpt() |
69 { |
69 { |
70 TRACE_PRN_FN_ENT; |
70 TRACE_PRN_FN_ENT; |
71 |
71 |
72 iCodecs.Reset(); |
72 iCodecs.Reset(); |
73 iCodecs.Close(); |
73 iCodecs.Close(); |
74 iArrBitrates.Reset(); |
74 iArrBitrates.Reset(); |
75 |
75 |
76 delete iVoIPUplink; |
76 delete iIPUplink; |
77 delete iVoIPDownlink; |
77 delete iIPDownlink; |
78 |
78 |
79 if (iMsgQueueUp.Handle() > 0) |
79 if (iMsgQueueUp.Handle() > 0) |
80 { |
80 { |
81 iMsgQueueUp.Close(); |
81 iMsgQueueUp.Close(); |
82 } |
82 } |
522 TRACE_PRN_FN_EXT; |
522 TRACE_PRN_FN_EXT; |
523 return status; |
523 return status; |
524 } |
524 } |
525 |
525 |
526 // ----------------------------------------------------------------------------- |
526 // ----------------------------------------------------------------------------- |
527 // CallIPAdpt::GetMaxVolume |
527 // TMSCallIPAdpt::GetMaxVolume |
528 // |
528 // |
529 // ----------------------------------------------------------------------------- |
529 // ----------------------------------------------------------------------------- |
530 // |
530 // |
531 gint CallIPAdpt::GetMaxVolume(guint& volume) |
531 gint TMSCallIPAdpt::GetMaxVolume(guint& volume) |
532 { |
532 { |
533 TRACE_PRN_FN_ENT; |
533 TRACE_PRN_FN_ENT; |
534 gint status(TMS_RESULT_INVALID_STATE); |
534 gint status(TMS_RESULT_INVALID_STATE); |
535 |
535 |
536 if (iDnlinkInitialized && iVoIPDownlink) |
536 if (iDnlinkInitialized && iIPDownlink) |
537 { |
537 { |
538 status = iVoIPDownlink->GetMaxVolume(volume); |
538 status = iIPDownlink->GetMaxVolume(volume); |
539 iMaxVolume = volume; |
539 iMaxVolume = volume; |
540 TRACE_PRN_N1(_L("TMS->CallIPAdpt: GetMaxVolume [%d]"), iMaxVolume); |
540 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume); |
541 } |
541 } |
542 |
542 |
543 TRACE_PRN_FN_EXT; |
543 TRACE_PRN_FN_EXT; |
544 return status; |
544 return status; |
545 } |
545 } |
546 |
546 |
547 // ----------------------------------------------------------------------------- |
547 // ----------------------------------------------------------------------------- |
548 // CallIPAdpt::SetVolume |
548 // TMSCallIPAdpt::SetVolume |
549 // |
549 // |
550 // ----------------------------------------------------------------------------- |
550 // ----------------------------------------------------------------------------- |
551 // |
551 // |
552 gint CallIPAdpt::SetVolume(const guint volume) |
552 gint TMSCallIPAdpt::SetVolume(const guint volume) |
553 { |
553 { |
554 TRACE_PRN_FN_ENT; |
554 TRACE_PRN_FN_ENT; |
555 gint status(TMS_RESULT_INVALID_STATE); |
555 gint status(TMS_RESULT_INVALID_STATE); |
556 if (iDnlinkInitialized && iVoIPDownlink) |
556 if (iDnlinkInitialized && iIPDownlink) |
557 { |
557 { |
558 status = iVoIPDownlink->SetVolume(volume); |
558 status = iIPDownlink->SetVolume(volume); |
559 NotifyClient(iDnlinkStreamId, ECmdSetVolume, status); |
559 NotifyClient(iDnlinkStreamId, ECmdSetVolume, status); |
560 } |
560 } |
561 TRACE_PRN_FN_EXT; |
561 TRACE_PRN_FN_EXT; |
562 return status; |
562 return status; |
563 } |
563 } |
564 |
564 |
565 // ----------------------------------------------------------------------------- |
565 // ----------------------------------------------------------------------------- |
566 // CallIPAdpt::GetVolume |
566 // TMSCallIPAdpt::GetVolume |
567 // |
567 // |
568 // ----------------------------------------------------------------------------- |
568 // ----------------------------------------------------------------------------- |
569 // |
569 // |
570 gint CallIPAdpt::GetVolume(guint& volume) |
570 gint TMSCallIPAdpt::GetVolume(guint& volume) |
571 { |
571 { |
572 TRACE_PRN_FN_ENT; |
572 TRACE_PRN_FN_ENT; |
573 gint status(TMS_RESULT_INVALID_STATE); |
573 gint status(TMS_RESULT_INVALID_STATE); |
574 if (iDnlinkInitialized && iVoIPDownlink) |
574 if (iDnlinkInitialized && iIPDownlink) |
575 { |
575 { |
576 status = iVoIPDownlink->GetVolume(volume); |
576 status = iIPDownlink->GetVolume(volume); |
577 } |
577 } |
578 TRACE_PRN_FN_EXT; |
578 TRACE_PRN_FN_EXT; |
579 return status; |
579 return status; |
580 } |
580 } |
581 |
581 |
582 // ----------------------------------------------------------------------------- |
582 // ----------------------------------------------------------------------------- |
583 // CallIPAdpt::GetMaxGain |
583 // TMSCallIPAdpt::GetMaxGain |
584 // |
584 // |
585 // ----------------------------------------------------------------------------- |
585 // ----------------------------------------------------------------------------- |
586 // |
586 // |
587 gint CallIPAdpt::GetMaxGain(guint& gain) |
587 gint TMSCallIPAdpt::GetMaxGain(guint& gain) |
588 { |
588 { |
589 TRACE_PRN_FN_ENT; |
589 TRACE_PRN_FN_ENT; |
590 gint status(TMS_RESULT_INVALID_STATE); |
590 gint status(TMS_RESULT_INVALID_STATE); |
591 if (iUplinkInitialized && iVoIPUplink) |
591 if (iUplinkInitialized && iIPUplink) |
592 { |
592 { |
593 status = iVoIPUplink->GetMaxGain(gain); |
593 status = iIPUplink->GetMaxGain(gain); |
594 iMaxGain = gain; |
594 iMaxGain = gain; |
595 TRACE_PRN_N1(_L("TMS->CallIPAdpt::GetMaxGain [%d]"), iMaxGain); |
595 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetMaxGain [%d]"), iMaxGain); |
596 } |
596 } |
597 TRACE_PRN_FN_EXT; |
597 TRACE_PRN_FN_EXT; |
598 return status; |
598 return status; |
599 } |
599 } |
600 |
600 |
601 // ----------------------------------------------------------------------------- |
601 // ----------------------------------------------------------------------------- |
602 // CallIPAdpt::SetGain |
602 // TMSCallIPAdpt::SetGain |
603 // |
603 // |
604 // ----------------------------------------------------------------------------- |
604 // ----------------------------------------------------------------------------- |
605 // |
605 // |
606 gint CallIPAdpt::SetGain(const guint gain) |
606 gint TMSCallIPAdpt::SetGain(const guint gain) |
607 { |
607 { |
608 TRACE_PRN_FN_ENT; |
608 TRACE_PRN_FN_ENT; |
609 gint status(TMS_RESULT_INVALID_STATE); |
609 gint status(TMS_RESULT_INVALID_STATE); |
610 if (iUplinkInitialized && iVoIPUplink) |
610 if (iUplinkInitialized && iIPUplink) |
611 { |
611 { |
612 status = iVoIPUplink->SetGain(gain); |
612 status = iIPUplink->SetGain(gain); |
613 NotifyClient(iUplinkStreamId, ECmdSetGain, status); |
613 NotifyClient(iUplinkStreamId, ECmdSetGain, status); |
614 } |
614 } |
615 TRACE_PRN_FN_EXT; |
615 TRACE_PRN_FN_EXT; |
616 return status; |
616 return status; |
617 } |
617 } |
618 |
618 |
619 // ----------------------------------------------------------------------------- |
619 // ----------------------------------------------------------------------------- |
620 // CallIPAdpt::GetGain |
620 // TMSCallIPAdpt::GetGain |
621 // |
621 // |
622 // ----------------------------------------------------------------------------- |
622 // ----------------------------------------------------------------------------- |
623 // |
623 // |
624 gint CallIPAdpt::GetGain(guint& gain) |
624 gint TMSCallIPAdpt::GetGain(guint& gain) |
625 { |
625 { |
626 TRACE_PRN_FN_ENT; |
626 TRACE_PRN_FN_ENT; |
627 gint status(TMS_RESULT_INVALID_STATE); |
627 gint status(TMS_RESULT_INVALID_STATE); |
628 if (iUplinkInitialized && iVoIPUplink) |
628 if (iUplinkInitialized && iIPUplink) |
629 { |
629 { |
630 status = iVoIPUplink->GetGain(gain); |
630 status = iIPUplink->GetGain(gain); |
631 } |
631 } |
632 TRACE_PRN_FN_EXT; |
632 TRACE_PRN_FN_EXT; |
633 return status; |
633 return status; |
634 } |
634 } |
635 |
635 |
636 // ----------------------------------------------------------------------------- |
636 // ----------------------------------------------------------------------------- |
637 // CallIPAdpt::GetGlobalMaxVolume |
637 // TMSCallIPAdpt::GetGlobalMaxVolume |
638 // |
638 // |
639 // ----------------------------------------------------------------------------- |
639 // ----------------------------------------------------------------------------- |
640 // |
640 // |
641 gint CallIPAdpt::GetGlobalMaxVolume(guint& volume) |
641 gint TMSCallIPAdpt::GetGlobalMaxVolume(guint& volume) |
642 { |
642 { |
643 TRACE_PRN_FN_ENT; |
643 TRACE_PRN_FN_ENT; |
644 gint status(TMS_RESULT_INVALID_STATE); |
644 gint status(TMS_RESULT_INVALID_STATE); |
645 if (iDnlinkInitialized && iVoIPDownlink) |
645 if (iDnlinkInitialized && iIPDownlink) |
646 { |
646 { |
647 status = iVoIPDownlink->GetMaxVolume(volume); |
647 status = iIPDownlink->GetMaxVolume(volume); |
648 iMaxVolume = volume; |
648 iMaxVolume = volume; |
649 TRACE_PRN_N1(_L("TMS->CallIPAdpt: GetMaxVolume [%d]"), iMaxVolume); |
649 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: GetMaxVolume [%d]"), iMaxVolume); |
650 } |
650 } |
651 TRACE_PRN_FN_EXT; |
651 TRACE_PRN_FN_EXT; |
652 return status; |
652 return status; |
653 } |
653 } |
654 |
654 |
655 // ----------------------------------------------------------------------------- |
655 // ----------------------------------------------------------------------------- |
656 // CallIPAdpt::SetGlobalVolume |
656 // TMSCallIPAdpt::SetGlobalVolume |
657 // |
657 // |
658 // ----------------------------------------------------------------------------- |
658 // ----------------------------------------------------------------------------- |
659 // |
659 // |
660 gint CallIPAdpt::SetGlobalVolume(const guint volume) |
660 gint TMSCallIPAdpt::SetGlobalVolume(const guint volume) |
661 { |
661 { |
662 TRACE_PRN_FN_ENT; |
662 TRACE_PRN_FN_ENT; |
663 gint status(TMS_RESULT_INVALID_STATE); |
663 gint status(TMS_RESULT_INVALID_STATE); |
664 if (iDnlinkInitialized && iVoIPDownlink) |
664 if (iDnlinkInitialized && iIPDownlink) |
665 { |
665 { |
666 status = iVoIPDownlink->SetVolume(volume); |
666 status = iIPDownlink->SetVolume(volume); |
667 } |
667 } |
668 TRACE_PRN_FN_EXT; |
668 TRACE_PRN_FN_EXT; |
669 return status; |
669 return status; |
670 } |
670 } |
671 |
671 |
672 // ----------------------------------------------------------------------------- |
672 // ----------------------------------------------------------------------------- |
673 // CallIPAdpt::GetGlobalVolume |
673 // TMSCallIPAdpt::GetGlobalVolume |
674 // |
674 // |
675 // ----------------------------------------------------------------------------- |
675 // ----------------------------------------------------------------------------- |
676 // |
676 // |
677 gint CallIPAdpt::GetGlobalVolume(guint& volume) |
677 gint TMSCallIPAdpt::GetGlobalVolume(guint& volume) |
678 { |
678 { |
679 TRACE_PRN_FN_ENT; |
679 TRACE_PRN_FN_ENT; |
680 gint status(TMS_RESULT_INVALID_STATE); |
680 gint status(TMS_RESULT_INVALID_STATE); |
681 if (iDnlinkInitialized && iVoIPDownlink) |
681 if (iDnlinkInitialized && iIPDownlink) |
682 { |
682 { |
683 status = iVoIPDownlink->GetVolume(volume); |
683 status = iIPDownlink->GetVolume(volume); |
684 } |
684 } |
685 TRACE_PRN_FN_EXT; |
685 TRACE_PRN_FN_EXT; |
686 return status; |
686 return status; |
687 } |
687 } |
688 |
688 |
689 // ----------------------------------------------------------------------------- |
689 // ----------------------------------------------------------------------------- |
690 // CallIPAdpt::GetGlobalMaxGain |
690 // TMSCallIPAdpt::GetGlobalMaxGain |
691 // |
691 // |
692 // ----------------------------------------------------------------------------- |
692 // ----------------------------------------------------------------------------- |
693 // |
693 // |
694 gint CallIPAdpt::GetGlobalMaxGain(guint& gain) |
694 gint TMSCallIPAdpt::GetGlobalMaxGain(guint& gain) |
695 { |
695 { |
696 TRACE_PRN_FN_ENT; |
696 TRACE_PRN_FN_ENT; |
697 gint status(TMS_RESULT_INVALID_STATE); |
697 gint status(TMS_RESULT_INVALID_STATE); |
698 if (iUplinkInitialized && iVoIPUplink) |
698 if (iUplinkInitialized && iIPUplink) |
699 { |
699 { |
700 status = iVoIPUplink->GetMaxGain(gain); |
700 status = iIPUplink->GetMaxGain(gain); |
701 iMaxGain = gain; |
701 iMaxGain = gain; |
702 TRACE_PRN_N1(_L("TMS->CallIPAdpt::GetMaxGain [%d]"), iMaxGain); |
702 TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt::GetMaxGain [%d]"), iMaxGain); |
703 } |
703 } |
704 TRACE_PRN_FN_EXT; |
704 TRACE_PRN_FN_EXT; |
705 return status; |
705 return status; |
706 } |
706 } |
707 |
707 |
708 // ----------------------------------------------------------------------------- |
708 // ----------------------------------------------------------------------------- |
709 // CallIPAdpt::SetGlobalGain |
709 // TMSCallIPAdpt::SetGlobalGain |
710 // |
710 // |
711 // ----------------------------------------------------------------------------- |
711 // ----------------------------------------------------------------------------- |
712 // |
712 // |
713 gint CallIPAdpt::SetGlobalGain(const guint gain) |
713 gint TMSCallIPAdpt::SetGlobalGain(const guint gain) |
714 { |
714 { |
715 TRACE_PRN_FN_ENT; |
715 TRACE_PRN_FN_ENT; |
716 gint status(TMS_RESULT_INVALID_STATE); |
716 gint status(TMS_RESULT_INVALID_STATE); |
717 if (iUplinkInitialized && iVoIPUplink) |
717 if (iUplinkInitialized && iIPUplink) |
718 { |
718 { |
719 status = iVoIPUplink->SetGain(gain); |
719 status = iIPUplink->SetGain(gain); |
720 } |
720 } |
721 TRACE_PRN_FN_EXT; |
721 TRACE_PRN_FN_EXT; |
722 return status; |
722 return status; |
723 } |
723 } |
724 |
724 |
725 // ----------------------------------------------------------------------------- |
725 // ----------------------------------------------------------------------------- |
726 // CallIPAdpt::GetGlobalGain |
726 // TMSCallIPAdpt::GetGlobalGain |
727 // |
727 // |
728 // ----------------------------------------------------------------------------- |
728 // ----------------------------------------------------------------------------- |
729 // |
729 // |
730 gint CallIPAdpt::GetGlobalGain(guint& gain) |
730 gint TMSCallIPAdpt::GetGlobalGain(guint& gain) |
731 { |
731 { |
732 TRACE_PRN_FN_ENT; |
732 TRACE_PRN_FN_ENT; |
733 gint status(TMS_RESULT_INVALID_STATE); |
733 gint status(TMS_RESULT_INVALID_STATE); |
734 if (iUplinkInitialized && iVoIPUplink) |
734 if (iUplinkInitialized && iIPUplink) |
735 { |
735 { |
736 status = iVoIPUplink->GetGain(gain); |
736 status = iIPUplink->GetGain(gain); |
737 } |
737 } |
738 TRACE_PRN_FN_EXT; |
738 TRACE_PRN_FN_EXT; |
739 return status; |
739 return status; |
740 } |
740 } |
741 |
741 |
742 // ----------------------------------------------------------------------------- |
742 // ----------------------------------------------------------------------------- |
743 // CallIPAdpt::GetCodecMode |
743 // TMSCallIPAdpt::GetCodecMode |
744 // |
744 // |
745 // ----------------------------------------------------------------------------- |
745 // ----------------------------------------------------------------------------- |
746 // |
746 // |
747 gint CallIPAdpt::GetCodecMode(const TMSFormatType fmttype, |
747 gint TMSCallIPAdpt::GetCodecMode(const TMSFormatType fmttype, |
748 const TMSStreamType strmtype, gint& mode) |
748 const TMSStreamType strmtype, gint& mode) |
749 { |
749 { |
750 TRACE_PRN_FN_ENT; |
750 TRACE_PRN_FN_ENT; |
751 gint status(TMS_RESULT_SUCCESS); |
751 gint status(TMS_RESULT_SUCCESS); |
752 switch (fmttype) |
752 switch (fmttype) |
790 TRACE_PRN_FN_EXT; |
790 TRACE_PRN_FN_EXT; |
791 return status; |
791 return status; |
792 } |
792 } |
793 |
793 |
794 // ----------------------------------------------------------------------------- |
794 // ----------------------------------------------------------------------------- |
795 // CallIPAdpt::GetSupportedBitRatesCount |
795 // TMSCallIPAdpt::GetSupportedBitRatesCount |
796 // |
796 // |
797 // ----------------------------------------------------------------------------- |
797 // ----------------------------------------------------------------------------- |
798 // |
798 // |
799 gint CallIPAdpt::GetSupportedBitRatesCount(guint& count) |
799 gint TMSCallIPAdpt::GetSupportedBitRatesCount(guint& count) |
800 { |
800 { |
801 TRACE_PRN_FN_ENT; |
801 TRACE_PRN_FN_ENT; |
802 gint status(TMS_RESULT_INVALID_STATE); |
802 gint status(TMS_RESULT_INVALID_STATE); |
803 if (iVoIPUplink) |
803 if (iIPUplink) |
804 { |
804 { |
805 status = iVoIPUplink->GetSupportedBitrates(iArrBitrates); |
805 status = iIPUplink->GetSupportedBitrates(iArrBitrates); |
806 count = iArrBitrates.Count(); |
806 count = iArrBitrates.Count(); |
807 } |
807 } |
808 TRACE_PRN_FN_EXT; |
808 TRACE_PRN_FN_EXT; |
809 return status; |
809 return status; |
810 } |
810 } |
811 |
811 |
812 // ----------------------------------------------------------------------------- |
812 // ----------------------------------------------------------------------------- |
813 // CallIPAdpt::GetSupportedBitRates |
813 // TMSCallIPAdpt::GetSupportedBitRates |
814 // |
814 // |
815 // Bitrates are already returned from the codec as a result of call to |
815 // Bitrates are already returned from the codec as a result of call to |
816 // GetSupportedBitratesCount(). Just pack them into a descriptor and return |
816 // GetSupportedBitratesCount(). Just pack them into a descriptor and return |
817 // back to the client. |
817 // back to the client. |
818 // ----------------------------------------------------------------------------- |
818 // ----------------------------------------------------------------------------- |
819 // |
819 // |
820 gint CallIPAdpt::GetSupportedBitRates(CBufFlat*& brbuffer) |
820 gint TMSCallIPAdpt::GetSupportedBitRates(CBufFlat*& brbuffer) |
821 { |
821 { |
822 TRAPD(status, GetSupportedBitRatesL(brbuffer)); |
822 TRAPD(status, GetSupportedBitRatesL(brbuffer)); |
823 return status; |
823 return status; |
824 } |
824 } |
825 |
825 |
826 // ----------------------------------------------------------------------------- |
826 // ----------------------------------------------------------------------------- |
827 // CallIPAdpt::GetSupportedBitRatesL |
827 // TMSCallIPAdpt::GetSupportedBitRatesL |
828 // |
828 // |
829 // GetSupportedBitRates implementation which can leave. |
829 // GetSupportedBitRates implementation which can leave. |
830 // ----------------------------------------------------------------------------- |
830 // ----------------------------------------------------------------------------- |
831 // |
831 // |
832 void CallIPAdpt::GetSupportedBitRatesL(CBufFlat*& brbuffer) |
832 void TMSCallIPAdpt::GetSupportedBitRatesL(CBufFlat*& brbuffer) |
833 { |
833 { |
834 TRACE_PRN_FN_ENT; |
834 TRACE_PRN_FN_ENT; |
835 RBufWriteStream stream; |
835 RBufWriteStream stream; |
836 stream.Open(*brbuffer); |
836 stream.Open(*brbuffer); |
837 CleanupClosePushL(stream); |
837 CleanupClosePushL(stream); |
838 guint numOfItems = iArrBitrates.Count(); |
838 guint numOfItems = iArrBitrates.Count(); |
839 |
839 |
840 for (guint i = 0; i < numOfItems; i++) |
840 for (guint i = 0; i < numOfItems; i++) |
841 { |
841 { |
842 stream.WriteUint32L(iArrBitrates[i]); |
842 stream.WriteUint32L(iArrBitrates[i]); |
843 //TRACE_PRN_N1(_L("TMS->CallIPAdpt: BR: [%d]"), iArrBitrates[i]); |
843 //TRACE_PRN_N1(_L("TMS->TMSCallIPAdpt: BR: [%d]"), iArrBitrates[i]); |
844 } |
844 } |
845 |
845 |
846 CleanupStack::PopAndDestroy(&stream); |
846 CleanupStack::PopAndDestroy(&stream); |
847 TRACE_PRN_FN_EXT; |
847 TRACE_PRN_FN_EXT; |
848 } |
848 } |
849 |
849 |
850 // ----------------------------------------------------------------------------- |
850 // ----------------------------------------------------------------------------- |
851 // CallIPAdpt::GetBitRate |
851 // TMSCallIPAdpt::GetBitRate |
852 // |
852 // |
853 // ----------------------------------------------------------------------------- |
853 // ----------------------------------------------------------------------------- |
854 // |
854 // |
855 gint CallIPAdpt::GetBitRate(guint& bitrate) |
855 gint TMSCallIPAdpt::GetBitRate(guint& bitrate) |
856 { |
856 { |
857 TRACE_PRN_FN_ENT; |
857 TRACE_PRN_FN_ENT; |
858 gint status(TMS_RESULT_INVALID_STATE); |
858 gint status(TMS_RESULT_INVALID_STATE); |
859 if (iVoIPUplink) |
859 if (iIPUplink) |
860 { |
860 { |
861 status = iVoIPUplink->GetBitrate(bitrate); |
861 status = iIPUplink->GetBitrate(bitrate); |
862 } |
862 } |
863 TRACE_PRN_FN_EXT; |
863 TRACE_PRN_FN_EXT; |
864 return status; |
864 return status; |
865 } |
865 } |
866 |
866 |
867 // ----------------------------------------------------------------------------- |
867 // ----------------------------------------------------------------------------- |
868 // CallIPAdpt::SetBitRate |
868 // TMSCallIPAdpt::SetBitRate |
869 // |
869 // |
870 // ----------------------------------------------------------------------------- |
870 // ----------------------------------------------------------------------------- |
871 // |
871 // |
872 gint CallIPAdpt::SetBitRate(const guint bitrate) |
872 gint TMSCallIPAdpt::SetBitRate(const guint bitrate) |
873 { |
873 { |
874 TRACE_PRN_FN_ENT; |
874 TRACE_PRN_FN_ENT; |
875 gint status(TMS_RESULT_INVALID_STATE); |
875 gint status(TMS_RESULT_INVALID_STATE); |
876 if (iVoIPUplink) |
876 if (iIPUplink) |
877 { |
877 { |
878 status = iVoIPUplink->SetBitrate(bitrate); |
878 status = iIPUplink->SetBitrate(bitrate); |
879 } |
879 } |
880 TRACE_PRN_FN_EXT; |
880 TRACE_PRN_FN_EXT; |
881 return status; |
881 return status; |
882 } |
882 } |
883 |
883 |
884 // ----------------------------------------------------------------------------- |
884 // ----------------------------------------------------------------------------- |
885 // CallIPAdpt::GetVAD |
885 // TMSCallIPAdpt::GetVAD |
886 // |
886 // |
887 // ----------------------------------------------------------------------------- |
887 // ----------------------------------------------------------------------------- |
888 // |
888 // |
889 gint CallIPAdpt::GetVAD(const TMSFormatType fmttype, gboolean& vad) |
889 gint TMSCallIPAdpt::GetVAD(const TMSFormatType fmttype, gboolean& vad) |
890 { |
890 { |
891 TRACE_PRN_FN_ENT; |
891 TRACE_PRN_FN_ENT; |
892 gint status(TMS_RESULT_INVALID_STATE); |
892 gint status(TMS_RESULT_INVALID_STATE); |
893 if (iVoIPUplink) |
893 if (iIPUplink) |
894 { |
894 { |
895 status = iVoIPUplink->GetVad(fmttype, vad); |
895 status = iIPUplink->GetVad(fmttype, vad); |
896 } |
896 } |
897 TRACE_PRN_FN_EXT; |
897 TRACE_PRN_FN_EXT; |
898 return status; |
898 return status; |
899 } |
899 } |
900 |
900 |
901 // ----------------------------------------------------------------------------- |
901 // ----------------------------------------------------------------------------- |
902 // CallIPAdpt::SetVAD |
902 // TMSCallIPAdpt::SetVAD |
903 // |
903 // |
904 // ----------------------------------------------------------------------------- |
904 // ----------------------------------------------------------------------------- |
905 // |
905 // |
906 gint CallIPAdpt::SetVAD(const TMSFormatType fmttype, const gboolean vad) |
906 gint TMSCallIPAdpt::SetVAD(const TMSFormatType fmttype, const gboolean vad) |
907 { |
907 { |
908 TRACE_PRN_FN_ENT; |
908 TRACE_PRN_FN_ENT; |
909 gint status(TMS_RESULT_INVALID_STATE); |
909 gint status(TMS_RESULT_INVALID_STATE); |
910 if (iVoIPUplink) |
910 if (iIPUplink) |
911 { |
911 { |
912 status = iVoIPUplink->SetVad(fmttype, vad); |
912 status = iIPUplink->SetVad(fmttype, vad); |
913 } |
913 } |
914 TRACE_PRN_FN_EXT; |
914 TRACE_PRN_FN_EXT; |
915 return status; |
915 return status; |
916 } |
916 } |
917 |
917 |
918 // ----------------------------------------------------------------------------- |
918 // ----------------------------------------------------------------------------- |
919 // CallIPAdpt::GetCNG |
919 // TMSCallIPAdpt::GetCNG |
920 // |
920 // |
921 // ----------------------------------------------------------------------------- |
921 // ----------------------------------------------------------------------------- |
922 // |
922 // |
923 gint CallIPAdpt::GetCNG(const TMSFormatType fmttype, gboolean& cng) |
923 gint TMSCallIPAdpt::GetCNG(const TMSFormatType fmttype, gboolean& cng) |
924 { |
924 { |
925 TRACE_PRN_FN_ENT; |
925 TRACE_PRN_FN_ENT; |
926 gint status(TMS_RESULT_INVALID_STATE); |
926 gint status(TMS_RESULT_INVALID_STATE); |
927 if (iVoIPDownlink) |
927 if (iIPDownlink) |
928 { |
928 { |
929 status = iVoIPDownlink->GetCng(fmttype, cng); |
929 status = iIPDownlink->GetCng(fmttype, cng); |
930 } |
930 } |
931 TRACE_PRN_FN_EXT; |
931 TRACE_PRN_FN_EXT; |
932 return status; |
932 return status; |
933 } |
933 } |
934 |
934 |
935 // ----------------------------------------------------------------------------- |
935 // ----------------------------------------------------------------------------- |
936 // CallIPAdpt::SetCNG |
936 // TMSCallIPAdpt::SetCNG |
937 // |
937 // |
938 // ----------------------------------------------------------------------------- |
938 // ----------------------------------------------------------------------------- |
939 // |
939 // |
940 gint CallIPAdpt::SetCNG(const TMSFormatType fmttype, const gboolean cng) |
940 gint TMSCallIPAdpt::SetCNG(const TMSFormatType fmttype, const gboolean cng) |
941 { |
941 { |
942 TRACE_PRN_FN_ENT; |
942 TRACE_PRN_FN_ENT; |
943 gint status(TMS_RESULT_INVALID_STATE); |
943 gint status(TMS_RESULT_INVALID_STATE); |
944 if (iVoIPDownlink) |
944 if (iIPDownlink) |
945 { |
945 { |
946 status = iVoIPDownlink->SetCng(fmttype, cng); |
946 status = iIPDownlink->SetCng(fmttype, cng); |
947 } |
947 } |
948 TRACE_PRN_FN_EXT; |
948 TRACE_PRN_FN_EXT; |
949 return status; |
949 return status; |
950 } |
950 } |
951 |
951 |
952 // ----------------------------------------------------------------------------- |
952 // ----------------------------------------------------------------------------- |
953 // CallIPAdpt::GetPlc |
953 // TMSCallIPAdpt::GetPlc |
954 // |
954 // |
955 // ----------------------------------------------------------------------------- |
955 // ----------------------------------------------------------------------------- |
956 // |
956 // |
957 gint CallIPAdpt::GetPlc(const TMSFormatType fmttype, gboolean& plc) |
957 gint TMSCallIPAdpt::GetPlc(const TMSFormatType fmttype, gboolean& plc) |
958 { |
958 { |
959 TRACE_PRN_FN_ENT; |
959 TRACE_PRN_FN_ENT; |
960 gint status(TMS_RESULT_INVALID_STATE); |
960 gint status(TMS_RESULT_INVALID_STATE); |
961 if (iVoIPDownlink) |
961 if (iIPDownlink) |
962 { |
962 { |
963 status = iVoIPDownlink->GetPlc(fmttype, plc); |
963 status = iIPDownlink->GetPlc(fmttype, plc); |
964 } |
964 } |
965 TRACE_PRN_FN_EXT; |
965 TRACE_PRN_FN_EXT; |
966 return status; |
966 return status; |
967 } |
967 } |
968 |
968 |
969 // ----------------------------------------------------------------------------- |
969 // ----------------------------------------------------------------------------- |
970 // CallIPAdpt::SetPlc |
970 // TMSCallIPAdpt::SetPlc |
971 // |
971 // |
972 // ----------------------------------------------------------------------------- |
972 // ----------------------------------------------------------------------------- |
973 // |
973 // |
974 gint CallIPAdpt::SetPlc(const TMSFormatType fmttype, const gboolean plc) |
974 gint TMSCallIPAdpt::SetPlc(const TMSFormatType fmttype, const gboolean plc) |
975 { |
975 { |
976 TRACE_PRN_FN_ENT; |
976 TRACE_PRN_FN_ENT; |
977 gint status(TMS_RESULT_INVALID_STATE); |
977 gint status(TMS_RESULT_INVALID_STATE); |
978 if (iVoIPDownlink) |
978 if (iIPDownlink) |
979 { |
979 { |
980 status = iVoIPDownlink->SetPlc(fmttype, plc); |
980 status = iIPDownlink->SetPlc(fmttype, plc); |
981 } |
981 } |
982 TRACE_PRN_FN_EXT; |
982 TRACE_PRN_FN_EXT; |
983 return status; |
983 return status; |
984 } |
984 } |
985 |
985 |
986 // ----------------------------------------------------------------------------- |
986 // ----------------------------------------------------------------------------- |
987 // CallIPAdpt::OpenDownlinkL |
987 // TMSCallIPAdpt::OpenDownlinkL |
988 // Method for player initialization. |
988 // Method for player initialization. |
989 // ----------------------------------------------------------------------------- |
989 // ----------------------------------------------------------------------------- |
990 // |
990 // |
991 gint CallIPAdpt::OpenDownlinkL(const RMessage2& aMessage) |
991 gint TMSCallIPAdpt::OpenDownlinkL(const RMessage2& aMessage) |
992 { |
992 { |
993 TRACE_PRN_FN_ENT; |
993 TRACE_PRN_FN_ENT; |
994 gint status(TMS_RESULT_SUCCESS); |
994 gint status(TMS_RESULT_SUCCESS); |
995 |
995 |
996 // Ensure clients have MultimediaDD capability to use this priority/pref |
996 // Clients must have MultimediaDD capability to use this priority/pref. |
997 // TODO: TMS must monitor for emergency call now |
997 // TODO: Also, TMS will monitor for emergency call and if detected it |
998 iPriority.iPref = TMdaPriorityPreference(KAudioPrefVoipAudioDownlink); |
998 // will deny access to audio resources. |
999 iPriority.iPriority = TMdaPriority(KAudioPriorityVoipAudioDownlink); |
999 iPriority.iPref = KAudioPrefVoipAudioDownlink; |
1000 |
1000 iPriority.iPriority = KAudioPriorityVoipAudioDownlink; |
1001 if (!iVoIPDownlink) |
1001 |
1002 { |
1002 if (!iIPDownlink) |
1003 iVoIPDownlink = TMSVoIPDownlink::NewL(iDnFourCC, iPriority); |
1003 { |
1004 } |
1004 iIPDownlink = TMSIPDownlink::NewL(iDnFourCC, iPriority); |
1005 |
1005 } |
1006 if (iVoIPDownlink) |
1006 |
|
1007 if (iIPDownlink) |
1007 { |
1008 { |
1008 // Open message queue for handling server notifications to the client |
1009 // Open message queue for handling server notifications to the client |
1009 if (iMsgQueueDn.Handle() <= 0) |
1010 if (iMsgQueueDn.Handle() <= 0) |
1010 { |
1011 { |
1011 // Second argument in TMSCallProxy::InitStream |
1012 // Second argument in TMSCallProxy::InitStream |
1080 iDnFourCC = aFormat; |
1081 iDnFourCC = aFormat; |
1081 } |
1082 } |
1082 } |
1083 } |
1083 |
1084 |
1084 // ----------------------------------------------------------------------------- |
1085 // ----------------------------------------------------------------------------- |
1085 // CallIPAdpt::BufferFilled |
1086 // TMSCallIPAdpt::BufferFilled |
1086 // |
1087 // |
1087 // ----------------------------------------------------------------------------- |
1088 // ----------------------------------------------------------------------------- |
1088 // |
1089 // |
1089 void CallIPAdpt::BufferFilledL(TUint dataSize) |
1090 void TMSCallIPAdpt::BufferFilledL(TUint dataSize) |
1090 { |
1091 { |
1091 if (iVoIPDownlink) |
1092 if (iIPDownlink) |
1092 { |
1093 { |
1093 iVoIPDownlink->BufferFilled(dataSize); |
1094 iIPDownlink->BufferFilled(dataSize); |
1094 } |
1095 } |
1095 } |
1096 } |
1096 |
1097 |
1097 // ----------------------------------------------------------------------------- |
1098 // ----------------------------------------------------------------------------- |
1098 // CallIPAdpt::BufferEmptied |
1099 // TMSCallIPAdpt::BufferEmptied |
1099 // |
1100 // |
1100 // ----------------------------------------------------------------------------- |
1101 // ----------------------------------------------------------------------------- |
1101 // |
1102 // |
1102 void CallIPAdpt::BufferEmptiedL() |
1103 void TMSCallIPAdpt::BufferEmptiedL() |
1103 { |
1104 { |
1104 if (iVoIPUplink) |
1105 if (iIPUplink) |
1105 { |
1106 { |
1106 iVoIPUplink->BufferEmptied(); |
1107 iIPUplink->BufferEmptied(); |
1107 } |
1108 } |
1108 } |
1109 } |
1109 |
1110 |
1110 // ---------------------------------------------------------------------------- |
1111 // ----------------------------------------------------------------------------- |
1111 // CallIPAdpt::GetDataXferChunkHndl |
1112 // TMSCallIPAdpt::GetDataXferChunkHndl |
1112 // |
1113 // |
1113 // ---------------------------------------------------------------------------- |
1114 // ----------------------------------------------------------------------------- |
1114 // |
1115 // |
1115 gint CallIPAdpt::GetDataXferChunkHndl(const TMSStreamType strmType, |
1116 gint TMSCallIPAdpt::GetDataXferChunkHndl(const TMSStreamType strmType, |
1116 const TUint32 key, RChunk& chunk) |
1117 const TUint32 key, RChunk& chunk) |
1117 { |
1118 { |
1118 TRACE_PRN_FN_ENT; |
1119 TRACE_PRN_FN_ENT; |
1119 |
1120 |
1120 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1121 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1121 switch (strmType) |
1122 switch (strmType) |
1122 { |
1123 { |
1123 case TMS_STREAM_DOWNLINK: |
1124 case TMS_STREAM_DOWNLINK: |
1124 { |
1125 { |
1125 if (iVoIPDownlink) |
1126 if (iIPDownlink) |
1126 { |
1127 { |
1127 status = iVoIPDownlink->GetDataXferChunkHndl(key, chunk); |
1128 status = iIPDownlink->GetDataXferChunkHndl(key, chunk); |
1128 } |
1129 } |
1129 break; |
1130 break; |
1130 } |
1131 } |
1131 case TMS_STREAM_UPLINK: |
1132 case TMS_STREAM_UPLINK: |
1132 { |
1133 { |
1133 if (iVoIPUplink) |
1134 if (iIPUplink) |
1134 { |
1135 { |
1135 status = iVoIPUplink->GetDataXferChunkHndl(key, chunk); |
1136 status = iIPUplink->GetDataXferChunkHndl(key, chunk); |
1136 } |
1137 } |
1137 break; |
1138 break; |
1138 } |
1139 } |
1139 default: |
1140 default: |
1140 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
1141 status = TMS_RESULT_STREAM_TYPE_NOT_SUPPORTED; |
1144 TRACE_PRN_FN_EXT; |
1145 TRACE_PRN_FN_EXT; |
1145 return status; |
1146 return status; |
1146 } |
1147 } |
1147 |
1148 |
1148 // ----------------------------------------------------------------------------- |
1149 // ----------------------------------------------------------------------------- |
1149 // CallIPAdpt::SetIlbcCodecMode |
1150 // TMSCallIPAdpt::SetIlbcCodecMode |
1150 // |
1151 // |
1151 // ----------------------------------------------------------------------------- |
1152 // ----------------------------------------------------------------------------- |
1152 // |
1153 // |
1153 gint CallIPAdpt::SetIlbcCodecMode(const gint mode, const TMSStreamType strmtype) |
1154 gint TMSCallIPAdpt::SetIlbcCodecMode(const gint mode, |
|
1155 const TMSStreamType strmtype) |
1154 { |
1156 { |
1155 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1157 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1156 |
1158 |
1157 if (strmtype == TMS_STREAM_DOWNLINK) |
1159 if (strmtype == TMS_STREAM_DOWNLINK) |
1158 { |
1160 { |
1159 if (iDnlinkInitialized && iVoIPDownlink) |
1161 if (iDnlinkInitialized && iIPDownlink) |
1160 { |
1162 { |
1161 status = iVoIPDownlink->SetIlbcCodecMode(mode); |
1163 status = iIPDownlink->SetIlbcCodecMode(mode); |
1162 } |
1164 } |
1163 } |
1165 } |
1164 else if (strmtype == TMS_STREAM_UPLINK) |
1166 else if (strmtype == TMS_STREAM_UPLINK) |
1165 { |
1167 { |
1166 if (iUplinkInitialized && iVoIPUplink) |
1168 if (iUplinkInitialized && iIPUplink) |
1167 { |
1169 { |
1168 status = iVoIPUplink->SetIlbcCodecMode(mode); |
1170 status = iIPUplink->SetIlbcCodecMode(mode); |
1169 } |
1171 } |
1170 } |
1172 } |
1171 |
1173 |
1172 return status; |
1174 return status; |
1173 } |
1175 } |
1174 |
1176 |
1175 // ----------------------------------------------------------------------------- |
1177 // ----------------------------------------------------------------------------- |
1176 // CallIPAdpt::GetIlbcCodecMode |
1178 // TMSCallIPAdpt::GetIlbcCodecMode |
1177 // |
1179 // |
1178 // ----------------------------------------------------------------------------- |
1180 // ----------------------------------------------------------------------------- |
1179 // |
1181 // |
1180 gint CallIPAdpt::GetIlbcCodecMode(gint& mode, const TMSStreamType strmtype) |
1182 gint TMSCallIPAdpt::GetIlbcCodecMode(gint& mode, const TMSStreamType strmtype) |
1181 { |
1183 { |
1182 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1184 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1183 |
1185 |
1184 if (strmtype == TMS_STREAM_DOWNLINK) |
1186 if (strmtype == TMS_STREAM_DOWNLINK) |
1185 { |
1187 { |
1186 if (iDnlinkInitialized && iVoIPDownlink) |
1188 if (iDnlinkInitialized && iIPDownlink) |
1187 { |
1189 { |
1188 status = iVoIPDownlink->GetIlbcCodecMode(mode); |
1190 status = iIPDownlink->GetIlbcCodecMode(mode); |
1189 } |
1191 } |
1190 } |
1192 } |
1191 else if (strmtype == TMS_STREAM_UPLINK) |
1193 else if (strmtype == TMS_STREAM_UPLINK) |
1192 { |
1194 { |
1193 if (iUplinkInitialized && iVoIPUplink) |
1195 if (iUplinkInitialized && iIPUplink) |
1194 { |
1196 { |
1195 status = iVoIPUplink->GetIlbcCodecMode(mode); |
1197 status = iIPUplink->GetIlbcCodecMode(mode); |
1196 } |
1198 } |
1197 } |
1199 } |
1198 |
1200 |
1199 return status; |
1201 return status; |
1200 } |
1202 } |
1201 |
1203 |
1202 // ----------------------------------------------------------------------------- |
1204 // ----------------------------------------------------------------------------- |
1203 // CallIPAdpt::SetG711CodecMode |
1205 // TMSCallIPAdpt::SetG711CodecMode |
1204 // |
1206 // |
1205 // ----------------------------------------------------------------------------- |
1207 // ----------------------------------------------------------------------------- |
1206 // |
1208 // |
1207 gint CallIPAdpt::SetG711CodecMode(const gint mode, const TMSStreamType strmtype) |
1209 gint TMSCallIPAdpt::SetG711CodecMode(const gint mode, |
|
1210 const TMSStreamType strmtype) |
1208 { |
1211 { |
1209 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1212 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1210 |
1213 |
1211 if (strmtype == TMS_STREAM_DOWNLINK) |
1214 if (strmtype == TMS_STREAM_DOWNLINK) |
1212 { |
1215 { |
1213 if (iDnlinkInitialized && iVoIPDownlink) |
1216 if (iDnlinkInitialized && iIPDownlink) |
1214 { |
1217 { |
1215 status = iVoIPDownlink->SetG711CodecMode(mode); |
1218 status = iIPDownlink->SetG711CodecMode(mode); |
1216 } |
1219 } |
1217 } |
1220 } |
1218 else if (strmtype == TMS_STREAM_UPLINK) |
1221 else if (strmtype == TMS_STREAM_UPLINK) |
1219 { |
1222 { |
1220 if (iUplinkInitialized && iVoIPUplink) |
1223 if (iUplinkInitialized && iIPUplink) |
1221 { |
1224 { |
1222 status = iVoIPUplink->SetG711CodecMode(mode); |
1225 status = iIPUplink->SetG711CodecMode(mode); |
1223 } |
1226 } |
1224 } |
1227 } |
1225 |
1228 |
1226 return status; |
1229 return status; |
1227 } |
1230 } |
1228 |
1231 |
1229 // ----------------------------------------------------------------------------- |
1232 // ----------------------------------------------------------------------------- |
1230 // CallIPAdpt::GetG711CodecMode |
1233 // TMSCallIPAdpt::GetG711CodecMode |
1231 // |
1234 // |
1232 // ----------------------------------------------------------------------------- |
1235 // ----------------------------------------------------------------------------- |
1233 // |
1236 // |
1234 gint CallIPAdpt::GetG711CodecMode(gint& mode, const TMSStreamType strmtype) |
1237 gint TMSCallIPAdpt::GetG711CodecMode(gint& mode, const TMSStreamType strmtype) |
1235 { |
1238 { |
1236 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1239 gint status(TMS_RESULT_INVALID_ARGUMENT); |
1237 |
1240 |
1238 if (strmtype == TMS_STREAM_DOWNLINK) |
1241 if (strmtype == TMS_STREAM_DOWNLINK) |
1239 { |
1242 { |
1240 if (iDnlinkInitialized && iVoIPDownlink) |
1243 if (iDnlinkInitialized && iIPDownlink) |
1241 { |
1244 { |
1242 status = iVoIPDownlink->GetG711CodecMode(mode); |
1245 status = iIPDownlink->GetG711CodecMode(mode); |
1243 } |
1246 } |
1244 } |
1247 } |
1245 else if (strmtype == TMS_STREAM_UPLINK) |
1248 else if (strmtype == TMS_STREAM_UPLINK) |
1246 { |
1249 { |
1247 if (iUplinkInitialized && iVoIPUplink) |
1250 if (iUplinkInitialized && iIPUplink) |
1248 { |
1251 { |
1249 status = iVoIPUplink->GetG711CodecMode(mode); |
1252 status = iIPUplink->GetG711CodecMode(mode); |
1250 } |
1253 } |
1251 } |
1254 } |
1252 |
1255 |
1253 return status; |
1256 return status; |
1254 } |
1257 } |
1255 |
1258 |
1256 // ----------------------------------------------------------------------------- |
1259 // ----------------------------------------------------------------------------- |
1257 // CallIPAdpt::FrameModeRequiredForEC |
1260 // TMSCallIPAdpt::FrameModeRequiredForEC |
1258 // |
1261 // |
1259 // ----------------------------------------------------------------------------- |
1262 // ----------------------------------------------------------------------------- |
1260 // |
1263 // |
1261 gint CallIPAdpt::FrameModeRqrdForEC(gboolean& frmodereq) |
1264 gint TMSCallIPAdpt::FrameModeRqrdForEC(gboolean& frmodereq) |
1262 { |
1265 { |
1263 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1266 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1264 if (iVoIPDownlink) |
1267 if (iIPDownlink) |
1265 { |
1268 { |
1266 status = iVoIPDownlink->FrameModeRqrdForEC(frmodereq); |
1269 status = iIPDownlink->FrameModeRqrdForEC(frmodereq); |
1267 } |
1270 } |
1268 return status; |
1271 return status; |
1269 } |
1272 } |
1270 |
1273 |
1271 // ----------------------------------------------------------------------------- |
1274 // ----------------------------------------------------------------------------- |
1272 // CallIPAdpt::SetFrameMode |
1275 // TMSCallIPAdpt::SetFrameMode |
1273 // |
1276 // |
1274 // ----------------------------------------------------------------------------- |
1277 // ----------------------------------------------------------------------------- |
1275 // |
1278 // |
1276 gint CallIPAdpt::SetFrameMode(const gboolean frmode) |
1279 gint TMSCallIPAdpt::SetFrameMode(const gboolean frmode) |
1277 { |
1280 { |
1278 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1281 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1279 if (iVoIPDownlink) |
1282 if (iIPDownlink) |
1280 { |
1283 { |
1281 status = iVoIPDownlink->SetFrameMode(frmode); |
1284 status = iIPDownlink->SetFrameMode(frmode); |
1282 } |
1285 } |
1283 return status; |
1286 return status; |
1284 } |
1287 } |
1285 |
1288 |
1286 // ----------------------------------------------------------------------------- |
1289 // ----------------------------------------------------------------------------- |
1287 // CallIPAdpt::GetFrameMode |
1290 // TMSCallIPAdpt::GetFrameMode |
1288 // |
1291 // |
1289 // ----------------------------------------------------------------------------- |
1292 // ----------------------------------------------------------------------------- |
1290 // |
1293 // |
1291 gint CallIPAdpt::GetFrameMode(gboolean& frmode) |
1294 gint TMSCallIPAdpt::GetFrameMode(gboolean& frmode) |
1292 { |
1295 { |
1293 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1296 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1294 if (iVoIPDownlink) |
1297 if (iIPDownlink) |
1295 { |
1298 { |
1296 status = iVoIPDownlink->GetFrameMode(frmode); |
1299 status = iIPDownlink->GetFrameMode(frmode); |
1297 } |
1300 } |
1298 return status; |
1301 return status; |
1299 } |
1302 } |
1300 |
1303 |
1301 // ----------------------------------------------------------------------------- |
1304 // ----------------------------------------------------------------------------- |
1302 // CallIPAdpt::ConcealErrorForNextBuffer |
1305 // TMSCallIPAdpt::ConcealErrorForNextBuffer |
1303 // ----------------------------------------------------------------------------- |
1306 // ----------------------------------------------------------------------------- |
1304 // |
1307 // |
1305 gint CallIPAdpt::ConcealErrorForNextBuffer() |
1308 gint TMSCallIPAdpt::ConcealErrorForNextBuffer() |
1306 { |
1309 { |
1307 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1310 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1308 if (iVoIPDownlink) |
1311 if (iIPDownlink) |
1309 { |
1312 { |
1310 status = iVoIPDownlink->ConcealErrorForNextBuffer(); |
1313 status = iIPDownlink->ConcealErrorForNextBuffer(); |
1311 } |
1314 } |
1312 return status; |
1315 return status; |
1313 } |
1316 } |
1314 |
1317 |
1315 // ----------------------------------------------------------------------------- |
1318 // ----------------------------------------------------------------------------- |
1316 // CallIPAdpt::BadLsfNextBuffer |
1319 // TMSCallIPAdpt::BadLsfNextBuffer |
1317 // |
1320 // |
1318 // ----------------------------------------------------------------------------- |
1321 // ----------------------------------------------------------------------------- |
1319 // |
1322 // |
1320 gint CallIPAdpt::BadLsfNextBuffer() |
1323 gint TMSCallIPAdpt::BadLsfNextBuffer() |
1321 { |
1324 { |
1322 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1325 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1323 if (iVoIPDownlink) |
1326 if (iIPDownlink) |
1324 { |
1327 { |
1325 status = iVoIPDownlink->BadLsfNextBuffer(); |
1328 status = iIPDownlink->BadLsfNextBuffer(); |
1326 } |
1329 } |
1327 return status; |
1330 return status; |
1328 } |
1331 } |
1329 |
1332 |
1330 // ----------------------------------------------------------------------------- |
1333 // ----------------------------------------------------------------------------- |
1331 // CallIPAdpt::SetOutput |
1334 // TMSCallIPAdpt::SetOutput |
1332 // |
1335 // |
1333 // ----------------------------------------------------------------------------- |
1336 // ----------------------------------------------------------------------------- |
1334 // |
1337 // |
1335 gint CallIPAdpt::SetOutput(TMSAudioOutput output) |
1338 gint TMSCallIPAdpt::SetOutput(TMSAudioOutput output) |
1336 { |
1339 { |
1337 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1340 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1338 if (iDnlinkInitialized && iVoIPDownlink) |
1341 if (iDnlinkInitialized && iIPDownlink) |
1339 { |
1342 { |
1340 TRAP(status, iVoIPDownlink->SetAudioDeviceL(output)); |
1343 TRAP(status, iIPDownlink->SetAudioDeviceL(output)); |
1341 } |
1344 } |
1342 return status; |
1345 return status; |
1343 } |
1346 } |
1344 // ----------------------------------------------------------------------------- |
1347 // ----------------------------------------------------------------------------- |
1345 // CallIPAdpt::GetOutput |
1348 // TMSCallIPAdpt::GetOutput |
1346 // |
1349 // |
1347 // ----------------------------------------------------------------------------- |
1350 // ----------------------------------------------------------------------------- |
1348 // |
1351 // |
1349 gint CallIPAdpt::GetOutput(TMSAudioOutput& output) |
1352 gint TMSCallIPAdpt::GetOutput(TMSAudioOutput& output) |
1350 { |
1353 { |
1351 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1354 gint status(TMS_RESULT_UNINITIALIZED_OBJECT); |
1352 if (iDnlinkInitialized && iVoIPDownlink) |
1355 if (iDnlinkInitialized && iIPDownlink) |
1353 { |
1356 { |
1354 TRAP(status, iVoIPDownlink->GetAudioDeviceL(output)); |
1357 TRAP(status, iIPDownlink->GetAudioDeviceL(output)); |
1355 } |
1358 } |
1356 return status; |
1359 return status; |
1357 } |
1360 } |
1358 // ----------------------------------------------------------------------------- |
1361 // ----------------------------------------------------------------------------- |
1359 // CallIPAdpt::GetPreviousOutput |
1362 // TMSCallIPAdpt::GetPreviousOutput |
1360 // |
1363 // |
1361 // ----------------------------------------------------------------------------- |
1364 // ----------------------------------------------------------------------------- |
1362 // |
1365 // |
1363 gint CallIPAdpt::GetPreviousOutput(TMSAudioOutput& /*output*/) |
1366 gint TMSCallIPAdpt::GetPreviousOutput(TMSAudioOutput& /*output*/) |
1364 { |
1367 { |
1365 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
1368 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
1366 } |
1369 } |
1367 |
1370 |
1368 // ----------------------------------------------------------------------------- |
1371 // ----------------------------------------------------------------------------- |
1369 // CallIPAdpt::GetAvailableOutputsL |
1372 // TMSCallIPAdpt::GetAvailableOutputsL |
1370 // |
1373 // |
1371 // ----------------------------------------------------------------------------- |
1374 // ----------------------------------------------------------------------------- |
1372 // |
1375 // |
1373 gint CallIPAdpt::GetAvailableOutputsL(gint& /*count*/, CBufFlat*& /*outputsbuffer*/) |
1376 gint TMSCallIPAdpt::GetAvailableOutputsL(gint& /*count*/, |
|
1377 CBufFlat*& /*outputsbuffer*/) |
1374 { |
1378 { |
1375 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
1379 return TMS_RESULT_FEATURE_NOT_SUPPORTED; |
1376 } |
1380 } |
1377 |
1381 |
1378 // ----------------------------------------------------------------------------- |
1382 // ----------------------------------------------------------------------------- |
1379 // CallIPAdpt::NotifyClient |
1383 // TMSCallIPAdpt::NotifyClient |
1380 // ----------------------------------------------------------------------------- |
1384 // ----------------------------------------------------------------------------- |
1381 // |
1385 // |
1382 void CallIPAdpt::NotifyClient(const gint strmId, const TInt aCommand, |
1386 void TMSCallIPAdpt::NotifyClient(const gint strmId, const TInt aCommand, |
1383 const TInt aStatus, const TInt64 /*aInt64*/) |
1387 const TInt aStatus, const TInt64 /*aInt64*/) |
1384 { |
1388 { |
1385 iMsgBuffer.iRequest = aCommand; |
1389 iMsgBuffer.iRequest = aCommand; |
1386 iMsgBuffer.iStatus = aStatus; |
1390 iMsgBuffer.iStatus = aStatus; |
1387 |
1391 |