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

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

MTK

开发平台：

C/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_features.h"
  61. #include "StdC.h"
  62. #include "L4Dr1.h"
  64. #if defined(__MMI_SMART_MESSAGE_MT__) || (defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__))
  66. #ifndef _MMI_PICMSG_C
  67. #define _MMI_PICMSG_C
  69. // #ifdef __MMI_PICMSG__
  71. /*  Include: MMI header file */
  72. #include "PixtelDataTypes.h"
  73. #include "DebugInitDef.h"
  74. #include "picturemsg.h"
  75. #include "PicMsgApiToOthers.h"
  76. #include "CommonNSM.h"
  77. #include "FileSystemDef.h"
  78. #include "ems.h"
  79. #include "customer_ps_inc.h"
  81. #include "smsguiinterfacetype.h"
  83. /*  Include: PS header file */
  84. /* ... Add More PS header */
  86. /* 
  87.  ************************* Define ****************************
  88.  */
  89. #define MODULUS                  241
  90. #define ONE_BYTE_SIZE            8
  91. #define MMI_EXTRA_BMP_HEADER_SIZE   6
  92. #define PIC_MSG_SIGNATURE        "0504158A"
  93. #define RING_TONE_MSG_SIGNATURE     "05041581"
  94. #define BMP_HEADER_SIZE          (sizeof(BmpFileHeader_sturct)-2)
  95. #define MAX_PIC_HIEGHT_PIXEL     32
  96. #define MAX_PIC_WIDTH_PIXEL         96 / ONE_BYTE_SIZE  /* We store 8 bits in one bytes */
  97. #define MAX_BMP_HDR_SIZE         64
  99. /* Start JP */
  100. #define     MAX_NSM_PIC_WIDTH    72
  101. #define     MAX_NSM_PIC_HEIGHT      28
  102. /* End JP */
  104. /* 
  105.  *************************** Typedef  *******************************
  106.  */
  107. typedef enum
  108. {
  109.     SMRT_NORMAL_SMS_0,
  110.     SMRT_PICTURE_SMS_1,
  111.     SMRT_RING_TONE_SMS_2
  112. } smrt_sms_type_enum;
  114. typedef enum
  115. {
  116.     PMSG_FIRST_FOUR_BITS = 1,
  117.     PMSG_SECOND_FOUR_BITS = 2
  118. } pmsg_bits_position_enum;
  120. /* 
  121.  *************** Function Declaration *****************************
  122.  */
  124. S16 mmi_smrt_message_type(U8 *SmsData);
  126. #if (0)
  127. /* under construction !*/
  128. /* under construction !*/
  129. #endif /* (0) */ 
  131. U8 *mmi_pmsg_convert_ota_to_bmp(U8 *otaData);
  132. U8 *mmi_pmsg_convert_bmp_to_ota(U8 *BmpBuffer);
  133. U8 mmi_pmsg_convert_ascii_hex_to_dec(S8 character);
  134. U8 mmi_pmsg_convert_binary_dec_to_hex(const U8 DecimalVal, U8 part);
  136. void mmi_pmsg_convert_ascii_hex_string_2_dec_string(U8 *DecStr, U8 *AsciiStr);
  137. void mmi_pmsg_convert_dec_string_2_ascii_hex_string(U8 *AsciiStr, U8 *DecStr);
  139. U8 *mmi_pmsg_create_ota_data(U8 *BinaryData, S16 H, S16 W);
  140. U8 *mmi_pmsg_create_bmp_data(void);
  141. void mmi_pmsg_set_default_values_bmp_header(void);
  142. S16 mmi_pmsg_read_picture_header(U8 *OtaPattern);
  143. S16 mmi_pmsg_read_bmp_data(U8 *RawData, U8 *BmpData, S16 *H, S16 *W);
  144. U16 mmi_pmsg_get_size_bmp_data(U8 *BmpData);
  145. U16 mmi_pmsg_get_size_ota_data(U8 *OtaBuffer);
  146. BOOL mmi_pmsg_is_smart_picture(U8 *BmpData);
  148. S16 mmi_pmsg_add_bmp_header_info(U8 *BmpData);
  149. U16 mmi_pmsg_add_picture_text(U8 *OtaData, U8 *TextBuffer);
  150. void mmi_pmsg_add_nokia_header(U8 *PictureMessage, U8 TotalSegment, U8 CurrentSegment);
  151. void mmi_pmsg_add_header(U8 *header, U16 HeaderLen, U8 *Data, U16 DataLen);
  153. void mmi_pmsg_shift_n_bytes(S8 *Data, S16 offset, S16 nBytes, S16 length);
  154. U8 mmi_pmsg_get_n_bits(U8 *Data, U16 Offset, U16 Bits);
  155. U8 mmi_pmsg_get_next_byte(void);
  156. void mmi_pmsg_fskip(FILE_HANDLE fp, S16 num_bytes);
  158. S16 mmi_pmsg_string_search(S8 *Pattern, S8 *Text);
  159. S16 mmi_pmsg_hash(S8 *str);
  160. S16 mmi_pmsg_HashN(S8 *Str, S16 PatternLength);
  161. S16 mmi_pmsg_HashIncrement(S8 *str, S16 PrevIndex, S16 PrevHash, S16 PatternLength);
  163. /* 
  164.  ************************ Global Variables ****************************
  165.  */
  166. /* This is a BMP Header which strored the information of file */
  167. static BmpFileHeader_sturct g_pmsg_BmpHeader;
  169. /*  This var shall store the pointer of OTA data to retrieve the values */
  170. static U8 *OTAdata = NULL;
  172. /*  This var shall store the pointer index of OTA data to retrieve the values */
  173. static U16 g_pmsg_ota_index = 0;
  175. /* This var shall store the Text of Picture message and shall be used by Category screen to show the text */
  176. S8 g_pmsg_TextInMessage[MAX_PICTEXT_BUFF_SIZE + (TEXT_BUFF_PADDING)];
  178. /* This var shall store the Ota Picture len */
  179. static U16 gOtaDataLen = 0;
  181. #if (defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__))
  182. extern nsm_msg_struct g_nsm_msg_context;
  183. #endif 
  185. #if defined(__MMI_SMART_MESSAGE_MT__)
  186. #include "MessagesExDcl.h"
  187. extern nsm_picmsg_text_struct picmsg_text_struct;
  188. #endif /* defined(__MMI_SMART_MESSAGE_MT__) */ 
  189. /* 
  190.  ************************ Global Functions ****************************
  191.  */
  192. extern EMSData *GetEMSDataForView(EMSData **p, U8 force);
  194. /* 
  195.  ************************ Temp Var for testing and debugging the code ********
  196.  */
  197. // Assh..whole data.
  198. //S8  OTAdata[] = "0B0504158A000000030103013000000002010000481C01FF5C0151C104555FFFFEAA00278A00AAAFFFFF5C00001500155FFFBEB8000802002AAFFF7FD8005D04000557FFBFF800012800DAAFFF5FF0000E40001557FFBEF80000A0008AABFF5FD0000100001555FFAFF8000080000AABFF55D8000000000555FFAAB8800000000AAAFF557DC000001505557F0B0504158A00000003010302AAAAF80002EFA22AFF555C100015F554457FA0A80A802FA0AA22FF405801405500151474A028E880AA280280BE4015DC01557F00047EA029FE002AFFA802BE4015FF4055FFF4007C800BAC80AAACF800BE00101440151C14015D80A88800AB382800BA415841005110540155AAA82000A80B8000AA555801005415000150AAA80B0504158A000000030103030200A8000002A8";
  199. // Line S8  OTAdata[] = "00480E01803804020300C01800600C06030100400C002006020301806006001802010080C030010008030180C0600800C0060180C040300600600200C040201003003001806020301801801800802030100C00800C006030101806004006002018180C030060030018080C060100200000080C040301803000000606020100801000";
  200. // Chess Data.
  201. //S8  OTAdata[] = "0040400100FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FFFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF0000FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FFFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF0000FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FFFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF0000FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FFFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00";
  202. // PMT data.
  203. //S8  OTAdata[] = "00481C01FFFFFFFFFFFFFFFFFF000000FFFFFFFFFFFFFFFFFF000000FFFFFFFFFFFFFFFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF5FFFAFFAFFFAFFFF000000FF57FFAFFAFFFAFFFF000000FF59FFAF7AFFFAFFFF000000FF5E0FAEBAFFFAFFFF000000FF5FEFADDAFFFAFFFF000000FF5FEFADDAFFFAFFFF000000FF5FEFBBEEFFFAFFFF000000FF5F0FB7F6FFFAFFFF000000";
  204. // Function Spec data.
  205. //S8  OTAdata[] = "00480E01FFFFFFFFFFFFFFFFFF000000000000000000FFFFFFFFFFFFFFFFFF00000000000000000010F000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001";
  207. #if defined (MMI_ON_WIN32)
  208. U8 AshBmpDataHex[500] = 
  209. {
  210.     0x01, 0x00, 0x8E, 0x01, 0x00, 0x00,
  211.     0x42, 0x4D, 0x8E, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x28, 0x00,
  212.     0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
  213.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  214.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8,
  215.     0x02, 0x00, 0xA8, 0x00, 0x00, 0x02, 0xA8, 0x00, 0x00, 0x00, 0x55, 0x58, 0x01, 0x00, 0x54, 0x15,
  216.     0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0x20, 0x00, 0xA8, 0x0B, 0x80, 0x00, 0xAA, 0x00,
  217.     0x00, 0x00, 0x41, 0x58, 0x41, 0x00, 0x51, 0x10, 0x54, 0x01, 0x55, 0x00, 0x00, 0x00, 0x80, 0xA8,
  218.     0x88, 0x00, 0xAB, 0x38, 0x28, 0x00, 0xBA, 0x00, 0x00, 0x00, 0x00, 0x10, 0x14, 0x40, 0x15, 0x1C,
  219.     0x14, 0x01, 0x5D, 0x00, 0x00, 0x00, 0x80, 0x0B, 0xAC, 0x80, 0xAA, 0xAC, 0xF8, 0x00, 0xBE, 0x00,
  220.     0x00, 0x00, 0x40, 0x15, 0xFF, 0x40, 0x55, 0xFF, 0xF4, 0x00, 0x7C, 0x00, 0x00, 0x00, 0xA0, 0x29,
  221.     0xFE, 0x00, 0x2A, 0xFF, 0xA8, 0x02, 0xBE, 0x00, 0x00, 0x00, 0x40, 0x15, 0xDC, 0x01, 0x55, 0x7F,
  222.     0x00, 0x04, 0x7E, 0x00, 0x00, 0x00, 0xA0, 0x28, 0xE8, 0x80, 0xAA, 0x28, 0x02, 0x80, 0xBE, 0x00,
  223.     0x00, 0x00, 0x40, 0x58, 0x01, 0x40, 0x55, 0x00, 0x15, 0x14, 0x74, 0x00, 0x00, 0x00, 0xA0, 0xA8,
  224.     0x0A, 0x80, 0x2F, 0xA0, 0xAA, 0x22, 0xFF, 0x00, 0x00, 0x00, 0x55, 0x5C, 0x10, 0x00, 0x15, 0xF5,
  225.     0x54, 0x45, 0x7F, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xF8, 0x00, 0x02, 0xEF, 0xA2, 0x2A, 0xFF, 0x00,
  226.     0x00, 0x00, 0x55, 0x7D, 0xC0, 0x00, 0x00, 0x15, 0x05, 0x55, 0x7F, 0x00, 0x00, 0x00, 0xAA, 0xB8,
  227.     0x80, 0x00, 0x00, 0x00, 0x0A, 0xAA, 0xFF, 0x00, 0x00, 0x00, 0x55, 0xD8, 0x00, 0x00, 0x00, 0x00,
  228.     0x05, 0x55, 0xFF, 0x00, 0x00, 0x00, 0xAF, 0xF8, 0x00, 0x00, 0x80, 0x00, 0x0A, 0xAB, 0xFF, 0x00,
  229.     0x00, 0x00, 0x5F, 0xD0, 0x00, 0x01, 0x00, 0x00, 0x15, 0x55, 0xFF, 0x00, 0x00, 0x00, 0xBE, 0xF8,
  230.     0x00, 0x00, 0xA0, 0x00, 0x8A, 0xAB, 0xFF, 0x00, 0x00, 0x00, 0x5F, 0xF0, 0x00, 0x0E, 0x40, 0x00,
  231.     0x15, 0x57, 0xFF, 0x00, 0x00, 0x00, 0xBF, 0xF8, 0x00, 0x01, 0x28, 0x00, 0xDA, 0xAF, 0xFF, 0x00,
  232.     0x00, 0x00, 0x7F, 0xD8, 0x00, 0x5D, 0x04, 0x00, 0x05, 0x57, 0xFF, 0x00, 0x00, 0x00, 0xBE, 0xB8,
  233.     0x00, 0x08, 0x02, 0x00, 0x2A, 0xAF, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x5C, 0x00, 0x00, 0x15, 0x00,
  234.     0x15, 0x5F, 0xFF, 0x00, 0x00, 0x00, 0xFE, 0xAA, 0x00, 0x27, 0x8A, 0x00, 0xAA, 0xAF, 0xFF, 0x00,
  235.     0x00, 0x00, 0xFF, 0x5C, 0x01, 0x51, 0xC1, 0x04, 0x55, 0x5F, 0xFF, 0x00, 0x00, 0x00
  236. };
  238. #endif /* defined (MMI_ON_WIN32) */ 
  240. /*********************************************************************************
  241.  ************************* Funtion Definition Starts *****************************
  242.  *********************************************************************************/
  245. /*****************************************************************************
  246.  * FUNCTION
  247.  *  mmi_pmsg_set_default_values_bmp_header
  248.  * DESCRIPTION
  249.  *  Set default values in BMP Header.
  250.  * PARAMETERS
  251.  *  void
  252.  * RETURNS
  253.  *  void
  254.  *****************************************************************************/
  255. void mmi_pmsg_set_default_values_bmp_header(void)
  256. {
  257.     /*----------------------------------------------------------------*/
  258.     /* Local Variables                                                */
  259.     /*----------------------------------------------------------------*/
  261.     /*----------------------------------------------------------------*/
  262.     /* Code Body                                                      */
  263.     /*----------------------------------------------------------------*/
  264.     memset(&g_pmsg_BmpHeader, 0x00, BMP_HEADER_SIZE + 2);
  265.     g_pmsg_BmpHeader.BmpBMPFileHeader.Signature = (U16) 19778;
  266.     g_pmsg_BmpHeader.BmpBMPFileHeader.DataOffset = (U32) BMP_HEADER_SIZE;
  267.     g_pmsg_BmpHeader.BmpBMPInfoHeader.HeaderSize = (U32) 40;
  268.     g_pmsg_BmpHeader.BmpBMPInfoHeader.Bits = (U16) 1;
  269.     g_pmsg_BmpHeader.BmpBMPInfoHeader.Planes = (U16) 1;
  270.     g_pmsg_BmpHeader.BmpColors1.Blue = (U8) 255;
  271.     g_pmsg_BmpHeader.BmpColors1.Green = (U8) 255;
  272.     g_pmsg_BmpHeader.BmpColors1.Red = (U8) 255;
  273. }
  276. /*****************************************************************************
  277.  * FUNCTION
  278.  *  mmi_pmsg_convert_ota_to_bmp
  279.  * DESCRIPTION
  280.  *  Converter of OTA format to BMP format.
  281.  * PARAMETERS
  282.  *  Data        [?]     
  283.  *  S8 *, OTA data.(?)
  284.  * RETURNS
  285.  *  void
  286.  *****************************************************************************/
  287. U8 *mmi_pmsg_convert_ota_to_bmp(U8 *Data)
  288. {
  289.     /*----------------------------------------------------------------*/
  290.     /* Local Variables                                                */
  291.     /*----------------------------------------------------------------*/
  292.     S16 PictureHeaderLen = 0;
  294.     /*----------------------------------------------------------------*/
  295.     /* Code Body                                                      */
  296.     /*----------------------------------------------------------------*/
  297.     g_pmsg_ota_index = 0;
  299.     PictureHeaderLen = mmi_pmsg_read_picture_header(Data);
  301.     if (PictureHeaderLen == -1)
  302.     {
  303.         return NULL;
  304.     }
  306.     mmi_pmsg_shift_n_bytes((S8*) Data, 0, (S16) PictureHeaderLen, gOtaDataLen);        /* Remove the Picture Message Header */
  308.     OTAdata = Data;
  310.     mmi_pmsg_set_default_values_bmp_header();
  312.     return mmi_pmsg_create_bmp_data();
  313. }
  316. /*****************************************************************************
  317.  * FUNCTION
  318.  *  mmi_pmsg_convert_bmp_to_ota
  319.  * DESCRIPTION
  320.  *  Convets the BMP file format to OTA format
  321.  * PARAMETERS
  322.  *  BmpBuffer       [?]     
  323.  *  Bmp Buffer.(?)
  324.  * RETURNS
  325.  *  Pointer to OTA data.
  326.  *****************************************************************************/
  327. U8 *mmi_pmsg_convert_bmp_to_ota(U8 *BmpBuffer)
  328. {
  329.     /*----------------------------------------------------------------*/
  330.     /* Local Variables                                                */
  331.     /*----------------------------------------------------------------*/
  332.     S16 Hight = 0;
  333.     S16 Width = 0;
  335.     /* U8 BmpBinaryData[(PIC_BUFF_MAX_LEN)]; */
  336.     U8 *BmpBinaryData;
  337.     U8 *ptr_OtaData = NULL;
  338.     U8 *BmpDataPtr;
  340.     /*----------------------------------------------------------------*/
  341.     /* Code Body                                                      */
  342.     /*----------------------------------------------------------------*/
  343.     /* AshBmpDataHex */
  344.     BmpBinaryData = OslMalloc(PIC_BUFF_MAX_LEN);
  345.     BmpDataPtr = BmpBuffer + MMI_EXTRA_BMP_HEADER_SIZE; /* removed the MMI header information */
  347.     memset(BmpBinaryData, '', (PIC_BUFF_MAX_LEN));
  349.     if (mmi_pmsg_read_bmp_data(BmpBinaryData, BmpDataPtr, &Hight, &Width) != 0)
  350.     {
  351.         return NULL;
  352.     }
  354.     ptr_OtaData = mmi_pmsg_create_ota_data(BmpBinaryData, Hight, Width);
  355.     OslMfree(BmpBinaryData);
  356.     /* return mmi_pmsg_create_ota_data(BmpBinaryData, Hight,Width); */
  357.     return ptr_OtaData;
  358. }
  361. /*****************************************************************************
  362.  * FUNCTION
  363.  *  mmi_pmsg_read_bmp_data
  364.  * DESCRIPTION
  365.  *  Read the whole bits format of Bmp file.
  366.  * PARAMETERS
  367.  *  RawData     [?]     
  368.  *  BmpData     [?]     
  369.  *  H           [?]     
  370.  *  W           [?]     
  371.  *  File Name with Path of Bmp file and pointe of data to store picture data.(?)
  372.  * RETURNS
  373.  *  -1 if any error.
  374.  *****************************************************************************/
  375. S16 mmi_pmsg_read_bmp_data(U8 *RawData, U8 *BmpData, S16 *H, S16 *W)
  376. {
  377.     /*----------------------------------------------------------------*/
  378.     /* Local Variables                                                */
  379.     /*----------------------------------------------------------------*/
  380.     U8 RotatedData[MAX_PIC_HIEGHT_PIXEL][MAX_PIC_WIDTH_PIXEL];
  381.     S16 i = 0, j = 0;
  382.     S16 width = 0;
  383.     S16 height = 0;
  384.     S16 num_colors = 0;
  385.     S16 index = 0;
  386.     S16 x = 0;
  387.     BOOL complement_flag = FALSE;   /* JP for predefined NSM Pictures */
  389.     /*----------------------------------------------------------------*/
  390.     /* Code Body                                                      */
  391.     /*----------------------------------------------------------------*/
  392.     memset(RotatedData, '', MAX_PIC_HIEGHT_PIXEL * MAX_PIC_WIDTH_PIXEL);
  394.     /* check to see if it is a valid bitmap file */
  396.     if ((BmpData[index++] != 'B') || (BmpData[index++] != 'M'))
  397.     {
  398.         PRINT_INFORMATION(("It is not a bitmap file.n"));
  399.         return -1;
  400.     }
  402.     /* read in the width and height of the image, and the number of colors used; ignore the rest */
  403.     index += 16;
  405.     width = BmpData[index++];
  406.     width |= BmpData[index++] << ONE_BYTE_SIZE;
  408.     index += 2;
  410.     height = BmpData[index++];
  411.     height |= BmpData[index++] << ONE_BYTE_SIZE;
  413.     index += 22;
  415.     num_colors = BmpData[index++];
  416.     num_colors |= BmpData[index++] << ONE_BYTE_SIZE;
  418.     if (num_colors > 1)
  419.     {
  420.         PRINT_INFORMATION(("It is a multi color bitmap file.n"));
  421.         complement_flag = TRUE;
  422.         /* return -1; *//* JP commented for tracker issue 396 */
  423.     }
  425.     /* First Header end. */
  426.     index += 6;
  428.     /* Skip the color table */
  429.     index += 8;
  431.     if (width / ONE_BYTE_SIZE > 8)
  432.     {
  433.         j = 12;
  434.     }
  435.     else
  436.     {
  437.         j = 8;
  438.     }
  440.     for (x = 0; x < height; x++)
  441.     {
  442.         for (i = 0; i < j; i++)
  443.         {
  444.             /* 
  445.              * JP 20050629
  446.              * We have to complement Predfined NSM
  447.              * Picture data
  448.              */
  449.             if (complement_flag)
  450.             {
  451.                 RotatedData[x][i] = (~BmpData[index++]);
  452.             }
  453.             else
  454.             {
  455.                 RotatedData[x][i] = (BmpData[index++]);
  456.             }
  458.         }
  459.     }
  461.     index = 0;
  463.     for (i = x - 1; i >= 0; i--)
  464.     {
  465.         for (j = 0; j < width / ONE_BYTE_SIZE; j++)
  466.         {
  467.             RawData[index++] = RotatedData[i][j];
  468.         }
  469.     }
  471.     *H = height;
  472.     *W = width;
  474.     return 0;
  475. }
  478. /*****************************************************************************
  479.  * FUNCTION
  480.  *  mmi_pmsg_create_bmp_data
  481.  * DESCRIPTION
  482.  *  Prepared the BMP file format based on OTA data.
  483.  * PARAMETERS
  484.  *  void
  485.  * RETURNS
  486.  *  void
  487.  *****************************************************************************/
  488. U8 *mmi_pmsg_create_bmp_data()
  489. {
  490.     /*----------------------------------------------------------------*/
  491.     /* Local Variables                                                */
  492.     /*----------------------------------------------------------------*/
  493.     U8 BmpDataHeader[MAX_BMP_HDR_SIZE];
  494.     U8 RotatedData[MAX_PIC_HIEGHT_PIXEL][MAX_PIC_WIDTH_PIXEL];
  495.     U8 *BmpData = NULL;
  496.     S16 HeaderLen = 0;
  497.     S16 TotalSizeOfBmp = 0;
  498.     S16 index = 0;
  499.     S16 x = 0, i = 0, j = 0, k = 0;
  501.     /*----------------------------------------------------------------*/
  502.     /* Code Body                                                      */
  503.     /*----------------------------------------------------------------*/
  504.     memset(RotatedData, '', MAX_PIC_HIEGHT_PIXEL * MAX_PIC_WIDTH_PIXEL);
  505.     memset(BmpDataHeader, '', MAX_BMP_HDR_SIZE);
  507.     /* this is info field. */
  508.     mmi_pmsg_get_next_byte();
  510.     /* this is width field. */
  511.     g_pmsg_BmpHeader.BmpBMPInfoHeader.Width = (U32) mmi_pmsg_get_next_byte();
  513.     /* this is height field. */
  514.     g_pmsg_BmpHeader.BmpBMPInfoHeader.Height = (U32) mmi_pmsg_get_next_byte();
  516.     /* this is Depth field. */
  517.     mmi_pmsg_get_next_byte();
  519.     HeaderLen = (S16) g_pmsg_BmpHeader.BmpBMPInfoHeader.Width / ONE_BYTE_SIZE;
  521.     for (i = 0; i < gOtaDataLen; i++)
  522.     {
  523.         RotatedData[j][k] = mmi_pmsg_get_next_byte();
  524.         k++;
  525.         if (k >= HeaderLen)
  526.         {
  527.             k = 0;
  528.             j++;
  529.         }
  530.     }
  532.     if (HeaderLen > 8)
  533.     {
  534.         HeaderLen = 12;
  535.     }
  536.     else if (HeaderLen > 4)
  537.     {
  538.         HeaderLen = 8;
  539.     }
  540.     else
  541.     {
  542.         HeaderLen = 4;
  543.     }
  545.     /* Six extra bytes added for MMI support */
  546.     TotalSizeOfBmp = BMP_HEADER_SIZE + (HeaderLen * j) + MMI_EXTRA_BMP_HEADER_SIZE;
  548.     /* Put the real size of BMP */
  549.     g_pmsg_BmpHeader.BmpBMPFileHeader.FileSize = (U32) TotalSizeOfBmp - MMI_EXTRA_BMP_HEADER_SIZE;
  551.     memcpy(&BmpDataHeader, &g_pmsg_BmpHeader, BMP_HEADER_SIZE + 2);
  553.     BmpData = (U8*) OslMalloc(TotalSizeOfBmp);
  554.     /* memset((S8*)BmpData,'',TotalSizeOfBmp); */
  556.     BmpData[index++] = 0x1;
  557.     BmpData[index++] = 0x0;
  558.     BmpData[index++] = (U8) ((g_pmsg_BmpHeader.BmpBMPFileHeader.FileSize & 0x000000FF));
  559.     BmpData[index++] = (U8) ((g_pmsg_BmpHeader.BmpBMPFileHeader.FileSize & 0x0000FF00) >> 8);
  560.     BmpData[index++] = (U8) ((g_pmsg_BmpHeader.BmpBMPFileHeader.FileSize & 0x00FF0000) >> 16);
  561.     BmpData[index++] = (U8) ((g_pmsg_BmpHeader.BmpBMPFileHeader.FileSize & 0xFF000000) >> 24);
  563.     for (i = 0; i < BMP_HEADER_SIZE; i++)
  564.     {
  565.         BmpData[index++] = BmpDataHeader[i + 2];
  566.     }
  568.     for (i = j - 1; i >= 0; i--)
  569.     {
  570.         for (x = 0; x < HeaderLen; x++)
  571.         {
  572.             BmpData[index++] = RotatedData[i][x];
  573.         }
  574.     }
  576.     return (U8*) BmpData;
  577. }
  580. /*****************************************************************************
  581.  * FUNCTION
  582.  *  mmi_pmsg_get_next_byte
  583.  * DESCRIPTION
  584.  *  Combine the two Hex value
  585.  * PARAMETERS
  586.  *  void
  587.  * RETURNS
  588.  *  void
  589.  *****************************************************************************/
  590. U8 mmi_pmsg_get_next_byte(void)
  591. {
  592.     /*----------------------------------------------------------------*/
  593.     /* Local Variables                                                */
  594.     /*----------------------------------------------------------------*/
  595.     U8 value;
  597.     /*----------------------------------------------------------------*/
  598.     /* Code Body                                                      */
  599.     /*----------------------------------------------------------------*/
  600.     value = OTAdata[g_pmsg_ota_index];
  601.     g_pmsg_ota_index++;
  603.     return value;
  604. }
  607. /*****************************************************************************
  608.  * FUNCTION
  609.  *  mmi_pmsg_get_n_bits
  610.  * DESCRIPTION
  611.  *  Find out the required bits in given data.
  612.  * PARAMETERS
  613.  *  Data        [?]         Offset and req bits.
  614.  *  Offset      [IN]        
  615.  *  Bits        [IN]        
  616.  * RETURNS
  617.  *  Bits value.
  618.  *****************************************************************************/
  619. U8 mmi_pmsg_get_n_bits(U8 *Data, U16 Offset, U16 Bits)
  620. {
  621.     /*----------------------------------------------------------------*/
  622.     /* Local Variables                                                */
  623.     /*----------------------------------------------------------------*/
  624.     U16 index = Offset / ONE_BYTE_SIZE;
  625.     U8 BitsfromFirstIndex = ONE_BYTE_SIZE - (Offset % ONE_BYTE_SIZE);
  626.     U8 firstByte = Data[index];
  627.     U8 secondByte = Data[index + 1];
  628.     U8 result = 0;
  630.     /*----------------------------------------------------------------*/
  631.     /* Code Body                                                      */
  632.     /*----------------------------------------------------------------*/
  633.     if (Bits > ONE_BYTE_SIZE)
  634.     {
  635.         return 0;
  636.     }
  638.     result = (firstByte << (ONE_BYTE_SIZE - BitsfromFirstIndex)) | (secondByte >> BitsfromFirstIndex);
  640.     result = result >> (ONE_BYTE_SIZE - Bits);
  642.     return result;
  644. }
  647. /*****************************************************************************
  648.  * FUNCTION
  649.  *  mmi_pmsg_convert_ascii_hex_to_dec
  650.  * DESCRIPTION
  651.  *  Converts Ascii value to Decimal value
  652.  * PARAMETERS
  653.  *  character       [IN]        
  654.  *  S8 ascii values(?)
  655.  * RETURNS
  656.  *  U8 Decimal value.
  657.  *****************************************************************************/
  658. U8 mmi_pmsg_convert_ascii_hex_to_dec(S8 character)
  659. {
  660.     /*----------------------------------------------------------------*/
  661.     /* Local Variables                                                */
  662.     /*----------------------------------------------------------------*/
  664.     /*----------------------------------------------------------------*/
  665.     /* Code Body                                                      */
  666.     /*----------------------------------------------------------------*/
  667.     if (character > 47 && character < 58)   /* Digits 0..9 */
  668.     {
  669.         return (character - 48);
  670.     }
  671.     else if (character > 64 && character < 71)  /* Characters A..F */
  672.     {
  673.         return (character - 55);
  674.     }
  675.     else if (character > 96 && character < 103) /* Characters a..f */
  676.     {
  677.         return (character - 87);
  678.     }
  679.     else
  680.     {
  681.         return (0xFF);
  682.     }
  683. }
  686. /*****************************************************************************
  687.  * FUNCTION
  688.  *  mmi_pmsg_convert_binary_dec_to_hex
  689.  * DESCRIPTION
  690.  *  Converts Binary value to Hex value.
  691.  * PARAMETERS
  692.  *  DecimalVal      [IN]        
  693.  *  part            [IN]        Which says about first byte or second byte data needed.
  694.  * RETURNS
  695.  *  U8 Hex value.
  696.  *****************************************************************************/
  697. U8 mmi_pmsg_convert_binary_dec_to_hex(const U8 DecimalVal, U8 part)
  698. {
  699.     /*----------------------------------------------------------------*/
  700.     /* Local Variables                                                */
  701.     /*----------------------------------------------------------------*/
  702.     U8 Firstpart = 0xf0 & DecimalVal;
  703.     U8 Secondpart = 0xf & DecimalVal;
  704.     U8 ReturnVal = 0;
  706.     /*----------------------------------------------------------------*/
  707.     /* Code Body                                                      */
  708.     /*----------------------------------------------------------------*/
  709.     Firstpart >>= 4;
  711.     ReturnVal = Secondpart;
  712.     if (part == PMSG_FIRST_FOUR_BITS)
  713.     {
  714.         ReturnVal = Firstpart;
  715.     }
  717.     if (ReturnVal < 10)
  718.     {
  719.         ReturnVal += 48;
  720.     }
  721.     else
  722.     {
  723.         ReturnVal += 55;
  724.     }
  726.     return ReturnVal;
  727. }
  730. /*****************************************************************************
  731.  * FUNCTION
  732.  *  mmi_pmsg_fskip
  733.  * DESCRIPTION
  734.  *  Skip the file pointer of num bytes.
  735.  * PARAMETERS
  736.  *  fp              [IN]        
  737.  *  num_bytes       [IN]        
  738.  *  file pointer and skip times.(?)
  739.  * RETURNS
  740.  *  void
  741.  *****************************************************************************/
  742. void mmi_pmsg_fskip(FILE_HANDLE fp, S16 num_bytes)
  743. {
  744.     /*----------------------------------------------------------------*/
  745.     /* Local Variables                                                */
  746.     /*----------------------------------------------------------------*/
  747.     U32 errorCode = 0;
  748.     S8 Data[64];
  750.     /*----------------------------------------------------------------*/
  751.     /* Code Body                                                      */
  752.     /*----------------------------------------------------------------*/
  753.     pfread(Data, 1, num_bytes, fp, &errorCode);
  754. }
  757. /*****************************************************************************
  758.  * FUNCTION
  759.  *  mmi_pmsg_create_ota_data
  760.  * DESCRIPTION
  761.  *  Creates OTA file.
  762.  * PARAMETERS
  763.  *  BinaryData      [?]         
  764.  *  H               [IN]        
  765.  *  W               [IN]        
  766.  *  Pointer to OTA data,Pointer of binary data, Hieght and width.(?)
  767.  * RETURNS
  768.  *  void
  769.  *****************************************************************************/
  770. U8 *mmi_pmsg_create_ota_data(U8 *BinaryData, S16 H, S16 W)
  771. {
  772.     /*----------------------------------------------------------------*/
  773.     /* Local Variables                                                */
  774.     /*----------------------------------------------------------------*/
  775.     S16 i = 0;
  776.     S16 index = 0;
  777.     U8 *OtaData = NULL;
  778.     U16 DataSize = (H * W / ONE_BYTE_SIZE) + 4; /* infofield, width, height, and depth */
  780.     /*----------------------------------------------------------------*/
  781.     /* Code Body                                                      */
  782.     /*----------------------------------------------------------------*/
  783.     gOtaDataLen = DataSize;
  784.     OtaData = (U8*) OslMalloc(MAX_DATA_SIZE);
  785.     memset(OtaData, '', MAX_DATA_SIZE);
  787.     /* Put OTA tyep field */
  788.     OtaData[index++] = 0x02;
  790.     /* Put OTA Size field */
  791.     OtaData[index++] = (U8) ((DataSize & 0xff00) >> ONE_BYTE_SIZE);
  792.     OtaData[index++] = (U8) (DataSize & 0x00ff);
  794.     /* Put Info field */
  795.     OtaData[index++] = 0x00;
  797.     /* Put width */
  798.     OtaData[index++] = (U8) W;
  800.     /* Put Hieght */
  801.     OtaData[index++] = (U8) H;
  803.     /* Put Color */
  804.     OtaData[index++] = 0x01;
  806.     /* Put Data */
  807.     for (i = 0; i < W * H / ONE_BYTE_SIZE; i++)
  808.     {
  809.         OtaData[index++] = BinaryData[i];
  810.     }
  812.     return OtaData;
  813. }
  816. /*****************************************************************************
  817.  * FUNCTION
  818.  *  mmi_pmsg_string_search
  819.  * DESCRIPTION
  820.  *  This algorithm uses hashing to implement string searching in linear time.
  821.  * PARAMETERS
  822.  *  Pattern     [?]     
  823.  *  Text        [?]     In which pattern is to be search.
  824.  * RETURNS
  825.  *  if success then starting location of pattern else -1 if pattern not found.
  826.  *****************************************************************************/
  827. S16 mmi_pmsg_string_search(S8 *Pattern, S8 *Text)
  828. {
  829.     /*----------------------------------------------------------------*/
  830.     /* Local Variables                                                */
  831.     /*----------------------------------------------------------------*/
  832.     S16 num_iteration = 0;
  833.     S16 PatternLength = 0;
  834.     S16 PatternHash = 0;
  835.     S16 TextHash = 0;
  836.     S16 i = 0;
  838.     /*----------------------------------------------------------------*/
  839.     /* Code Body                                                      */
  840.     /*----------------------------------------------------------------*/
  841.     if (Pattern == NULL || Text == NULL)
  842.     {
  843.         return -1;
  844.     }
  845.     else
  846.     {
  848.         PatternLength = strlen((S8*) Pattern);
  849.         num_iteration = strlen((S8*) Text) - PatternLength + 1;
  851.         /* Find initial hash values for Pattern and Text */
  852.         /* These are called FINGERPRINT */
  853.         PatternHash = mmi_pmsg_hash(Pattern);
  854.         TextHash = mmi_pmsg_HashN(Text, PatternLength);
  856.         for (i = 0; i < num_iteration; i++)
  857.         {
  858.             if ((PatternHash == TextHash) && !(strncmp(Pattern, (Text + i), PatternLength)))
  859.             {
  860.                 return i;
  861.             }
  862.             TextHash = mmi_pmsg_HashIncrement(Text, i, TextHash, PatternLength);
  863.         }
  864.     }
  866.     return -1;
  867. }
  870. /*****************************************************************************
  871.  * FUNCTION
  872.  *  mmi_pmsg_hash
  873.  * DESCRIPTION
  874.  *  Calculate the hash of given string.
  875.  * PARAMETERS
  876.  *  str     [?]     
  877.  *  Pointer to given string.(?)
  878.  * RETURNS
  879.  *  Hash value.
  880.  *****************************************************************************/
  881. S16 mmi_pmsg_hash(S8 *str)
  882. {
  883.     /*----------------------------------------------------------------*/
  884.     /* Local Variables                                                */
  885.     /*----------------------------------------------------------------*/
  886.     S16 sum = 0;
  888.     /*----------------------------------------------------------------*/
  889.     /* Code Body                                                      */
  890.     /*----------------------------------------------------------------*/
  891.     for (; *str; str++)
  892.     {
  893.         sum += *str;
  894.     }
  896.     return sum % MODULUS;
  897. }
  900. /*****************************************************************************
  901.  * FUNCTION
  902.  *  mmi_pmsg_HashN
  903.  * DESCRIPTION
  904.  *  Calculate the hash value of given number of bytes.
  905.  * PARAMETERS
  906.  *  Str                 [?]         
  907.  *  PatternLength       [IN]        
  908.  *  Pointer to Data, Length of Pattern which hash value to be needed.(?)
  909.  * RETURNS
  910.  *  Calculated hash value.
  911.  *****************************************************************************/
  912. S16 mmi_pmsg_HashN(S8 *Str, S16 PatternLength)
  913. {
  914.     /*----------------------------------------------------------------*/
  915.     /* Local Variables                                                */
  916.     /*----------------------------------------------------------------*/
  917.     S8 ch = Str[PatternLength];
  918.     S16 HashValue;
  920.     /*----------------------------------------------------------------*/
  921.     /* Code Body                                                      */
  922.     /*----------------------------------------------------------------*/
  923.     Str[PatternLength] = '';
  924.     HashValue = mmi_pmsg_hash(Str);
  925.     Str[PatternLength] = ch;
  927.     return HashValue;
  928. }
  931. /*****************************************************************************
  932.  * FUNCTION
  933.  *  mmi_pmsg_HashIncrement
  934.  * DESCRIPTION
  935.  *  Increment the hash values by removing previous value and adding next value.
  936.  * PARAMETERS
  937.  *  str                 [?]         
  938.  *  PrevIndex           [IN]        
  939.  *  PrevHash            [IN]        
  940.  *  PatternLength       [IN]        
  941.  *  Pointer to given String, Previous Index, Previous hash value, Pattern Length.(?)
  942.  * RETURNS
  943.  *  New hash value.
  944.  *****************************************************************************/
  945. S16 mmi_pmsg_HashIncrement(S8 *str, S16 PrevIndex, S16 PrevHash, S16 PatternLength)
  946. {
  947.     /*----------------------------------------------------------------*/
  948.     /* Local Variables                                                */
  949.     /*----------------------------------------------------------------*/
  950.     S16 val;
  952.     /*----------------------------------------------------------------*/
  953.     /* Code Body                                                      */
  954.     /*----------------------------------------------------------------*/
  955.     val = (PrevHash - (S16) str[PrevIndex]) + (str[PrevIndex + PatternLength]);
  957.     return val < 0 ? val + MODULUS : val % MODULUS;
  958. }
  961. /*****************************************************************************
  962.  * FUNCTION
  963.  *  mmi_pmsg_shift_n_bytes
  964.  * DESCRIPTION
  965.  *  Remove the specified N byte from the given Data and shift the whole values.
  966.  * PARAMETERS
  967.  *  Data        [?]         Location from Data to be removed, Number of byte to be removed.
  968.  *  offset      [IN]        
  969.  *  nBytes      [IN]        
  970.  *  length      [IN]        
  971.  * RETURNS
  972.  *  void
  973.  *****************************************************************************/
  974. void mmi_pmsg_shift_n_bytes(S8 *Data, S16 offset, S16 nBytes, S16 length)
  975. {
  976.     /*----------------------------------------------------------------*/
  977.     /* Local Variables                                                */
  978.     /*----------------------------------------------------------------*/
  979.     S16 index = offset, j = 0;
  980.     S8 *DataPtr = Data + offset + nBytes;
  981.     S16 len = length;
  983.     /*----------------------------------------------------------------*/
  984.     /* Code Body                                                      */
  985.     /*----------------------------------------------------------------*/
  986.     while (len > 0)
  987.     {
  988.         Data[index++] = *DataPtr++;
  989.         len--;
  990.     }
  992.     for (j = 0; j < nBytes; j++)
  993.     {
  994.         Data[index++] = '';
  995.     }
  997. }
  1000. /*****************************************************************************
  1001.  * FUNCTION
  1002.  *  mmi_pmsg_add_header
  1003.  * DESCRIPTION
  1004.  *  Add the Header into given data. ( Data must be big enought to add header buffer)
  1005.  * PARAMETERS
  1006.  *  header          [?]         
  1007.  *  HeaderLen       [IN]        
  1008.  *  Data            [?]         & Data Size.
  1009.  *  DataLen         [IN]        
  1010.  * RETURNS
  1011.  *  void
  1012.  *****************************************************************************/
  1013. void mmi_pmsg_add_header(U8 *header, U16 HeaderLen, U8 *Data, U16 DataLen)
  1014. {
  1015.     /*----------------------------------------------------------------*/
  1016.     /* Local Variables                                                */
  1017.     /*----------------------------------------------------------------*/
  1018.     U8 *DataBackUp = NULL;
  1019.     U16 i = 0, j = 0;
  1021.     /*----------------------------------------------------------------*/
  1022.     /* Code Body                                                      */
  1023.     /*----------------------------------------------------------------*/
  1024.     DataBackUp = (U8*) OslMalloc(DataLen + HeaderLen + 4);
  1025.     memset(DataBackUp, 0x00, (DataLen + HeaderLen + 4));
  1027.     while (j < HeaderLen)
  1028.     {
  1029.         DataBackUp[i++] = header[j];
  1030.         j++;
  1031.     }
  1033.     j = 0;
  1034.     while (j < DataLen)
  1035.     {
  1036.         DataBackUp[i++] = Data[j];
  1037.         j++;
  1038.     }
  1040.     memset(Data, 0x00, i + 1);
  1042.     j = 0;
  1043.     while (j < i)
  1044.     {
  1045.         Data[j] = DataBackUp[j];
  1046.         j++;
  1047.     }
  1048.     OslMfree(DataBackUp);
  1049. }
  1052. /*****************************************************************************
  1053.  * FUNCTION
  1054.  *  mmi_pmsg_read_picture_header
  1055.  * DESCRIPTION
  1056.  *  Read the Picture Header information and put the checks.
  1057.  * PARAMETERS
  1058.  *  OtaPattern      [?]     
  1059.  *  Pointer to OtaData.(?)
  1060.  * RETURNS
  1061.  *  If error return -1 else len of picture message header.
  1062.  *****************************************************************************/
  1063. S16 mmi_pmsg_read_picture_header(U8 *OtaPattern)
  1064. {
  1065.     /*----------------------------------------------------------------*/
  1066.     /* Local Variables                                                */
  1067.     /*----------------------------------------------------------------*/
  1068.     U8 RecvVal = 0;
  1069.     U16 index = 0;
  1070.     S16 i = 0;
  1071.     U16 OtaDataLen = 0;
  1073.     /* S8 tempTextBuffer[MAX_PICTEXT_BUFF_SIZE+(TEXT_BUFF_PADDING)]; */
  1074.     S8 *tempTextBuffer = NULL;
  1075.     U16 charType = 0;
  1076.     EMSData *pEms;
  1077.     U16 EmsDataLen = 0;
  1078.     U8 missSegStr[] = EMS_MISS_SEG_DELIMIT_STR;
  1079.     U16 missSegStrLen = strlen((const char*)missSegStr);
  1081.     /*----------------------------------------------------------------*/
  1082.     /* Code Body                                                      */
  1083.     /*----------------------------------------------------------------*/
  1084.     GetEMSDataForView(&pEms, 0);
  1085.     EmsDataLen = pEms->textLength / 2;
  1086.     memset(g_pmsg_TextInMessage, '', MAX_PICTEXT_BUFF_SIZE + (TEXT_BUFF_PADDING));
  1088.     /* Version Information */
  1089.     RecvVal = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1090.     index += ONE_BYTE_SIZE;
  1092.     if (RecvVal != 48)
  1093.     {
  1094.         return -1;
  1095.     }
  1097.     /* Type */
  1098.     RecvVal = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1099.     index += ONE_BYTE_SIZE;
  1100.     charType = RecvVal;
  1102.     if (RecvVal == 0 || RecvVal == 1)   /* Message Text */
  1103.     {
  1104.         /* Item Len */
  1105.         OtaDataLen = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1106.         index += ONE_BYTE_SIZE;
  1108.         RecvVal = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1109.         index += ONE_BYTE_SIZE;
  1111.         OtaDataLen <<= ONE_BYTE_SIZE;
  1112.         OtaDataLen = OtaDataLen | RecvVal;
  1114.         /* tempTextBuffer = OslMalloc((MAX_PICTEXT_BUFF_SIZE+TEXT_BUFF_PADDING)); */
  1115.         tempTextBuffer = OslMalloc((OtaDataLen) + TEXT_BUFF_PADDING);
  1117.         /* memset(tempTextBuffer, '',(MAX_PICTEXT_BUFF_SIZE+TEXT_BUFF_PADDING)); */
  1118.         memset(tempTextBuffer, '', ((OtaDataLen) + TEXT_BUFF_PADDING));
  1120.         /* Read the Text */
  1121.         for (i = 0; i < OtaDataLen; i++)
  1122.         {
  1123.             tempTextBuffer[i] = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1124.             index += ONE_BYTE_SIZE;
  1125.         }
  1127.         if (charType == 0)
  1128.         {
  1129.             AnsiiToUnicodeString((S8*) g_pmsg_TextInMessage, (S8*) tempTextBuffer);
  1130.         }
  1131.         else
  1132.         {
  1133.             /* For Unicode character : JP */
  1134.             {
  1135.                 S32 count = 0;
  1136.                 U8 temp = 0;
  1138.                 while (count < OtaDataLen)
  1139.                 {
  1140.                     temp = tempTextBuffer[count];
  1141.                     tempTextBuffer[count] = tempTextBuffer[count + 1];
  1142.                     tempTextBuffer[count + 1] = temp;
  1143.                     count = count + 2;
  1144.                 }
  1146.                 pfnUnicodeStrcpy((S8*) g_pmsg_TextInMessage, (S8*) (tempTextBuffer));
  1147.             }
  1148.         }
  1149.         OslMfree(tempTextBuffer);
  1151.         /* Read the OTA bitmat type : 02 */
  1152.         RecvVal = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1153.         index += ONE_BYTE_SIZE;
  1155.         if (RecvVal != 2)
  1156.         {
  1157.             return -1;
  1158.         }
  1159.     }
  1160.     else if (RecvVal == 2)
  1161.     {
  1162.         /* There is not text part in message */
  1163.     }
  1164.     else
  1165.     {
  1166.         return -1;
  1167.     }
  1169.     OtaDataLen = 0;
  1171.     /* Read the len of OTA data */
  1172.     OtaDataLen = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1173.     index += ONE_BYTE_SIZE;
  1175.     RecvVal = mmi_pmsg_get_n_bits(OtaPattern, index, ONE_BYTE_SIZE);
  1176.     index += ONE_BYTE_SIZE;
  1178.     OtaDataLen <<= ONE_BYTE_SIZE;
  1179.     gOtaDataLen = OtaDataLen | RecvVal;
  1181.     /* Incomplete message content */
  1182.     if (((EmsDataLen - (index / ONE_BYTE_SIZE)) < gOtaDataLen) ||
  1183.         !strncmp((const char*)(OtaPattern + (EmsDataLen - missSegStrLen)), (const char*)missSegStr, missSegStrLen))
  1184.     {
  1185.         return -1;
  1186.     }
  1188.     return (index / ONE_BYTE_SIZE);
  1189. }
  1192. /*****************************************************************************
  1193.  * FUNCTION
  1194.  *  mmi_smrt_message_type
  1195.  * DESCRIPTION
  1196.  *  Find Out the type of Message.
  1197.  * PARAMETERS
  1198.  *  SmsData     [?]     
  1199.  *  Pointer to SMS data.(?)
  1200.  * RETURNS
  1201.  *  TYPE of SMS ( Normal, Picture or Ring Tone)
  1202.  *****************************************************************************/
  1203. S16 mmi_smrt_message_type(U8 *SmsData)
  1204. {
  1205.     /*----------------------------------------------------------------*/
  1206.     /* Local Variables                                                */
  1207.     /*----------------------------------------------------------------*/
  1208.     S16 IsFindPattern = -1;
  1210.     /*----------------------------------------------------------------*/
  1211.     /* Code Body                                                      */
  1212.     /*----------------------------------------------------------------*/
  1213.     /* search the picture message signature */
  1214.     IsFindPattern = mmi_pmsg_string_search((S8*) PIC_MSG_SIGNATURE, (S8*) SmsData);
  1215.     if (IsFindPattern >= 0)
  1216.     {
  1217.         return SMRT_PICTURE_SMS_1;
  1218.     }
  1220.     /* search the ring tone message signature */
  1221.     IsFindPattern = mmi_pmsg_string_search((S8*) RING_TONE_MSG_SIGNATURE, (S8*) SmsData);
  1222.     if (IsFindPattern >= 0)
  1223.     {
  1224.         return SMRT_RING_TONE_SMS_2;
  1225.     }
  1227.     /* search the ring tone message signature */
  1228.     IsFindPattern = mmi_pmsg_string_search((S8*) RING_TONE_MELODY_SIGNATURE, (S8*) SmsData);
  1229.     if (IsFindPattern >= 0)
  1230.     {
  1231.         return SMRT_RING_TONE_SMS_2;
  1232.     }
  1234.     /* It is neither Picture massage nor Rong tone */
  1235.     return SMRT_NORMAL_SMS_0;
  1236. }
  1238. #if (0)
  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. /* under construction !*/
  1283. /* under construction !*/
  1284. /* under construction !*/
  1285. /* under construction !*/
  1286. /* under construction !*/
  1287. /* under construction !*/
  1288. /* under construction !*/
  1289. /* under construction !*/
  1290. /* under construction !*/
  1291. /* under construction !*/
  1292. /* under construction !*/
  1293. /* under construction !*/
  1294. /* under construction !*/
  1295. /* under construction !*/
  1296. /* under construction !*/
  1297. /* under construction !*/
  1298. /* under construction !*/
  1299. /* under construction !*/
  1300. /* under construction !*/
  1301. /* under construction !*/
  1302. /* under construction !*/
  1303. /* under construction !*/
  1304. /* under construction !*/
  1305. /* under construction !*/
  1306. /* under construction !*/
  1307. /* under construction !*/
  1308. /* under construction !*/
  1309. /* under construction !*/
  1310. /* under construction !*/
  1311. /* under construction !*/
  1312. /* under construction !*/
  1313. /* under construction !*/
  1314. /* under construction !*/
  1315. /* under construction !*/
  1316. /* under construction !*/
  1317. /* under construction !*/
  1318. /* under construction !*/
  1319. #endif /* (0) */ 
  1322. /*****************************************************************************
  1323.  * FUNCTION
  1324.  *  mmi_pmsg_add_picture_text
  1325.  * DESCRIPTION
  1326.  *  Prepared the Picture message format and add the picture text.
  1327.  * PARAMETERS
  1328.  *  OtaData         [?]     
  1329.  *  TextBuffer      [?]     
  1330.  *  OTA data & text buffer.(?)
  1331.  * RETURNS
  1332.  *  Length of OTA data with header.
  1333.  *****************************************************************************/
  1334. U16 mmi_pmsg_add_picture_text(U8 *OtaData, U8 *TextBuffer)
  1335. {
  1336.     /*----------------------------------------------------------------*/
  1337.     /* Local Variables                                                */
  1338.     /*----------------------------------------------------------------*/
  1339.     U16 TextLen;                    /* = (pfnUnicodeStrlen((S8*)TextBuffer)*2); */
  1340.     U16 DataLen = gOtaDataLen + 3;  /* type (02 for OTA-bitmap), length ( 2 bytes) */
  1342.     /* U8  OtaText[MAX_PICTEXT_BUFF_SIZE+TEXT_BUFF_PADDING]; */
  1343.     U8 *OtaText = NULL;
  1344.     U16 index = 0, i = 0;
  1346.     /*----------------------------------------------------------------*/
  1347.     /* Code Body                                                      */
  1348.     /*----------------------------------------------------------------*/
  1349.     OtaText = OslMalloc((MAX_PICTEXT_BUFF_SIZE + TEXT_BUFF_PADDING));
  1350.     memset(OtaText, 0x00, MAX_PICTEXT_BUFF_SIZE + TEXT_BUFF_PADDING);
  1352.     /* Version */
  1353.     OtaText[index++] = 0x30;
  1355. #if (defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__))
  1357.     if (g_nsm_msg_context.UCS2_count > 0)
  1358.     {
  1359.         /* text type */
  1360.         OtaText[index++] = 0x01;
  1361.         TextLen = (pfnUnicodeStrlen((S8*) TextBuffer) * 2); /* JP */
  1362.     }
  1363.     else
  1364.     {
  1365.         /* text type */
  1366.         OtaText[index++] = 0x00;
  1367.         TextLen = strlen((S8*) TextBuffer); /* JP */
  1368.     }
  1370. #elif defined(__MMI_SMART_MESSAGE_MT__)
  1372.     if (picmsg_text_struct.ucs2_count > 0)
  1373.     {
  1374.         /* text type */
  1375.         OtaText[index++] = 0x01;
  1376.         TextLen = (pfnUnicodeStrlen((S8*) TextBuffer) * 2); /* JP */
  1377.     }
  1378.     else
  1379.     {
  1380.         /* text type */
  1381.         OtaText[index++] = 0x00;
  1382.         TextLen = strlen((S8*) TextBuffer); /* JP */
  1383.     }
  1384. #endif 
  1386.     /* text length */
  1387.     OtaText[index++] = (U8) ((TextLen & 0xff00) >> ONE_BYTE_SIZE);
  1388.     OtaText[index++] = (U8) (TextLen & 0x00ff);
  1390. #if defined(__MMI_SMART_MESSAGE_MT__)
  1391.     if (picmsg_text_struct.ucs2_count > 0)
  1392.     {
  1393. #elif (defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__))
  1394.     if (g_nsm_msg_context.UCS2_count > 0)
  1395.     {
  1396. #endif 
  1397.         /* For Unicode text : Reverse bytes order for Nokia chinese problem */
  1398.         {
  1399.             U8 temp1 = 0;
  1400.             U8 temp2 = 0;
  1401.             U8 temparr[3] = {0, 0, 0};
  1402.             U16 count = 0;
  1404.             while (i < TextLen)
  1405.             {
  1406.                 temp1 = TextBuffer[i];
  1407.                 i++;
  1408.                 temp2 = TextBuffer[i];
  1409.                 i++;
  1410.                 temparr[0] = temp2;
  1411.                 temparr[1] = temp1;
  1412.                 for (count = 0; count < 2; count++)
  1413.                 {
  1414.                     OtaText[index++] = (U8) temparr[count];
  1415.                 }
  1417.                 /* Reset all temp variables */
  1418.                 temp1 = 0;
  1419.                 temp2 = 0;
  1420.                 memset(temparr, 0x00, sizeof(temparr));
  1421.             }
  1422.         }
  1423.     }
  1424.     else
  1425.     {
  1426.         /* Only ascii text : DO not change bytes order */
  1427.         while (i < TextLen)
  1428.         {
  1429.             OtaText[index++] = (U8) TextBuffer[i];
  1430.             i++;
  1431.         }
  1432.     }
  1434.     mmi_pmsg_add_header(OtaText, index, OtaData, DataLen);
  1435.     OslMfree(OtaText);
  1437.     return (U16) (index + DataLen);
  1438. }
  1441. /*****************************************************************************
  1442.  * FUNCTION
  1443.  *  mmi_pmsg_add_nokia_header
  1444.  * DESCRIPTION
  1445.  *  Prefix the Nokia Header on given Picture Message.
  1446.  * PARAMETERS
  1447.  *  PictureMessage      [?]         
  1448.  *  TotalSegment        [IN]        
  1449.  *  CurrentSegment      [IN]        
  1450.  *  OTA data ,Total Part & Part of Header (first, second or third ..)(?)
  1451.  * RETURNS
  1452.  *  void
  1453.  *****************************************************************************/
  1454. void mmi_pmsg_add_nokia_header(U8 *PictureMessage, U8 TotalSegment, U8 CurrentSegment)
  1455. {
  1456.     /*----------------------------------------------------------------*/
  1457.     /* Local Variables                                                */
  1458.     /*----------------------------------------------------------------*/
  1459.     const S16 NokiaTotalSegmentLocation = 21;
  1460.     const S16 NokiaCurrectSegmentLocation = 23;
  1461.     const S16 NokiaHeaderSize = 24;
  1462.     const S16 NokiaMaxSegments = 4;
  1464.     U8 NokiaHeader[MAX_NOKIA_HEADER_SIZE];
  1465.     U8 SegmentNumber[] = { '0', '1', '2', '3', '4' };
  1466.     U16 DataSize = strlen((S8*) PictureMessage);
  1468.     /*----------------------------------------------------------------*/
  1469.     /* Code Body                                                      */
  1470.     /*----------------------------------------------------------------*/
  1471.     if ((PictureMessage == NULL)
  1472.         || (TotalSegment > NokiaMaxSegments) || (CurrentSegment > NokiaMaxSegments) || (DataSize > 296))
  1473.     {
  1474.         return;
  1475.     }
  1477.     memset(NokiaHeader, 0x00, MAX_NOKIA_HEADER_SIZE);
  1479.     strcpy((S8*) NokiaHeader, (S8*) "0B0504158A00000003010301");
  1481.     NokiaHeader[NokiaTotalSegmentLocation] = SegmentNumber[TotalSegment];
  1483.     NokiaHeader[NokiaCurrectSegmentLocation] = SegmentNumber[CurrentSegment];
  1485.     mmi_pmsg_add_header(NokiaHeader, NokiaHeaderSize, PictureMessage, DataSize);
  1486. }
  1489. /*****************************************************************************
  1490.  * FUNCTION
  1491.  *  mmi_pmsg_convert_ascii_hex_string_2_dec_string
  1492.  * DESCRIPTION
  1493.  *  Convert the ascii string into Decimal string.
  1494.  * PARAMETERS
  1495.  *  DecStr          [?]     
  1496.  *  AsciiStr        [?]     
  1497.  *  Pointer to Dec string & Pointer to Ascii string.Ascii len must be even number.(?)
  1498.  * RETURNS
  1499.  *  void
  1500.  *****************************************************************************/
  1501. void mmi_pmsg_convert_ascii_hex_string_2_dec_string(U8 *DecStr, U8 *AsciiStr)
  1502. {
  1503.     /*----------------------------------------------------------------*/
  1504.     /* Local Variables                                                */
  1505.     /*----------------------------------------------------------------*/
  1506.     U8 *AsciiStrPtr = AsciiStr;
  1507.     U8 *DecStrPtr = DecStr;
  1508.     U8 FirstVal = 0;
  1509.     U8 SecondVal = 0;
  1511.     /*----------------------------------------------------------------*/
  1512.     /* Code Body                                                      */
  1513.     /*----------------------------------------------------------------*/
  1514.     if (AsciiStrPtr == NULL)
  1515.     {
  1516.         return;
  1517.     }
  1519.     while (*AsciiStrPtr != '')
  1520.     {
  1521.         FirstVal = mmi_pmsg_convert_ascii_hex_to_dec(*AsciiStrPtr++);
  1522.         SecondVal = mmi_pmsg_convert_ascii_hex_to_dec(*AsciiStrPtr++);
  1523.         *DecStrPtr++ = ((FirstVal << 4) | (SecondVal));
  1524.     }
  1525. }
  1528. /*****************************************************************************
  1529.  * FUNCTION
  1530.  *  mmi_pmsg_convert_dec_string_2_ascii_hex_string
  1531.  * DESCRIPTION
  1532.  *  Convert the Decimal string into ascii string.
  1533.  * PARAMETERS
  1534.  *  AsciiStr        [?]     
  1535.  *  DecStr          [?]     
  1536.  *  Pointer to Ascii string & Pointer to Dec string. Ascii string len must be double of Dec string.(?)
  1537.  * RETURNS
  1538.  *  void
  1539.  *****************************************************************************/
  1540. void mmi_pmsg_convert_dec_string_2_ascii_hex_string(U8 *AsciiStr, U8 *DecStr)
  1541. {
  1542.     /*----------------------------------------------------------------*/
  1543.     /* Local Variables                                                */
  1544.     /*----------------------------------------------------------------*/
  1545.     U8 *AsciiStrPtr = AsciiStr;
  1546.     U8 *DecStrPtr = DecStr;
  1548.     /*----------------------------------------------------------------*/
  1549.     /* Code Body                                                      */
  1550.     /*----------------------------------------------------------------*/
  1551.     if (DecStrPtr == NULL)
  1552.     {
  1553.         return;
  1554.     }
  1556.     while (*DecStrPtr != '')
  1557.     {
  1558.         *AsciiStrPtr++ = mmi_pmsg_convert_binary_dec_to_hex(*DecStrPtr, PMSG_FIRST_FOUR_BITS);
  1559.         *AsciiStrPtr++ = mmi_pmsg_convert_binary_dec_to_hex(*DecStrPtr, PMSG_SECOND_FOUR_BITS);
  1560.         DecStrPtr++;
  1561.     }
  1562. }
  1565. /*****************************************************************************
  1566.  * FUNCTION
  1567.  *  mmi_pmsg_get_size_bmp_data
  1568.  * DESCRIPTION
  1569.  *  This fun find out the real size of Bmp data.
  1570.  * PARAMETERS
  1571.  *  BmpData     [?]     
  1572.  *  Pointer of BMP data MMI format.(?)
  1573.  * RETURNS
  1574.  *  Size of Bmp file.
  1575.  *****************************************************************************/
  1576. U16 mmi_pmsg_get_size_bmp_data(U8 *BmpData)
  1577. {
  1578.     /*----------------------------------------------------------------*/
  1579.     /* Local Variables                                                */
  1580.     /*----------------------------------------------------------------*/
  1581.     U16 BmpDataSize = 0;
  1582.     S16 index = 2;
  1583.     U16 val[4];
  1585.     /*----------------------------------------------------------------*/
  1586.     /* Code Body                                                      */
  1587.     /*----------------------------------------------------------------*/
  1588.     val[0] = (U16) BmpData[index++];
  1589.     val[1] = (U16) BmpData[index++];
  1590.     val[2] = (U16) BmpData[index++];
  1591.     val[3] = (U16) BmpData[index++];
  1593.     BmpDataSize = (U16) (val[3] << 24 | val[2] << 16 | val[1] << 8 | val[0]);
  1595.     return (BmpDataSize + MMI_EXTRA_BMP_HEADER_SIZE);
  1596. }
  1599. /*****************************************************************************
  1600.  * FUNCTION
  1601.  *  mmi_pmsg_get_size_ota_data
  1602.  * DESCRIPTION
  1603.  *  This fun find out the real size of Ota Picture data.
  1604.  * PARAMETERS
  1605.  *  OtaBuffer       [?]     
  1606.  *  Pointer of Ota data .(?)
  1607.  * RETURNS
  1608.  *  Size of Ota Data.
  1609.  *****************************************************************************/
  1610. U16 mmi_pmsg_get_size_ota_data(U8 *OtaBuffer)
  1611. {
  1612.     /*----------------------------------------------------------------*/
  1613.     /* Local Variables                                                */
  1614.     /*----------------------------------------------------------------*/
  1615.     S16 OtaHeaderLen = 0;
  1617.     /*----------------------------------------------------------------*/
  1618.     /* Code Body                                                      */
  1619.     /*----------------------------------------------------------------*/
  1620.     OtaHeaderLen = mmi_pmsg_read_picture_header(OtaBuffer);
  1622.     if (OtaHeaderLen == -1)
  1623.     {
  1624.         return 0;
  1625.     }
  1627.     return (U16) (gOtaDataLen + OtaHeaderLen) * 2 + 8;
  1629. }
  1632. /*****************************************************************************
  1633.  * FUNCTION
  1634.  *  mmi_pmsg_add_bmp_header_info
  1635.  * DESCRIPTION
  1636.  *  This fun added the BMP extra header info to show the Picture in UI.Prepared MMI format.
  1637.  * PARAMETERS
  1638.  *  BmpData     [?]     
  1639.  *  Pointer of BMP data .(?)
  1640.  * RETURNS
  1641.  *  void
  1642.  *****************************************************************************/
  1643. S16 mmi_pmsg_add_bmp_header_info(U8 *BmpData)
  1644. {
  1645.     /*----------------------------------------------------------------*/
  1646.     /* Local Variables                                                */
  1647.     /*----------------------------------------------------------------*/
  1648.     S8 HeaderInfo[16];
  1649.     U16 BmpDataSize = 0;
  1650.     U16 index = 0;
  1652.     /*----------------------------------------------------------------*/
  1653.     /* Code Body                                                      */
  1654.     /*----------------------------------------------------------------*/
  1655.     if (mmi_pmsg_is_smart_picture(BmpData) == FALSE)
  1656.     {
  1657.         return -1;
  1658.     }
  1660.     memset(HeaderInfo, 0x00, 16);
  1662.     BmpDataSize = ((BmpData[2]) | (BmpData[3] << 8) | (BmpData[4] << 16) | (BmpData[5] << 24));
  1663.     HeaderInfo[index++] = 0x1;
  1664.     HeaderInfo[index++] = 0x0;
  1665.     HeaderInfo[index++] = (S8) ((BmpDataSize & 0x000000FF));
  1666.     HeaderInfo[index++] = (S8) ((BmpDataSize & 0x0000FF00) >> 8);
  1667.     HeaderInfo[index++] = (S8) ((BmpDataSize & 0x00FF0000) >> 16);
  1668.     HeaderInfo[index++] = (S8) ((BmpDataSize & 0xFF000000) >> 24);
  1670.     mmi_pmsg_add_header((U8*) HeaderInfo, index, (U8*) BmpData, BmpDataSize);
  1672.     return 0;
  1673. }
  1676. /*****************************************************************************
  1677.  * FUNCTION
  1678.  *  mmi_pmsg_is_smart_picture
  1679.  * DESCRIPTION
  1680.  *  
  1681.  * PARAMETERS
  1682.  *  BmpData     [?]     
  1683.  * RETURNS
  1684.  *  
  1685.  *****************************************************************************/
  1686. BOOL mmi_pmsg_is_smart_picture(U8 *BmpData)
  1687. {
  1688.     /*----------------------------------------------------------------*/
  1689.     /* Local Variables                                                */
  1690.     /*----------------------------------------------------------------*/
  1691.     S16 index = 0, num_colors = 0;
  1692.     U8 height;
  1693.     U8 width;
  1695.     /*----------------------------------------------------------------*/
  1696.     /* Code Body                                                      */
  1697.     /*----------------------------------------------------------------*/
  1698.     if ((BmpData[index++] != 'B') || (BmpData[index++] != 'M'))
  1699.     {
  1700.         PRINT_INFORMATION(("It is not a bitmap file.n"));
  1701.         return FALSE;
  1702.     }
  1704.     /* Start : JP check of height and width NSM picture */
  1705.     index += 16;    /* Hack */
  1707.     width = BmpData[index];
  1709.     if ((width > MAX_NSM_PIC_WIDTH) || (width == 0))    /* Width is greater then 72 */
  1710.     {
  1711.         return FALSE;
  1712.     }
  1714.     index += 4; /* Hack */
  1715.     height = BmpData[index];
  1717.     if ((height > MAX_NSM_PIC_HEIGHT) || (height == 0)) /* Height is greater then 72 */
  1718.     {
  1719.         return FALSE;
  1720.     }
  1721.     /* index += 40; */
  1722.     /* End : JP check of height and width NSM picture */
  1723.     index += 20;
  1725.     num_colors = BmpData[index++];
  1726.     num_colors |= BmpData[index++] << ONE_BYTE_SIZE;
  1728.     if (num_colors > 1)
  1729.     {
  1730.         PRINT_INFORMATION(("It is a multi color bitmap file.n"));
  1731.         num_colors = 1; /* JP for tracker issue 20050628 */
  1732.         /* return FALSE; */
  1733.     }
  1734.     return TRUE;
  1735. }
  1736. #endif /* _MMI_PICMSG_C */ /* if include picmsg_c */
  1737. #endif /* defined(__MMI_SMART_MESSAGE_MT__) || (defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__)) */