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: 

    15 *

    16 */

    17 

    18 #include <stdio.h>

    19 #include <stdlib.h>

    20 #include <string.h>

    21 

    22 #include <stdarg.h>

    23 #include "openmaxalwrapper.h"

    24 #include "xaglobals.h"

    25 #include "xaengine.h"

    26 /*

    27  *  compare two XAInterfaceIDs, return true if same

    28  */

    29 XAboolean XACommon_EqualIIds(XAInterfaceID idA, XAInterfaceID idB)

    30 {

    31     XAboolean nodeOk;

    32     XAuint16 nodeIdx;

    33     if(idA==idB) return XA_BOOLEAN_TRUE;

    34     if(!idA||!idB) return XA_BOOLEAN_FALSE;

    35     if( idA->time_low == idB->time_low &&

    36         idA->time_mid == idB->time_mid &&

    37         idA->time_hi_and_version == idB->time_hi_and_version &&

    38         idA->clock_seq == idB->clock_seq)

    39         {

    40             nodeOk = XA_BOOLEAN_TRUE;

    41             for(nodeIdx = 0; nodeIdx < sizeof(idA->node); nodeIdx++ )

    42             {

    43                 if(idA->node[nodeIdx] != idB->node[nodeIdx])

    44                 {

    45                     nodeOk = XA_BOOLEAN_FALSE;

    46                     break;

    47                 }

    48             }

    49             if(nodeOk)

    50             {

    51                 return XA_BOOLEAN_TRUE;

    52             }

    53         }

    54     return XA_BOOLEAN_FALSE;

    55 }

    56 

    57 /* Check source availability and content type. Return error only if we are sure

    58  * content is not valid, otherwise let adaptation try to identify and use content.

    59  * @param type: on return, contains content type, if known.

    60  * @return Success code

    61  */

    62 XAresult XACommon_CheckDataSource(XADataSource* source, XAMediaType* type)

    63 {

    64     XAresult ret=XA_RESULT_SUCCESS;

    65     XAchar* fname=NULL;

    66     XAchar* mime=NULL;

    67     XAboolean isLocal=XA_BOOLEAN_FALSE;

    68 

    69 

    70     if(!source || !source->pLocator)

    71     {

    72         DEBUG_ERR("Invalid XADataSource structure!!");

    73         return XA_RESULT_PARAMETER_INVALID;

    74     }

    75 

    76     /* check URI availability */

    77     if( *(XAuint32*)(source->pLocator) == XA_DATALOCATOR_URI )

    78     {

    79         fname = (XAchar*)((XADataLocator_URI*)(source->pLocator))->URI;

    80         /* check protocol prefix */

    81         if(strstr((char*)fname,":///"))

    82         {

    83             if(strncmp((char*)fname, "file:///", 8) == 0)

    84             {

    85                 isLocal=XA_BOOLEAN_TRUE;

    86                 fname += 8;

    87             }

    88             else

    89             {   /* add support for other protocols if needed */

    90                 isLocal=XA_BOOLEAN_FALSE;

    91             }

    92         }

    93         else

    94         {

    95             isLocal=XA_BOOLEAN_TRUE;

    96         }

    97         if(isLocal)

    98         {

    99             FILE* file=fopen((char*)fname, "r");

   100             if(!file)

   101             {

   102                 DEBUG_INFO_A1("%s not found from filesystem", fname);

   103                 ret = XA_RESULT_CONTENT_NOT_FOUND;

   104             }

   105             else

   106             {

   107                 fclose(file);

   108             }

   109         }

   110     }

   111 

   112     /* check content type */

   113     if( type )

   114     {

   115         if(source->pFormat)

   116         {

   117             switch( *(XAuint32*)source->pFormat )

   118             {

   119                 case XA_DATAFORMAT_MIME:

   120                 {

   121                     /* try to parse mimetype first */

   122                     mime = ((XADataFormat_MIME*)(source->pFormat))->mimeType;

   123                     if(strncmp((char*)mime,"audio",5)==0)

   124                     {

   125                         *type = XA_MEDIATYPE_AUDIO;

   126                     }

   127                     else if(strncmp((char*)mime,"video",5)==0)

   128                     {

   129                         *type = XA_MEDIATYPE_VIDEO;

   130                     }

   131                     else if(strncmp((char*)mime,"image",5)==0)

   132                     {

   133                         *type = XA_MEDIATYPE_IMAGE;

   134                     }

   135                     else

   136                     {

   137                         /* try to parse containertype next */

   138                         switch( ((XADataFormat_MIME*)(source->pFormat))->containerType )

   139                         {

   140                             case XA_CONTAINERTYPE_M4A:

   141                             case XA_CONTAINERTYPE_MP3:

   142                             case XA_CONTAINERTYPE_WAV:

   143                             case XA_CONTAINERTYPE_XMF_0:

   144                             case XA_CONTAINERTYPE_XMF_1:

   145                             case XA_CONTAINERTYPE_XMF_2:

   146                             case XA_CONTAINERTYPE_XMF_3:

   147                             case XA_CONTAINERTYPE_XMF_GENERIC:

   148                             case XA_CONTAINERTYPE_AMR:

   149                             case XA_CONTAINERTYPE_AAC:

   150                             case XA_CONTAINERTYPE_3GA:

   151                             case XA_CONTAINERTYPE_DMF:

   152                             case XA_CONTAINERTYPE_SMF:

   153                             case XA_CONTAINERTYPE_MOBILE_DLS:

   154                                 *type = XA_MEDIATYPE_AUDIO;

   155                                 break;

   156 

   157                             case XA_CONTAINERTYPE_ASF:

   158                             case XA_CONTAINERTYPE_AVI:

   159                             case XA_CONTAINERTYPE_MP4:

   160                             case XA_CONTAINERTYPE_MPEG_ES:

   161                             case XA_CONTAINERTYPE_MPEG_PS:

   162                             case XA_CONTAINERTYPE_MPEG_TS:

   163                             case XA_CONTAINERTYPE_QT:

   164                             case XA_CONTAINERTYPE_3GPP:

   165                             case XA_CONTAINERTYPE_RM:

   166                                 *type = XA_MEDIATYPE_VIDEO;

   167                                 break;

   168 

   169                             case XA_CONTAINERTYPE_BMP:

   170                             case XA_CONTAINERTYPE_JPG:

   171                             case XA_CONTAINERTYPE_JPG2000:

   172                                 *type = XA_MEDIATYPE_IMAGE;

   173                                 break;

   174 

   175                             case XA_CONTAINERTYPE_RAW:

   176                             case XA_CONTAINERTYPE_UNSPECIFIED:

   177                             default:

   178                                 *type = XA_MEDIATYPE_UNKNOWN;

   179                                 break;

   180                         }

   181                     }

   182                 }

   183                 break;

   184 

   185                 case XA_DATAFORMAT_PCM:

   186                     *type = XA_MEDIATYPE_AUDIO;

   187                 break;

   188 

   189                 case XA_DATAFORMAT_RAWIMAGE:

   190                     *type = XA_MEDIATYPE_IMAGE;

   191                 break;

   192 

   193                 default:

   194                     *type = XA_MEDIATYPE_UNKNOWN;

   195                     DEBUG_INFO("Warning: unknown dataformat");

   196                 break;

   197             }

   198         }

   199         else

   200         {

   201             DEBUG_ERR("Warning: no data format set");

   202             *type = XA_MEDIATYPE_UNKNOWN;

   203         }

   204 

   205         /* Expand this list if add new supported media type */

   206         /* If media type unknow check it from file extension */

   207         if(*type == XA_MEDIATYPE_UNKNOWN && fname)

   208         {

   209             if( (strstr((char*)fname,".wav")) || (strstr((char*)fname,".mid"))

   210                 || (strstr((char*)fname,".amr")))

   211             {

   212                 *type = XA_MEDIATYPE_AUDIO;

   213             }

   214             if( (strstr((char*)fname,".avi")) || (strstr((char*)fname,".ogg")) )

   215             {

   216 

   217             }

   218             if(strstr((char*)fname,".jpg"))

   219             {

   220                 *type = XA_MEDIATYPE_IMAGE;

   221             }

   222         }

   223     }

   224     return ret;

   225 }

   226 

   227 /* Validate XADataSink and XADataSrc object creation parameters.

   228  * @return Success code

   229  */

   230 XAresult XACommon_ValidateDataLocator(XAuint32 pCounter, void* pSnk, ... )

   231 {

   232     va_list argptr;

   233     XAuint32 counter = 0;

   234     XADataLocator_URI* uri = NULL;

   235     XADataLocator_NativeDisplay* display = NULL;

   236     XADataLocator_OutputMix* omix = NULL;

   237     XADataLocator_Address* address = NULL;

   238     XADataLocator_IODevice* iodevice = NULL;

   239     XAresult ret = XA_RESULT_SUCCESS;

   240     XADataSink* xaSnk = NULL;

   241     DEBUG_API("->XACommon_ValidateDataLocator");

   242 

   243     xaSnk = (XADataSink*)pSnk;

   244 

   245     /* Initialize variable arguments. */

   246     //va_start (argptr, xaSnk); TL: Replaced with:

   247   	va_start (argptr, pSnk);    

   248     while( counter < pCounter )

   249     {

   250         if( counter > 0)

   251         {

   252             /*XADataSink and XADataSrc are equivalent, use XADataSink for both*/

   253             xaSnk = va_arg(argptr, XADataSink*);

   254         }

   255         if( !xaSnk )

   256         {   /*NULL sinks/sources are possible, not checked here*/

   257             counter++;

   258             continue;

   259         }

   260         else if( !xaSnk->pLocator )

   261         {

   262             DEBUG_ERR_A1("NULL XADataLocator in parameter %d",(int)counter);

   263             ret = XA_RESULT_PARAMETER_INVALID;

   264             va_end(argptr);

   265     				DEBUG_API("<-XACommon_ValidateDataLocator");

   266     				return ret;

   267         }

   268         switch ( *(XAuint32*)(xaSnk->pLocator) )

   269         {

   270             case XA_DATALOCATOR_URI:

   271                 DEBUG_INFO("XA_DATALOCATOR_URI");

   272                 uri = (XADataLocator_URI*)xaSnk->pLocator;

   273                 if( !uri->URI && !xaSnk->pFormat )

   274                 {

   275                     DEBUG_ERR("Invalid parameter set for uri ");

   276                     ret = XA_RESULT_PARAMETER_INVALID;

   277                 }

   278                 break;

   279             case XA_DATALOCATOR_NATIVEDISPLAY:

   280                 DEBUG_INFO("Sink locator type - XA_DATALOCATOR_NATIVEDISPLAY");

   281                 display = (XADataLocator_NativeDisplay*)(xaSnk->pLocator);

   282                 if( !display->hDisplay || !display->hWindow )

   283                 {

   284                     /*No action at this time*/

   285                     DEBUG_INFO("Warning - no display or window handle set");

   286                 }

   287                 break;

   288             case XA_DATALOCATOR_OUTPUTMIX:

   289                 DEBUG_INFO("Sink locator type - XA_DATALOCATOR_OUTPUTMIX");

   290                 {

   291                     omix = (XADataLocator_OutputMix*)(xaSnk->pLocator);

   292                     if ( !omix->outputMix )

   293                     {

   294                         DEBUG_ERR("Invalid parameter set for outputmix");

   295                         ret = XA_RESULT_PARAMETER_INVALID;

   296                     }

   297                 }

   298                 break;

   299             case XA_DATALOCATOR_ADDRESS:

   300                 DEBUG_INFO("XA_DATALOCATOR_ADDRESS");

   301                 address = (XADataLocator_Address*)(xaSnk->pLocator);

   302                 if( !address->pAddress && !xaSnk->pFormat )

   303                 {

   304                     DEBUG_ERR("Invalid parameter set for address");

   305                     ret = XA_RESULT_PARAMETER_INVALID;

   306                 }

   307                 break;

   308             case XA_DATALOCATOR_IODEVICE:

   309                 DEBUG_INFO("XA_DATALOCATOR_IODEVICE");

   310                 iodevice = (XADataLocator_IODevice*)(xaSnk->pLocator);

   311                 if( iodevice->device )

   312                 {

   313                     DEBUG_INFO("Media object as IODevice");

   314                 }

   315                 else

   316                 {

   317                     DEBUG_INFO("Iodevice id used");

   318                 }

   319                 break;

   320             default:

   321                 DEBUG_ERR("Incorrect data locator for sink.")

   322                 ret = XA_RESULT_PARAMETER_INVALID;

   323                 break;

   324         }

   325         counter ++;

   326     }

   327     va_end(argptr);

   328     DEBUG_API("<-XACommon_ValidateDataLocator");

   329     return ret;

   330 }