开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
WriteRes.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：142k
源码类别：

MTK

开发平台：

C/C++

WriteRes.c：源码内容
  1.  *  Load_Audio_Data
  2.  * DESCRIPTION
  3.  *  load and write audio header and data
  4.  * PARAMETERS
  5.  *  offset                  [OUT]       File offset --> file offset
  6.  *  output_file             [IN]        -> Name of the file to which buffer
  7.  *  input_file              [IN]        ->  Name of the input audio file
  8.  *  pImgData                [OUT]       -> buffer containing image data
  9.  *  audio_identifier        [IN]        -> audio identifier
  10.  *  is(?)                   [IN]        To be written
  11.  * RETURNS
  12.  *  S32 --> file size
  13.  *****************************************************************************/
  14. S32 Load_Audio_Data(U32 *offset, FILE *output_file, FILE *input_file, U8 *pImgData, U8 audio_identifier)
  15. {
  16.     /*----------------------------------------------------------------*/
  17.     /* Local Variables                                                */
  18.     /*----------------------------------------------------------------*/
  19.     U32 file_size, i, o = 0;
  20.     U8 ch;
  22.     /*----------------------------------------------------------------*/
  23.     /* Code Body                                                      */
  24.     /*----------------------------------------------------------------*/
  25.     fseek(input_file, 0, SEEK_END);
  26.     file_size = ftell(input_file);
  27.     fseek(input_file, 0, SEEK_SET);
  29.     if (toolFlag)
  30.     {
  31.         fprintf(
  32.             dest_file,
  33.             "%c%c%c%c%c%c%c%c",
  34.             audio_identifier,
  35.             file_size & 0xff,
  36.             (file_size & 0xff00) >> 8,
  37.             (file_size & 0xff0000) >> 16,
  38.             (file_size & 0xff000000) >> 24,
  39.             0,
  40.             0,
  41.             0);
  42.     }
  43.     else
  44.     {
  45.         fprintf(
  46.             output_file /* output_data_file */ ,
  47.             "nt0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x00, 0x00, 0x00,nt",
  48.             audio_identifier,
  49.             file_size & 0xff,
  50.             (file_size & 0xff00) >> 8,
  51.             (file_size & 0xff0000) >> 16,
  52.             (file_size & 0xff000000) >> 24);
  53.     }
  55.     pImgData[0] = (U8) audio_identifier;
  56.     pImgData[1] = (U8) (file_size & 0xff);
  57.     pImgData[2] = (U8) ((file_size & 0xff00) >> 8);
  58.     pImgData[3] = (U8) ((file_size & 0xff0000) >> 16);
  59.     pImgData[4] = (U8) ((file_size & 0xff000000) >> 24);
  61.     for (i = 0; i < file_size; i++)
  62.     {
  63.         ch = fgetc(input_file);
  65.         if (toolFlag)
  66.         {
  67.             fputc(ch, dest_file);
  68.             (*offset)++;
  69.             (pImgData)[i + 6] = ch;
  70.         }
  71.         else
  72.         {
  73.             fprintf(output_file, "0x%02X, ", ch);
  74.             (*offset)++;
  75.             (pImgData)[i + 6] = ch;
  76.             o++;
  77.             if ((o % 16) == 0)
  78.             {
  79.                 fprintf(output_file, "nt");
  80.             }
  81.         }
  82.     }
  84.     return file_size + 8;
  85. }
  87. /* 101205 audio resource Calvin End */
  90. /*****************************************************************************
  91.  * FUNCTION
  92.  *  Write_Sequential_Image_Header
  93.  * DESCRIPTION
  94.  *  Construct the header for sequential images
  95.  * PARAMETERS
  96.  *  output_file             [IN]        -> output file handle
  97.  *  image_identifier        [IN]        -> sequential image type
  98.  *  n_frames                [IN]        -> the number of the frames
  99.  *  seq_filesize            [IN]        -> pointer to a list of file sizes
  100.  *  seq_offset              [OUT]       -> pointer to a list of offsets
  101.  * RETURNS
  102.  *  void
  103.  *****************************************************************************/
  104. void Write_Sequential_Image_Header(
  105.         FILE *output_file,
  106.         U8 image_identifier,
  107.         S32 n_frames,
  108.         S32 *seq_filesize,
  109.         S32 *seq_offset)
  110. {
  111.     /*----------------------------------------------------------------*/
  112.     /* Local Variables                                                */
  113.     /*----------------------------------------------------------------*/
  114.     S32 i;
  115.     S32 offset = 8;
  116.     S32 real_size;
  118.     /*----------------------------------------------------------------*/
  119.     /* Code Body                                                      */
  120.     /*----------------------------------------------------------------*/
  121.     if (toolFlag == 1)
  122.     {
  123.         fprintf(dest_file, "%c%c%c%c%c%c%c%c", image_identifier, n_frames, 0, 0, 0, 0, 0, 0);   /* the major header */
  124.         for (i = 0; i < n_frames; i++)
  125.         {
  126.             int interval = sequential_interval[i];
  128.             seq_offset[i] = offset;
  129.             real_size = ((seq_filesize[i] + 3) >> 2) << 2;
  130.             fprintf(dest_file, "%c%c%c%c", seq_offset[i] & 0xff, (seq_offset[i] & 0xff00) >> 8, (seq_offset[i] & 0xff0000) >> 16, (seq_offset[i] & 0xff000000) >> 24);  /* the offset for each file */
  131.             fprintf(dest_file, "%c%c%c%c", seq_filesize[i] & 0xff, (seq_filesize[i] & 0xff00) >> 8, (seq_filesize[i] & 0xff0000) >> 16, (seq_filesize[i] & 0xff000000) >> 24);  /* the size for each file */
  132.             fprintf(dest_file, "%c%c%c%c", interval & 0xff, (interval & 0xff00) >> 8, (interval & 0xff0000) >> 16, (interval & 0xff000000) >> 24);      /* the interval for each file */
  133.             offset += real_size;
  134.         }
  135.     }
  136. /* 100206 ENFB support Start */
  137. #ifdef __MMI_RESOURCE_ENFB_SUPPORT__
  138.     else if (enfbFlag == 1) /* write ENFB header to CustImgDataxxx.h and image header/data to ENFB image data file */
  139.     {
  140.         S32 data_size = 0;
  141.         for (i = 0; i < n_frames; i++)
  142.         {
  143.             real_size = ((seq_filesize[i] + 3) >> 2) << 2;
  144.             data_size += real_size;
  145.         }
  146.         enfb_size = 8 + 12*n_frames + data_size;
  147.         
  148.         /* write ENFB header to CustImgDataxxx.h */
  149.         fprintf(
  150.             output_file,
  151.             "nt0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02Xt",
  152.             (U8) 255,//type
  153.             (U8) ENFBAssociatedIDAdded,//associated id
  154.             (U8) 0,//reserved
  155.             (U8) 0,//reserved
  156.             (U8) (enfb_offset & 0xff),
  157.             (U8) ((enfb_offset >> 8) & 0xff),
  158.             (U8) ((enfb_offset >> 16) & 0xff),
  159.             (U8) ((enfb_offset >> 24) & 0xff),
  160.             (U8) (enfb_size & 0xff),
  161.             (U8) ((enfb_size >> 8) & 0xff),
  162.             (U8) ((enfb_size >> 16) & 0xff),
  163.             (U8) ((enfb_size >> 24) & 0xff));
  164.         
  165.         /* image header/data to ENFB image data file */
  166.         fprintf(enfb_img_data_file, "%c%c%c%c%c%c%c%c", image_identifier, n_frames, 0, 0, 0, 0, 0, 0);   /* the major header */
  167.         for (i = 0; i < n_frames; i++)
  168.         {
  169.             int interval = sequential_interval[i];
  171.             seq_offset[i] = offset;
  172.             real_size = ((seq_filesize[i] + 3) >> 2) << 2;
  173.             fprintf(enfb_img_data_file, "%c%c%c%c", seq_offset[i] & 0xff, (seq_offset[i] & 0xff00) >> 8, (seq_offset[i] & 0xff0000) >> 16, (seq_offset[i] & 0xff000000) >> 24);  /* the offset for each file */
  174.             fprintf(enfb_img_data_file, "%c%c%c%c", seq_filesize[i] & 0xff, (seq_filesize[i] & 0xff00) >> 8, (seq_filesize[i] & 0xff0000) >> 16, (seq_filesize[i] & 0xff000000) >> 24);  /* the size for each file */
  175.             fprintf(enfb_img_data_file, "%c%c%c%c", interval & 0xff, (interval & 0xff00) >> 8, (interval & 0xff0000) >> 16, (interval & 0xff000000) >> 24);      /* the interval for each file */
  176.             offset += real_size;
  177.         }
  178.         
  179.         enfb_offset += enfb_size;
  180.     }
  181. #endif
  182. /* 100206 ENFB support End */  
  183.     else
  184.     {
  185.         fprintf(output_file, "nt0x%02X, 0x%02X, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,nt", image_identifier, n_frames);        /* the major header */
  186.         for (i = 0; i < n_frames; i++)
  187.         {
  188.             int interval = sequential_interval[i];
  190.             seq_offset[i] = offset;
  191.             real_size = ((seq_filesize[i] + 3) >> 2) << 2;
  192.             fprintf(output_file, "0x%02X, 0x%02X, 0x%02X, 0x%02X, ", seq_offset[i] & 0xff, (seq_offset[i] & 0xff00) >> 8, (seq_offset[i] & 0xff0000) >> 16, (seq_offset[i] & 0xff000000) >> 24);        /* the offset for each file */
  193.             fprintf(output_file, "0x%02X, 0x%02X, 0x%02X, 0x%02X, ", seq_filesize[i] & 0xff, (seq_filesize[i] & 0xff00) >> 8, (seq_filesize[i] & 0xff0000) >> 16, (seq_filesize[i] & 0xff000000) >> 24);        /* the size for each file */
  194.             fprintf(output_file, "0x%02X, 0x%02X, 0x%02X, 0x%02X,nt", interval & 0xff, (interval & 0xff00) >> 8, (interval & 0xff0000) >> 16, (interval & 0xff000000) >> 24); /* the interval for each file */
  195.             offset += real_size;
  197.             g_ressize += seq_filesize[i];
  198.         }
  199.     }
  200. }
  203. /*****************************************************************************
  204.  * FUNCTION
  205.  *  Write_Sequential_Image_File
  206.  * DESCRIPTION
  207.  *  Write raw date from a frame of an image to the output file
  208.  * PARAMETERS
  209.  *  output_file     [IN]        -> output file handle
  210.  *  input_file      [IN]        -> input file handle
  211.  *  filesize        [IN]        -> the input file size
  212.  * RETURNS
  213.  *  void
  214.  *****************************************************************************/
  215. void Write_Sequential_Image_File(FILE *output_file, FILE *input_file, S32 filesize)
  216. {
  217.     /*----------------------------------------------------------------*/
  218.     /* Local Variables                                                */
  219.     /*----------------------------------------------------------------*/
  220.     U32 i;
  221.     U32 o = 0;
  222.     U8 ch;
  224.     /*----------------------------------------------------------------*/
  225.     /* Code Body                                                      */
  226.     /*----------------------------------------------------------------*/
  227.     if (toolFlag == 1)
  228.     {
  229.         for (i = 0; i < filesize; i++)
  230.         {
  231.             ch = fgetc(input_file);
  232.             fprintf(dest_file, "%c", ch);
  233.         }
  235.         for (i = filesize; i % 4 != 0; i++)
  236.         {
  237.             fprintf(dest_file, "%c", 0);    /* for 4 byte alignment */
  238.         }
  239.     }
  240. /* 100206 ENFB support Start */
  241. #ifdef __MMI_RESOURCE_ENFB_SUPPORT__
  242.     else if (enfbFlag == 1) /* write ENFB header to CustImgDataxxx.h and image header/data to ENFB image data file */
  243.     {
  244.         for (i = 0; i < filesize; i++)
  245.         {
  246.             ch = fgetc(input_file);
  247.             fprintf(enfb_img_data_file, "%c", ch);
  248.         }
  250.         for (i = filesize; i % 4 != 0; i++)
  251.         {
  252.             fprintf(enfb_img_data_file, "%c", 0);    /* for 4 byte alignment */
  253.         }
  254.     }
  255. #endif
  256. /* 100206 ENFB support End */  
  257.     else
  258.     {
  259.         for (i = 0; i < filesize; i++)
  260.         {
  261.             ch = fgetc(input_file);
  262.             fprintf(output_file, "0x%02X, ", ch);
  263.             o++;
  264.             if ((o % 16) == 0)
  265.             {
  266.                 fprintf(output_file, "nt");
  267.             }
  268.         }
  270.         for (i = filesize; i % 4 != 0; i++)
  271.         {
  272.             fprintf(output_file, "0x00, "); /* for 4 byte alignment */
  273.         }
  275.         if ((o % 16) != 0)
  276.         {
  277.             fprintf(output_file, "nt");
  278.         }
  279.     }
  280. }
  282. /* Calvin end */
  283. /* __CUSTPACK_MULTIBIN Calvin END */
  285. /* 101205 audio resource Calvin Satrt */
  288. /*****************************************************************************
  289.  * FUNCTION
  290.  *  Extract_Name
  291.  * DESCRIPTION
  292.  *  Exract image name from the supplied string
  293.  * PARAMETERS
  294.  *  dest            [OUT]       -> Extrected file name from string
  295.  *  src             [IN]        -> string containing file name and path
  296.  *  res_type        [IN]        
  297.  * RETURNS
  298.  *  void
  299.  *****************************************************************************/
  300. void Extract_Name(S8 *dest, S8 *src, U32 res_type)
  301. {
  302.     /*----------------------------------------------------------------*/
  303.     /* Local Variables                                                */
  304.     /*----------------------------------------------------------------*/
  305.     U32 iLen = strlen(src);
  306.     U16 nCount = 0;
  308.     S8 *pSrc = src;
  309.     char a, b;
  310.     S8 *pCustPath;
  311.     U32 ExtFlag;
  313.     /*----------------------------------------------------------------*/
  314.     /* Code Body                                                      */
  315.     /*----------------------------------------------------------------*/
  316.     switch (res_type)
  317.     {
  318.         case RES_IMAGE:
  319.         case RES_MEDIA:
  320.         case RES_JAVA_GAME:
  321.             pCustPath = CustImgPath;
  322.             ExtFlag = ExtImageFlag;
  323.             break;
  325.         case RES_AUDIO:
  326.             pCustPath = CustAdoPath;
  327.             ExtFlag = ExtAudioFlag;
  328.             break;
  330.         default:
  331.             printf("res_type in Extract_Name is invalid!!");
  332.             pCustPath = CustImgPath;
  333.             ExtFlag = ExtImageFlag;
  334.             break;
  335.     }
  337.     iLen = strlen(pCustPath);
  339.     for (nCount = 0; nCount < iLen; nCount++)
  340.     {
  341.         a = toupper(pCustPath[nCount]);
  342.         b = toupper(src[nCount]);
  343.         if (a != b)
  344.         {
  345.             break;
  346.         }
  347.     }
  348.     if (iLen == nCount)
  349.     {
  350.         pSrc = &src[iLen];
  351.     }
  353.     iLen = strlen(pSrc);
  354.     nCount = 0;
  356.     while (iLen)
  357.     {
  358.         if ((pSrc[nCount] == '.') || (pSrc[nCount] == '-') || (pSrc[nCount] == ' ') || (pSrc[nCount] == '\'))
  359.         {
  360.             dest[nCount] = '_';
  361.         }
  362.         else
  363.         {
  364.             dest[nCount] = pSrc[nCount];
  365.         }
  367.         ++nCount;
  368.         --iLen;
  369.     }
  371.     /* __CUSTPACK_MULTIBIN Calvin BEGIN */
  372.     if (ExtFlag == 1)   /* 040805 CustPack: Calvin added */
  373.     {
  374.         dest[nCount] = '_'; /* add a '_' in the end to distinguish from the original */
  375.         dest[nCount + 1] = '';
  376.     }
  377.     /* __CUSTPACK_MULTIBIN Calvin END */
  378.     else
  379.     {
  380.         dest[nCount] = '';
  381.     }
  382.     return;
  383. }
  385. /* 101205 audio resource Calvin End */
  387. /* 101205 audio resource Calvin Satrt */
  390. /* 070306 Alpha layer Start */
  391. /*****************************************************************************
  392.  * FUNCTION
  393.  *  ExtractExtension
  394.  * DESCRIPTION
  395.  *  Function Extracting the extension
  396.  * PARAMETERS
  397.  *  src             [?]         
  398.  *  res_type        [IN]        -> resource type
  399.  *  string(?)       [IN]        -> string containing file name
  400.  * RETURNS
  401.  *  U8
  402.  *****************************************************************************/
  403. U8 ExtractExtension(S8 *src, U32 res_type)
  404. {
  405.     /*----------------------------------------------------------------*/
  406.     /* Local Variables                                                */
  407.     /*----------------------------------------------------------------*/
  408.     S32 i, j;
  409.     S32 type_number;
  410.     U8 ret = 0;
  411.     S8 *arr;
  412.     RESOURCE_INFO *pResource_info;
  414.     /*----------------------------------------------------------------*/
  415.     /* Code Body                                                      */
  416.     /*----------------------------------------------------------------*/
  417.     i = strlen(src) - 1;
  418.     arr = src+i;
  420.     for (j = 0; j < 5 ; j--)
  421.     {
  422.         if(*arr == '.')
  423.         {
  424.             arr++;
  425.             break;
  426.         }
  427.         else
  428.     {
  429.             arr--;
  430.         }
  431.     }
  433.     if(j >= 5)
  434.     {
  435.         return ret;
  436.     }
  438.     switch (res_type)
  439.     {
  440.         case RES_IMAGE:
  441.         case RES_MEDIA:
  442.             ret = IMAGE_TYPE_INVALID;
  443.             pResource_info = image_resource_info;
  444.             type_number = sizeof(image_resource_info) / sizeof(RESOURCE_INFO);
  445.             break;
  447.         case RES_AUDIO:
  448.             ret = AUDIO_TYPE_INVALID;
  449.             pResource_info = audio_resource_info;
  450.             type_number = sizeof(audio_resource_info) / sizeof(RESOURCE_INFO);
  451.             break;
  453.         default:
  454.             printf("res_type in Extract_Name is invalid!!");
  455.             ret = IMAGE_TYPE_INVALID;
  456.             pResource_info = image_resource_info;
  457.             type_number = sizeof(image_resource_info) / sizeof(RESOURCE_INFO);
  458.             break;
  459.     }
  461.     for (i = 0; i < type_number; i++)
  462.     {
  463.         if (!(strcmp(arr, pResource_info[i].filename_ext)))
  464.         {
  465.             ret = pResource_info[i].file_type;
  466.         }
  467.     }
  469.     return ret;
  470. }
  473. /*****************************************************************************
  474.  * FUNCTION
  475.  *  ChangeExtension
  476.  * DESCRIPTION
  477.  *  Function Change the extension
  478.  * PARAMETERS
  479.  *  src             [IN]        -> string containing file name 
  480.  *  res_type        [IN]        -> resource type
  481.  *  ext_type        [IN]        -> extension type
  482.  * RETURNS
  483.  *  BOOL
  484.  *****************************************************************************/
  485. BOOL ChangeExtension(S8 *src, U32 res_type, S32 ext_type)
  486. {
  487.     /*----------------------------------------------------------------*/
  488.     /* Local Variables                                                */
  489.     /*----------------------------------------------------------------*/
  490.     S32 i, j;
  491.     S32 type_number;
  492.     U8 ret = 0;
  493.     S8 *arr;
  494.     RESOURCE_INFO *pResource_info;
  496.     /*----------------------------------------------------------------*/
  497.     /* Code Body                                                      */
  498.     /*----------------------------------------------------------------*/
  499.     i = strlen(src) - 1;
  500.     arr = src+i;
  502.     for (j = 0; j < 5 ; j--)
  503.     {
  504.         if(*arr == '.')
  505.         {
  506.             arr++;
  507.             break;
  508.         }
  509.         else
  510.         {
  511.             arr--;
  512.         }
  513.     }
  515.     if (j >= 5)
  516.     {
  517.         return FALSE;
  518.     }
  520.     switch (res_type)
  521.     {
  522.         case RES_IMAGE:
  523.         case RES_MEDIA:
  524.             ret = IMAGE_TYPE_INVALID;
  525.             pResource_info = image_resource_info;
  526.             type_number = sizeof(image_resource_info) / sizeof(RESOURCE_INFO);
  527.             break;
  529.         case RES_AUDIO:
  530.             ret = AUDIO_TYPE_INVALID;
  531.             pResource_info = audio_resource_info;
  532.             type_number = sizeof(audio_resource_info) / sizeof(RESOURCE_INFO);
  533.             break;
  535.         default:
  536.             printf("res_type in Extract_Name is invalid!!");
  537.             ret = IMAGE_TYPE_INVALID;
  538.             pResource_info = image_resource_info;
  539.             type_number = sizeof(image_resource_info) / sizeof(RESOURCE_INFO);
  540.             break;
  541.     }
  543.     for (i = 0; i < type_number; i++)
  544.     {
  545.         if (pResource_info[i].file_type == ext_type)
  546.         {
  547.             break;
  548.         }
  549.     }
  551.     if (i >= type_number)
  552.     {
  553.         return FALSE;
  554.     }
  556.     for (j = 0; j < 5; j++)
  557.     {
  558.         *(arr+j) = *(pResource_info[i].filename_ext+j);
  559.     }
  561.     return TRUE;
  562. }
  563. /* 070306 Alpha layer End */
  566. /*****************************************************************************
  567.  * FUNCTION
  568.  *  isEmsImage
  569.  * DESCRIPTION
  570.  *  Decide if the iamge is used for EMS picture
  571.  *  
  572.  *  use EMS_IMAGE_PATH (defined in CustDataRes.h) to decide if a EMS picture
  573.  * PARAMETERS
  574.  *  path        [IN]        -> string containing file name and path
  575.  * RETURNS
  576.  *  U8 --> 1: EMS picture, 0: Not EMS picture
  577.  *****************************************************************************/
  578. U8 isEmsImage(S8 *path)
  579. {
  580.     /*----------------------------------------------------------------*/
  581.     /* Local Variables                                                */
  582.     /*----------------------------------------------------------------*/
  583.     S8 ems_path[] = EMS_IMAGE_PATH;
  584.     U8 pos = 0, ems_len = 0, i = 0;
  586.     /*----------------------------------------------------------------*/
  587.     /* Code Body                                                      */
  588.     /*----------------------------------------------------------------*/
  589.     ems_len = strlen(ems_path);
  590.     pos = strlen(path) - 1;
  591.     while (path[pos] != '\')
  592.     {
  593.         /* __CUSTPACK_MULTIBIN Calvin BEGIN */
  594.         if (pos == 0)   /* 040805 CustPack: Calvin added */
  595.         {
  596.             return 0;
  597.         }
  598.         /* __CUSTPACK_MULTIBIN Calvin END */
  599.         pos--;
  600.     }
  601.     pos -= ems_len + 1;
  602.     for (i = 0; i < ems_len; i++)
  603.     {
  604.         if (ems_path[i] != path[pos])
  605.         {
  606.             return 0;
  607.         }
  608.         else
  609.         {
  610.             pos++;
  611.         }
  612.     }
  614.     return 1;
  615. }
  618. /*****************************************************************************
  619.  * FUNCTION
  620.  *  isMainmenuImage
  621.  * DESCRIPTION
  622.  *  Decide if the iamge is used for Mainmenu picture
  623.  * PARAMETERS
  624.  *  path        [IN]        -> string containing file name and path
  625.  * RETURNS
  626.  *  U8 --> 1: Matrix Mainmenu picture, 0: Not Matrix mainmenu picture
  627.  *****************************************************************************/
  628. MMI_BOOL isMainmenuImage(S8 *path)
  629. {
  630.     /*----------------------------------------------------------------*/
  631.     /* Local Variables                                                */
  632.     /*----------------------------------------------------------------*/
  634.     /*----------------------------------------------------------------*/
  635.     /* Code Body                                                      */
  636.     /*----------------------------------------------------------------*/
  637.     if ((strstr(path, "\MATRIX\") != NULL) && (strstr(path, ".GIF") != NULL))
  638.     {
  639.         return MMI_TRUE;
  640.     }
  641.     else
  642.     {
  643.         return MMI_FALSE;
  644.     }
  645. }
  648. /*****************************************************************************
  649.  * FUNCTION
  650.  *  isSubmenuImage
  651.  * DESCRIPTION
  652.  *  Decide if the iamge is used for Submenu picture
  653.  *  
  654.  *  use SUBMENU_IMAGE_PATH (defined in CustDataRes.h) to decide if a EMS picture
  655.  * PARAMETERS
  656.  *  path        [IN]        -> string containing file name and path
  657.  * RETURNS
  658.  *  U8 --> 1: Submenu picture, 0: Not Submenu picture
  659.  *****************************************************************************/
  660. U8 isSubmenuImage(S8 *path)
  661. {
  662. #ifndef __MMI_SLIM_LISTMENU_NUMBER__
  663.     /*----------------------------------------------------------------*/
  664.     /* Local Variables                                                */
  665.     /*----------------------------------------------------------------*/
  667.     /*----------------------------------------------------------------*/
  668.     /* Code Body                                                      */
  669.     /*----------------------------------------------------------------*/
  670.     return 0;
  671. #else /* __MMI_SLIM_LISTMENU_NUMBER__ */ 
  672.     S8 submenu_path[] = SUBMENU_IMAGE_PATH;
  673.     U8 pos = 0, submenu_len = 0, i = 0;
  675.     if (strstr(path, submenu_path) != NULL)
  676.     {
  677.         return 1;
  678.     }
  679.     else
  680.     {
  681.         return 0;
  682.     }
  683.     /*
  684.      * submenu_len = strlen(submenu_path);
  685.      * pos = strlen (path)-1;
  686.      * while (path[pos]!='\') pos--;
  687.      * pos-=submenu_len+1;
  688.      * for ( i=0; i<submenu_len; i++){
  689.      * if ( submenu_path[i] != path[pos] ) return 0;
  690.      * else pos++;
  691.      * }
  692.      * return 1;
  693.      */
  694. #endif /* __MMI_SLIM_LISTMENU_NUMBER__ */ 
  695. }
  697. /* __CUSTPACK_MULTIBIN Calvin BEGIN */
  698. /* 040805 CustPack: Calvin added */
  701. /*****************************************************************************
  702.  * FUNCTION
  703.  *  ToUpper
  704.  * DESCRIPTION
  705.  *  
  706.  * PARAMETERS
  707.  *  ch      [IN]        
  708.  * RETURNS
  709.  *  
  710.  *****************************************************************************/
  711. S8 ToUpper(S8 ch)
  712. {
  713.     /*----------------------------------------------------------------*/
  714.     /* Local Variables                                                */
  715.     /*----------------------------------------------------------------*/
  717.     /*----------------------------------------------------------------*/
  718.     /* Code Body                                                      */
  719.     /*----------------------------------------------------------------*/
  720.     return toupper(ch);
  721. }
  723. /* Calvin end */
  724. /* __CUSTPACK_MULTIBIN Calvin END */
  727. /*****************************************************************************
  728.  * FUNCTION
  729.  *  Iload
  730.  * DESCRIPTION
  731.  *  Load the file image to buffer and writes to CustImgRes.c
  732.  * PARAMETERS
  733.  *  string      [IN]        -> string containing file name and path
  734.  *  pType       [OUT]       -> Image Type
  735.  * RETURNS
  736.  *  void* --> buffer containing image data
  737.  *****************************************************************************/
  738. MMI_BOOL Iload(S8 *string, PU16 pType)
  739. {
  740.     /*----------------------------------------------------------------*/
  741.     /* Local Variables                                                */
  742.     /*----------------------------------------------------------------*/
  743.     U32 image_counter = 0;
  744.     U32 image_offset = 0;
  745.     U32 failure_counter = 0;
  746.     U8 *pBuffer = NULL;
  747.     S32 j, sequence_counter, n_frames;
  748.     MMI_BOOL failure_flag;
  749.     U8 image_identifier;
  750.     S32 n_images = 0;
  751.     S32 file_size1 = 0;
  752.     S32 file_size = 0;
  753.     S32 nImageSize = 0;
  754.     U8 *pBuffer1 = NULL;
  755.     S32 extension_type = -1;
  756.     U8 staticFlag = 1;  /* Non animated image */
  757.     /* 070306 Alpha layer Start */
  758.     //#ifdef __MMI_ALPHA_LAYER_SUPPORT__
  759.     S32 ext_type = -1;
  760.     //#endif
  761.     /* 070306 Alpha layer End */
  763.     // __CUSTPACK_MULTIBIN Calvin BEGIN
  764.     //S8         tempDestFile[] = {"..\\..\\Customer\\IMAGES\TEMPIMAGE"};
  765.     S8 tempDestFile[] = { "TEMPIMAGE" };    /* 040805 CustPack: Calvin modified */
  766.     int ret = 1;
  768.     /* __CUSTPACK_MULTIBIN Calvin END */
  769.     S8 tempCommand[200];
  770.     size_t size;
  771.     U32 o = 0;
  772.     S16 filenameLen;
  773.     char *curr_output_data_filename;
  775. #ifdef __MMI_RESOURCE_ENFB_SUPPORT__
  776.     U32 enfb_width, enfb_height;//100206 ENFB support
  777.     S32 enfb_ret;
  778. #endif
  780.     /*----------------------------------------------------------------*/
  781.     /* Code Body                                                      */
  782.     /*----------------------------------------------------------------*/
  783.     g_ressize = 0;
  785.     if (ExtImageFlag == EXT_IMAGE)
  786.     {
  787.         curr_output_data_filename = OUTPUT_DATA_FILENAME_EXT;
  788.     }
  789.     else if (ExtImageFlag == SYSTEM_IMAGE)
  790.     {
  791.         curr_output_data_filename = OUTPUT_DATA_FILENAME;
  792.     }
  793.     else
  794.     {
  795.         curr_output_data_filename = NFB_IMAGE_DATA_FILENAME;
  796.         nfb_img_res_file = fopen(NFB_IMAGE_RES_FILENAME, "ab");
  797.     }
  799.     if (toolFlag == 1)
  800.     {   /* 040805 CustPack: Calvin added */
  801.         curr_output_data_filename = "temp";
  802.     }
  804.     strcpy(filename_buffer, curr_output_data_filename); /* 040805 CustPack: Calvin modified */
  805.     /* __CUSTPACK_MULTIBIN Calvin END */
  807.     output_data_file = fopen(filename_buffer, "ab");
  808.     while (!output_data_file)
  809.     {
  810.         Sleep(50);
  811.         output_data_file = fopen(filename_buffer, "ab");
  812.     }
  813.     //Move behind
  814.     //fprintf(output_data_file,"const U8 ");
  816.     output_image_names = (S8*) malloc(100);
  817.     strcpy(filename_buffer, string);
  818.     if (!(strcmp(filename_buffer, "")))
  819.     {
  821.         strcpy(filename_buffer, NOIMAGE_FILENAMEBUFFER);
  822.     }
  824.     Extract_Name(output_image_names, filename_buffer, RES_IMAGE);
  825. #ifdef __MMI_SLIM_LISTMENU_NUMBER__
  826.     if (isSubmenuImage(filename_buffer))
  827.     {
  828.         int i, len;
  830.         len = strlen(filename_buffer);
  832.         for (i = len; i > 0; i--)
  833.         {
  834.             if (filename_buffer[i] == 'U' && filename_buffer[i - 1] == 'N' && filename_buffer[i - 2] == 'E' &&
  835.                 filename_buffer[i - 3] == 'M' && filename_buffer[i - 4] == 'B' && filename_buffer[i - 5] == 'U' &&
  836.                 filename_buffer[i - 6] == 'S')
  837.             {
  838.                 filename_buffer[i + 1] = '2';
  839.                 break;
  840.             }
  841.             else
  842.             {
  843.                 filename_buffer[i + 1] = filename_buffer[i];
  844.             }
  846.         }
  847.         filename_buffer[len + 1] = '';
  848.     }
  849. #endif /* __MMI_SLIM_LISTMENU_NUMBER__ */ 
  851.     failure_flag = MMI_TRUE;
  852.     extension_type = -1;
  853.     sequence_counter = 0;
  855. /* 070306 Alpha layer Start */
  856. #ifdef __MMI_ALPHA_LAYER_SUPPORT__
  857.     //printf("inside 1n");
  858.     ext_type = ExtractExtension(filename_buffer, RES_IMAGE);
  859.     if (ext_type == IMAGE_TYPE_GIF || ext_type == IMAGE_TYPE_BMP)
  860.     {
  861.         //printf("inside GIF..BMP  %sn", filename_buffer);
  862.         ChangeExtension(filename_buffer, RES_IMAGE, IMAGE_TYPE_PNG);
  863.         //printf("out GIF..BMP  %sn", filename_buffer);
  864.     }
  865.     else if (ext_type == IMAGE_TYPE_DEVICE_BITMAP)
  866.     {
  867.         ChangeExtension(filename_buffer, RES_IMAGE, IMAGE_TYPE_PPN);
  868.     }
  870.     image_data_file = fopen(filename_buffer, "rb");
  871.     if (image_data_file == NULL)
  872.     {
  873.         ChangeExtension(filename_buffer, RES_IMAGE, ext_type);
  874.     }
  875.     else
  876.     {
  877.         fclose(image_data_file);
  878.     }
  879. #endif
  881.     ext_type = ExtractExtension(filename_buffer, RES_IMAGE);
  882.     if (ext_type == IMAGE_TYPE_PPN)
  883.     {
  884.         //ChangeExtension(filename_buffer, RES_IMAGE, IMAGE_TYPE_PNG);
  885.         strcpy((char*)tempBMPFile, (const char*)filename_buffer);
  886.         ChangeExtension(tempBMPFile, RES_IMAGE, IMAGE_TYPE_DEVICE_BITMAP);
  887.         sprintf(tempCommand,"convert.exe png:%s bmp:%s", filename_buffer, tempBMPFile);
  888.         //sprintf(tempCommand,"convert.exe png:%s bmp:%s", filename_buffer, "4.pbm");
  889.         //printf("%sn",tempCommand);
  890.         system(tempCommand);
  891.         strcpy((char*)filename_buffer, (const char*)tempBMPFile);
  892.         //printf("%sn",filename_buffer);
  893.     }
  894. /* 070306 Alpha layer End */
  896.     filenameLen = strlen(filename_buffer);
  898.     /* MTK Leo add, for EMS */
  899.     if (isEmsImage(filename_buffer))
  900.         /* if (filename_buffer[filenameLen-3] =='P' && filename_buffer[filenameLen-2] == 'I' && filename_buffer[filenameLen-1] =='C' ) */
  901.     {
  902.         image_data_file = fopen(filename_buffer, "rb");
  903.         if (image_data_file != NULL)
  904.         {
  905.             /* __CUSTPACK_MULTIBIN Calvin BEGIN */
  906.             if (toolFlag == 0)  /* 040805 CustPack: Calvin modified */
  907.             {
  908.                 fprintf(output_data_file, "const U8 ");
  909.                 fprintf(output_data_file, output_image_names);
  910.                 fprintf(output_data_file, "[]=");
  911.                 fclose(output_data_file);
  912.             }
  913.             //sprintf(tempCommand,"%s %s -b %s", EMSCONVERTER_FILENAME,filename_buffer,OUTPUT_DATA_FILENAME);//,output_image_names);
  914.             //system(tempCommand);
  915.             ret = bmp2ems(filename_buffer, curr_output_data_filename, 1, 0);    /* 040805 CustPack: Calvin modified */
  916.             if (toolFlag)
  917.             {
  918.                 if (ret == 0)//100206 ENFB support
  919.                 {
  920.                     resultFailFlag = 1;
  921.                 }
  922.             }
  923.             /* __CUSTPACK_MULTIBIN Calvin END */
  924.         }
  925.         else
  926.         {
  927.             /* fclose(image_data_file); */
  928.             failure_flag = MMI_FALSE;
  929.         }
  930.     }
  931.     else if ((filename_buffer[filenameLen - 1] == 'P' || filename_buffer[filenameLen - 1] == 'M') &&
  932.              (filename_buffer[filenameLen - 2] == 'R' || filename_buffer[filenameLen - 2] == 'B') &&
  933.              filename_buffer[filenameLen - 3] == 'P')
  934.     {
  935.         image_data_file = fopen(filename_buffer, "rb");
  936.         if (image_data_file != NULL)
  937.         {
  938.             if (filename_buffer[filenameLen - 2] == 'R')
  939.             {
  940.                 //sprintf(tempCommand,"%s %s %s", GIFCONVERTER_FILENAME,filename_buffer,tempDestFile);
  941.                 //system(tempCommand);//010505 Calvin moved
  942.                 GIFLoader(filename_buffer, tempDestFile);   /* 010505 Calvin added */
  943.             }
  944.             else
  945.             {
  946.                 //sprintf(tempCommand,"%s %s %s", BMPCONVERTER_FILENAME,filename_buffer,tempDestFile);
  947.                 //system(tempCommand);//010505 Calvin moved
  948.                 // __CUSTPACK_MULTIBIN Calvin BEGIN
  949.                 ret = BMPLoader(filename_buffer, tempDestFile); /* 010505 Calvin added */
  950.                 if (toolFlag)
  951.                 {
  952.                     if (ret = 0)
  953.                     {
  954.                         resultFailFlag = 1;
  955.                     }
  956.                 }
  957.                 /* __CUSTPACK_MULTIBIN Calvin END */
  958.             }
  959.             /* system(tempCommand);//010505 Calvin moved */
  960.             fclose(image_data_file);
  962.             /* __CUSTPACK_MULTIBIN Calvin BEGIN */
  963.             if (toolFlag == 0)  /* 040805 CustPack: Calvin modified */
  964.             {
  965.                 image_data_file = fopen(tempDestFile, "rb");
  966.                 if (image_data_file != NULL)
  967.                 {
  968.                     strcpy((char*)autoimagename_buffer, (const char*)output_image_names);
  969.                     strcat((char*)autoimagename_buffer, "[]=n");
  970.                     fprintf(output_data_file, "const U8 ");
  971.                     fprintf(output_data_file, autoimagename_buffer);
  972.                     if (ExtImageFlag == NFB_PROGRESS_IMAGE)
  973.                     {
  974.                         if (nfb_img_res_file != NULL)
  975.                         {
  976.                             fprintf(nfb_img_res_file, "(U8*)&%s,n", output_image_names);
  977.                             fclose(nfb_img_res_file);
  978.                         }
  979.                         else
  980.                         {
  981.                             printf("nfb_img_res_file not openedn");
  982.                         }
  983.                     }
  985.                     fseek(image_data_file, 0, SEEK_END);
  986.                     file_size = ftell(image_data_file);
  987.                     fseek(image_data_file, 0, SEEK_SET);
  989.                     while (!feof(image_data_file))
  990.                     {
  991.                         size = fread(tempCommand, sizeof(char), 200, image_data_file);
  992.                         if (size)
  993.                         {
  994.                             fwrite(tempCommand, sizeof(char), size, output_data_file);
  995.                         }
  996.                     }
  997.                     fputs("n", output_data_file);
  999.                 }
  1000.             }
  1001.             /* __CUSTPACK_MULTIBIN Calvin END */
  1002.         }
  1003.         else
  1004.         {
  1005.             failure_flag = MMI_FALSE;
  1006.         }
  1007.     }
  1008.     else
  1009.     {
  1010.         image_data_file = fopen(filename_buffer, "rb");
  1011.         /* MTK Leo add, for read images with same filename but different in ".bmp" and ".gif" */
  1012.         if (image_data_file == NULL)
  1013.         {
  1014.             Sleep(50);
  1015.             if (filename_buffer[filenameLen - 1] == 'P' && filename_buffer[filenameLen - 2] == 'M' &&
  1016.                 filename_buffer[filenameLen - 3] == 'B')
  1017.             {
  1018.                 filename_buffer[filenameLen - 1] = 'F';
  1019.                 filename_buffer[filenameLen - 2] = 'I';
  1020.                 filename_buffer[filenameLen - 3] = 'G';
  1021.             }
  1022.             else if (isMainmenuImage(filename_buffer))
  1023.             {
  1024.                 filename_buffer[filenameLen - 1] = 'M';
  1025.                 filename_buffer[filenameLen - 2] = 'B';
  1026.                 filename_buffer[filenameLen - 3] = 'P';
  1027.                 image_data_file = fopen(filename_buffer, "rb");
  1028.                 if (image_data_file != NULL)
  1029.                 {
  1030.                     //sprintf(tempCommand,"%s %s %s", BMPCONVERTER_FILENAME,filename_buffer,tempDestFile);
  1031.                     //system(tempCommand);
  1032.                     // __CUSTPACK_MULTIBIN Calvin BEGIN
  1033.                     ret = BMPLoader(filename_buffer, tempDestFile);     /* 010505 Calvin added */
  1034.                     if (toolFlag)
  1035.                     {
  1036.                         if (ret = 0)
  1037.                         {
  1038.                             resultFailFlag = 1;
  1039.                         }
  1040.                     }
  1041.                     /* __CUSTPACK_MULTIBIN Calvin END */
  1043.                     /* __CUSTPACK_MULTIBIN Calvin BEGIN */
  1044.                     if (toolFlag == 0)  /* 040805 CustPack: Calvin modified */
  1045.                     {
  1046.                         image_data_file = fopen(tempDestFile, "rb");
  1047.                         if (image_data_file != NULL)
  1048.                         {
  1049.                             strcpy((char*)autoimagename_buffer, (const char*)output_image_names);
  1050.                             strcat((char*)autoimagename_buffer, "[]=n");
  1051.                             fprintf(output_data_file, "const U8 ");
  1052.                             fprintf(output_data_file, autoimagename_buffer);
  1053.                             if (ExtImageFlag == NFB_PROGRESS_IMAGE)
  1054.                             {
  1055.                                 if (nfb_img_res_file != NULL)
  1056.                                 {
  1057.                                     fprintf(nfb_img_res_file, "(U8*)&%s,n", output_image_names);
  1058.                                     fclose(nfb_img_res_file);
  1059.                                 }
  1060.                                 else
  1061.                                 {
  1062.                                     printf("nfb_img_res_file not openedn");
  1063.                                 }
  1064.                             }
  1066.                             fseek(image_data_file, 0, SEEK_END);
  1067.                             file_size = ftell(image_data_file);
  1068.                             fseek(image_data_file, 0, SEEK_SET);
  1070.                             while (!feof(image_data_file))
  1071.                             {
  1072.                                 size = fread(tempCommand, sizeof(char), 200, image_data_file);
  1073.                                 if (size)
  1074.                                 {
  1075.                                     fwrite(tempCommand, sizeof(char), size, output_data_file);
  1076.                                 }
  1077.                             }
  1078.                             fputs("n", output_data_file);
  1080.                         }
  1081.                         fclose(image_data_file);
  1082.                     }
  1083.                     fclose(output_data_file);
  1084.                     return MMI_TRUE;
  1085.                     /* __CUSTPACK_MULTIBIN Calvin END */
  1086.                 }
  1087.             }
  1088.             else if (filename_buffer[filenameLen - 1] == 'F' && filename_buffer[filenameLen - 2] == 'I' &&
  1089.                      filename_buffer[filenameLen - 3] == 'G')
  1090.             {
  1091.                 filename_buffer[filenameLen - 1] = 'P';
  1092.                 filename_buffer[filenameLen - 2] = 'M';
  1093.                 filename_buffer[filenameLen - 3] = 'B';
  1094.             }
  1095.             image_data_file = fopen(filename_buffer, "rb");
  1096.         }
  1097.         /* MTK Leo end */
  1098.         if (image_data_file == NULL)
  1099.         {
  1101.             /* Add extension add search */
  1102.             FILE *fail = fopen("fail.txt", "a+");
  1104.             if (fail != NULL)
  1105.             {
  1106.                 /* __CUSTPACK_MULTIBIN Calvin BEGIN */
  1107.                 if (toolFlag == 0)  /* 040805 CustPack: Calvin modified */
  1108.                 {
  1109.                     fprintf(fail, "%sn", filename_buffer);
  1110.                     fclose(fail);
  1111.                 }
  1112.                 failure_flag = MMI_FALSE;   /* 021705 Calvin moved from down */
  1113.                 /* __CUSTPACK_MULTIBIN Calvin END */
  1114.             }
  1116.         /* 070306 Alpha layer Start */
  1117.         /* Find the right extension file name */
  1118.         #ifdef __MMI_ALPHA_LAYER_SUPPORT__
  1119.             for (j = SUPPORT_N_SEQUENTIAL_IMAGE_TYPE-1; j >= 0; j--)//search from PNG       
  1120.         #else
  1121.             for (j = 0; j < SUPPORT_N_SEQUENTIAL_IMAGE_TYPE; j++)//search from BMP       
  1122.         #endif
  1123.         /* 070306 Alpha layer End */
  1124.             {
  1125.                 itoa(0, number_string, 10);
  1126.                 extension_type = -1;
  1127.                 strcpy(autofilename_buffer, filename_buffer);
  1128.                 strcat(autofilename_buffer, "\\");
  1129.                 /* strcat(autofilename_buffer,output_image_names); */
  1130.                 strcat(autofilename_buffer, number_string);
  1131.                 strcat(autofilename_buffer, ".");
  1132.                 strcat(autofilename_buffer, sequential_image[j].filename_ext);
  1133.                 image_data_file = fopen(autofilename_buffer, "rb");
  1134.                 if (image_data_file != NULL)
  1135.                 {
  1136.                     failure_flag = MMI_TRUE;
  1137.                     extension_type = sequential_image[j].file_type;
  1138.                     staticFlag = 0;
  1139.                     *pType = (U16) extension_type;
  1140.                     sequential_extension_type = j;  /* 031705 Calvin modified */
  1141.                     fclose(image_data_file);
  1142.                     break;
  1143.                 }
  1144.             }
  1146.             // __CUSTPACK_MULTIBIN Calvin BEGIN    
  1147.             //failure_flag = MMI_FALSE;//021705 Calvin moved to up
  1148.             // __CUSTPACK_MULTIBIN Calvin END
  1149.         }
  1150.         else
  1151.         {
  1152.             /* patch added by vikram for getting image file size */
  1153.             fseek(image_data_file, 0, SEEK_END);
  1154.             nImageSize = ftell(image_data_file);
  1155.             fseek(image_data_file, 0, SEEK_SET);
  1157.         }
  1159.         if ((failure_flag == MMI_TRUE) && !(staticFlag))
  1160.         {
  1161.             /* Sequence found */
  1162.             /* Find how many files are in sequence */
  1164.             j = 0;
  1165.             sequence_counter = 0;
  1166.             n_frames = 0;
  1167.             while (1)
  1168.             {
  1169.                 itoa(j, number_string, 10);
  1170.                 strcpy(autofilename_buffer, "");
  1171.                 strcpy(autofilename_buffer, filename_buffer);
  1172.                 strcat(autofilename_buffer, "\\");
  1173.                 /* strcat(autofilename_buffer,output_image_names); */
  1174.                 strcat(autofilename_buffer, number_string);
  1175.                 strcat(autofilename_buffer, ".");
  1176.                 strcat(autofilename_buffer, sequential_image[sequential_extension_type].filename_ext);  /* 031705 Calvin modified */
  1177.                 image_data_file = fopen(autofilename_buffer, "rb");
  1178.                 if (image_data_file != NULL)
  1179.                 {
  1180.                     sequence_counter++;
  1181.                     fseek(image_data_file, 0, SEEK_END);
  1182.                     sequential_filesize[j] = ftell(image_data_file);
  1183.                     fseek(image_data_file, 0, SEEK_SET);
  1184.                     fclose(image_data_file);
  1185.                 }
  1186.                 else
  1187.                 {   /*   Sequence complete */
  1188.                     if (j > 0)
  1189.                     {
  1190.                         break;
  1191.                     }
  1192.                 }
  1193.                 j++;
  1194.             }
  1195.             /* read during */
  1196.             {
  1197.                 int i;
  1199.                 strcpy(autofilename_buffer, filename_buffer);
  1200.                 strcat(autofilename_buffer, "\\interval.txt");
  1202.                 /* 070306 interval missing Start */
  1203.                 image_data_file = NULL;
  1204.                 image_data_file = fopen(autofilename_buffer, "r");
  1205.                 if (image_data_file == NULL)
  1206.                 {
  1207.                     printf("ERROR: Can't find %sn", autofilename_buffer);
  1208.                     staticFlag = 1;
  1209.                     failure_flag = MMI_FALSE;
  1210.                 }
  1211.                 else
  1212.                 {
  1213.                     for (i = 0; i < sequence_counter; i++)
  1214.                     {
  1215.                         if (fscanf(image_data_file, "%d", &sequential_interval[i]) != 1)
  1216.                         {
  1217.                             printf("ERROR: %s, interval [%d] value missing!!n", autofilename_buffer, i);
  1218.                             staticFlag = 1;
  1219.                             failure_flag = MMI_FALSE;
  1220.                             break;
  1221.                         }
  1222.                     }
  1223.                 }
  1224.                 if (image_data_file != NULL)
  1225.                 {
  1226.                     fclose(image_data_file);
  1227.                 }
  1228.                 /* 070306 interval missing End */
  1229.             }
  1231.             /* 070306 interval missing Start */
  1232.             if(!staticFlag)
  1233.             {               
  1234.             /* 100206 ENFB support Start */
  1235.             #ifdef __MMI_RESOURCE_ENFB_SUPPORT__                
  1236.                 itoa(0, number_string, 10);
  1237.                 strcpy(autofilename_buffer, "");
  1238.                 strcpy(autofilename_buffer, filename_buffer);
  1239.                 strcat(autofilename_buffer, "\\");
  1240.                 strcat(autofilename_buffer, number_string);
  1241.                 strcat(autofilename_buffer, ".");
  1242.                 strcat(autofilename_buffer, sequential_image[sequential_extension_type].filename_ext);  /* 031705 Calvin modified */
  1243.                 enfb_ret = Image_Test(autofilename_buffer, &enfb_width, &enfb_height);
  1244.                 if (enfb_ret!= ENFB_IMAGE_NONE)
  1245.                 {
  1246.                     enfbFlag = 1;
  1247.                     if (enfb_ret == ENFB_IMAGE_ASSOCIATE)
  1248.                     {
  1249.                         ENFBAssociatedIDAdded = MMI_TRUE;
  1250.                     }
  1251.                 }
  1252.                 //printf("sequential %s --> %d x %dn", autofilename_buffer, enfb_width, enfb_height);
  1253.             #endif
  1254.             /* 100206 ENFB support Start */
  1255.             
  1256.                 /* n_frames=sequence_counter; */
  1257.                 sequential_frame = sequence_counter;
  1259.                 /* Construct the data structure name  */
  1260.                 strcpy(autoimagename_buffer, output_image_names);
  1261.                 strcat(autoimagename_buffer, OUTPUT_IMAGE_NAMES_END);
  1262.                 fprintf(output_data_file, "__align(4) const U8 ");
  1263.                 fprintf(output_data_file, autoimagename_buffer);
  1265.                 Write_Sequential_Image_Header(output_data_file, sequential_image[sequential_extension_type].file_type, sequential_frame, sequential_filesize, sequential_offset);   /* 031705 Calvin modified */
  1267.                 /* Load all files in the sequence   */
  1268.                 j = 0;
  1269.                 sequence_counter = 0;
  1270.                 while (1)
  1271.                 {
  1272.                     itoa(j, number_string, 10);
  1273.                     strcpy(autofilename_buffer, "");
  1274.                     strcpy(autofilename_buffer, filename_buffer);
  1275.                     strcat(autofilename_buffer, "\\");
  1276.                     /* strcat(autofilename_buffer,output_image_names); */
  1277.                     strcat(autofilename_buffer, number_string);
  1278.                     strcat(autofilename_buffer, ".");
  1279.                     strcat(autofilename_buffer, sequential_image[sequential_extension_type].filename_ext);  /* 031705 Calvin modified */
  1280.                     image_data_file = fopen(autofilename_buffer, "rb");
  1281.                     if (image_data_file != NULL)
  1282.                     {
  1283.                         Write_Sequential_Image_File(output_data_file, image_data_file, sequential_filesize[j]);
  1284.                         sequence_counter++;
  1285.                         fclose(image_data_file);
  1286.                     }
  1287.                     else
  1288.                     {   /*   Sequence complete */
  1289.                         if (j > 0)
  1290.                         {
  1291.                             break;
  1292.                         }
  1293.                     }
  1294.                     j++;
  1295.                 }
  1296.                 fprintf(output_data_file, "n};n");
  1297.             /* 100206 ENFB support Start */
  1298.             #ifdef __MMI_RESOURCE_ENFB_SUPPORT__
  1299.                 enfbFlag = 0;
  1300.             #endif
  1301.             /* 100206 ENFB support Start */
  1302.             }
  1303.             /* 070306 interval missing End */
  1304.         }   /* End of Animated image processor block */
  1306.         if ((failure_flag == MMI_TRUE) && (staticFlag))
  1307.         {
  1308.             /* Currently assuming that all single files are BMP   */
  1309.             if (nImageSize == 0)
  1310.             {
  1311.                 image_identifier = IMAGE_TYPE_INVALID;  /* 031705 Calvin modified */
  1312.             }
  1313.             else
  1314.             {
  1315.                 /* MTK Leo add, for read images with same filename but different in ".bmp" and ".gif" */
  1316.                 image_identifier = ExtractExtension(filename_buffer, RES_IMAGE);        /* 101205 audio resource Calvin */
  1317.             }
  1318.             /* To be changed later for multiple file types */
  1319.             *pType = ExtractExtension(filename_buffer, RES_IMAGE);      /* 101205 audio resource Calvin */
  1320.             /* MTK Leo end */
  1321.             /*   Load the data  */
  1323.             /* Construct the data structure name */
  1324.             strcpy(autoimagename_buffer, output_image_names);
  1325.             strcat(autoimagename_buffer, OUTPUT_IMAGE_NAMES_END);
  1326.             if (image_identifier == IMAGE_TYPE_GIF || image_identifier == IMAGE_TYPE_3GP ||
  1327.                 image_identifier == IMAGE_TYPE_MP4 || image_identifier == IMAGE_TYPE_AVI ||
  1328.                 image_identifier == IMAGE_TYPE_PNG || image_identifier == IMAGE_TYPE_M3D ||
  1329.                 image_identifier == IMAGE_TYPE_SWFLASH)
  1330.             {
  1331.                 fprintf(output_data_file, "__align(4) const U8 ");
  1332.             }
  1333.             else
  1334.             {
  1335.                 fprintf(output_data_file, "const U8 ");
  1336.             }
  1337.             fprintf(output_data_file, autoimagename_buffer);
  1339.             fseek(image_data_file, 0, SEEK_END);
  1341.             if (image_identifier == IMAGE_TYPE_GIF || image_identifier == IMAGE_TYPE_3GP ||
  1342.                 image_identifier == IMAGE_TYPE_MP4 || image_identifier == IMAGE_TYPE_AVI ||
  1343.                 image_identifier == IMAGE_TYPE_PNG || image_identifier == IMAGE_TYPE_M3D ||
  1344.                 image_identifier == IMAGE_TYPE_SWFLASH)
  1345.             {
  1346.                 file_size1 = file_size1 + ftell(image_data_file) + 8;
  1347.             }
  1348.             else
  1349.             {
  1350.                 file_size1 = file_size1 + ftell(image_data_file) + 6;
  1351.             }
  1352.             fseek(image_data_file, 0, SEEK_SET);
  1354.             pBuffer = (U8*) malloc(file_size1);
  1355.             if (pBuffer == NULL)
  1356.             {
  1357.                 /* Add Debug Message */
  1358.             }
  1359.             pBuffer1 = pBuffer;
  1361.         /* 100206 ENFB support Start */
  1362.         #ifdef __MMI_RESOURCE_ENFB_SUPPORT__
  1363.             enfb_ret = Image_Test(filename_buffer, &enfb_width, &enfb_height);
  1364.             if (enfb_ret != ENFB_IMAGE_NONE)
  1365.             {
  1366.                 enfbFlag = 1;
  1367.                 if (enfb_ret == ENFB_IMAGE_ASSOCIATE)
  1368.                 {
  1369.                     ENFBAssociatedIDAdded = MMI_TRUE;
  1370.                 }
  1371.             }
  1372.         #endif
  1373.         /* 100206 ENFB support End */
  1375.             g_ressize = Load_Image_Data(&image_offset, output_data_file, image_data_file, pBuffer1, image_identifier, 0);
  1377.         /* 100206 ENFB support Start */
  1378.         #ifdef __MMI_RESOURCE_ENFB_SUPPORT__
  1379.             enfbFlag = 0;
  1380.         #endif
  1381.         /* 100206 ENFB support Start */
  1383.             //printf("load_image_datan");//070306 Alpha layer
  1384.             if (ExtImageFlag == NFB_PROGRESS_IMAGE)
  1385.             {
  1386.                 printf("NFB_PROGRESS_IMAGEn");
  1387.                 if (nfb_img_res_file != NULL)
  1388.                 {
  1389.                     printf("nfb_img_res_filen");
  1390.                     fprintf(nfb_img_res_file, "(U8*)&%s,n", output_image_names);
  1391.                     fclose(nfb_img_res_file);
  1392.                 }
  1393.                 else
  1394.                 {
  1395.                     printf("nfb_img_res_file not openedn");
  1396.                 }
  1397.             }
  1399.             free(pBuffer);
  1400.             fprintf(output_data_file, "n };n");
  1401.             fclose(image_data_file);
  1402.         }
  1403.     }
  1405.     /* 120704 Calvin added for populating with .bmp or .gif but actually extsion name is not */
  1406.     if (failure_flag == MMI_FALSE)
  1407.     {
  1408.         /* printf("*************failed !!!********************n"); */
  1409.         for (j = 0; j < SUPPORT_N_MEDIA_TYPE; j++)
  1410.         {
  1411.             S32 l;
  1413.             for (l = 0; l < 3; l++)
  1414.             {
  1415.                 filename_buffer[filenameLen - 1 - l] = support_media_ext[j][2 - l];
  1416.             }
  1417.             /* printf("%s__%sn", support_media_ext[j], filename_buffer); */
  1419.             image_data_file = fopen(filename_buffer, "rb");
  1420.             if (image_data_file != NULL)
  1421.             {
  1422.                 break;
  1423.             }
  1424.         }
  1426.         if (image_data_file != NULL)
  1427.         {
  1428.             failure_flag = MMI_TRUE;
  1429.             /* printf("got %s n", filename_buffer); */
  1431.             fseek(image_data_file, 0, SEEK_END);
  1432.             nImageSize = ftell(image_data_file);
  1433.             fseek(image_data_file, 0, SEEK_SET);
  1435.             /* Currently assuming that all single files are BMP   */
  1436.             if (nImageSize == 0)
  1437.             {
  1438.                 image_identifier = IMAGE_TYPE_INVALID;  /* 031705 Calvin modified */
  1439.             }
  1440.             else
  1441.             {
  1442.                 /* MTK Leo add, for read images with same filename but different in ".bmp" and ".gif" */
  1443.                 image_identifier = ExtractExtension(filename_buffer, RES_IMAGE);        /* 101205 audio resource Calvin */
  1444.             }
  1445.             /* To be changed later for multiple file types */
  1446.             *pType = ExtractExtension(filename_buffer, RES_IMAGE);      /* 101205 audio resource Calvin */
  1447.             /* MTK Leo end */
  1448.             /*   Load the data  */
  1450.             /* Construct the data structure name */
  1451.             strcpy(autoimagename_buffer, output_image_names);
  1452.             strcat(autoimagename_buffer, OUTPUT_IMAGE_NAMES_END);
  1454.             if (image_identifier == IMAGE_TYPE_GIF || image_identifier == IMAGE_TYPE_3GP ||
  1455.                 image_identifier == IMAGE_TYPE_MP4 || image_identifier == IMAGE_TYPE_AVI ||
  1456.                 image_identifier == IMAGE_TYPE_PNG || image_identifier == IMAGE_TYPE_M3D ||
  1457.                 image_identifier == IMAGE_TYPE_SWFLASH)
  1458.             {
  1459.                 fprintf(output_data_file, "__align(4) const U8 ");
  1460.             }
  1461.             else
  1462.             {
  1463.                 fprintf(output_data_file, "const U8 ");
  1464.             }
  1465.             fprintf(output_data_file, autoimagename_buffer);
  1467.             fseek(image_data_file, 0, SEEK_END);
  1469.             if (image_identifier == IMAGE_TYPE_GIF || image_identifier == IMAGE_TYPE_3GP ||
  1470.                 image_identifier == IMAGE_TYPE_MP4 || image_identifier == IMAGE_TYPE_AVI ||
  1471.                 image_identifier == IMAGE_TYPE_PNG || image_identifier == IMAGE_TYPE_M3D ||
  1472.                 image_identifier == IMAGE_TYPE_SWFLASH)
  1473.             {
  1474.                 file_size1 = file_size1 + ftell(image_data_file) + 8;
  1475.             }
  1476.             else
  1477.             {
  1478.                 file_size1 = file_size1 + ftell(image_data_file) + 6;
  1479.             }
  1480.             fseek(image_data_file, 0, SEEK_SET);
  1482.             pBuffer = (U8*) malloc(file_size1);
  1483.             if (pBuffer == NULL)
  1484.             {
  1485.                 /* Add Debug Message */
  1486.             }
  1487.             pBuffer1 = pBuffer;
  1489.         /* 100206 ENFB support Start */
  1490.         #ifdef __MMI_RESOURCE_ENFB_SUPPORT__
  1491.             enfb_ret = Image_Test(filename_buffer, &enfb_width, &enfb_height);
  1492.             if (enfb_ret != ENFB_IMAGE_NONE)
  1493.             {
  1494.                 enfbFlag = 1;
  1495.                 if (enfb_ret == ENFB_IMAGE_ASSOCIATE)
  1496.                 {
  1497.                     ENFBAssociatedIDAdded = MMI_TRUE;
  1498.                 }
  1499.             }
  1500.         #endif
  1501.         /* 100206 ENFB support End */
  1502.         
  1503.             g_ressize = Load_Image_Data(&image_offset, output_data_file, image_data_file, pBuffer1, image_identifier, 0);
  1504.    
  1505.         /* 100206 ENFB support Start */
  1506.         #ifdef __MMI_RESOURCE_ENFB_SUPPORT__
  1507.             enfbFlag = 0;
  1508.         #endif
  1509.         /* 100206 ENFB support End */
  1510.         
  1511.             //printf("load_image_datan");//070306 Alpha layer
  1512.             if (ExtImageFlag == NFB_PROGRESS_IMAGE)
  1513.             {
  1514.                 printf("NFB_PROGRESS_IMAGEn");
  1515.                 if (nfb_img_res_file != NULL)
  1516.                 {
  1517.                     printf("nfb_img_res_filen");
  1518.                     fprintf(nfb_img_res_file, "(U8*)&%s,n", output_image_names);
  1519.                     fclose(nfb_img_res_file);
  1520.                 }
  1521.                 else
  1522.                 {
  1523.                     printf("nfb_img_res_file not openedn");
  1524.                 }
  1525.             }
  1527.             free(pBuffer);
  1528.             fprintf(output_data_file, "n };n");
  1529.             fclose(image_data_file);
  1530.         }
  1531.     }
  1532.     /* Calvin end */
  1534.     if (image_data_file != NULL)
  1535.     {
  1536.         fclose(image_data_file);
  1537.     }
  1538.     if (output_data_file != NULL)
  1539.     {
  1540.         fclose(output_data_file);
  1541.     }
  1542.     return failure_flag;
  1543. }
  1545. /* 101205 audio resource Calvin Satrt */
  1548. /*****************************************************************************
  1549.  * FUNCTION
  1550.  *  Aload
  1551.  * DESCRIPTION
  1552.  *  Load the file audio to buffer and writes to CustAdoRes.c
  1553.  * PARAMETERS
  1554.  *  string      [IN]        -> string containing file name and path
  1555.  *  pType       [OUT]       -> Audio Type
  1556.  * RETURNS
  1557.  *  void* --> buffer containing Audio data
  1558.  *****************************************************************************/
  1559. MMI_BOOL Aload(S8 *string, PU16 pType)
  1560. {
  1561.     /*----------------------------------------------------------------*/
  1562.     /* Local Variables                                                */
  1563.     /*----------------------------------------------------------------*/
  1564.     U32 audio_offset = 0;
  1565.     U8 *pBuffer = NULL;
  1566.     S32 j, n_frames;
  1567.     MMI_BOOL failure_flag;
  1568.     U8 audio_identifier;
  1569.     S32 file_size1 = 0;
  1570.     S32 file_size = 0;
  1571.     S32 nAudioSize = 0;
  1572.     U8 *pBuffer1 = NULL;
  1573.     U8 staticFlag = 1;  /* Non animated audio */
  1575.     /* S8           tempDestFile[] = {"TEMPAUDIO"}; */
  1576.     int ret = 1;
  1578.     /* S8           tempCommand[200]; */
  1579.     size_t size;
  1580.     U32 o = 0;
  1581.     S16 filenameLen;
  1582.     char *curr_output_data_filename;
  1584.     /*----------------------------------------------------------------*/
  1585.     /* Code Body                                                      */
  1586.     /*----------------------------------------------------------------*/
  1587.     g_ressize = 0;
  1589.     if (ExtAudioFlag == TRUE)   /* 040805 CustPack: Calvin added */
  1590.     {
  1591.         curr_output_data_filename = AUDIO_OUTPUT_DATA_FILENAME_EXT;
  1592.     }
  1593.     else
  1594.     {
  1595.         curr_output_data_filename = AUDIO_OUTPUT_DATA_FILENAME;
  1596.     }
  1598.     if (toolFlag == 1)
  1599.     {   /* 040805 CustPack: Calvin added */
  1600.         curr_output_data_filename = "temp";
  1601.     }
  1603.     strcpy(filename_buffer, curr_output_data_filename); /* 040805 CustPack: Calvin modified */
  1605.     output_data_file = fopen(filename_buffer, "ab");
  1606.     while (!output_data_file)
  1607.     {
  1608.         Sleep(50);
  1609.         output_data_file = fopen(filename_buffer, "ab");
  1610.     }
  1612.     output_audio_names = (S8*) malloc(100);
  1613.     strcpy(filename_buffer, string);
  1614.     if (!(strcmp(filename_buffer, "")))
  1615.     {
  1617.         strcpy(filename_buffer, NOAUDIO_FILENAMEBUFFER);
  1618.     }
  1620.     Extract_Name(output_audio_names, filename_buffer, RES_AUDIO);
  1622.     failure_flag = MMI_TRUE;
  1623.     filenameLen = strlen(filename_buffer);
  1625. #if 0
  1626. /* under construction !*/
  1627. /* under construction !*/
  1628. /* under construction !*/
  1629. /* under construction !*/
  1630. /* under construction !*/
  1631. /* under construction !*/
  1632. /* under construction !*/
  1633. /* under construction !*/
  1634. /* under construction !*/
  1635. /* under construction !*/
  1636. /* under construction !*/
  1637. /* under construction !*/
  1638. /* under construction !*/
  1639. /* under construction !*/
  1640. /* under construction !*/
  1641. /* under construction !*/
  1642. /* under construction !*/
  1643. /* under construction !*/
  1644. /* under construction !*/
  1645. /* under construction !*/
  1646. /* under construction !*/
  1647. /* under construction !*/
  1648. /* under construction !*/
  1649. /* under construction !*/
  1650. /* under construction !*/
  1651. /* under construction !*/
  1652. /* under construction !*/
  1653. /* under construction !*/
  1654. /* under construction !*/
  1655. /* under construction !*/
  1656. /* under construction !*/
  1657. /* under construction !*/
  1658. /* under construction !*/
  1659. /* under construction !*/
  1660. /* under construction !*/
  1661. /* under construction !*/
  1662. /* under construction !*/
  1663. /* under construction !*/
  1664. /* under construction !*/
  1665. /* under construction !*/
  1666. /* under construction !*/
  1667. /* under construction !*/
  1668. /* under construction !*/
  1669. /* under construction !*/
  1670. /* under construction !*/
  1671. /* under construction !*/
  1672. /* under construction !*/
  1673. /* under construction !*/
  1674. /* under construction !*/
  1675. /* under construction !*/
  1676. /* under construction !*/
  1677. /* under construction !*/
  1678. /* under construction !*/
  1679. /* under construction !*/
  1680. /* under construction !*/
  1681. /* under construction !*/
  1682. /* under construction !*/
  1683. /* under construction !*/
  1684. /* under construction !*/
  1685. /* under construction !*/
  1686. #endif /* 0 */ 
  1687.     {
  1688.         audio_data_file = fopen(filename_buffer, "rb");
  1689.         if (audio_data_file == NULL)
  1690.         {
  1691.             /* Add extension add search */
  1692.             FILE *fail = fopen("fail.txt", "a+");
  1694.             if (fail != NULL)
  1695.             {
  1696.                 if (toolFlag == 0)  /* 040805 CustPack: Calvin modified */
  1697.                 {
  1698.                     fprintf(fail, "%sn", filename_buffer);
  1699.                     fclose(fail);
  1700.                 }
  1701.                 failure_flag = MMI_FALSE;   /* 021705 Calvin moved from down */
  1702.             }
  1703.         }
  1704.         else
  1705.         {
  1706.             /* patch added by vikram for getting audio file size */
  1707.             fseek(audio_data_file, 0, SEEK_END);
  1708.             nAudioSize = ftell(audio_data_file);
  1709.             fseek(audio_data_file, 0, SEEK_SET);
  1710.         }
  1712.         if ((failure_flag == MMI_TRUE) && (staticFlag))
  1713.         {
  1714.             /* Currently assuming that all single files are BMP   */
  1715.             if (nAudioSize == 0)
  1716.             {
  1717.                 audio_identifier = AUDIO_TYPE_INVALID;  /* 031705 Calvin modified */
  1718.             }
  1719.             else
  1720.             {
  1721.                 /* MTK Leo add, for read audios with same filename but different in ".bmp" and ".gif" */
  1722.                 audio_identifier = ExtractExtension(filename_buffer, RES_AUDIO);        /* 101205 audio resource Calvin */
  1723.             }
  1724.             /* To be changed later for multiple file types */
  1725.             *pType = ExtractExtension(filename_buffer, RES_AUDIO);      /* 101205 audio resource Calvin */
  1727.             /*   Load the data  */
  1729.             /* Construct the data structure name */
  1730.             strcpy(autoimagename_buffer, output_audio_names);
  1731.             strcat(autoimagename_buffer, OUTPUT_AUDIO_NAMES_END);
  1732.             fprintf(output_data_file, "__align(4) const U8 ");
  1733.             fprintf(output_data_file, autoimagename_buffer);
  1735.             fseek(audio_data_file, 0, SEEK_END);
  1736.             file_size1 = file_size1 + ftell(audio_data_file) + 8;
  1737.             fseek(audio_data_file, 0, SEEK_SET);
  1739.             pBuffer = (U8*) malloc(file_size1);
  1740.             if (pBuffer == NULL)
  1741.             {
  1742.                 /* Add Debug Message */
  1743.             }
  1744.             pBuffer1 = pBuffer;
  1746.             g_ressize = Load_Audio_Data(&audio_offset, output_data_file, audio_data_file, pBuffer1, audio_identifier);
  1748.             free(pBuffer);
  1749.             fprintf(output_data_file, "n };n");
  1750.             fclose(audio_data_file);
  1751.         }
  1752.     }
  1754. #if 0
  1755. /* under construction !*/
  1756. /* under construction !*/
  1757. /* under construction !*/
  1758. /* under construction !*/
  1759. /* under construction !*/
  1760. /* under construction !*/
  1761. /* under construction !*/
  1762. /* under construction !*/
  1763. /* under construction !*/
  1764. /* under construction !*/
  1765. /* under construction !*/
  1766. /* under construction !*/
  1767. /* under construction !*/
  1768. /* under construction !*/
  1769. /* under construction !*/
  1770. /* under construction !*/
  1771. /* under construction !*/
  1772. /* under construction !*/
  1773. /* under construction !*/
  1774. /* under construction !*/
  1775. /* under construction !*/
  1776. /* under construction !*/
  1777. /* under construction !*/
  1778. /* under construction !*/
  1779. /* under construction !*/
  1780. /* under construction !*/
  1781. /* under construction !*/
  1782. /* under construction !*/
  1783. /* under construction !*/
  1784. /* under construction !*/
  1785. /* under construction !*/
  1786. /* under construction !*/
  1787. /* under construction !*/
  1788. /* under construction !*/
  1789. /* under construction !*/
  1790. /* under construction !*/
  1791. /* under construction !*/
  1792. /* under construction !*/
  1793. /* under construction !*/
  1794. /* under construction !*/
  1795. /* under construction !*/
  1796. /* under construction !*/
  1797. /* under construction !*/
  1798. /* under construction !*/
  1799. /* under construction !*/
  1800. /* under construction !*/
  1801. /* under construction !*/
  1802. /* under construction !*/
  1803. /* under construction !*/
  1804. /* under construction !*/
  1805. /* under construction !*/
  1806. /* under construction !*/
  1807. /* under construction !*/
  1808. /* under construction !*/
  1809. /* under construction !*/
  1810. /* under construction !*/
  1811. /* under construction !*/
  1812. /* under construction !*/
  1813. /* under construction !*/
  1814. /* under construction !*/
  1815. /* under construction !*/
  1816. /* under construction !*/
  1817. /* under construction !*/
  1818. /* under construction !*/
  1819. /* under construction !*/
  1820. /* under construction !*/
  1821. /* under construction !*/
  1822. /* under construction !*/
  1823. /* under construction !*/
  1824. /* under construction !*/
  1825. /* under construction !*/
  1826. /* under construction !*/
  1827. /* under construction !*/
  1828. /* under construction !*/
  1829. /* under construction !*/
  1830. /* under construction !*/
  1831. /* under construction !*/
  1832. /* under construction !*/
  1833. /* under construction !*/
  1834. /* under construction !*/
  1835. #endif /* 0 */ 
  1837.     if (audio_data_file != NULL)
  1838.     {
  1839.         fclose(audio_data_file);
  1840.     }
  1842.     if (output_data_file != NULL)
  1843.     {
  1844.         fclose(output_data_file);
  1845.     }
  1847.     return failure_flag;
  1848. }
  1850. /* 101205 audio resource Calvin End */
  1853. /*****************************************************************************
  1854.  * FUNCTION
  1855.  *  ClearHWIMageFile
  1856.  * DESCRIPTION
  1857.  *  Clear image file
  1858.  * PARAMETERS
  1859.  *  void
  1860.  * RETURNS
  1861.  *  void
  1862.  *****************************************************************************/
  1863. void ClearHWIMageFile()
  1864. {
  1865.     /*----------------------------------------------------------------*/
  1866.     /* Local Variables                                                */
  1867.     /*----------------------------------------------------------------*/
  1868.     FILE *fp;
  1870.     /*----------------------------------------------------------------*/
  1871.     /* Code Body                                                      */
  1872.     /*----------------------------------------------------------------*/
  1873.     fp = fopen(OUTPUT_DATA_FILENAME, "w+");
  1874.     if (fp)
  1875.     {
  1876.         fprintf(fp, "#if ( defined (MMI_ON_WIN32) || !defined (__MTK_TARGET__) )nt#define __align(x)n#endifn");
  1877.         fclose(fp);
  1878.     }
  1880.     /* __CUSTPACK_MULTIBIN Calvin BEGIN */
  1881.     fp = fopen(OUTPUT_DATA_FILENAME_EXT, "w+"); /* 040805 CustPack: Calvin added */
  1882.     /* __CUSTPACK_MULTIBIN Calvin END */
  1883.     if (fp)
  1884.     {
  1885.         fprintf(fp, "#if ( defined (MMI_ON_WIN32) || !defined (__MTK_TARGET__) )nt#define __align(x)n#endifn");
  1886.         fclose(fp);
  1887.     }
  1889.     /* 101205 audio resource Calvin Satrt */
  1890.     fp = fopen(AUDIO_OUTPUT_DATA_FILENAME, "w+");
  1891.     if (fp)
  1892.     {
  1893.         fprintf(fp, "#if ( defined (MMI_ON_WIN32) || !defined (__MTK_TARGET__) )nt#define __align(x)n#endifn");
  1894.         fclose(fp);
  1895.     }
  1897.     fp = fopen(AUDIO_OUTPUT_DATA_FILENAME_EXT, "w+");
  1898.     if (fp)
  1899.     {
  1900.         fprintf(fp, "#if ( defined (MMI_ON_WIN32) || !defined (__MTK_TARGET__) )nt#define __align(x)n#endifn");
  1901.         fclose(fp);
  1902.     }
  1903.     /* 101205 audio resource Calvin End */
  1904.     
  1905.     /* 100206 ENFB support Satrt */
  1906. #ifdef __MMI_RESOURCE_ENFB_SUPPORT__
  1907.     enfb_img_data_file = fopen(ENFB_IMAGE_DATA_FILENAME, "w+");
  1908.     if (enfb_img_data_file)
  1909.     {
  1910.         fclose(enfb_img_data_file);
  1911.     }
  1912.     enfb_img_data_file = fopen(ENFB_IMAGE_DATA_FILENAME, "ab");
  1913. #endif
  1914.     /* 100206 ENFB support End */
  1915. }
  1916. #endif /* DEVELOPER_BUILD_FIRST_PASS */ 
  1918. #if defined(CUSTOMIZATION_BUILD_FIRST_PASS) || defined(CUSTOMIZATION_BUILD_SECOND_PASS)
  1919. CURR_SCREEN_RESOURCE gsCurrScreenInfo;
  1920. extern CUSTOM_MENU nCustMenus[MAX_MENU_ITEMS];
  1921. extern U16 CurrMaxMenuItemIndex;
  1924. /*****************************************************************************
  1925.  * FUNCTION
  1926.  *  SetCurrentScreenStrings
  1927.  * DESCRIPTION
  1928.  *  SEt the current screen strings
  1929.  * PARAMETERS
  1930.  *  nNum        [IN]        ..
  1931.  * RETURNS
  1932.  *  void
  1933.  *****************************************************************************/
  1934. void SetCurrentScreenStrings(U16 nNum, ...)
  1935. {
  1936.     /*----------------------------------------------------------------*/
  1937.     /* Local Variables                                                */
  1938.     /*----------------------------------------------------------------*/
  1939.     U16 nId;
  1940.     U16 nCount = 0;
  1941.     va_list vlist;
  1943.     /*----------------------------------------------------------------*/
  1944.     /* Code Body                                                      */
  1945.     /*----------------------------------------------------------------*/
  1946.     va_start(vlist, nNum);
  1948.     gsCurrScreenInfo.nNoOfStrings = nNum;
  1950.     while (nNum > nCount)
  1951.     {
  1952.         nId = va_arg(vlist, U16);
  1953.         gsCurrScreenInfo.nStringIdList[nCount] = nId;
  1954.         ++nCount;
  1955.     }
  1956.     va_end(vlist);
  1957.     return;
  1958. }
  1961. /*****************************************************************************
  1962.  * FUNCTION
  1963.  *  SetCurrentScreenImages
  1964.  * DESCRIPTION
  1965.  *  SEt the current screen images
  1966.  * PARAMETERS
  1967.  *  nNum        [IN]        ..
  1968.  * RETURNS
  1969.  *  void
  1970.  *****************************************************************************/
  1971. void SetCurrentScreenImages(U16 nNum, ...)
  1972. {
  1973.     /*----------------------------------------------------------------*/
  1974.     /* Local Variables                                                */
  1975.     /*----------------------------------------------------------------*/
  1976.     U16 nId;
  1977.     U16 nCount = 0;
  1978.     va_list vlist;
  1980.     /*----------------------------------------------------------------*/
  1981.     /* Code Body                                                      */
  1982.     /*----------------------------------------------------------------*/
  1983.     va_start(vlist, nNum);
  1985.     gsCurrScreenInfo.nNoOfImages = nNum;
  1987.     while (nNum > nCount)
  1988.     {
  1989.         nId = va_arg(vlist, U16);
  1990.         gsCurrScreenInfo.nImageIdList[nCount] = nId;
  1991.         ++nCount;
  1992.     }
  1993.     va_end(vlist);
  1994.     return;
  1995. }
  1998. /*****************************************************************************
  1999.  * FUNCTION
  2000.  *  AppendCurrentScreenImages
  2001.  * DESCRIPTION
  2002.  *  SEt the current screen images
  2003.  * PARAMETERS
  2004.  *  nNum        [IN]        
  2005.  *  pList       [IN]        
  2006.  * RETURNS
  2007.  *  void
  2008.  *****************************************************************************/
  2009. void AppendCurrentScreenImages(int nNum, U16 *pList)
  2010. {
  2011.     /*----------------------------------------------------------------*/
  2012.     /* Local Variables                                                */
  2013.     /*----------------------------------------------------------------*/
  2014.     U16 nCount = 0;
  2015.     U16 i = 0;
  2016.     U8 flag = 0;
  2017.     U16 nOrgCount = gsCurrScreenInfo.nNoOfImages;
  2019.     /*----------------------------------------------------------------*/
  2020.     /* Code Body                                                      */
  2021.     /*----------------------------------------------------------------*/
  2022.     gsCurrScreenInfo.nNoOfImages = nNum + gsCurrScreenInfo.nNoOfImages;
  2024.     while (nNum > nCount)
  2025.     {
  2026.         flag = 0;
  2027.         //for(i = nOrgCount+1;i<(nOrgCount+nCount ) ;i++)
  2028.         //for(i = (nOrgCount+nCount);i>0 ;i--)
  2029.         for (i = 0; i < nCount; i++)
  2030.         {
  2031.             if (gsCurrScreenInfo.nImageIdList[i + nOrgCount] == pList[nCount])
  2032.             {
  2033.                 flag = 1;
  2034.                 break;
  2035.             }
  2036.         }
  2038.         if (flag == 0)
  2039.         {
  2040.             gsCurrScreenInfo.nImageIdList[nOrgCount + nCount] = pList[nCount];
  2041.         }
  2043.         ++nCount;
  2044.     }
  2045.     return;
  2046. }
  2049. /*****************************************************************************
  2050.  * FUNCTION
  2051.  *  AppendCurrentScreenStrings
  2052.  * DESCRIPTION
  2053.  *  SEt the current screen images
  2054.  * PARAMETERS
  2055.  *  nNum        [IN]        
  2056.  *  pList       [IN]        
  2057.  * RETURNS
  2058.  *  void
  2059.  *****************************************************************************/
  2060. void AppendCurrentScreenStrings(int nNum, U16 *pList)
  2061. {
  2062.     /*----------------------------------------------------------------*/
  2063.     /* Local Variables                                                */
  2064.     /*----------------------------------------------------------------*/
  2065.     U16 nCount = 0;
  2066.     U16 nOrgCount = gsCurrScreenInfo.nNoOfStrings;
  2068.     /*----------------------------------------------------------------*/
  2069.     /* Code Body                                                      */
  2070.     /*----------------------------------------------------------------*/
  2071.     gsCurrScreenInfo.nNoOfStrings = nNum + gsCurrScreenInfo.nNoOfStrings;
  2073.     while (nNum > nCount)
  2074.     {
  2075.         gsCurrScreenInfo.nStringIdList[nOrgCount + nCount] = pList[nCount];
  2076.         ++nCount;
  2077.     }
  2078.     return;
  2079. }
  2082. /*****************************************************************************
  2083.  * FUNCTION
  2084.  *  SetCurrentScreenMenus
  2085.  * DESCRIPTION
  2086.  *  SEt the current screen menus
  2087.  * PARAMETERS
  2088.  *  nNum        [IN]        ..
  2089.  * RETURNS
  2090.  *  void
  2091.  *****************************************************************************/
  2092. void SetCurrentScreenMenus(U16 nNum, ...)
  2093. {
  2094.     /*----------------------------------------------------------------*/
  2095.     /* Local Variables                                                */
  2096.     /*----------------------------------------------------------------*/
  2097.     U16 nId;
  2098.     U16 nCount = 0;
  2099.     U16 nParentIdCount = 0;
  2100.     va_list vlist;
  2102.     /*----------------------------------------------------------------*/
  2103.     /* Code Body                                                      */
  2104.     /*----------------------------------------------------------------*/
  2105.     va_start(vlist, nNum);
  2107.     gsCurrScreenInfo.nNoOfMenus = nNum;
  2109.     while (nNum > nCount)
  2110.     {
  2111.         nId = va_arg(vlist, U16);
  2112.         gsCurrScreenInfo.sMenuInfo[nCount].nId = nId;
  2113.         nParentIdCount = 0;
  2114.         while (nParentIdCount > CurrMaxMenuItemIndex)
  2115.         {
  2116.             if (nCustMenus[nParentIdCount].nMenuItemId == nId)
  2117.             {
  2118.                 gsCurrScreenInfo.sMenuInfo[nCount].nParentId = nCustMenus[nParentIdCount].nParentId;
  2119.                 break;
  2120.             }
  2121.             ++nParentIdCount;
  2122.         }
  2123.         ++nCount;
  2124.     }
  2125.     va_end(vlist);
  2126.     return;
  2127. }
  2129. #endif /* defined(CUSTOMIZATION_BUILD_FIRST_PASS) || defined(CUSTOMIZATION_BUILD_SECOND_PASS) */