plugin/mms_plugin/MmsPluginSMILValidate.cpp

   1 /*
   2 *
   3 * Copyright (c) 2000-2012 Samsung Electronics Co., Ltd. All Rights Reserved.
   4 *
   5 * This file is part of msg-service.
   6 *
   7 * Contact: Jaeyun Jeong <jyjeong@samsung.com>
   8 *          Sangkoo Kim <sangkoo.kim@samsung.com>
   9 *          Seunghwan Lee <sh.cat.lee@samsung.com>
  10 *          SoonMin Jung <sm0415.jung@samsung.com>
  11 *          Jae-Young Lee <jy4710.lee@samsung.com>
  12 *          KeeBum Kim <keebum.kim@samsung.com>
  13 *
  14 * PROPRIETARY/CONFIDENTIAL
  15 *
  16 * This software is the confidential and proprietary information of
  17 * SAMSUNG ELECTRONICS ("Confidential Information"). You shall not
  18 * disclose such Confidential Information and shall use it only in
  19 * accordance with the terms of the license agreement you entered
  20 * into with SAMSUNG ELECTRONICS.
  21 *
  22 * SAMSUNG make no representations or warranties about the suitability
  23 * of the software, either express or implied, including but not limited
  24 * to the implied warranties of merchantability, fitness for a particular
  25 * purpose, or non-infringement. SAMSUNG shall not be liable for any
  26 * damages suffered by licensee as a result of using, modifying or
  27 * distributing this software or its derivatives.
  28 *
  29 */
  30
  31 #include "MmsPluginSMILValidate.h"
  32 #include "MsgDebug.h"
  33 #include "MsgUtilFile.h"
  34 #include "MmsPluginSmil.h"
  35 #include "MsgMmsMessage.h"
  36
  37 #define MSG_RETURN_VAL_IF_FAIL(Expr, Val)                                       \
  38                 if (!(Expr)) {                                                                          \
  39                         MSG_DEBUG("%s:[%s] Failed - %d\n", __FUNCTION__, __LINE__, Val); \
  40                         return Val;                                                                             \
  41                 };
  42
  43 MSG_SMIL_ERR_E MsgMMSCreateSMIL(MMS_MESSAGE_DATA_S *pMsgData)
  44 {
  45         MSG_BEGIN();
  46
  47         MSG_SMIL_ERR_E eRet = MSG_SMIL_ERR_UNKNOWN;
  48         bool bRegAdded = false;
  49
  50         MSG_RETURN_VAL_IF_FAIL((pMsgData!= NULL), MSG_SMIL_ERR_INVALID_PARAM);
  51         MSG_RETURN_VAL_IF_FAIL((strlen(pMsgData->szSmilFilePath)> 0), MSG_SMIL_ERR_INVALID_SMIL_FILE_PATH);
  52
  53         eRet = _MsgMMSValidateSMILRootLayout(pMsgData);
  54         if (eRet != MSG_SMIL_SUCCESS) {
  55                 MSG_DEBUG("MsgMMSCreateSMIL: Root Layout Information Invalid eRet =%d\n", eRet);
  56                 return eRet;
  57         }
  58
  59         eRet = _MsgMMSValidateSMILRegion(pMsgData, &bRegAdded);
  60         if (eRet != MSG_SMIL_SUCCESS) {
  61                 MSG_DEBUG("MsgMMSCreateSMIL: Region Information Invalid eRet =%d\n", eRet);
  62                 return eRet;
  63         }
  64
  65         eRet = _MsgMMSValidateSMILPage(pMsgData, bRegAdded);
  66         if (eRet != MSG_SMIL_SUCCESS) {
  67                 MSG_DEBUG("MsgMMSCreateSMIL: Page Information Invalid eRet =%d\n", eRet);
  68                 return eRet;
  69         }
  70
  71         if (MMSGenerateSmilBuffer(pMsgData)) {
  72                 MSG_DEBUG("MsgMMSCreateSMIL: Generate SMIL Buffer is success eRet =%d\n", eRet);
  73                 eRet = MSG_SMIL_SUCCESS;
  74         } else {
  75                 MSG_DEBUG("MsgMMSCreateSMIL: Generate SMIL Buffer failed eRet =%d\n", eRet);
  76                 eRet = MSG_SMIL_ERR_UNKNOWN;
  77         }
  78
  79         MSG_END();
  80         return eRet;
  81 }
  82
  83 MSG_SMIL_ERR_E _MsgMMSValidateSMILRootLayout(MMS_MESSAGE_DATA_S *pMsgData)
  84 {
  85         MSG_BEGIN();
  86
  87         MSG_SMIL_ERR_E eRet = MSG_SMIL_ERR_INVALID_ROOTLAYOUT;
  88
  89         MSG_RETURN_VAL_IF_FAIL((pMsgData!= NULL), MSG_SMIL_ERR_INVALID_PARAM);
  90
  91         if ((pMsgData->rootlayout.width.value >  0) &&
  92                 (pMsgData->rootlayout.height.value> 0)) {
  93                 if (pMsgData->rootlayout.width.bUnitPercent == pMsgData->rootlayout.height.bUnitPercent) {
  94                         MSG_DEBUG("_MsgMMSValidateSMILRootLayout: Root Layout Information Valid \n");
  95                         eRet = MSG_SMIL_SUCCESS;
  96                 }
  97         } else  {
  98                 MSG_DEBUG("_MsgMMSValidateSMILRootLayout: Root Layout Information not Present \n");
  99                 eRet = _MsgMMSAddDefaultSMILRootLayout(pMsgData);
 100         }
 101
 102         MSG_END();
 103         return eRet;
 104 }
 105
 106 MSG_SMIL_ERR_E _MsgMMSAddDefaultSMILRootLayout(MMS_MESSAGE_DATA_S *pMsgData)
 107 {
 108         MSG_BEGIN();
 109
 110         char *pContent = (char *)MSG_SMIL_ROOT_LAYOUT_BG_COLOR;
 111
 112         MSG_RETURN_VAL_IF_FAIL((pMsgData!= NULL), MSG_SMIL_ERR_INVALID_PARAM);
 113
 114         pMsgData->rootlayout.width.value = MSG_SMIL_ROOT_LAYOUT_WIDTH;
 115         pMsgData->rootlayout.width.bUnitPercent = MSG_SMIL_ROOT_LAYOUT_IN_PERCENT;
 116
 117         pMsgData->rootlayout.height.value = MSG_SMIL_ROOT_LAYOUT_HEIGHT;
 118         pMsgData->rootlayout.height.bUnitPercent = MSG_SMIL_ROOT_LAYOUT_IN_PERCENT;
 119
 120         pMsgData->rootlayout.bgColor = MmsSmilAtoIHexa((char *)&pContent[1]);
 121
 122         MSG_END();
 123         return MSG_SMIL_SUCCESS;
 124 }
 125
 126 MSG_SMIL_ERR_E _MsgMMSValidateSMILRegion(MMS_MESSAGE_DATA_S *pMsgData, bool *pbRegAdded)
 127 {
 128         MSG_BEGIN();
 129
 130         MSG_SMIL_ERR_E eRet = MSG_SMIL_ERR_INVALID_REGION_INFO;
 131
 132         MSG_RETURN_VAL_IF_FAIL((pMsgData!= NULL), MSG_SMIL_ERR_INVALID_PARAM);
 133         MSG_RETURN_VAL_IF_FAIL((pbRegAdded!= NULL), MSG_SMIL_ERR_INVALID_PARAM);
 134
 135         if (pMsgData->regionCnt == 0) {
 136                 bool bTextReg = MSG_SMIL_TEXT_ON_TOP;
 137                 bool bfullReg = false;
 138                 bool btwoReg = false;
 139
 140                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Region Information not Present \n");
 141
 142                 for (int PgIdx = 0; PgIdx < pMsgData->pageCnt; ++PgIdx) {
 143                         MMS_PAGE_S *pPage = _MsgMmsGetPage(pMsgData, PgIdx);
 144                         int nMediaCnt = 0;
 145
 146                         MSG_RETURN_VAL_IF_FAIL((NULL != pPage), MSG_SMIL_ERR_INVALID_PAGE_INFO);
 147
 148                         for (int MediaIdx = 0; MediaIdx < pPage->mediaCnt; ++MediaIdx) {
 149                                 MMS_MEDIA_S *pMedia = _MsgMmsGetMedia(pPage, MediaIdx);
 150
 151                                 MSG_RETURN_VAL_IF_FAIL((NULL != pMedia), MSG_SMIL_ERR_INVALID_PAGE_INFO);
 152
 153                                 if (pMedia->mediatype != MMS_SMIL_MEDIA_AUDIO)
 154                                         nMediaCnt++;
 155                         }
 156
 157                         if (nMediaCnt == 1)
 158                                 bfullReg = true;
 159                         else if (nMediaCnt == 2)
 160                                 btwoReg = true;
 161                         else if (nMediaCnt > 2) {
 162                                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Invalid Region Information\n");
 163                                 eRet = MSG_SMIL_ERR_INVALID_PAGE_INFO;
 164                                 return eRet;
 165                         }
 166                 }
 167
 168                 if (bfullReg) {
 169                         eRet = _MsgMMSAddDefaultFullSMILRegion(pMsgData);
 170                         if (eRet != MSG_SMIL_SUCCESS) {
 171                                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Invalid Region Information\n");
 172                                 return eRet;
 173                         }
 174                 }
 175                 if (btwoReg) {
 176                         eRet = _MsgMMSAddDefaultFirstSMILRegion(pMsgData, bTextReg);
 177                         if (eRet != MSG_SMIL_SUCCESS) {
 178                                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Invalid Region Information\n");
 179                                 return eRet;
 180                         }
 181
 182                         eRet = _MsgMMSAddDefaultSecondSMILRegion(pMsgData,!bTextReg);
 183                         if (eRet != MSG_SMIL_SUCCESS) {
 184                                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Invalid Region Information\n");
 185                                 return eRet;
 186                         }
 187                 }
 188                 *pbRegAdded  = true;
 189                 eRet = MSG_SMIL_SUCCESS;
 190         } else {
 191                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Region Information Present \n");
 192
 193                 for (int Idx = 0; Idx< pMsgData->regionCnt; ++Idx) {
 194                         MMS_SMIL_REGION *pRegion = _MsgMmsGetSmilRegion(pMsgData, Idx);
 195
 196                         if ((pRegion->width.value == 0) ||
 197                                         (pRegion->height.value == 0)) {
 198                                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Invalid Region information\n");
 199
 200                                 return eRet;
 201                         }
 202
 203                         if (pMsgData->rootlayout.width.bUnitPercent == true) {
 204                                 if ((pRegion->width.value > 100) ||
 205                                         (pRegion->height.value > 100) ||
 206                                         (pRegion->nLeft.value > 100) ||
 207                                         (pRegion->nTop.value > 100)) {
 208                                         MSG_DEBUG("_MsgMMSValidateSMILRegion: Region and root layout information does not map\n");
 209
 210                                         return eRet;
 211                                 }
 212                         } else {
 213                                 if (((pRegion->width.bUnitPercent == true) && (pRegion->width.value > 100)) ||
 214                                         ((pRegion->height.bUnitPercent == true) && (pRegion->height.value > 100)) ||
 215                                         ((pRegion->nLeft.bUnitPercent == true) && (pRegion->nLeft.value > 100)) ||
 216                                         ((pRegion->nTop.bUnitPercent == true) && (pRegion->nTop.value > 100))) {
 217                                         MSG_DEBUG("_MsgMMSValidateSMILRegion: Invalid Region information\n");
 218
 219                                         return eRet;
 220                                 }
 221                         }
 222                 }
 223
 224                 eRet = MSG_SMIL_SUCCESS;
 225         }
 226
 227         MSG_END();
 228         return eRet;
 229 }
 230
 231 MSG_SMIL_ERR_E _MsgMMSAddDefaultFirstSMILRegion(MMS_MESSAGE_DATA_S *pMsgData, bool bTextReg)
 232 {
 233         MSG_BEGIN();
 234
 235         MSG_SMIL_ERR_E eRet = MSG_SMIL_ERR_INVALID_REGION_INFO;
 236         MMS_SMIL_REGION *pRegion = NULL;
 237         char *pszfit = (char *)MSG_SMIL_REG_FIT_TYPE;
 238         char *pContent = (char *)MSG_SMIL_REG_BG_COLOR;
 239
 240         MSG_RETURN_VAL_IF_FAIL((pMsgData!= NULL), MSG_SMIL_ERR_INVALID_PARAM);
 241         pRegion = (MMS_SMIL_REGION *)calloc(sizeof(MMS_SMIL_REGION), 1);
 242
 243         if (pRegion == NULL) {
 244                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Memory Allocation failed\n");
 245                 return eRet;
 246         }
 247
 248         if (!strcmp(pszfit, "meet"))
 249                 pRegion->fit = MMSUI_IMAGE_REGION_FIT_MEET;
 250         else
 251                 pRegion->fit = MMSUI_IMAGE_REGION_FIT_HIDDEN;
 252         pRegion->bgColor = MmsSmilAtoIHexa((char *)&pContent[1]);
 253
 254         pRegion->nLeft.value = MSG_SMIL_FIRST_REG_LEFT;
 255         pRegion->nLeft.bUnitPercent = true;
 256         pRegion->nTop.value = MSG_SMIL_FIRST_REG_TOP;
 257         pRegion->nTop.bUnitPercent = true;
 258         pRegion->width.value = MSG_SMIL_FIRST_REG_WIDTH;
 259         pRegion->width.bUnitPercent = true;
 260         pRegion->height.value = MSG_SMIL_FIRST_REG_HEIGHT;
 261         pRegion->height.bUnitPercent = true;
 262
 263         if (bTextReg)
 264                 snprintf(pRegion->szID, MAX_SMIL_REGION_ID, "%s", MSG_SMIL_DEFAULT_TXT_REG);
 265         else
 266                 snprintf(pRegion->szID, MAX_SMIL_REGION_ID, "%s", MSG_SMIL_DEFAULT_IMG_REG);
 267
 268         if (_MsgMmsAddRegion(pMsgData,pRegion) != MSG_SUCCESS) {
 269                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Add Region failed\n");
 270                 free(pRegion);
 271
 272                 return eRet;
 273         }
 274
 275         eRet = MSG_SMIL_SUCCESS;
 276
 277         MSG_END();
 278         return eRet;
 279 }
 280
 281 MSG_SMIL_ERR_E _MsgMMSAddDefaultSecondSMILRegion(MMS_MESSAGE_DATA_S *pMsgData, bool bTextReg)
 282 {
 283         MSG_BEGIN();
 284
 285         MSG_SMIL_ERR_E eRet = MSG_SMIL_ERR_INVALID_REGION_INFO;
 286         MMS_SMIL_REGION *pRegion = NULL;
 287         char *pszfit = (char *)MSG_SMIL_REG_FIT_TYPE;
 288         char *pContent = (char *)MSG_SMIL_REG_BG_COLOR;
 289
 290         MSG_RETURN_VAL_IF_FAIL((pMsgData!= NULL), MSG_SMIL_ERR_INVALID_PARAM);
 291         pRegion = (MMS_SMIL_REGION *)calloc(sizeof(MMS_SMIL_REGION), 1);
 292
 293         if (pRegion == NULL) {
 294                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Memory Allocation failed\n");
 295                 return eRet;
 296         }
 297
 298         if (!strcmp(pszfit, "meet"))
 299                 pRegion->fit = MMSUI_IMAGE_REGION_FIT_MEET;
 300         else
 301                 pRegion->fit = MMSUI_IMAGE_REGION_FIT_HIDDEN;
 302         pRegion->bgColor = MmsSmilAtoIHexa((char *)&pContent[1]);
 303
 304         pRegion->nLeft.value = MSG_SMIL_SECOND_REG_LEFT;
 305         pRegion->nLeft.bUnitPercent = true;
 306         pRegion->nTop.value = MSG_SMIL_SECOND_REG_TOP;
 307         pRegion->nTop.bUnitPercent = true;
 308         pRegion->width.value = MSG_SMIL_SECOND_REG_WIDTH;
 309         pRegion->width.bUnitPercent = true;
 310         pRegion->height.value = MSG_SMIL_SECOND_REG_HEIGHT;
 311         pRegion->height.bUnitPercent = true;
 312
 313         if (bTextReg)
 314                 snprintf(pRegion->szID, MAX_SMIL_REGION_ID, "%s", MSG_SMIL_DEFAULT_TXT_REG);
 315         else
 316                 snprintf(pRegion->szID, MAX_SMIL_REGION_ID, "%s", MSG_SMIL_DEFAULT_IMG_REG);
 317
 318         if (_MsgMmsAddRegion(pMsgData,pRegion) != MSG_SUCCESS) {
 319                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Add Region failed\n");
 320                 free(pRegion);
 321
 322                 return eRet;
 323         }
 324
 325         eRet = MSG_SMIL_SUCCESS;
 326
 327         MSG_END();
 328         return eRet;
 329 }
 330
 331 MSG_SMIL_ERR_E _MsgMMSAddDefaultFullSMILRegion(MMS_MESSAGE_DATA_S *pMsgData)
 332 {
 333         MSG_BEGIN();
 334
 335         MSG_SMIL_ERR_E eRet = MSG_SMIL_ERR_INVALID_REGION_INFO;
 336         MMS_SMIL_REGION *pRegion = NULL;
 337         char *pszfit = (char *)MSG_SMIL_REG_FIT_TYPE;
 338         char *pContent = (char *)MSG_SMIL_REG_BG_COLOR;
 339
 340         MSG_RETURN_VAL_IF_FAIL((pMsgData!= NULL), MSG_SMIL_ERR_INVALID_PARAM);
 341         pRegion = (MMS_SMIL_REGION *)calloc(sizeof(MMS_SMIL_REGION), 1);
 342
 343         if (pRegion == NULL) {
 344                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Memory Allocation failed\n");
 345                 return eRet;
 346         }
 347
 348         if (!strcmp(pszfit, "meet"))
 349                 pRegion->fit = MMSUI_IMAGE_REGION_FIT_MEET;
 350         else
 351                 pRegion->fit = MMSUI_IMAGE_REGION_FIT_HIDDEN;
 352         pRegion->bgColor = MmsSmilAtoIHexa((char *)&pContent[1]);
 353
 354         pRegion->nLeft.value = MSG_SMIL_FULL_REG_LEFT;
 355         pRegion->nLeft.bUnitPercent = true;
 356         pRegion->nTop.value = MSG_SMIL_FULL_REG_TOP;
 357         pRegion->nTop.bUnitPercent = true;
 358         pRegion->width.value = MSG_SMIL_FULL_REG_WIDTH;
 359         pRegion->width.bUnitPercent = true;
 360         pRegion->height.value = MSG_SMIL_FULL_REG_HEIGHT;
 361         pRegion->height.bUnitPercent = true;
 362
 363         snprintf(pRegion->szID, MAX_SMIL_REGION_ID, "%s", MSG_SMIL_DEFAULT_FULL_REG);
 364
 365         if (_MsgMmsAddRegion(pMsgData,pRegion) != MSG_SUCCESS) {
 366                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Add Region failed\n");
 367                 free(pRegion);
 368
 369                 return eRet;
 370         }
 371
 372         eRet = MSG_SMIL_SUCCESS;
 373
 374         MSG_END();
 375         return eRet;
 376 }
 377
 378 MSG_SMIL_ERR_E  _MsgMMSValidateSMILPage(MMS_MESSAGE_DATA_S *pMsgData, bool bRegAdded)
 379 {
 380         MSG_BEGIN();
 381
 382         MSG_SMIL_ERR_E eRet = MSG_SMIL_ERR_INVALID_PAGE_INFO;
 383
 384         MSG_RETURN_VAL_IF_FAIL((pMsgData!= NULL), MSG_SMIL_ERR_INVALID_PARAM);
 385         MSG_RETURN_VAL_IF_FAIL((pMsgData->pageCnt > 0), eRet);
 386
 387         for (int PgIdx = 0; PgIdx < pMsgData->pageCnt; ++PgIdx) {
 388                 MMS_PAGE_S *pPage = _MsgMmsGetPage(pMsgData, PgIdx);
 389                 int PageRegionCnt = 0;
 390                 int PageRegionIdx = 0;
 391                 bool bVidExists = false;
 392                 bool bImgExists = false;
 393                 bool bTxtExists = false;
 394                 bool bAudExists = false;
 395                 bool bImgOrVidExists = false;
 396                 bool bResetRegion = false;
 397
 398                 MSG_RETURN_VAL_IF_FAIL((NULL != pPage), MSG_SMIL_ERR_INVALID_PAGE_INFO);
 399                 MSG_RETURN_VAL_IF_FAIL((pPage->nDur >= 0), MSG_SMIL_ERR_INVALID_PAGE_DUR);
 400
 401                 for (int MediaIdx = 0; MediaIdx < pPage->mediaCnt; ++MediaIdx) {
 402                         MMS_MEDIA_S *pMedia = _MsgMmsGetMedia(pPage, MediaIdx);
 403
 404                         MSG_RETURN_VAL_IF_FAIL((NULL != pMedia), MSG_SMIL_ERR_INVALID_PAGE_INFO);
 405
 406                         bResetRegion = false;
 407                         if ((pMedia->mediatype != MMS_SMIL_MEDIA_AUDIO)) {
 408                                 if (bRegAdded) {
 409                                         bResetRegion = true;
 410                                 } else if ((strlen(pMedia->regionId) == 0)) {
 411                                         MSG_DEBUG("_MsgMMSValidateSMILRegion: Invalid Region Information\n");
 412                                         return MSG_SMIL_ERR_INVALID_REGION_INFO;
 413                                 }
 414                                 PageRegionCnt++;
 415                         }
 416                 }
 417
 418                 for (int MediaIdx = 0; MediaIdx < pPage->mediaCnt; ++MediaIdx) {
 419                         MMS_MEDIA_S *pMedia = _MsgMmsGetMedia(pPage, MediaIdx);
 420
 421                         MSG_RETURN_VAL_IF_FAIL((NULL != pMedia), MSG_SMIL_ERR_INVALID_PAGE_INFO);
 422                         MSG_RETURN_VAL_IF_FAIL((strlen(pMedia->szFilePath) > 0), MSG_SMIL_ERR_INVALID_PAGE_INFO);
 423
 424                         switch (pMedia->mediatype) {
 425                         case MMS_SMIL_MEDIA_IMG:
 426                                 {
 427                                         if ((bImgExists == true) || (bVidExists == true) ||
 428                                                 (bImgOrVidExists== true)) {
 429                                                 eRet = MSG_SMIL_ERR_SIMILAR_MEDIA_EXISTS;
 430                                         } else
 431                                                 bImgExists = true;
 432                                 }
 433                                 break;
 434                         case MMS_SMIL_MEDIA_AUDIO:
 435                                 {
 436                                         if ((bAudExists == true) || (bVidExists == true) ||
 437                                                 (bImgOrVidExists== true)) {
 438                                                 eRet = MSG_SMIL_ERR_SIMILAR_MEDIA_EXISTS;
 439                                         } else
 440                                                 bAudExists = true;
 441                                 }
 442                                 break;
 443                         case MMS_SMIL_MEDIA_VIDEO:
 444                                 {
 445                                         if ((bImgExists == true) || (bVidExists == true) ||
 446                                                 (bImgOrVidExists== true)) {
 447                                                 eRet = MSG_SMIL_ERR_SIMILAR_MEDIA_EXISTS;
 448                                         } else
 449                                                 bVidExists = true;
 450                                 }
 451                                 break;
 452                         case MMS_SMIL_MEDIA_TEXT:
 453                                 {
 454                                         if (bTxtExists == true) {
 455                                                 eRet = MSG_SMIL_ERR_SIMILAR_MEDIA_EXISTS;
 456                                         } else
 457                                                 bTxtExists = true;
 458                                 }
 459                                 break;
 460                         case MMS_SMIL_MEDIA_IMG_OR_VIDEO:
 461                                 {
 462                                         if ((bImgExists == true) || (bVidExists == true) ||
 463                                                 (bImgOrVidExists== true)) {
 464                                                 eRet = MSG_SMIL_ERR_SIMILAR_MEDIA_EXISTS;
 465                                         } else
 466                                                 bImgOrVidExists = true;
 467                                 }
 468                                 break;
 469                         default:
 470                                 {
 471                                         MSG_DEBUG("_MsgMMSValidateSMILRegion: Invalid Media Information\n");
 472                                         return eRet;
 473                                 }
 474                                 break;
 475                         }
 476
 477                         if (eRet == MSG_SMIL_ERR_SIMILAR_MEDIA_EXISTS) {
 478                                 MSG_DEBUG("_MsgMMSValidateSMILRegion: Similar Media Exists\n");
 479                                 return eRet;
 480                         }
 481
 482                         if (bResetRegion) {
 483                                 if (PageRegionCnt > 1) {
 484                                         if (pMedia->mediatype == MMS_SMIL_MEDIA_AUDIO) {
 485                                                 memset(pMedia->regionId,0x00, MAX_SMIL_REGION_ID);
 486                                                 continue;
 487                                         }
 488
 489                                         if (pMedia->mediatype == MMS_SMIL_MEDIA_TEXT)
 490                                                 snprintf(pMedia->regionId, MAX_SMIL_REGION_ID, "%s", MSG_SMIL_DEFAULT_TXT_REG);
 491                                         else
 492                                                 snprintf(pMedia->regionId, MAX_SMIL_REGION_ID, "%s", MSG_SMIL_DEFAULT_IMG_REG);
 493                                 } else
 494                                         snprintf(pMedia->regionId, MAX_SMIL_REGION_ID, "%s", MSG_SMIL_DEFAULT_FULL_REG);
 495                         }
 496                         PageRegionIdx++;
 497                 }
 498         }
 499
 500         eRet = MSG_SMIL_SUCCESS;
 501
 502         MSG_END();
 503
 504         return eRet;
 505 }
 506