plugin/mms_plugin/MmsPluginSMILValidate.cpp

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