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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
picturemsg.c
资源名称：SMRTRingToneConverter.rar　[点击查看]
上传用户：helaifa584
上传日期：2022-06-15
资源大小：29k
文件大小：58k
源码类别：

MTK

开发平台：

Objective-C

picturemsg.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  * pictruemsg.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  * PDG1
  45.  *
  46.  * Description:
  47.  * ------------
  48.  * This file implements Picture Message back end application.
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  * -------
  54.  *
  55.  *============================================================================
  56.  *             HISTORY
  57.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  58.  *------------------------------------------------------------------------------
  59.  */
  60. #include "MMI_include.h"
  62. #if defined(__MMI_SMART_MESSAGE_MT__) || (defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__))
  64. #ifndef _MMI_PICMSG_C
  65. #define _MMI_PICMSG_C
  67. // #ifdef __MMI_PICMSG__
  69. /*  Include: MMI header file */
  70. #include "picturemsg.h"
  71. #include "PicMsgApiToOthers.h"
  72. #include "CommonNSM.h"
  73. #include "ems.h"
  74. #include "customer_ps_inc.h"
  76. #include "smsguiinterfacetype.h"
  78. /*  Include: PS header file */
  79. /* ... Add More PS header */
  81. /* 
  82.  ************************* Define ****************************
  83.  */
  84. #define MODULUS                  241
  85. #define ONE_BYTE_SIZE            8
  86. #define MMI_EXTRA_BMP_HEADER_SIZE   6
  87. #define PIC_MSG_SIGNATURE        "0504158A"
  88. #define RING_TONE_MSG_SIGNATURE     "05041581"
  89. #define BMP_HEADER_SIZE          (sizeof(BmpFileHeader_sturct)-2)
  90. #define MAX_PIC_HIEGHT_PIXEL     32
  91. #define MAX_PIC_WIDTH_PIXEL         96 / ONE_BYTE_SIZE  /* We store 8 bits in one bytes */
  92. #define MAX_BMP_HDR_SIZE         64
  94. /* Start JP */
  95. #define     MAX_NSM_PIC_WIDTH    72
  96. #define     MAX_NSM_PIC_HEIGHT      28
  97. /* End JP */
  99. /* 
  100.  *************************** Typedef  *******************************
  101.  */
  102. typedef enum
  103. {
  104.     SMRT_NORMAL_SMS_0,
  105.     SMRT_PICTURE_SMS_1,
  106.     SMRT_RING_TONE_SMS_2
  107. } smrt_sms_type_enum;
  109. typedef enum
  110. {
  111.     PMSG_FIRST_FOUR_BITS = 1,
  112.     PMSG_SECOND_FOUR_BITS = 2
  113. } pmsg_bits_position_enum;
  115. /* 
  116.  *************** Function Declaration *****************************
  117.  */
  119. S16 mmi_smrt_message_type(U8 *SmsData);
  121. #if (0)
  122. /* under construction !*/
  123. /* under construction !*/
  124. #endif /* (0) */ 
  126. U8 *mmi_pmsg_convert_ota_to_bmp(U8 *otaData);
  127. U8 *mmi_pmsg_convert_bmp_to_ota(U8 *BmpBuffer);
  128. U8 mmi_pmsg_convert_ascii_hex_to_dec(S8 character);
  129. U8 mmi_pmsg_convert_binary_dec_to_hex(const U8 DecimalVal, U8 part);
  131. void mmi_pmsg_convert_ascii_hex_string_2_dec_string(U8 *DecStr, U8 *AsciiStr);
  132. void mmi_pmsg_convert_dec_string_2_ascii_hex_string(U8 *AsciiStr, U8 *DecStr);
  134. U8 *mmi_pmsg_create_ota_data(U8 *BinaryData, S16 H, S16 W);
  135. U8 *mmi_pmsg_create_bmp_data(void);
  136. void mmi_pmsg_set_default_values_bmp_header(void);
  137. S16 mmi_pmsg_read_picture_header(U8 *OtaPattern);
  138. S16 mmi_pmsg_read_bmp_data(U8 *RawData, U8 *BmpData, S16 *H, S16 *W);
  139. U16 mmi_pmsg_get_size_bmp_data(U8 *BmpData);
  140. U16 mmi_pmsg_get_size_ota_data(U8 *OtaBuffer);
  141. BOOL mmi_pmsg_is_smart_picture(U8 *BmpData);
  143. S16 mmi_pmsg_add_bmp_header_info(U8 *BmpData);
  144. U16 mmi_pmsg_add_picture_text(U8 *OtaData, U8 *TextBuffer);
  145. void mmi_pmsg_add_nokia_header(U8 *PictureMessage, U8 TotalSegment, U8 CurrentSegment);
  146. void mmi_pmsg_add_header(U8 *header, U16 HeaderLen, U8 *Data, U16 DataLen);
  148. void mmi_pmsg_shift_n_bytes(S8 *Data, S16 offset, S16 nBytes, S16 length);
  149. U8 mmi_pmsg_get_n_bits(U8 *Data, U16 Offset, U16 Bits);
  150. U8 mmi_pmsg_get_next_byte(void);
  151. void mmi_pmsg_fskip(FS_HANDLE fp, S16 num_bytes);
  153. S16 mmi_pmsg_string_search(S8 *Pattern, S8 *Text);
  154. S16 mmi_pmsg_hash(S8 *str);
  155. S16 mmi_pmsg_HashN(S8 *Str, S16 PatternLength);
  156. S16 mmi_pmsg_HashIncrement(S8 *str, S16 PrevIndex, S16 PrevHash, S16 PatternLength);
  158. /* 
  159.  ************************ Global Variables ****************************
  160.  */
  161. /* This is a BMP Header which strored the information of file */
  162. static BmpFileHeader_sturct g_pmsg_BmpHeader;
  164. /*  This var shall store the pointer of OTA data to retrieve the values */
  165. static U8 *OTAdata = NULL;
  167. /*  This var shall store the pointer index of OTA data to retrieve the values */
  168. static U16 g_pmsg_ota_index = 0;
  170. /* This var shall store the Text of Picture message and shall be used by Category screen to show the text */
  171. S8 g_pmsg_TextInMessage[MAX_PICTEXT_BUFF_SIZE + (TEXT_BUFF_PADDING)];
  173. /* This var shall store the Ota Picture len */
  174. static U16 gOtaDataLen = 0;
  176. #if (defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__))
  177. extern nsm_msg_struct g_nsm_msg_context;
  178. #endif 
  180. #if defined(__MMI_SMART_MESSAGE_MT__)
  181. #include "MessagesExDcl.h"
  182. extern nsm_picmsg_text_struct picmsg_text_struct;
  183. #endif /* defined(__MMI_SMART_MESSAGE_MT__) */ 
  184. /* 
  185.  ************************ Global Functions ****************************
  186.  */
  187. extern EMSData *GetEMSDataForView(EMSData **p, U8 force);
  189. /* 
  190.  ************************ Temp Var for testing and debugging the code ********
  191.  */
  192. // Assh..whole data.
  193. //S8  OTAdata[] = "0B0504158A000000030103013000000002010000481C01FF5C0151C104555FFFFEAA00278A00AAAFFFFF5C00001500155FFFBEB8000802002AAFFF7FD8005D04000557FFBFF800012800DAAFFF5FF0000E40001557FFBEF80000A0008AABFF5FD0000100001555FFAFF8000080000AABFF55D8000000000555FFAAB8800000000AAAFF557DC000001505557F0B0504158A00000003010302AAAAF80002EFA22AFF555C100015F554457FA0A80A802FA0AA22FF405801405500151474A028E880AA280280BE4015DC01557F00047EA029FE002AFFA802BE4015FF4055FFF4007C800BAC80AAACF800BE00101440151C14015D80A88800AB382800BA415841005110540155AAA82000A80B8000AA555801005415000150AAA80B0504158A000000030103030200A8000002A8";
  194. // Line S8  OTAdata[] = "00480E01803804020300C01800600C06030100400C002006020301806006001802010080C030010008030180C0600800C0060180C040300600600200C040201003003001806020301801801800802030100C00800C006030101806004006002018180C030060030018080C060100200000080C040301803000000606020100801000";
  195. // Chess Data.
  196. //S8  OTAdata[] = "0040400100FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FFFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF0000FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FFFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF0000FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FFFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF0000FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FFFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00";
  197. // PMT data.
  198. //S8  OTAdata[] = "00481C01FFFFFFFFFFFFFFFFFF000000FFFFFFFFFFFFFFFFFF000000FFFFFFFFFFFFFFFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF57FFAFFAFFFAFFFF000000FF59FFAF7AFFFAFFFF000000FF5E0FAEBAFFFAFFFF000000FF5FEFADDAFFFAFFFF000000FF5FEFADDAFFFAFFFF000000FF5FEFBBEEFFFAFFFF000000FF5F0FB7F6FFFAFFFF000000";
  199. // Function Spec data.
  200. //S8  OTAdata[] = "00480E01FFFFFFFFFFFFFFFFFF000000000000000000FFFFFFFFFFFFFFFFFF00000000000000000010F000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001";
  202. /*********************************************************************************
  203.  ************************* Funtion Definition Starts *****************************
  204.  *********************************************************************************/
  207. /*****************************************************************************
  208.  * FUNCTION
  209.  *  mmi_pmsg_set_default_values_bmp_header
  210.  * DESCRIPTION
  211.  *  Set default values in BMP Header.
  212.  * PARAMETERS
  213.  *  void
  214.  * RETURNS
  215.  *  void
  216.  *****************************************************************************/
  217. void mmi_pmsg_set_default_values_bmp_header(void)
  218. {
  219.     /*----------------------------------------------------------------*/
  220.     /* Local Variables                                                */
  221.     /*----------------------------------------------------------------*/
  223.     /*----------------------------------------------------------------*/
  224.     /* Code Body                                                      */
  225.     /*----------------------------------------------------------------*/
  226.     memset(&g_pmsg_BmpHeader, 0x00, BMP_HEADER_SIZE + 2);
  227.     g_pmsg_BmpHeader.BmpBMPFileHeader.Signature = (U16) 19778;
  228.     g_pmsg_BmpHeader.BmpBMPFileHeader.DataOffset = (U32) BMP_HEADER_SIZE;
  229.     g_pmsg_BmpHeader.BmpBMPInfoHeader.HeaderSize = (U32) 40;
  230.     g_pmsg_BmpHeader.BmpBMPInfoHeader.Bits = (U16) 1;
  231.     g_pmsg_BmpHeader.BmpBMPInfoHeader.Planes = (U16) 1;
  232.     g_pmsg_BmpHeader.BmpColors1.Blue = (U8) 255;
  233.     g_pmsg_BmpHeader.BmpColors1.Green = (U8) 255;
  234.     g_pmsg_BmpHeader.BmpColors1.Red = (U8) 255;
  235. }
  238. /*****************************************************************************
  239.  * FUNCTION
  240.  *  mmi_pmsg_convert_ota_to_bmp
  241.  * DESCRIPTION
  242.  *  Converter of OTA format to BMP format.
  243.  * PARAMETERS
  244.  *  Data        [?]     
  245.  *  S8 *, OTA data.(?)
  246.  * RETURNS
  247.  *  void
  248.  *****************************************************************************/
  249. U8 *mmi_pmsg_convert_ota_to_bmp(U8 *Data)
  250. {
  251.     /*----------------------------------------------------------------*/
  252.     /* Local Variables                                                */
  253.     /*----------------------------------------------------------------*/
  254.     S16 PictureHeaderLen = 0;
  256.     /*----------------------------------------------------------------*/
  257.     /* Code Body                                                      */
  258.     /*----------------------------------------------------------------*/
  259.     g_pmsg_ota_index = 0;
  261.     PictureHeaderLen = mmi_pmsg_read_picture_header(Data);
  263.     if (PictureHeaderLen == -1)
  264.     {
  265.         return NULL;
  266.     }
  268.     mmi_pmsg_shift_n_bytes((S8*) Data, 0, (S16) PictureHeaderLen, gOtaDataLen);        /* Remove the Picture Message Header */
  270.     OTAdata = Data;
  272.     mmi_pmsg_set_default_values_bmp_header();
  274.     return mmi_pmsg_create_bmp_data();
  275. }
  278. /*****************************************************************************
  279.  * FUNCTION
  280.  *  mmi_pmsg_convert_bmp_to_ota
  281.  * DESCRIPTION
  282.  *  Convets the BMP file format to OTA format
  283.  * PARAMETERS
  284.  *  BmpBuffer       [?]     
  285.  *  Bmp Buffer.(?)
  286.  * RETURNS
  287.  *  Pointer to OTA data.
  288.  *****************************************************************************/
  289. U8 *mmi_pmsg_convert_bmp_to_ota(U8 *BmpBuffer)
  290. {
  291.     /*----------------------------------------------------------------*/
  292.     /* Local Variables                                                */
  293.     /*----------------------------------------------------------------*/
  294.     S16 Hight = 0;
  295.     S16 Width = 0;
  297.     /* U8 BmpBinaryData[(PIC_BUFF_MAX_LEN)]; */
  298.     U8 *BmpBinaryData;
  299.     U8 *ptr_OtaData = NULL;
  300.     U8 *BmpDataPtr;
  302.     /*----------------------------------------------------------------*/
  303.     /* Code Body                                                      */
  304.     /*----------------------------------------------------------------*/
  305.     /* AshBmpDataHex */
  306.     BmpBinaryData = OslMalloc(PIC_BUFF_MAX_LEN);
  307.     BmpDataPtr = BmpBuffer + MMI_EXTRA_BMP_HEADER_SIZE; /* removed the MMI header information */
  309.     memset(BmpBinaryData, '', (PIC_BUFF_MAX_LEN));
  311.     if (mmi_pmsg_read_bmp_data(BmpBinaryData, BmpDataPtr, &Hight, &Width) != 0)
  312.     {
  313.         return NULL;
  314.     }
  316.     ptr_OtaData = mmi_pmsg_create_ota_data(BmpBinaryData, Hight, Width);
  317.     OslMfree(BmpBinaryData);
  318.     /* return mmi_pmsg_create_ota_data(BmpBinaryData, Hight,Width); */
  319.     return ptr_OtaData;
  320. }
  323. /*****************************************************************************
  324.  * FUNCTION
  325.  *  mmi_pmsg_read_bmp_data
  326.  * DESCRIPTION
  327.  *  Read the whole bits format of Bmp file.
  328.  * PARAMETERS
  329.  *  RawData     [?]     
  330.  *  BmpData     [?]     
  331.  *  H           [?]     
  332.  *  W           [?]     
  333.  *  File Name with Path of Bmp file and pointe of data to store picture data.(?)
  334.  * RETURNS
  335.  *  -1 if any error.
  336.  *****************************************************************************/
  337. S16 mmi_pmsg_read_bmp_data(U8 *RawData, U8 *BmpData, S16 *H, S16 *W)
  338. {
  339.     /*----------------------------------------------------------------*/
  340.     /* Local Variables                                                */
  341.     /*----------------------------------------------------------------*/
  342.     U8 RotatedData[MAX_PIC_HIEGHT_PIXEL][MAX_PIC_WIDTH_PIXEL];
  343.     S16 i = 0, j = 0;
  344.     S16 width = 0;
  345.     S16 height = 0;
  346.     S16 num_colors = 0;
  347.     S16 index = 0;
  348.     S16 x = 0;
  349.     BOOL complement_flag = FALSE;   /* JP for predefined NSM Pictures */
  351.     /*----------------------------------------------------------------*/
  352.     /* Code Body                                                      */
  353.     /*----------------------------------------------------------------*/
  354.     memset(RotatedData, '', MAX_PIC_HIEGHT_PIXEL * MAX_PIC_WIDTH_PIXEL);
  356.     /* check to see if it is a valid bitmap file */
  358.     if ((BmpData[index++] != 'B') || (BmpData[index++] != 'M'))
  359.     {
  360.         PRINT_INFORMATION("It is not a bitmap file.n");
  361.         return -1;
  362.     }
  364.     /* read in the width and height of the image, and the number of colors used; ignore the rest */
  365.     index += 16;
  367.     width = BmpData[index++];
  368.     width |= BmpData[index++] << ONE_BYTE_SIZE;
  370.     index += 2;
  372.     height = BmpData[index++];
  373.     height |= BmpData[index++] << ONE_BYTE_SIZE;
  375.     index += 22;
  377.     num_colors = BmpData[index++];
  378.     num_colors |= BmpData[index++] << ONE_BYTE_SIZE;
  380.     if (num_colors > 1)
  381.     {
  382.         PRINT_INFORMATION("It is a multi color bitmap file.n");
  383.         complement_flag = TRUE;
  384.         /* return -1; *//* JP commented for tracker issue 396 */
  385.     }
  387.     /* First Header end. */
  388.     index += 6;
  390.     /* Skip the color table */
  391.     index += 8;
  393.     if (width / ONE_BYTE_SIZE > 8)
  394.     {
  395.         j = 12;
  396.     }
  397.     else
  398.     {
  399.         j = 8;
  400.     }
  402.     for (x = 0; x < height; x++)
  403.     {
  404.         for (i = 0; i < j; i++)
  405.         {
  406.             /* 
  407.              * JP 20050629
  408.              * We have to complement Predfined NSM
  409.              * Picture data
  410.              */
  411.             if (complement_flag)
  412.             {
  413.                 RotatedData[x][i] = (~BmpData[index++]);
  414.             }
  415.             else
  416.             {
  417.                 RotatedData[x][i] = (BmpData[index++]);
  418.             }
  420.         }
  421.     }
  423.     index = 0;
  425.     for (i = x - 1; i >= 0; i--)
  426.     {
  427.         for (j = 0; j < width / ONE_BYTE_SIZE; j++)
  428.         {
  429.             RawData[index++] = RotatedData[i][j];
  430.         }
  431.     }
  433.     *H = height;
  434.     *W = width;
  436.     return 0;
  437. }
  440. /*****************************************************************************
  441.  * FUNCTION
  442.  *  mmi_pmsg_create_bmp_data
  443.  * DESCRIPTION
  444.  *  Prepared the BMP file format based on OTA data.
  445.  * PARAMETERS
  446.  *  void
  447.  * RETURNS
  448.  *  void
  449.  *****************************************************************************/
  450. U8 *mmi_pmsg_create_bmp_data()
  451. {
  452.     /*----------------------------------------------------------------*/
  453.     /* Local Variables                                                */
  454.     /*----------------------------------------------------------------*/
  455.     U8 BmpDataHeader[MAX_BMP_HDR_SIZE];
  456.     U8 RotatedData[MAX_PIC_HIEGHT_PIXEL][MAX_PIC_WIDTH_PIXEL];
  457.     U8 *BmpData = NULL;
  458.     S16 HeaderLen = 0;
  459.     S16 TotalSizeOfBmp = 0;
  460.     S16 index = 0;
  461.     S16 x = 0, i = 0, j = 0, k = 0;
  463.     /*----------------------------------------------------------------*/
  464.     /* Code Body                                                      */
  465.     /*----------------------------------------------------------------*/
  466.     memset(RotatedData, '', MAX_PIC_HIEGHT_PIXEL * MAX_PIC_WIDTH_PIXEL);
  467.     memset(BmpDataHeader, '', MAX_BMP_HDR_SIZE);
  469.     /* this is info field. */
  470.     mmi_pmsg_get_next_byte();
  472.     /* this is width field. */
  473.     g_pmsg_BmpHeader.BmpBMPInfoHeader.Width = (U32) mmi_pmsg_get_next_byte();
  475.     /* this is height field. */
  476.     g_pmsg_BmpHeader.BmpBMPInfoHeader.Height = (U32) mmi_pmsg_get_next_byte();
  478.     /* this is Depth field. */
  479.     mmi_pmsg_get_next_byte();
  481.     HeaderLen = (S16) g_pmsg_BmpHeader.BmpBMPInfoHeader.Width / ONE_BYTE_SIZE;
  483.     for (i = 0; i < gOtaDataLen; i++)
  484.     {
  485.         RotatedData[j][k] = mmi_pmsg_get_next_byte();
  486.         k++;
  487.         if (k >= HeaderLen)
  488.         {
  489.             k = 0;
  490.             j++;
  491.         }
  492.     }
  494.     if (HeaderLen > 8)
  495.     {
  496.         HeaderLen = 12;
  497.     }
  498.     else if (HeaderLen > 4)
  499.     {
  500.         HeaderLen = 8;
  501.     }
  502.     else
  503.     {
  504.         HeaderLen = 4;
  505.     }
  507.     /* Six extra bytes added for MMI support */
  508.     TotalSizeOfBmp = BMP_HEADER_SIZE + (HeaderLen * j) + MMI_EXTRA_BMP_HEADER_SIZE;
  510.     /* Put the real size of BMP */
  511.     g_pmsg_BmpHeader.BmpBMPFileHeader.FileSize = (U32) TotalSizeOfBmp - MMI_EXTRA_BMP_HEADER_SIZE;
  513.     memcpy(&BmpDataHeader, &g_pmsg_BmpHeader, BMP_HEADER_SIZE + 2);
  515.     BmpData = (U8*) OslMalloc(TotalSizeOfBmp);
  516.     /* memset((S8*)BmpData,'',TotalSizeOfBmp); */
  518.     BmpData[index++] = 0x1;
  519.     BmpData[index++] = 0x0;
  520.     BmpData[index++] = (U8) ((g_pmsg_BmpHeader.BmpBMPFileHeader.FileSize & 0x000000FF));
  521.     BmpData[index++] = (U8) ((g_pmsg_BmpHeader.BmpBMPFileHeader.FileSize & 0x0000FF00) >> 8);
  522.     BmpData[index++] = (U8) ((g_pmsg_BmpHeader.BmpBMPFileHeader.FileSize & 0x00FF0000) >> 16);
  523.     BmpData[index++] = (U8) ((g_pmsg_BmpHeader.BmpBMPFileHeader.FileSize & 0xFF000000) >> 24);
  525.     for (i = 0; i < BMP_HEADER_SIZE; i++)
  526.     {
  527.         BmpData[index++] = BmpDataHeader[i + 2];
  528.     }
  530.     for (i = j - 1; i >= 0; i--)
  531.     {
  532.         for (x = 0; x < HeaderLen; x++)
  533.         {
  534.             BmpData[index++] = RotatedData[i][x];
  535.         }
  536.     }
  538.     return (U8*) BmpData;
  539. }
  542. /*****************************************************************************
  543.  * FUNCTION
  544.  *  mmi_pmsg_get_next_byte
  545.  * DESCRIPTION
  546.  *  Combine the two Hex value
  547.  * PARAMETERS
  548.  *  void
  549.  * RETURNS
  550.  *  void
  551.  *****************************************************************************/
  552. U8 mmi_pmsg_get_next_byte(void)
  553. {
  554.     /*----------------------------------------------------------------*/
  555.     /* Local Variables                                                */
  556.     /*----------------------------------------------------------------*/
  557.     U8 value;
  559.     /*----------------------------------------------------------------*/
  560.     /* Code Body                                                      */
  561.     /*----------------------------------------------------------------*/
  562.     value = OTAdata[g_pmsg_ota_index];
  563.     g_pmsg_ota_index++;
  565.     return value;
  566. }
  569. /*****************************************************************************
  570.  * FUNCTION
  571.  *  mmi_pmsg_get_n_bits
  572.  * DESCRIPTION
  573.  *  Find out the required bits in given data.
  574.  * PARAMETERS
  575.  *  Data        [?]         Offset and req bits.
  576.  *  Offset      [IN]        
  577.  *  Bits        [IN]        
  578.  * RETURNS
  579.  *  Bits value.
  580.  *****************************************************************************/
  581. U8 mmi_pmsg_get_n_bits(U8 *Data, U16 Offset, U16 Bits)
  582. {
  583.     /*----------------------------------------------------------------*/
  584.     /* Local Variables                                                */
  585.     /*----------------------------------------------------------------*/
  586.     U16 index = Offset / ONE_BYTE_SIZE;
  587.     U8 BitsfromFirstIndex = ONE_BYTE_SIZE - (Offset % ONE_BYTE_SIZE);
  588.     U8 firstByte = Data[index];
  589.     U8 secondByte = Data[index + 1];
  590.     U8 result = 0;
  592.     /*----------------------------------------------------------------*/
  593.     /* Code Body                                                      */
  594.     /*----------------------------------------------------------------*/
  595.     if (Bits > ONE_BYTE_SIZE)
  596.     {
  597.         return 0;
  598.     }
  600.     result = (firstByte << (ONE_BYTE_SIZE - BitsfromFirstIndex)) | (secondByte >> BitsfromFirstIndex);
  602.     result = result >> (ONE_BYTE_SIZE - Bits);
  604.     return result;
  606. }
  609. /*****************************************************************************
  610.  * FUNCTION
  611.  *  mmi_pmsg_convert_ascii_hex_to_dec
  612.  * DESCRIPTION
  613.  *  Converts Ascii value to Decimal value
  614.  * PARAMETERS
  615.  *  character       [IN]        
  616.  *  S8 ascii values(?)
  617.  * RETURNS
  618.  *  U8 Decimal value.
  619.  *****************************************************************************/
  620. U8 mmi_pmsg_convert_ascii_hex_to_dec(S8 character)
  621. {
  622.     /*----------------------------------------------------------------*/
  623.     /* Local Variables                                                */
  624.     /*----------------------------------------------------------------*/
  626.     /*----------------------------------------------------------------*/
  627.     /* Code Body                                                      */
  628.     /*----------------------------------------------------------------*/
  629.     if (character > 47 && character < 58)   /* Digits 0..9 */
  630.     {
  631.         return (character - 48);
  632.     }
  633.     else if (character > 64 && character < 71)  /* Characters A..F */
  634.     {
  635.         return (character - 55);
  636.     }
  637.     else if (character > 96 && character < 103) /* Characters a..f */
  638.     {
  639.         return (character - 87);
  640.     }
  641.     else
  642.     {
  643.         return (0xFF);
  644.     }
  645. }
  648. /*****************************************************************************
  649.  * FUNCTION
  650.  *  mmi_pmsg_convert_binary_dec_to_hex
  651.  * DESCRIPTION
  652.  *  Converts Binary value to Hex value.
  653.  * PARAMETERS
  654.  *  DecimalVal      [IN]        
  655.  *  part            [IN]        Which says about first byte or second byte data needed.
  656.  * RETURNS
  657.  *  U8 Hex value.
  658.  *****************************************************************************/
  659. U8 mmi_pmsg_convert_binary_dec_to_hex(const U8 DecimalVal, U8 part)
  660. {
  661.     /*----------------------------------------------------------------*/
  662.     /* Local Variables                                                */
  663.     /*----------------------------------------------------------------*/
  664.     U8 Firstpart = 0xf0 & DecimalVal;
  665.     U8 Secondpart = 0xf & DecimalVal;
  666.     U8 ReturnVal = 0;
  668.     /*----------------------------------------------------------------*/
  669.     /* Code Body                                                      */
  670.     /*----------------------------------------------------------------*/
  671.     Firstpart >>= 4;
  673.     ReturnVal = Secondpart;
  674.     if (part == PMSG_FIRST_FOUR_BITS)
  675.     {
  676.         ReturnVal = Firstpart;
  677.     }
  679.     if (ReturnVal < 10)
  680.     {
  681.         ReturnVal += 48;
  682.     }
  683.     else
  684.     {
  685.         ReturnVal += 55;
  686.     }
  688.     return ReturnVal;
  689. }
  692. /*****************************************************************************
  693.  * FUNCTION
  694.  *  mmi_pmsg_fskip
  695.  * DESCRIPTION
  696.  *  Skip the file pointer of num bytes.
  697.  * PARAMETERS
  698.  *  fp              [IN]        
  699.  *  num_bytes       [IN]        
  700.  *  file pointer and skip times.(?)
  701.  * RETURNS
  702.  *  void
  703.  *****************************************************************************/
  704. void mmi_pmsg_fskip(FS_HANDLE fp, S16 num_bytes)
  705. {
  706.     /*----------------------------------------------------------------*/
  707.     /* Local Variables                                                */
  708.     /*----------------------------------------------------------------*/
  709.     U32 errorCode = 0;
  710.     S8 Data[64];
  711.     U32 read_len = 0;
  713.     /*----------------------------------------------------------------*/
  714.     /* Code Body                                                      */
  715.     /*----------------------------------------------------------------*/
  716.     FS_Read( fp, (void*)Data, num_bytes, &read_len);
  717. }
  720. /*****************************************************************************
  721.  * FUNCTION
  722.  *  mmi_pmsg_create_ota_data
  723.  * DESCRIPTION
  724.  *  Creates OTA file.
  725.  * PARAMETERS
  726.  *  BinaryData      [?]         
  727.  *  H               [IN]        
  728.  *  W               [IN]        
  729.  *  Pointer to OTA data,Pointer of binary data, Hieght and width.(?)
  730.  * RETURNS
  731.  *  void
  732.  *****************************************************************************/
  733. U8 *mmi_pmsg_create_ota_data(U8 *BinaryData, S16 H, S16 W)
  734. {
  735.     /*----------------------------------------------------------------*/
  736.     /* Local Variables                                                */
  737.     /*----------------------------------------------------------------*/
  738.     S16 i = 0;
  739.     S16 index = 0;
  740.     U8 *OtaData = NULL;
  741.     U16 DataSize = (H * W / ONE_BYTE_SIZE) + 4; /* infofield, width, height, and depth */
  743.     /*----------------------------------------------------------------*/
  744.     /* Code Body                                                      */
  745.     /*----------------------------------------------------------------*/
  746.     gOtaDataLen = DataSize;
  747.     OtaData = (U8*) OslMalloc(MAX_DATA_SIZE);
  748.     memset(OtaData, '', MAX_DATA_SIZE);
  750.     /* Put OTA tyep field */
  751.     OtaData[index++] = 0x02;
  753.     /* Put OTA Size field */
  754.     OtaData[index++] = (U8) ((DataSize & 0xff00) >> ONE_BYTE_SIZE);
  755.     OtaData[index++] = (U8) (DataSize & 0x00ff);
  757.     /* Put Info field */
  758.     OtaData[index++] = 0x00;
  760.     /* Put width */
  761.     OtaData[index++] = (U8) W;
  763.     /* Put Hieght */
  764.     OtaData[index++] = (U8) H;
  766.     /* Put Color */
  767.     OtaData[index++] = 0x01;
  769.     /* Put Data */
  770.     for (i = 0; i < W * H / ONE_BYTE_SIZE; i++)
  771.     {
  772.         OtaData[index++] = BinaryData[i];
  773.     }
  775.     return OtaData;
  776. }
  779. /*****************************************************************************
  780.  * FUNCTION
  781.  *  mmi_pmsg_string_search
  782.  * DESCRIPTION
  783.  *  This algorithm uses hashing to implement string searching in linear time.
  784.  * PARAMETERS
  785.  *  Pattern     [?]     
  786.  *  Text        [?]     In which pattern is to be search.
  787.  * RETURNS
  788.  *  if success then starting location of pattern else -1 if pattern not found.
  789.  *****************************************************************************/
  790. S16 mmi_pmsg_string_search(S8 *Pattern, S8 *Text)
  791. {
  792.     /*----------------------------------------------------------------*/
  793.     /* Local Variables                                                */
  794.     /*----------------------------------------------------------------*/
  795.     S16 num_iteration = 0;
  796.     S16 PatternLength = 0;
  797.     S16 PatternHash = 0;
  798.     S16 TextHash = 0;
  799.     S16 i = 0;
  801.     /*----------------------------------------------------------------*/
  802.     /* Code Body                                                      */
  803.     /*----------------------------------------------------------------*/
  804.     if (Pattern == NULL || Text == NULL)
  805.     {
  806.         return -1;
  807.     }
  808.     else
  809.     {
  811.         PatternLength = strlen((S8*) Pattern);
  812.         num_iteration = strlen((S8*) Text) - PatternLength + 1;
  814.         /* Find initial hash values for Pattern and Text */
  815.         /* These are called FINGERPRINT */
  816.         PatternHash = mmi_pmsg_hash(Pattern);
  817.         TextHash = mmi_pmsg_HashN(Text, PatternLength);
  819.         for (i = 0; i < num_iteration; i++)
  820.         {
  821.             if ((PatternHash == TextHash) && !(strncmp(Pattern, (Text + i), PatternLength)))
  822.             {
  823.                 return i;
  824.             }
  825.             TextHash = mmi_pmsg_HashIncrement(Text, i, TextHash, PatternLength);
  826.         }
  827.     }
  829.     return -1;
  830. }
  833. /*****************************************************************************
  834.  * FUNCTION
  835.  *  mmi_pmsg_hash
  836.  * DESCRIPTION
  837.  *  Calculate the hash of given string.
  838.  * PARAMETERS
  839.  *  str     [?]     
  840.  *  Pointer to given string.(?)
  841.  * RETURNS
  842.  *  Hash value.
  843.  *****************************************************************************/
  844. S16 mmi_pmsg_hash(S8 *str)
  845. {
  846.     /*----------------------------------------------------------------*/
  847.     /* Local Variables                                                */
  848.     /*----------------------------------------------------------------*/
  849.     S16 sum = 0;
  851.     /*----------------------------------------------------------------*/
  852.     /* Code Body                                                      */
  853.     /*----------------------------------------------------------------*/
  854.     for (; *str; str++)
  855.     {
  856.         sum += *str;
  857.     }
  859.     return sum % MODULUS;
  860. }
  863. /*****************************************************************************
  864.  * FUNCTION
  865.  *  mmi_pmsg_HashN
  866.  * DESCRIPTION
  867.  *  Calculate the hash value of given number of bytes.
  868.  * PARAMETERS
  869.  *  Str                 [?]         
  870.  *  PatternLength       [IN]        
  871.  *  Pointer to Data, Length of Pattern which hash value to be needed.(?)
  872.  * RETURNS
  873.  *  Calculated hash value.
  874.  *****************************************************************************/
  875. S16 mmi_pmsg_HashN(S8 *Str, S16 PatternLength)
  876. {
  877.     /*----------------------------------------------------------------*/
  878.     /* Local Variables                                                */
  879.     /*----------------------------------------------------------------*/
  880.     S8 ch = Str[PatternLength];
  881.     S16 HashValue;
  883.     /*----------------------------------------------------------------*/
  884.     /* Code Body                                                      */
  885.     /*----------------------------------------------------------------*/
  886.     Str[PatternLength] = '';
  887.     HashValue = mmi_pmsg_hash(Str);
  888.     Str[PatternLength] = ch;
  890.     return HashValue;
  891. }
  894. /*****************************************************************************
  895.  * FUNCTION
  896.  *  mmi_pmsg_HashIncrement
  897.  * DESCRIPTION
  898.  *  Increment the hash values by removing previous value and adding next value.
  899.  * PARAMETERS
  900.  *  str                 [?]         
  901.  *  PrevIndex           [IN]        
  902.  *  PrevHash            [IN]        
  903.  *  PatternLength       [IN]        
  904.  *  Pointer to given String, Previous Index, Previous hash value, Pattern Length.(?)
  905.  * RETURNS
  906.  *  New hash value.
  907.  *****************************************************************************/
  908. S16 mmi_pmsg_HashIncrement(S8 *str, S16 PrevIndex, S16 PrevHash, S16 PatternLength)
  909. {
  910.     /*----------------------------------------------------------------*/
  911.     /* Local Variables                                                */
  912.     /*----------------------------------------------------------------*/
  913.     S16 val;
  915.     /*----------------------------------------------------------------*/
  916.     /* Code Body                                                      */
  917.     /*----------------------------------------------------------------*/
  918.     val = (PrevHash - (S16) str[PrevIndex]) + (str[PrevIndex + PatternLength]);
  920.     return val < 0 ? val + MODULUS : val % MODULUS;
  921. }
  924. /*****************************************************************************
  925.  * FUNCTION
  926.  *  mmi_pmsg_shift_n_bytes
  927.  * DESCRIPTION
  928.  *  Remove the specified N byte from the given Data and shift the whole values.
  929.  * PARAMETERS
  930.  *  Data        [?]         Location from Data to be removed, Number of byte to be removed.
  931.  *  offset      [IN]        
  932.  *  nBytes      [IN]        
  933.  *  length      [IN]        
  934.  * RETURNS
  935.  *  void
  936.  *****************************************************************************/
  937. void mmi_pmsg_shift_n_bytes(S8 *Data, S16 offset, S16 nBytes, S16 length)
  938. {
  939.     /*----------------------------------------------------------------*/
  940.     /* Local Variables                                                */
  941.     /*----------------------------------------------------------------*/
  942.     S16 index = offset, j = 0;
  943.     S8 *DataPtr = Data + offset + nBytes;
  944.     S16 len = length;
  946.     /*----------------------------------------------------------------*/
  947.     /* Code Body                                                      */
  948.     /*----------------------------------------------------------------*/
  949.     while (len > 0)
  950.     {
  951.         Data[index++] = *DataPtr++;
  952.         len--;
  953.     }
  955.     for (j = 0; j < nBytes; j++)
  956.     {
  957.         Data[index++] = '';
  958.     }
  960. }
  963. /*****************************************************************************
  964.  * FUNCTION
  965.  *  mmi_pmsg_add_header
  966.  * DESCRIPTION
  967.  *  Add the Header into given data. ( Data must be big enought to add header buffer)
  968.  * PARAMETERS
  969.  *  header          [?]         
  970.  *  HeaderLen       [IN]        
  971.  *  Data            [?]         & Data Size.
  972.  *  DataLen         [IN]        
  973.  * RETURNS
  974.  *  void
  975.  *****************************************************************************/
  976. void mmi_pmsg_add_header(U8 *header, U16 HeaderLen, U8 *Data, U16 DataLen)
  977. {
  978.     /*----------------------------------------------------------------*/
  979.     /* Local Variables                                                */
  980.     /*----------------------------------------------------------------*/
  981.     U8 *DataBackUp = NULL;
  982.     U16 i = 0, j = 0;
  984.     /*----------------------------------------------------------------*/
  985.     /* Code Body                                                      */
  986.     /*----------------------------------------------------------------*/
  987.     DataBackUp = (U8*) OslMalloc(DataLen + HeaderLen + 4);
  988.     memset(DataBackUp, 0x00, (DataLen + HeaderLen + 4));
  990.     while (j < HeaderLen)
  991.     {
  992.         DataBackUp[i++] = header[j];
  993.         j++;
  994.     }
  996.     j = 0;
  997.     while (j < DataLen)
  998.     {
  999.         DataBackUp[i++] = Data[j];
  1000.         j++;
  1001.     }
  1003.     memset(Data, 0x00, i + 1);
  1005.     j = 0;
  1006.     while (j < i)
  1007.     {
  1008.         Data[j] = DataBackUp[j];
  1009.         j++;
  1010.     }
  1011.     OslMfree(DataBackUp);
  1012. }
  1015. /*****************************************************************************
  1016.  * FUNCTION
  1017.  *  mmi_pmsg_read_picture_header
  1018.  * DESCRIPTION
  1019.  *  Read the Picture Header information and put the checks.
  1020.  * PARAMETERS
  1021.  *  OtaPattern      [?]     
  1022.  *  Pointer to OtaData.(?)
  1023.  * RETURNS
  1024.  *  If error return -1 else len of picture message header.
  1025.  *****************************************************************************/
  1026. S16 mmi_pmsg_read_picture_header(U8 *OtaPattern)
  1027. {
  1028.     /*----------------------------------------------------------------*/
  1029.     /* Local Variables                                                */
  1030.     /*----------------------------------------------------------------*/
  1031.     U8 RecvVal = 0;
  1032.     U16 index = 0;
  1033.     S16 i = 0;
  1034.     U16 OtaDataLen = 0;
  1036.     /* S8 tempTextBuffer[MAX_PICTEXT_BUFF_SIZE+(TEXT_BUFF_PADDING)]; */
  1037.     S8 *tempTextBuffer = NULL;
  1038.     U16 charType = 0;
  1039.     EMSData *pEms;
  1040.     U16 EmsDataLen = 0;
  1041.     U8 missSegStr[] = EMS_MISS_SEG_DELIMIT_STR;
  1042.     U16 missSegStrLen = strlen((const char*)missSegStr);
  1044.     /*----------------------------------------------------------------*/
  1045.     /* Code Body                                                      */
  1046.     /*----------------------------------------------------------------*/
  1047.     GetEMSDataForView(&pEms, 0);
  1048.     EmsDataLen = pEms->textLength / 2;
  1049.     memset(g_pmsg_TextInMessage, '', MAX_PICTEXT_BUFF_SIZE + (TEXT_BUFF_PADDING));
  1051.     /* Version Information */
  1052.     RecvVal = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1053.     index += ONE_BYTE_SIZE;
  1055.     if (RecvVal != 48)
  1056.     {
  1057.         return -1;
  1058.     }
  1060.     /* Type */
  1061.     RecvVal = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1062.     index += ONE_BYTE_SIZE;
  1063.     charType = RecvVal;
  1065.     if (RecvVal == 0 || RecvVal == 1)   /* Message Text */
  1066.     {
  1067.         /* Item Len */
  1068.         OtaDataLen = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1069.         index += ONE_BYTE_SIZE;
  1071.         RecvVal = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1072.         index += ONE_BYTE_SIZE;
  1074.         OtaDataLen <<= ONE_BYTE_SIZE;
  1075.         OtaDataLen = OtaDataLen | RecvVal;
  1077.         /* tempTextBuffer = OslMalloc((MAX_PICTEXT_BUFF_SIZE+TEXT_BUFF_PADDING)); */
  1078.         tempTextBuffer = OslMalloc((OtaDataLen) + TEXT_BUFF_PADDING);
  1080.         /* memset(tempTextBuffer, '',(MAX_PICTEXT_BUFF_SIZE+TEXT_BUFF_PADDING)); */
  1081.         memset(tempTextBuffer, '', ((OtaDataLen) + TEXT_BUFF_PADDING));
  1083.         /* Read the Text */
  1084.         for (i = 0; i < OtaDataLen; i++)
  1085.         {
  1086.             tempTextBuffer[i] = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1087.             index += ONE_BYTE_SIZE;
  1088.         }
  1090.         if (charType == 0)
  1091.         {
  1092.             mmi_asc_to_ucs2((S8*) g_pmsg_TextInMessage, (S8*) tempTextBuffer);
  1093.         }
  1094.         else
  1095.         {
  1096.             /* For Unicode character : JP */
  1097.             {
  1098.                 S32 count = 0;
  1099.                 U8 temp = 0;
  1101.                 while (count < OtaDataLen)
  1102.                 {
  1103.                     temp = tempTextBuffer[count];
  1104.                     tempTextBuffer[count] = tempTextBuffer[count + 1];
  1105.                     tempTextBuffer[count + 1] = temp;
  1106.                     count = count + 2;
  1107.                 }
  1109.                 mmi_ucs2cpy((S8*) g_pmsg_TextInMessage, (S8*) (tempTextBuffer));
  1110.             }
  1111.         }
  1112.         OslMfree(tempTextBuffer);
  1114.         /* Read the OTA bitmat type : 02 */
  1115.         RecvVal = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1116.         index += ONE_BYTE_SIZE;
  1118.         if (RecvVal != 2)
  1119.         {
  1120.             return -1;
  1121.         }
  1122.     }
  1123.     else if (RecvVal == 2)
  1124.     {
  1125.         /* There is not text part in message */
  1126.     }
  1127.     else
  1128.     {
  1129.         return -1;
  1130.     }
  1132.     OtaDataLen = 0;
  1134.     /* Read the len of OTA data */
  1135.     OtaDataLen = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1136.     index += ONE_BYTE_SIZE;
  1138.     RecvVal = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1139.     index += ONE_BYTE_SIZE;
  1141.     OtaDataLen <<= ONE_BYTE_SIZE;
  1142.     gOtaDataLen = OtaDataLen | RecvVal;
  1144.     /* Incomplete message content */
  1145.     if (((EmsDataLen - (index / ONE_BYTE_SIZE)) < gOtaDataLen) ||
  1146.         !strncmp((const char*)(OtaPattern + (EmsDataLen - missSegStrLen)), (const char*)missSegStr, missSegStrLen))
  1147.     {
  1148.         return -1;
  1149.     }
  1151.     return (index / ONE_BYTE_SIZE);
  1152. }
  1155. /*****************************************************************************
  1156.  * FUNCTION
  1157.  *  mmi_smrt_message_type
  1158.  * DESCRIPTION
  1159.  *  Find Out the type of Message.
  1160.  * PARAMETERS
  1161.  *  SmsData     [?]     
  1162.  *  Pointer to SMS data.(?)
  1163.  * RETURNS
  1164.  *  TYPE of SMS ( Normal, Picture or Ring Tone)
  1165.  *****************************************************************************/
  1166. S16 mmi_smrt_message_type(U8 *SmsData)
  1167. {
  1168.     /*----------------------------------------------------------------*/
  1169.     /* Local Variables                                                */
  1170.     /*----------------------------------------------------------------*/
  1171.     S16 IsFindPattern = -1;
  1173.     /*----------------------------------------------------------------*/
  1174.     /* Code Body                                                      */
  1175.     /*----------------------------------------------------------------*/
  1176.     /* search the picture message signature */
  1177.     IsFindPattern = mmi_pmsg_string_search((S8*) PIC_MSG_SIGNATURE, (S8*) SmsData);
  1178.     if (IsFindPattern >= 0)
  1179.     {
  1180.         return SMRT_PICTURE_SMS_1;
  1181.     }
  1183.     /* search the ring tone message signature */
  1184.     IsFindPattern = mmi_pmsg_string_search((S8*) RING_TONE_MSG_SIGNATURE, (S8*) SmsData);
  1185.     if (IsFindPattern >= 0)
  1186.     {
  1187.         return SMRT_RING_TONE_SMS_2;
  1188.     }
  1190.     /* search the ring tone message signature */
  1191.     IsFindPattern = mmi_pmsg_string_search((S8*) RING_TONE_MELODY_SIGNATURE, (S8*) SmsData);
  1192.     if (IsFindPattern >= 0)
  1193.     {
  1194.         return SMRT_RING_TONE_SMS_2;
  1195.     }
  1197.     /* It is neither Picture massage nor Rong tone */
  1198.     return SMRT_NORMAL_SMS_0;
  1199. }
  1201. #if (0)
  1202. /* under construction !*/
  1203. /* under construction !*/
  1204. /* under construction !*/
  1205. /* under construction !*/
  1206. /* under construction !*/
  1207. /* under construction !*/
  1208. /* under construction !*/
  1209. /* under construction !*/
  1210. /* under construction !*/
  1211. /* under construction !*/
  1212. /* under construction !*/
  1213. /* under construction !*/
  1214. /* under construction !*/
  1215. /* under construction !*/
  1216. /* under construction !*/
  1217. /* under construction !*/
  1218. /* under construction !*/
  1219. /* under construction !*/
  1220. /* under construction !*/
  1221. /* under construction !*/
  1222. /* under construction !*/
  1223. /* under construction !*/
  1224. /* under construction !*/
  1225. /* under construction !*/
  1226. /* under construction !*/
  1227. /* under construction !*/
  1228. /* under construction !*/
  1229. /* under construction !*/
  1230. /* under construction !*/
  1231. /* under construction !*/
  1232. /* under construction !*/
  1233. /* under construction !*/
  1234. /* under construction !*/
  1235. /* under construction !*/
  1236. /* under construction !*/
  1237. /* under construction !*/
  1238. /* under construction !*/
  1239. /* under construction !*/
  1240. /* under construction !*/
  1241. /* under construction !*/
  1242. /* under construction !*/
  1243. /* under construction !*/
  1244. /* under construction !*/
  1245. /* under construction !*/
  1246. /* under construction !*/
  1247. /* under construction !*/
  1248. /* under construction !*/
  1249. /* under construction !*/
  1250. /* under construction !*/
  1251. /* under construction !*/
  1252. /* under construction !*/
  1253. /* under construction !*/
  1254. /* under construction !*/
  1255. /* under construction !*/
  1256. /* under construction !*/
  1257. /* under construction !*/
  1258. /* under construction !*/
  1259. /* under construction !*/
  1260. /* under construction !*/
  1261. /* under construction !*/
  1262. /* under construction !*/
  1263. /* under construction !*/
  1264. /* under construction !*/
  1265. /* under construction !*/
  1266. /* under construction !*/
  1267. /* under construction !*/
  1268. /* under construction !*/
  1269. /* under construction !*/
  1270. /* under construction !*/
  1271. /* under construction !*/
  1272. /* under construction !*/
  1273. /* under construction !*/
  1274. /* under construction !*/
  1275. /* under construction !*/
  1276. /* under construction !*/
  1277. /* under construction !*/
  1278. /* under construction !*/
  1279. /* under construction !*/
  1280. /* under construction !*/
  1281. /* under construction !*/
  1282. #endif /* (0) */ 
  1285. /*****************************************************************************
  1286.  * FUNCTION
  1287.  *  mmi_pmsg_add_picture_text
  1288.  * DESCRIPTION
  1289.  *  Prepared the Picture message format and add the picture text.
  1290.  * PARAMETERS
  1291.  *  OtaData         [?]     
  1292.  *  TextBuffer      [?]     
  1293.  *  OTA data & text buffer.(?)
  1294.  * RETURNS
  1295.  *  Length of OTA data with header.
  1296.  *****************************************************************************/
  1297. U16 mmi_pmsg_add_picture_text(U8 *OtaData, U8 *TextBuffer)
  1298. {
  1299.     /*----------------------------------------------------------------*/
  1300.     /* Local Variables                                                */
  1301.     /*----------------------------------------------------------------*/
  1302.     U16 TextLen;                    /* = (mmi_ucs2strlen((S8*)TextBuffer)*2); */
  1303.     U16 DataLen = gOtaDataLen + 3;  /* type (02 for OTA-bitmap), length ( 2 bytes) */
  1305.     /* U8  OtaText[MAX_PICTEXT_BUFF_SIZE+TEXT_BUFF_PADDING]; */
  1306.     U8 *OtaText = NULL;
  1307.     U16 index = 0, i = 0;
  1309.     /*----------------------------------------------------------------*/
  1310.     /* Code Body                                                      */
  1311.     /*----------------------------------------------------------------*/
  1312.     OtaText = OslMalloc((MAX_PICTEXT_BUFF_SIZE + TEXT_BUFF_PADDING));
  1313.     memset(OtaText, 0x00, MAX_PICTEXT_BUFF_SIZE + TEXT_BUFF_PADDING);
  1315.     /* Version */
  1316.     OtaText[index++] = 0x30;
  1318. #if (defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__))
  1320.     if (g_nsm_msg_context.UCS2_count > 0)
  1321.     {
  1322.         /* text type */
  1323.         OtaText[index++] = 0x01;
  1324.         TextLen = (mmi_ucs2strlen((S8*) TextBuffer) * 2); /* JP */
  1325.     }
  1326.     else
  1327.     {
  1328.         /* text type */
  1329.         OtaText[index++] = 0x00;
  1330.         TextLen = strlen((S8*) TextBuffer); /* JP */
  1331.     }
  1333. #elif defined(__MMI_SMART_MESSAGE_MT__)
  1335.     if (picmsg_text_struct.ucs2_count > 0)
  1336.     {
  1337.         /* text type */
  1338.         OtaText[index++] = 0x01;
  1339.         TextLen = (mmi_ucs2strlen((S8*) TextBuffer) * 2); /* JP */
  1340.     }
  1341.     else
  1342.     {
  1343.         /* text type */
  1344.         OtaText[index++] = 0x00;
  1345.         TextLen = strlen((S8*) TextBuffer); /* JP */
  1346.     }
  1347. #endif 
  1349.     /* text length */
  1350.     OtaText[index++] = (U8) ((TextLen & 0xff00) >> ONE_BYTE_SIZE);
  1351.     OtaText[index++] = (U8) (TextLen & 0x00ff);
  1353. #if defined(__MMI_SMART_MESSAGE_MT__)
  1354.     if (picmsg_text_struct.ucs2_count > 0)
  1355.     {
  1356. #elif (defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__))
  1357.     if (g_nsm_msg_context.UCS2_count > 0)
  1358.     {
  1359. #endif 
  1360.         /* For Unicode text : Reverse bytes order for Nokia chinese problem */
  1361.         {
  1362.             U8 temp1 = 0;
  1363.             U8 temp2 = 0;
  1364.             U8 temparr[3] = {0, 0, 0};
  1365.             U16 count = 0;
  1367.             while (i < TextLen)
  1368.             {
  1369.                 temp1 = TextBuffer[i];
  1370.                 i++;
  1371.                 temp2 = TextBuffer[i];
  1372.                 i++;
  1373.                 temparr[0] = temp2;
  1374.                 temparr[1] = temp1;
  1375.                 for (count = 0; count < 2; count++)
  1376.                 {
  1377.                     OtaText[index++] = (U8) temparr[count];
  1378.                 }
  1380.                 /* Reset all temp variables */
  1381.                 temp1 = 0;
  1382.                 temp2 = 0;
  1383.                 memset(temparr, 0x00, sizeof(temparr));
  1384.             }
  1385.         }
  1386.     }
  1387.     else
  1388.     {
  1389.         /* Only ascii text : DO not change bytes order */
  1390.         while (i < TextLen)
  1391.         {
  1392.             OtaText[index++] = (U8) TextBuffer[i];
  1393.             i++;
  1394.         }
  1395.     }
  1397.     mmi_pmsg_add_header(OtaText, index, OtaData, DataLen);
  1398.     OslMfree(OtaText);
  1400.     return (U16) (index + DataLen);
  1401. }
  1404. /*****************************************************************************
  1405.  * FUNCTION
  1406.  *  mmi_pmsg_add_nokia_header
  1407.  * DESCRIPTION
  1408.  *  Prefix the Nokia Header on given Picture Message.
  1409.  * PARAMETERS
  1410.  *  PictureMessage      [?]         
  1411.  *  TotalSegment        [IN]        
  1412.  *  CurrentSegment      [IN]        
  1413.  *  OTA data ,Total Part & Part of Header (first, second or third ..)(?)
  1414.  * RETURNS
  1415.  *  void
  1416.  *****************************************************************************/
  1417. void mmi_pmsg_add_nokia_header(U8 *PictureMessage, U8 TotalSegment, U8 CurrentSegment)
  1418. {
  1419.     /*----------------------------------------------------------------*/
  1420.     /* Local Variables                                                */
  1421.     /*----------------------------------------------------------------*/
  1422.     const S16 NokiaTotalSegmentLocation = 21;
  1423.     const S16 NokiaCurrectSegmentLocation = 23;
  1424.     const S16 NokiaHeaderSize = 24;
  1425.     const S16 NokiaMaxSegments = 4;
  1427.     U8 NokiaHeader[MAX_NOKIA_HEADER_SIZE];
  1428.     U8 SegmentNumber[] = { '0', '1', '2', '3', '4' };
  1429.     U16 DataSize = strlen((S8*) PictureMessage);
  1431.     /*----------------------------------------------------------------*/
  1432.     /* Code Body                                                      */
  1433.     /*----------------------------------------------------------------*/
  1434.     if ((PictureMessage == NULL)
  1435.         || (TotalSegment > NokiaMaxSegments) || (CurrentSegment > NokiaMaxSegments) || (DataSize > 296))
  1436.     {
  1437.         return;
  1438.     }
  1440.     memset(NokiaHeader, 0x00, MAX_NOKIA_HEADER_SIZE);
  1442.     strcpy((S8*) NokiaHeader, (S8*) "0B0504158A00000003010301");
  1444.     NokiaHeader[NokiaTotalSegmentLocation] = SegmentNumber[TotalSegment];
  1446.     NokiaHeader[NokiaCurrectSegmentLocation] = SegmentNumber[CurrentSegment];
  1448.     mmi_pmsg_add_header(NokiaHeader, NokiaHeaderSize, PictureMessage, DataSize);
  1449. }
  1452. /*****************************************************************************
  1453.  * FUNCTION
  1454.  *  mmi_pmsg_convert_ascii_hex_string_2_dec_string
  1455.  * DESCRIPTION
  1456.  *  Convert the ascii string into Decimal string.
  1457.  * PARAMETERS
  1458.  *  DecStr          [?]     
  1459.  *  AsciiStr        [?]     
  1460.  *  Pointer to Dec string & Pointer to Ascii string.Ascii len must be even number.(?)
  1461.  * RETURNS
  1462.  *  void
  1463.  *****************************************************************************/
  1464. void mmi_pmsg_convert_ascii_hex_string_2_dec_string(U8 *DecStr, U8 *AsciiStr)
  1465. {
  1466.     /*----------------------------------------------------------------*/
  1467.     /* Local Variables                                                */
  1468.     /*----------------------------------------------------------------*/
  1469.     U8 *AsciiStrPtr = AsciiStr;
  1470.     U8 *DecStrPtr = DecStr;
  1471.     U8 FirstVal = 0;
  1472.     U8 SecondVal = 0;
  1474.     /*----------------------------------------------------------------*/
  1475.     /* Code Body                                                      */
  1476.     /*----------------------------------------------------------------*/
  1477.     if (AsciiStrPtr == NULL)
  1478.     {
  1479.         return;
  1480.     }
  1482.     while (*AsciiStrPtr != '')
  1483.     {
  1484.         FirstVal = mmi_pmsg_convert_ascii_hex_to_dec(*AsciiStrPtr++);
  1485.         SecondVal = mmi_pmsg_convert_ascii_hex_to_dec(*AsciiStrPtr++);
  1486.         *DecStrPtr++ = ((FirstVal << 4) | (SecondVal));
  1487.     }
  1488. }
  1491. /*****************************************************************************
  1492.  * FUNCTION
  1493.  *  mmi_pmsg_convert_dec_string_2_ascii_hex_string
  1494.  * DESCRIPTION
  1495.  *  Convert the Decimal string into ascii string.
  1496.  * PARAMETERS
  1497.  *  AsciiStr        [?]     
  1498.  *  DecStr          [?]     
  1499.  *  Pointer to Ascii string & Pointer to Dec string. Ascii string len must be double of Dec string.(?)
  1500.  * RETURNS
  1501.  *  void
  1502.  *****************************************************************************/
  1503. void mmi_pmsg_convert_dec_string_2_ascii_hex_string(U8 *AsciiStr, U8 *DecStr)
  1504. {
  1505.     /*----------------------------------------------------------------*/
  1506.     /* Local Variables                                                */
  1507.     /*----------------------------------------------------------------*/
  1508.     U8 *AsciiStrPtr = AsciiStr;
  1509.     U8 *DecStrPtr = DecStr;
  1511.     /*----------------------------------------------------------------*/
  1512.     /* Code Body                                                      */
  1513.     /*----------------------------------------------------------------*/
  1514.     if (DecStrPtr == NULL)
  1515.     {
  1516.         return;
  1517.     }
  1519.     while (*DecStrPtr != '')
  1520.     {
  1521.         *AsciiStrPtr++ = mmi_pmsg_convert_binary_dec_to_hex(*DecStrPtr, PMSG_FIRST_FOUR_BITS);
  1522.         *AsciiStrPtr++ = mmi_pmsg_convert_binary_dec_to_hex(*DecStrPtr, PMSG_SECOND_FOUR_BITS);
  1523.         DecStrPtr++;
  1524.     }
  1525. }
  1528. /*****************************************************************************
  1529.  * FUNCTION
  1530.  *  mmi_pmsg_get_size_bmp_data
  1531.  * DESCRIPTION
  1532.  *  This fun find out the real size of Bmp data.
  1533.  * PARAMETERS
  1534.  *  BmpData     [?]     
  1535.  *  Pointer of BMP data MMI format.(?)
  1536.  * RETURNS
  1537.  *  Size of Bmp file.
  1538.  *****************************************************************************/
  1539. U16 mmi_pmsg_get_size_bmp_data(U8 *BmpData)
  1540. {
  1541.     /*----------------------------------------------------------------*/
  1542.     /* Local Variables                                                */
  1543.     /*----------------------------------------------------------------*/
  1544.     U16 BmpDataSize = 0;
  1545.     S16 index = 2;
  1546.     U16 val[4];
  1548.     /*----------------------------------------------------------------*/
  1549.     /* Code Body                                                      */
  1550.     /*----------------------------------------------------------------*/
  1551.     val[0] = (U16) BmpData[index++];
  1552.     val[1] = (U16) BmpData[index++];
  1553.     val[2] = (U16) BmpData[index++];
  1554.     val[3] = (U16) BmpData[index++];
  1556.     BmpDataSize = (U16) (val[3] << 24 | val[2] << 16 | val[1] << 8 | val[0]);
  1558.     return (BmpDataSize + MMI_EXTRA_BMP_HEADER_SIZE);
  1559. }
  1562. /*****************************************************************************
  1563.  * FUNCTION
  1564.  *  mmi_pmsg_get_size_ota_data
  1565.  * DESCRIPTION
  1566.  *  This fun find out the real size of Ota Picture data.
  1567.  * PARAMETERS
  1568.  *  OtaBuffer       [?]     
  1569.  *  Pointer of Ota data .(?)
  1570.  * RETURNS
  1571.  *  Size of Ota Data.
  1572.  *****************************************************************************/
  1573. U16 mmi_pmsg_get_size_ota_data(U8 *OtaBuffer)
  1574. {
  1575.     /*----------------------------------------------------------------*/
  1576.     /* Local Variables                                                */
  1577.     /*----------------------------------------------------------------*/
  1578.     S16 OtaHeaderLen = 0;
  1580.     /*----------------------------------------------------------------*/
  1581.     /* Code Body                                                      */
  1582.     /*----------------------------------------------------------------*/
  1583.     OtaHeaderLen = mmi_pmsg_read_picture_header(OtaBuffer);
  1585.     if (OtaHeaderLen == -1)
  1586.     {
  1587.         return 0;
  1588.     }
  1590.     return (U16) (gOtaDataLen + OtaHeaderLen) * 2 + 8;
  1592. }
  1595. /*****************************************************************************
  1596.  * FUNCTION
  1597.  *  mmi_pmsg_add_bmp_header_info
  1598.  * DESCRIPTION
  1599.  *  This fun added the BMP extra header info to show the Picture in UI.Prepared MMI format.
  1600.  * PARAMETERS
  1601.  *  BmpData     [?]     
  1602.  *  Pointer of BMP data .(?)
  1603.  * RETURNS
  1604.  *  void
  1605.  *****************************************************************************/
  1606. S16 mmi_pmsg_add_bmp_header_info(U8 *BmpData)
  1607. {
  1608.     /*----------------------------------------------------------------*/
  1609.     /* Local Variables                                                */
  1610.     /*----------------------------------------------------------------*/
  1611.     S8 HeaderInfo[16];
  1612.     U16 BmpDataSize = 0;
  1613.     U16 index = 0;
  1615.     /*----------------------------------------------------------------*/
  1616.     /* Code Body                                                      */
  1617.     /*----------------------------------------------------------------*/
  1618.     if (mmi_pmsg_is_smart_picture(BmpData) == FALSE)
  1619.     {
  1620.         return -1;
  1621.     }
  1623.     memset(HeaderInfo, 0x00, 16);
  1625.     BmpDataSize = ((BmpData[2]) | (BmpData[3] << 8) | (BmpData[4] << 16) | (BmpData[5] << 24));
  1626.     HeaderInfo[index++] = 0x1;
  1627.     HeaderInfo[index++] = 0x0;
  1628.     HeaderInfo[index++] = (S8) ((BmpDataSize & 0x000000FF));
  1629.     HeaderInfo[index++] = (S8) ((BmpDataSize & 0x0000FF00) >> 8);
  1630.     HeaderInfo[index++] = (S8) ((BmpDataSize & 0x00FF0000) >> 16);
  1631.     HeaderInfo[index++] = (S8) ((BmpDataSize & 0xFF000000) >> 24);
  1633.     mmi_pmsg_add_header((U8*) HeaderInfo, index, (U8*) BmpData, BmpDataSize);
  1635.     return 0;
  1636. }
  1639. /*****************************************************************************
  1640.  * FUNCTION
  1641.  *  mmi_pmsg_is_smart_picture
  1642.  * DESCRIPTION
  1643.  *  
  1644.  * PARAMETERS
  1645.  *  BmpData     [?]     
  1646.  * RETURNS
  1647.  *  
  1648.  *****************************************************************************/
  1649. BOOL mmi_pmsg_is_smart_picture(U8 *BmpData)
  1650. {
  1651.     /*----------------------------------------------------------------*/
  1652.     /* Local Variables                                                */
  1653.     /*----------------------------------------------------------------*/
  1654.     S16 index = 0, num_colors = 0;
  1655.     U8 height;
  1656.     U8 width;
  1658.     /*----------------------------------------------------------------*/
  1659.     /* Code Body                                                      */
  1660.     /*----------------------------------------------------------------*/
  1661.     if ((BmpData[index++] != 'B') || (BmpData[index++] != 'M'))
  1662.     {
  1663.         PRINT_INFORMATION("It is not a bitmap file.n");
  1664.         return FALSE;
  1665.     }
  1667.     /* Start : JP check of height and width NSM picture */
  1668.     index += 16;    /* Hack */
  1670.     width = BmpData[index];
  1672.     if ((width > MAX_NSM_PIC_WIDTH) || (width == 0))    /* Width is greater then 72 */
  1673.     {
  1674.         return FALSE;
  1675.     }
  1677.     index += 4; /* Hack */
  1678.     height = BmpData[index];
  1680.     if ((height > MAX_NSM_PIC_HEIGHT) || (height == 0)) /* Height is greater then 72 */
  1681.     {
  1682.         return FALSE;
  1683.     }
  1684.     /* index += 40; */
  1685.     /* End : JP check of height and width NSM picture */
  1686.     index += 20;
  1688.     num_colors = BmpData[index++];
  1689.     num_colors |= BmpData[index++] << ONE_BYTE_SIZE;
  1691.     if (num_colors > 1)
  1692.     {
  1693.         PRINT_INFORMATION("It is a multi color bitmap file.n");
  1694.         num_colors = 1; /* JP for tracker issue 20050628 */
  1695.         /* return FALSE; */
  1696.     }
  1697.     return TRUE;
  1698. }
  1699. #endif /* _MMI_PICMSG_C */ /* if include picmsg_c */
  1700. #endif /* defined(__MMI_SMART_MESSAGE_MT__) || (defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__)) */