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 <e32cmn.h>

    19 #include <mmffourcc.h>

    20 #include <mmcccodecinformation.h>

    21 //#include <tms.h>

    22 #include "tmsutility.h"

    23 

    24 using namespace TMS;

    25 

    26 // -----------------------------------------------------------------------------

    27 // TMSUtility::TMSResult

    28 //

    29 // -----------------------------------------------------------------------------

    30 //

    31 EXPORT_C gint TMSUtility::TMSResult(const gint aError)

    32     {

    33     gint result(TMS_RESULT_SUCCESS);

    34 

    35     if (aError >= TMS_RESULT_SUCCESS)

    36         {

    37         return aError; //return TMS error

    38         }

    39 

    40     switch (aError)

    41         {

    42         case KErrNotFound: //-1

    43             result = TMS_RESULT_DOES_NOT_EXIST;

    44             break;

    45         case KErrGeneral: //-2

    46             result = TMS_RESULT_GENERAL_ERROR;

    47             break;

    48         case KErrCancel: //-3

    49             result = TMS_RESULT_OPERATION_CANCELLED;

    50             break;

    51         case KErrNoMemory: //-4

    52             result = TMS_RESULT_INSUFFICIENT_MEMORY;

    53             break;

    54         case KErrNotSupported: //-5

    55             result = TMS_RESULT_DOES_NOT_EXIST;

    56             break;

    57         case KErrArgument: //-6

    58             result = TMS_RESULT_INVALID_ARGUMENT;

    59             break;

    60         case KErrTotalLossOfPrecision: //-7

    61             result = TMS_RESULT_GENERAL_ERROR;

    62             break;

    63         case KErrBadHandle: //-8

    64             result = TMS_RESULT_INVALID_ARGUMENT;

    65             break;

    66         case KErrOverflow: //-9

    67         case KErrUnderflow: //-10

    68             result = TMS_RESULT_BUFFER_LATENCY_ERROR;

    69             break;

    70         case KErrAlreadyExists: //-11

    71             result = TMS_RESULT_ALREADY_EXIST;

    72             break;

    73         case KErrPathNotFound: //-12

    74             result = TMS_RESULT_GENERAL_ERROR;

    75             break;

    76         case KErrDied: //-13

    77         case KErrInUse: //-14

    78         case KErrServerTerminated: //-15

    79             result = TMS_RESULT_FATAL_ERROR;

    80             break;

    81         case KErrServerBusy: //-16

    82         case KErrCompletion: //-17

    83         case KErrNotReady: //-18

    84         case KErrUnknown: //-19

    85         case KErrCorrupt: //-20

    86         case KErrAccessDenied: //-21

    87         case KErrLocked: //-22

    88         case KErrWrite: //-23

    89         case KErrDisMounted: //-24

    90         case KErrEof: //-25

    91         case KErrDiskFull: //-26

    92         case KErrBadDriver: //-27

    93         case KErrBadName: //-28

    94         case KErrCommsLineFail: //-29

    95         case KErrCommsFrame: //-30

    96         case KErrCommsOverrun: //-31

    97         case KErrCommsParity: //-32

    98         case KErrTimedOut: //-33

    99         case KErrCouldNotConnect: //-34

   100         case KErrCouldNotDisconnect: //-35

   101         case KErrDisconnected: //-36

   102         case KErrBadLibraryEntryPoint: //-37

   103         case KErrBadDescriptor: //-38

   104         case KErrAbort: //-39

   105         case KErrTooBig: //-40

   106         case KErrDivideByZero: //-41

   107         case KErrBadPower: //-42

   108         case KErrDirFull: //-43

   109         case KErrHardwareNotAvailable: //-44

   110         case KErrSessionClosed: //-45

   111         case KErrPermissionDenied: //-46

   112         case KErrExtensionNotSupported: //-47

   113         case KErrCommsBreak: //-48

   114         case KErrNoSecureTime: //-49

   115         default:

   116             result = TMS_RESULT_GENERAL_ERROR;

   117             break;

   118         }

   119     return result;

   120     }

   121 

   122 // -----------------------------------------------------------------------------

   123 // TMSUtility::ToTMSOutput

   124 //

   125 // -----------------------------------------------------------------------------

   126 //

   127 EXPORT_C TMSAudioOutput TMSUtility::ToTMSOutput(

   128         CTelephonyAudioRouting::TAudioOutput taroutput)

   129     {

   130     TMSAudioOutput output = TMS_AUDIO_OUTPUT_NONE;

   131     switch (taroutput)

   132         {

   133         case CTelephonyAudioRouting::ENotActive:

   134         case CTelephonyAudioRouting::ENone:

   135             output = TMS_AUDIO_OUTPUT_NONE;

   136             break;

   137         case CTelephonyAudioRouting::EHandset:

   138             output = TMS_AUDIO_OUTPUT_HANDSET;

   139             break;

   140         case CTelephonyAudioRouting::ELoudspeaker:

   141             output = TMS_AUDIO_OUTPUT_LOUDSPEAKER;

   142             break;

   143         case CTelephonyAudioRouting::EWiredAudioAccessory:

   144             output = TMS_AUDIO_OUTPUT_WIRED_ACCESSORY;

   145             break;

   146         case CTelephonyAudioRouting::EBTAudioAccessory:

   147             output = TMS_AUDIO_OUTPUT_ACCESSORY;

   148             break;

   149         case CTelephonyAudioRouting::ETTY:

   150             output = TMS_AUDIO_OUTPUT_ETTY;

   151             break;

   152         default:

   153             break;

   154         }

   155     return output;

   156     }

   157 

   158 // -----------------------------------------------------------------------------

   159 // TMSUtility::ToTAROutput

   160 //

   161 // -----------------------------------------------------------------------------

   162 //

   163 EXPORT_C CTelephonyAudioRouting::TAudioOutput TMSUtility::ToTAROutput(

   164         TMSAudioOutput output)

   165     {

   166     CTelephonyAudioRouting::TAudioOutput taroutput =

   167             CTelephonyAudioRouting::ENone;

   168     switch (output)

   169         {

   170         case TMS_AUDIO_OUTPUT_NONE:

   171             taroutput = CTelephonyAudioRouting::ENone;

   172             break;

   173         case TMS_AUDIO_OUTPUT_HANDSET:

   174             taroutput = CTelephonyAudioRouting::EHandset;

   175             break;

   176         case TMS_AUDIO_OUTPUT_LOUDSPEAKER:

   177             taroutput = CTelephonyAudioRouting::ELoudspeaker;

   178             break;

   179         case TMS_AUDIO_OUTPUT_WIRED_ACCESSORY:

   180             taroutput = CTelephonyAudioRouting::EWiredAudioAccessory;

   181             break;

   182         case TMS_AUDIO_OUTPUT_ACCESSORY:

   183             taroutput = CTelephonyAudioRouting::EBTAudioAccessory;

   184             break;

   185         case TMS_AUDIO_OUTPUT_ETTY:

   186             taroutput = CTelephonyAudioRouting::ETTY;

   187             break;

   188         default:

   189             break;

   190         }

   191     return taroutput;

   192     }

   193 

   194 // -----------------------------------------------------------------------------

   195 // TMSUtility::ToFourCC

   196 //

   197 // -----------------------------------------------------------------------------

   198 //

   199 EXPORT_C TUint32 TMSUtility::ToFourCC(TMSFormatType frmtType)

   200     {

   201     TUint32 fourCC(NULL);

   202     switch (frmtType)

   203         {

   204         case TMS_FORMAT_PCM:

   205             fourCC = KMMFFourCCCodePCM16;

   206             break;

   207         case TMS_FORMAT_AMR:

   208             fourCC = KMccFourCCIdAMRNB;

   209             break;

   210         case TMS_FORMAT_G711:

   211             fourCC = KMccFourCCIdG711;

   212             break;

   213         case TMS_FORMAT_G729:

   214             fourCC = KMccFourCCIdG729;

   215             break;

   216         case TMS_FORMAT_ILBC:

   217             fourCC = KMccFourCCIdILBC;

   218             break;

   219         default:

   220             break;

   221         }

   222     return fourCC;

   223     }

   224 

   225 // -----------------------------------------------------------------------------

   226 // TMSUtility::FourCCToTMSFormat

   227 //

   228 // -----------------------------------------------------------------------------

   229 //

   230 EXPORT_C TMSFormatType TMSUtility::FourCCToTMSFormat(TUint32 fourcc)

   231     {

   232     TMSFormatType format = NULL;

   233     switch (fourcc)

   234         {

   235         case KMMFFourCCCodePCM16:   // = 0x36315020

   236             format = TMS_FORMAT_PCM;

   237             break;

   238         case KMccFourCCIdAMRNB:     //= 0x524d4120;

   239             format = TMS_FORMAT_AMR;

   240             break;

   241         case KMccFourCCIdG711:      // = 0x31313747;

   242             format = TMS_FORMAT_G711;

   243             break;

   244         case KMccFourCCIdG729:      // = 0x39323747;

   245             format = TMS_FORMAT_G729;

   246             break;

   247         case KMccFourCCIdILBC:      // = 0x43424c49;

   248             format = TMS_FORMAT_ILBC;

   249             break;

   250         default:

   251             break;

   252         }

   253     return format;

   254     }