FT_Hal_Utils.cpp

00001 #include "FT_Platform.h"
00002 #include "mbed.h"
00003 //#include "SDFileSystem.h"
00004 
00005 #define DEBUG
00006 
00007 /* meta-commands, sequences of several display-list entries condensed into simpler to use functions at the price of some overhead */
00008 
00009 ft_void_t FT813::Point(ft_int16_t x, ft_int16_t y, ft_uint16_t size)
00010 {
00011     ft_uint32_t calc;
00012 
00013     StartFunc(FT_CMD_SIZE*4);
00014     SendCmd(DL_BEGIN | FT8_POINTS);
00015     calc = POINT_SIZE(size*16);
00016     SendCmd(calc);
00017     calc = VERTEX2F(x * 16, y * 16);
00018     SendCmd(calc);
00019     SendCmd(DL_END);
00020     EndFunc();
00021 }
00022 
00023 ft_void_t FT813::Line(ft_int16_t x0, ft_int16_t y0, ft_int16_t x1, ft_int16_t y1, ft_int16_t width)
00024 {
00025     ft_uint32_t calc;
00026 
00027     StartFunc(FT_CMD_SIZE*5);
00028     SendCmd(DL_BEGIN | FT8_LINES);
00029     calc = LINE_WIDTH(width * 16);
00030     SendCmd(calc);
00031     calc = VERTEX2F(x0 * 16, y0 * 16);
00032     SendCmd(calc);
00033     calc = VERTEX2F(x1 * 16, y1 * 16);
00034     SendCmd(calc);
00035     SendCmd(DL_END);
00036     EndFunc();
00037 }
00038 
00039 ft_void_t FT813::Rect(ft_int16_t x0, ft_int16_t y0, ft_int16_t x1, ft_int16_t y1, ft_int16_t corner)
00040 {
00041     ft_uint32_t calc;
00042 
00043     StartFunc(FT_CMD_SIZE*5);
00044     SendCmd(DL_BEGIN | FT8_RECTS);
00045     calc = LINE_WIDTH(corner * 16);
00046     SendCmd(calc);
00047     calc = VERTEX2F(x0 * 16, y0 * 16);
00048     SendCmd(calc);
00049     calc = VERTEX2F(x1 * 16, y1 * 16);
00050     SendCmd(calc);
00051     SendCmd(DL_END);
00052     EndFunc();
00053 }
00054 
00055 ft_void_t FT813::RectWH(ft_int16_t x0, ft_int16_t y0, ft_int16_t w, ft_int16_t h, ft_int16_t corner)
00056 {
00057     ft_uint32_t calc;
00058     x0 += corner;
00059     y0 += corner;
00060     w -= corner*2;
00061     h -= corner*2;
00062     ft_int16_t x1 = x0 + w;
00063     ft_int16_t y1 = y0 + h;
00064     StartFunc(FT_CMD_SIZE*5);
00065     SendCmd(DL_BEGIN | FT8_RECTS);
00066     calc = LINE_WIDTH(corner * 16);
00067     SendCmd(calc);
00068     calc = VERTEX2F(x0 * 16, y0 * 16);
00069     SendCmd(calc);
00070     calc = VERTEX2F(x1 * 16, y1 * 16);
00071     SendCmd(calc);
00072     SendCmd(DL_END);
00073     EndFunc();
00074 }
00075 
00076 /* Function to load JPG file from the filesystem into the FT800 buffer. */
00077 /* First the graphics data have to be load into the FT800 buffer.       */
00078 /* The FT800 will decode the JPG data into a bitmap.                    */      
00079 /* In the second step this bitmap will displayed on the LCD.            */  
00080 /* return 0 if jpg is ok                                                */
00081 /* return x_size and y_size of jpg                                      */
00082 ft_uint8_t FT813::LoadJpg(char* filename, ft_int16_t* x_size, ft_int16_t* y_size)
00083 {
00084 //    unsigned char pbuff[8192];
00085     int bufferSize = 8192;
00086 //    void* pbuff;
00087     char* pbuff = (char*)malloc(bufferSize);
00088 //    char pbuff[BUFFER_SIZE] = {0};
00089     unsigned short marker;
00090     unsigned short length;
00091     unsigned char data[4];
00092   
00093     ft_uint16_t blocklen;
00094  
00095 //    printf("LoadJpg: Open filename \"%s\".\n", filename);
00096 
00097     FILE *fp = fopen(filename, "rb");
00098     if(fp == NULL) {
00099         free(pbuff);
00100         printf("LoadJpg: Cannot open file \"%s\".\n", filename);
00101         return (-1);         // cannot open file
00102     }
00103  
00104     // https://en.wikipedia.org/wiki/JPEG
00105     // search for 0xFFC0 marker
00106     fseek(fp, 0, SEEK_END);
00107     unsigned int filesize = ftell(fp);
00108     printf("LoadJpg: Size: %d.\n", filesize);
00109 
00110     fseek(fp, 2, SEEK_SET); // Beginning of file
00111     fread(data, 4, 1, fp); // Read first 4 bytes
00112     marker = data[0] << 8 | data[1];
00113     length = data[2] << 8 | data[3];
00114     do {
00115         if(marker == 0xFFC0)
00116             break;
00117         if(marker & 0xFF00 != 0xFF00)
00118             break;
00119         if (fseek(fp, length - 2,SEEK_CUR) != 0) // Skip marker
00120             break;
00121         fread(data, 4, 1, fp);
00122         marker = data[0] << 8 | data[1];
00123         length = data[2] << 8 | data[3];
00124     } while(1);
00125     
00126     if(marker != 0xFFC0) {
00127         free(pbuff);
00128         printf("LoadJpg: marker != 0xFFC0\n");
00129         return (-2);  // No FFC0 Marker, wrong format no baseline DCT-based JPEG
00130     }
00131     
00132     fseek(fp, 1, SEEK_CUR); // Skip marker
00133     fread(data, 8, 1, fp);  // Read next 8 bytes & extract height & width
00134     *y_size = (data[0] << 8 | data[1]);
00135     *x_size = (data[2] << 8 | data[3]);
00136     uint16_t size_y = (data[0] << 8 | data[1]);
00137     uint16_t size_x = (data[2] << 8 | data[3]);
00138 
00139     uint16_t disp_x = DispWidth;
00140     uint16_t disp_y = DispHeight;
00141     if ((_orientation == FT8_DISPLAY_PORTRAIT_90CW) || (_orientation == FT8_DISPLAY_PORTRAIT_90CCW)) {
00142         disp_x = DispHeight;
00143         disp_y = DispWidth;
00144     }
00145   
00146 // http://www.ftdichip.com/Support/Documents/AppNotes/AN_339%20Using%20JPEGs%20with%20the%20FT800%20series.pdf, page 11
00147 //    if (marker_next_byte[0] == 0xC2){ //check if progressive JPEG
00148 //        error_code = 3;
00149 //    }
00150 
00151 //    if(*x_size > TFT.FT_DispWidth || *y_size > TFT.FT_DispHeight) return (-3);  // to big to fit on screen
00152     if(*x_size > disp_x || *y_size > disp_y)
00153     {
00154         free(pbuff);
00155         printf("LoadJpg: Too big to fit on screen\n");
00156         printf("LoadJpg: JPG (%dx%d) does not fit on TFT (%dx%d)\n", *x_size, *y_size, DispWidth, DispHeight);
00157         return (-3);  // Too big to fit on screen
00158     }
00159  
00160 //    printf("LoadJpg: JPG (%dx%d) fits on TFT (%dx%d)\n", *x_size, *y_size, DispWidth, DispHeight);
00161 
00162     fseek(fp, 0, SEEK_SET);
00163     
00164     
00165     WrCmd32(CMD_LOADIMAGE);
00166     WrCmd32(_address);             //destination address of jpg decode
00167     
00168     // Keep track of of the start addresses of loaded images
00169     // Increment _address
00170     _addresses[_bitmap_count] = _address;
00171     _bitmap_count++;
00172     _address += (uint32_t) (size_x * size_y * 2);
00173     _addresses[_bitmap_count] = _address;
00174     // 0 OPT_RGB565
00175     // 1 OPT_MONO
00176     // 2 OPT_NODL
00177     // 256 OPT_FLAT
00178     // 256 OPT_SIGNED
00179     // 512 OPT_CENTERX
00180     // 1024 OPT_CENTERY
00181     // 1536 OPT_CENTER
00182     // 2048 OPT_RIGHTX
00183     // 4096 OPT_NOBACK
00184     // 8192 OPT_NOTICKS
00185     WrCmd32(0);             //output format of the bitmap - default is rgb565
00186     while(filesize > 0) {
00187         /* download the data into the command buffer by 8kb one shot */
00188         blocklen = filesize > bufferSize ? bufferSize : filesize;
00189 //        printf("LoadJpg: blocklen: %d\n", blocklen);
00190 //        printf("LoadJpg: filesize: %d\n", filesize);
00191 
00192         /* copy the data into pbuff and then transfter it to command buffer */
00193 //        int size = fread(&pbuff[0], 1, blocklen, fp);
00194         int size = fread(pbuff, 1, blocklen, fp);
00195 //        printf("LoadJpg: fread: %d, %d\n", blocklen, size);
00196         filesize -= blocklen;
00197         /* copy data continuously into command memory */
00198 //        TFT.Ft_Gpu_Hal_WrCmdBuf(pbuff, blocklen); //alignment is already taken care by this api
00199         WrCmdBuf((uint8_t *)pbuff, blocklen); //alignment is already taken care by this api
00200     }
00201     fclose(fp);
00202     free(pbuff);
00203  
00204     return(0);
00205 }
00206 
00207 ft_uint8_t FT813::LoadPng(char* filename, ft_int16_t* x_size, ft_int16_t* y_size)
00208 {
00209     int bufferSize = 8192;
00210     ft_uint32_t filesize = 0;
00211     ft_uint16_t blocklen = 0;
00212     uint32_t marker1;
00213     uint32_t marker2;
00214     unsigned short length;
00215     unsigned char data[32];
00216 
00217 //    printf("------------------------------\n");
00218     printf("LoadPng: Filename \"%s\".\n", filename);
00219   
00220     FILE *fp = fopen(filename, "rb");
00221     if(fp == NULL) {
00222         printf("LoadPng: Cannot open file \"%s\".\n", filename);
00223         return (-1);         // cannot open file
00224     }
00225  
00226     // Get file size
00227     fseek(fp, 0, SEEK_END); // End of file
00228     filesize = ftell(fp);
00229     fseek(fp, 0, SEEK_SET); // Beginning of file
00230     printf("LoadPng: Filesize %d\n", filesize);
00231 
00232     // search for 0x89504E47 and 0x0D0A1A0A markers "‰PNG...."
00233     fread(data, 1, 32, fp); // Read first 32 bytes
00234 //    rewind(fp); // Beginning of file
00235     fseek(fp, 0, SEEK_SET); // Beginning of file
00236 
00237     // Check that this is indeed a PNG file
00238     unsigned char png_header[] = {0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A};
00239     // Make sure you have an IHDR
00240     unsigned char ihdr_name[] = "IHDR";
00241     if ((memcmp(data, png_header, 8)) || (memcmp(data+8+4, ihdr_name, 4))) {
00242         printf("LoadPng: Invalid PNG file.\n");
00243         return (-2);  // No FFC0 Marker, wrong format no baseline DCT-based JPEG
00244     }
00245 
00246     // PNG actually stores integers in big-endian.
00247     *x_size = ReadBigInt32(data, 24 - 8);
00248     *y_size = ReadBigInt32(data, 24 - 4);
00249     uint16_t size_x = ReadBigInt32(data, 24 - 8);
00250     uint16_t size_y = ReadBigInt32(data, 24 - 4);
00251   
00252     uint16_t disp_x = DispWidth;
00253     uint16_t disp_y = DispHeight;
00254     if ((_orientation == FT8_DISPLAY_PORTRAIT_90CW) || (_orientation == FT8_DISPLAY_PORTRAIT_90CCW)) {
00255         disp_x = DispHeight;
00256         disp_y = DispWidth;
00257     }
00258 
00259     if(*x_size > disp_x || *y_size > disp_y)
00260     {
00261         printf("LoadPng: Too big to fit on screen\n");
00262         printf("LoadPng: PNG (%dx%d) does not fit on TFT (%dx%d)\n", *x_size, *y_size, DispWidth, DispHeight);
00263         return (-3);  // Too big to fit on screen
00264     }
00265 
00266 //    printf("LoadPng: PNG (%dx%d) fits on TFT (%dx%d)\n", *x_size, *y_size, DispWidth, DispHeight);
00267     
00268     // http://www.ftdichip.com/Support/Documents/AppNotes/AN_339%20Using%20JPEGs%20with%20the%20FT800%20series.pdf
00269     // CMD_LOADIMAGE: This function will decode the JPEG file, produce
00270     // either RGB565 or L8 bitmap data and store this in graphics RAM.
00271     // It also writes commands to the display list to set the source, layout and size of the
00272     // image (BITMAP_SOURCE, BITMAP_LAYOUT and BITMAP_SIZE).
00273     // Note that only a BEGIN and VERTEX2F (or VERTEX2II) display list commands are then
00274     // required to complete the display list needed to render the image.
00275     WrCmd32(CMD_LOADIMAGE); 
00276     WrCmd32(_address);             //destination address of png decode
00277     // 0 OPT_RGB565
00278     // 1 OPT_MONO
00279     // 2 OPT_NODL
00280     // 256 OPT_FLAT
00281     // 256 OPT_SIGNED
00282     // 512 OPT_CENTERX
00283     // 1024 OPT_CENTERY
00284     // 1536 OPT_CENTER
00285     // 2048 OPT_RIGHTX
00286     // 4096 OPT_NOBACK
00287     // 8192 OPT_NOTICKS
00288     // By default, option OPT_RGB565 means the loaded bitmap is in RGB565 format.
00289     
00290     // Keep track of of the start addresses of loaded images
00291     // Increment _address
00292     _addresses[_bitmap_count] = _address;
00293     _bitmap_count++;
00294     _address += (uint32_t) (size_x * size_y * 2);
00295     _addresses[_bitmap_count] = _address;
00296     printf("LoadPng: Bitmap# %d, Res. %dx%d, Address %d-%d\n", _bitmap_count - 1, *x_size, *y_size, _addresses[_bitmap_count-1], _addresses[_bitmap_count]);
00297 
00298     WrCmd32(OPT_RGB565);             // Output format of the bitmap OPT_RGB565
00299 //    unsigned int filesizeCounter = filesize;
00300     char* pbuff = (char*)malloc(bufferSize);
00301     while(filesize > 0) {
00302         blocklen = filesize > bufferSize ? bufferSize : filesize;
00303         int size = fread(pbuff, 1, blocklen, fp);
00304         filesize -= blocklen;
00305 
00306         WrCmdBuf((uint8_t *)pbuff, blocklen); //alignment is already taken care by this api
00307     }
00308     fclose(fp);
00309     // If the number of bytes in the JPEG file to be written to the command buffer is not a multiple of
00310     // four, then one, two or three bytes (of any value) should be added to ensure four-byte alignment of
00311     // the next command.
00312 //    blocklen = filesize % 4;
00313 //    memset(pbuff, 0, blocklen);
00314 //    WrCmdBuf((uint8_t *)pbuff, blocklen); //alignment is already taken care by this api
00315  
00316     free(pbuff);
00317 
00318     printf("LoadPng: Done.\n");
00319 
00320     return(0);
00321 }
00322 
00323 int FT813::LoadRaw(char* filename)
00324 {
00325     ft_uint16_t filesize = 0;
00326     ft_uint16_t blocklen;
00327     ft_uint16_t ram_start = _address;
00328     int bufferSize = 8192;
00329 
00330     FILE *fp = fopen(filename, "rb");   //  open file
00331     if (fp == NULL)
00332     {
00333         // Cannot open file  
00334         printf("Unable to open: %s\n", filename);
00335         return -1;
00336     }
00337     fseek(fp, 0, SEEK_END);             //  set file position to end of file
00338     filesize = ftell(fp);               //  determine file size
00339     fseek(fp, 0, SEEK_SET);             //  return to beginning of file    
00340 
00341     // Keep track of of the start addresses of loaded images
00342     // Increment _address
00343     _addresses[_bitmap_count] = _address;
00344     _bitmap_count++;
00345     _address += (uint32_t) filesize;
00346     _addresses[_bitmap_count] = _address;
00347     printf("LoadRaw: Bitmap# %d, Address %d-%d\n", _bitmap_count - 1, _addresses[_bitmap_count-1], _addresses[_bitmap_count]);
00348 
00349     char* pbuff = (char*)malloc(bufferSize);
00350     while(filesize > 0)
00351     {
00352         //copy the .raw file data to pbuff[8192] in 8k block
00353         blocklen = filesize > bufferSize ? bufferSize : filesize;
00354         fread(pbuff, 1, blocklen, fp);
00355         filesize -= blocklen;
00356         //write pbuff contents to graphics RAM at address ram_start = 0x00
00357         Wr8s(ram_start, (uint8_t *)pbuff, blocklen); //alignment is already taken care by this api
00358         ram_start += blocklen;   
00359     }
00360     fclose(fp);
00361     free(pbuff);
00362     return 0;
00363 }
00364 
00365 int FT813::LoadRawFile(ft_uint32_t address, const char *filename)
00366 {
00367     int bufferSize = 8192;
00368     ft_uint32_t filesize = 0;
00369     ft_uint16_t blocklen = 0;
00370 
00371     _address = address;
00372     ft_uint32_t addr = address;
00373     
00374     FILE *fp = fopen(filename, "rb");
00375     if (fp == NULL)
00376     {
00377         printf("LoadRawFile: Cannot open file \"%s\".\n", filename);
00378         return 0;
00379     }
00380     fseek(fp, 0, SEEK_END); // End of file
00381     filesize = ftell(fp);
00382     fseek(fp, 0, SEEK_SET); // Beginning of file
00383 
00384     // Keep track of of the start addresses of loaded images
00385     // Increment _address
00386     _addresses[_bitmap_count] = _address;
00387     _bitmap_count++;
00388     _address += (uint32_t) filesize;
00389     _addresses[_bitmap_count] = _address;
00390     printf("LoadRawFile: Bitmap# %d, Address %d-%d\n", _bitmap_count - 1, _addresses[_bitmap_count-1], _addresses[_bitmap_count]);
00391 
00392     char* pbuff = (char*)malloc(bufferSize);
00393     while (filesize > 0)
00394     {
00395         blocklen = filesize >  bufferSize ? bufferSize : filesize;
00396         fread(pbuff, 1, blocklen, fp);
00397         filesize -= blocklen;
00398         WrMem(addr, (ft_uint8_t *)pbuff, blocklen);
00399         addr += blocklen;
00400 //        WrCmdBuf((ft_uint8_t *)pbuff, blocklen); //alignment is already taken care by this api
00401     }
00402     fclose(fp);
00403     free(pbuff);
00404 
00405     printf("LoadRawFile: Done.\n");
00406     return 1;
00407 }
00408 
00409 int FT813::LoadInflateFile(ft_uint32_t address, const char *filename)
00410 {
00411     int bufferSize = 8192;
00412     ft_uint32_t filesize = 0;
00413     ft_uint16_t blocklen = 0;
00414     ft_uint32_t addr = address;
00415     ft_uint32_t filesize_org = address;
00416 
00417     _address = address;
00418 
00419     FILE *fp = fopen(filename, "rb");      // read Binary (rb)
00420     if (fp == NULL)
00421     {
00422         printf("LoadInflateFile: Cannot open file \"%s\".\n", filename);
00423         return 0;
00424     }
00425     fseek(fp, 0, SEEK_END); // End of file
00426     filesize = ftell(fp);
00427     fseek(fp, 0, SEEK_SET); // Beginning of file
00428 
00429     // Keep track of of the start addresses of loaded images
00430     // Increment _address
00431     _addresses[_bitmap_count] = _address;
00432     _bitmap_count++;
00433 //    _address += (uint32_t) 0;
00434     _addresses[_bitmap_count] = _address;
00435 //    printf("# %d, Addr %d\n", _bitmap_count - 1, _addresses[_bitmap_count-1]);
00436 
00437     WrCmd32(CMD_INFLATE);
00438     WrCmd32(address);             //destination address of bin decode
00439 
00440     char* pbuff = (char*)malloc(bufferSize);
00441     while (filesize > 0)
00442     {
00443         blocklen = filesize > bufferSize ? bufferSize : filesize;
00444         int size = fread(pbuff, 1, blocklen, fp);   /* copy the data into pbuff and then transfter it to command buffer */
00445         filesize -= blocklen;
00446 
00447 //        WrMem(addr, (ft_uint8_t *)pbuff, blocklen);
00448 //        addr += blocklen;
00449 
00450         //Do not call "Ft_Gpu_Hal_WrCmdBuf_nowait" because it may cause emulator process hang. 
00451         WrCmdBuf((ft_uint8_t *)pbuff, blocklen); //alignment is already taken care by this api
00452 //        WaitCmdfifo_empty();
00453     }   
00454     // If the number of bytes in the JPEG file to be written to the command buffer is not a multiple of
00455     // four, then one, two or three bytes (of any value) should be added to ensure four-byte alignment of
00456     // the next command.
00457 //    blocklen = filesize_org % 4;
00458 //    memset(pbuff, 0, blocklen);
00459 //    WrMem(addr, (ft_uint8_t *)pbuff, blocklen);
00460 //    WrCmdBuf((uint8_t *)pbuff, blocklen); //alignment is already taken care by this api
00461 
00462 //    WaitCmdfifo_empty();            
00463 
00464     fclose(fp);                                              /* close the opened jpg file */
00465     free(pbuff);
00466     return 1;
00467 }
00468 
00469 int FT813::LoadImageFile(ft_uint32_t address, const char *filename)
00470 {
00471     int bufferSize = 8192;
00472     ft_uint32_t filesize = 0;
00473     ft_uint16_t blocklen = 0;
00474 
00475     _address = address;
00476 
00477     FILE *fp = fopen(filename, "rb");      // read Binary (rb)
00478     if (fp == NULL)
00479     {
00480         printf("LoadImageFile: Cannot open file \"%s\".\n", filename);
00481         return 0;
00482     }
00483     // TODO: Let it write into the scratch display list handle, 
00484     //  and read it out and write into the bitmapInfo the proper 
00485     //  values to use. Replace compressed bool with uint8 enum to
00486     //  specify the loading mechanism
00487     fseek(fp, 0, SEEK_END); // End of file
00488     filesize = ftell(fp);
00489     fseek(fp, 0, SEEK_SET); // Beginning of file
00490 
00491     // Keep track of of the start addresses of loaded images
00492     // Increment _address
00493     _addresses[_bitmap_count] = _address;
00494     _bitmap_count++;
00495     _address += (uint32_t) filesize;
00496     _addresses[_bitmap_count] = _address;
00497     printf("LoadImageFile: Bitmap# %d, Address %d-%d\n", _bitmap_count - 1, _addresses[_bitmap_count-1], _addresses[_bitmap_count]);
00498 
00499     WrCmd32(CMD_LOADIMAGE);
00500     WrCmd32(address);             //destination address of png decode
00501     // 0 OPT_RGB565
00502     // 1 OPT_MONO
00503     // 2 OPT_NODL
00504     // 256 OPT_FLAT
00505     // 256 OPT_SIGNED
00506     // 512 OPT_CENTERX
00507     // 1024 OPT_CENTERY
00508     // 1536 OPT_CENTER
00509     // 2048 OPT_RIGHTX
00510     // 4096 OPT_NOBACK
00511     // 8192 OPT_NOTICKS
00512     // By default, option OPT_RGB565 means the loaded bitmap is in RGB565 format.
00513     WrCmd32(OPT_RGB565);             // Output format of the bitmap OPT_RGB565
00514 //    WrCmd32(OPT_NODL);
00515     char* pbuff = (char*)malloc(bufferSize);
00516     while (filesize > 0)
00517     {
00518         blocklen = filesize > bufferSize ? bufferSize : filesize;
00519         int size = fread(pbuff, 1, blocklen, fp);   /* copy the data into pbuff and then transfter it to command buffer */
00520         filesize -= blocklen;
00521 //        blocklen += 3;
00522 //        blocklen -= blocklen % 4;
00523         
00524         //Do not call "Ft_Gpu_Hal_WrCmdBuf_nowait" because it may cause emulator process hang. 
00525         WrCmdBuf((ft_uint8_t *)pbuff, blocklen); //alignment is already taken care by this api
00526     }   
00527 //    WaitCmdfifo_empty();
00528     
00529     fclose(fp);                                              /* close the opened jpg file */
00530     free(pbuff);
00531     return 1;
00532 }
00533 
00534 ft_void_t FT813::SetEndAddressForSize(ft_uint32_t addr)
00535 {
00536     _addresses[_bitmap_count] = _addresses[_bitmap_count - 1] + addr;
00537 }
00538 
00539 ft_void_t FT813::Wr8s(ft_uint32_t addr, ft_uint8_t *buffer, ft_uint8_t length)
00540 {
00541 //    StartTransfer(FT_GPU_WRITE, addr);
00542 //    if (FT_GPU_READ == rw) {  // if (FT_GPU_READ == FT_GPU_WRITE)
00543 //        _ss = 0;       // cs low
00544 //        _spi.write(addr >> 16);
00545 //        _spi.write(addr >> 8);
00546 //        _spi.write(addr & 0xff);
00547 //        _spi.write(0); //Dummy Read Byte
00548 //        status = READING;
00549 //    } else {
00550         _ss = 0;       // cs low
00551         _spi.write(0x80 | (addr >> 16));
00552         _spi.write(addr >> 8);
00553         _spi.write(addr & 0xff);
00554         status = WRITING;
00555 //    }
00556 
00557 //    Transfer8(v);
00558 //    _spi.write(v);
00559 
00560     while (length--) {
00561 //            Transfer8(*buffer);
00562         _spi.write(*buffer);
00563         buffer++;
00564 //            SizeTransfered++;
00565     }
00566 
00567 //    EndTransfer();
00568     _ss = 1;
00569     status = OPENED;
00570 }
00571 
00572 //{
00573 //ft_uint8_t imbuff[8192];
00574 //ft_uint16_t blocklen;
00575 ////decompress the .bin file using CMD_INFLATE
00576 //WrCmd32(phost,CMD_INFLATE);
00577 ////specify starting address in graphics RAM
00578 //WrCmd32(phost,0L);
00579 ////check filesize and adjust number of bytes to multiple of 4
00580 //chdir("..\\..\\..\\Test"); //change directory to location (Test) of .bin file
00581 //pfile = fopen("lenaface40.bin","rb");
00582 //fseek(pfile,0,SEEK_END); //set file position to end of file
00583 //filesize = ftell(pfile); // determine file size
00584 //fseek(pfile,0,SEEK_SET); // return to beginning of file
00585 //while(filesize > 0)
00586 //{
00587 // //copy the .raw file data to imbuff[8192] in 8k blocks
00588 //blocklen = filesize>8192?8192:filesize;
00589 //fread(imbuff,1,blocklen,pfile);
00590 //filesize -= blocklen; //reduce filesize by blocklen
00591 ////write imbuff contents to the FT800 FIFO command buffer
00592 //Ft_Gpu_Hal_WrCmdBuf(phost,imbuff,blocklen);
00593 //}
00594 //fclose(pfile); /* close the opened .bin file */
00595 //}
00596 
00597 int FT813::LoadRawFile(ft_uint32_t address, char* filename)
00598 {
00599     ft_uint16_t filesize;
00600     ft_uint16_t blocklen;
00601     ft_uint32_t addr = address;
00602     int bufferSize = 8192;
00603 
00604     FILE *fp = fopen(filename, "rb");   //  open file
00605     if (fp == NULL)
00606     {
00607         // Cannot open file  
00608         printf("Unable to open: %s\n", filename);
00609         return -1;
00610     }
00611     fseek(fp, 0, SEEK_END);             //  set file position to end of file
00612     filesize = ftell(fp);               //  determine file size
00613     fseek(fp, 0, SEEK_SET);             //  return to beginning of file
00614 #ifdef DEBUG
00615     printf("LoadRawFile: %s %d @ %d\n", filename, filesize, address);
00616 #endif
00617 
00618     char* pbuff = (char*)malloc(bufferSize);
00619     while(filesize > 0)
00620     {
00621         //copy the .raw file data to pbuff[8192] in 8k block
00622         blocklen = filesize > bufferSize ? bufferSize : filesize;
00623         fread(pbuff, 1, blocklen, fp);
00624         filesize -= blocklen;
00625         //write pbuff contents to graphics RAM at addr
00626         WrMem(addr, (ft_uint8_t *)pbuff, blocklen);
00627         addr += blocklen;   
00628     }
00629     fclose(fp);
00630     free(pbuff);
00631     return 0;
00632 }
00633 
00634 void FT813::FillBitmap(ft_int16_t bitmap_number)
00635 {
00636     int bufferSize = 8192;
00637     uint8_t* pbuff = (uint8_t*)malloc(bufferSize);
00638     // Clear buffer
00639     memset(pbuff, 0, bufferSize);
00640 
00641     ft_int32_t addr_start = _addresses[bitmap_number];
00642     ft_int32_t addr_end = _addresses[bitmap_number+1];
00643     printf("FillBitmap %d (%d - %d).\n", bitmap_number, addr_start, addr_end);
00644 //    ft_int32_t bufferSize = addr_end - addr_start;
00645     ft_int32_t filesize = addr_end - addr_start;
00646 //    ft_int32_t addr = addr_start;
00647     
00648     WrCmd32(CMD_LOADIMAGE);
00649     WrCmd32(addr_start);             //destination address of png decode
00650     WrCmd32(0);             //output format of the bitmap - default is rgb565
00651     printf("filesize = %d\n", filesize);
00652     printf("while(filesize > 0)...\n");
00653     while(filesize > 0) {
00654         ft_uint16_t blocklen = filesize > bufferSize ? bufferSize : filesize;
00655 //    printf("WrCmdBuf %d.\n", bufferSize);
00656         filesize -= blocklen;
00657         printf("blocklen = %d\n", blocklen);
00658         printf("WrCmdBuf...\n");
00659         WrCmdBuf(pbuff, blocklen); //alignment is already taken care by this api
00660         printf("Done.\n");
00661     }
00662     printf("free(pbuff)...\n");
00663     free(pbuff);
00664     printf("Done.\n");
00665 }
00666 
00667 void FT813::ClearBitmapCount(void)
00668 {
00669     _bitmap_count = 0;
00670 }
00671 
00672 ft_uint32_t FT813::ReadBigInt32(unsigned char* data, ft_uint32_t offset)
00673 {
00674     return (data[offset + 0] << 24 | data[24 - 4 + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]);
00675 }
00676 
00677 // Loads JPG at x, y on the screen
00678 ft_uint8_t FT813::Jpg(char *jpg_filename, int x, int y)
00679 {
00680     ft_int16_t x_size,y_size;
00681     int err;
00682 
00683     err = LoadJpg(jpg_filename, & x_size, & y_size);      // load graphic data into buffer and decode jpg to bitmap
00684     if(err != 0) {                                           // something is wrong - display error   
00685         printf("LoadJpg: Error.\n");
00686         return(-1);
00687     }
00688     DL(BEGIN(BITMAPS));                  
00689 //    LoadIdentity();
00690 //    SetMatrix();
00691     DL(VERTEX2F(x * 16, y * 16));                  
00692 
00693     // jpg is loaded and decoded into bitmap
00694 //    printf("jpg %s is loaded and decoded into bitmap (%dx%d)\n", jpg_filename, x_size, y_size);
00695 
00696     return(0);
00697 }
00698 
00699 // Loads PNG at x, y on the screen
00700 ft_uint8_t FT813::Png(char *png_filename, int x, int y)
00701 {
00702     ft_int16_t x_size,y_size;
00703     int err;
00704 
00705     err = LoadPng(png_filename, & x_size, & y_size);      // load graphic data into buffer and decode png to bitmap
00706     if(err != 0) {                                           // something is wrong - display error   
00707         printf("LoadPng: Error.\n");
00708         return(-1);
00709     }
00710     DL(BEGIN(BITMAPS));                  
00711 //    LoadIdentity();
00712 //    SetMatrix();
00713     DL(VERTEX2F(x * 16, y * 16));                  
00714 
00715     // png is loaded and decoded into bitmap
00716 //    printf("png %s is loaded and decoded into bitmap (%dx%d)\n", png_filename, x_size, y_size);
00717 
00718     return(0);
00719 }
00720 
00721 // Loads PNG at x, y on the screen at given address
00722 ft_uint8_t FT813::Png(char *png_filename, int x, int y, ft_int32_t address)
00723 {
00724     ft_int16_t x_size,y_size;
00725     int err;
00726     _address = address;
00727     err = LoadPng(png_filename, & x_size, & y_size);      // load graphic data into buffer and decode png to bitmap
00728     if(err != 0) {                                           // something is wrong - display error   
00729         printf("LoadPng: Error.\n");
00730         return(-1);
00731     }
00732     DL(BEGIN(BITMAPS));                  
00733 //    LoadIdentity();
00734 //    SetMatrix();
00735     DL(VERTEX2F(x * 16, y * 16));                  
00736 
00737 //    DL(DISPLAY()); //ends the display,commands after this ignored                 
00738 
00739     // png is loaded and decoded into bitmap
00740     printf("png %s is loaded and decoded into bitmap (%dx%d)\n", png_filename, x_size, y_size);
00741 
00742     return(0);
00743 }
00744 
00745 // Loads JPG at the center of the screen (splash screen)
00746 // Background color specified
00747 ft_uint8_t FT813::JpgSplash(char *jpg_filename, ft_uint8_t r, ft_uint8_t g, ft_uint8_t b)
00748 {
00749     ft_int16_t x_size,y_size;
00750     int err;
00751 
00752     DLstart();                              // start a new display command list
00753     DL(CLEAR_COLOR_RGB(r, g, b));  // set the clear color to white
00754     DL(CLEAR(1, 1, 1));                     // clear buffers -> color buffer,stencil buffer, tag buffer
00755 
00756     err = LoadJpg(jpg_filename, & x_size, & y_size);      // load graphic data into buffer and decode jpg to bitmap
00757     if(err != 0) {                                           // something is wrong - display error   
00758         printf("LoadJpg: Error.\n");
00759         return(-1);
00760     }
00761     
00762     DL(BEGIN(BITMAPS));                  
00763     LoadIdentity();
00764     SetMatrix();
00765     int x = (DispWidth - x_size) / 2;
00766     int y = (DispHeight - y_size) / 2;
00767     DL(VERTEX2F(x * 16, y * 16));                  
00768 
00769     DL(DISPLAY());                          // Display the image
00770     Swap();                                 // Swap the current display list
00771     Flush_Co_Buffer();                      // Download the command list into fifo
00772     WaitCmdfifo_empty();                    // Wait till coprocessor completes the operation
00773     
00774     return(0);
00775 }
00776 
00777 // ***************************************************************************************************************
00778 // *** Utility and helper functions ******************************************************************************
00779 // ***************************************************************************************************************
00780 
00781 // Find the space available in the GPU AKA CoProcessor AKA command buffer AKA FIFO
00782 ft_uint16_t FT813::CoProFIFO_FreeSpace(void)
00783 {
00784     ft_uint16_t cmdBufferDiff, cmdBufferRd, cmdBufferWr, retval;
00785     
00786     cmdBufferRd = Rd16(REG_CMD_READ + RAM_REG);
00787     cmdBufferWr = Rd16(REG_CMD_WRITE + RAM_REG);
00788     
00789     cmdBufferDiff = (cmdBufferWr-cmdBufferRd) % FT_CMD_FIFO_SIZE; // FT81x Programmers Guide 5.1.1
00790     retval = (FT_CMD_FIFO_SIZE - 4) - cmdBufferDiff;
00791     return (retval);
00792 }
00793 
00794 // Sit and wait until there are the specified number of bytes free in the <GPU/CoProcessor> incoming FIFO
00795 void FT813::Wait4CoProFIFO(ft_uint32_t room)
00796 {
00797     ft_uint16_t getfreespace;
00798     
00799     do {
00800         getfreespace = CoProFIFO_FreeSpace();
00801     } while(getfreespace < room);
00802 }
00803 
00804 // Sit and wait until the CoPro FIFO is empty
00805 void FT813::Wait4CoProFIFOEmpty(void)
00806 {
00807   while(Rd16(REG_CMD_READ + RAM_REG) != Rd16(REG_CMD_WRITE + RAM_REG));
00808 }
00809 
00810 // Check if the CoPro FIFO is empty
00811 // returns 1 if the CoPro FIFO is empty
00812 // returns 0 if the CoPro FIFO is not empty
00813 ft_uint8_t FT813::CheckIfCoProFIFOEmpty(void)
00814 {
00815     return (Rd16(REG_CMD_READ + RAM_REG) == Rd16(REG_CMD_WRITE + RAM_REG)) ? 1 : 0;
00816 }
00817 
00818 // Write a block of data into Eve RAM space a byte at a time.
00819 // Return the last written address + 1 (The next available RAM address)
00820 ft_uint32_t FT813::WriteBlockRAM(ft_uint32_t Add, const ft_uint8_t *buff, ft_uint32_t count)
00821 {
00822     ft_uint32_t index;
00823     ft_uint32_t WriteAddress = Add;  // I want to return the value instead of modifying the variable in place
00824     
00825     for (index = 0; index < count; index++) {
00826         Wr8(WriteAddress++, buff[index]);
00827     }
00828     return (WriteAddress);
00829 }
00830 
00831 /* function to load jpg file from filesystem */
00832 /* return 0 if jpg is ok                     */
00833 /* return x_size and y_size of jpg           */
00834 
00835 //int FT813::Load_jpg(char* filename, ft_int16_t* x_size, ft_int16_t* y_size, ft_uint32_t address)
00836 //{
00837 //    unsigned char pbuff[8192];
00838 //    unsigned short marker;
00839 //    unsigned short length;
00840 //    unsigned char data[4];
00841 //
00842 //    ft_uint16_t blocklen;
00843 ////    sd.mount();
00844 //    FILE *fp = fopen(filename, "r");
00845 //    if(fp == NULL) return (-1);         // connot open file
00846 //
00847 //    // search for 0xFFC0 marker
00848 //    fseek(fp, 0, SEEK_END);
00849 //    unsigned int filesize = ftell(fp);
00850 //    fseek(fp, 2, SEEK_SET);
00851 //    fread(data,4,1,fp);
00852 //    marker = data[0] << 8 | data[1];
00853 //    length = data[2] << 8 | data[3];
00854 //    do {
00855 //        if(marker == 0xFFC0) break;
00856 //        if(marker & 0xFF00 != 0xFF00) break;
00857 //        if (fseek(fp, length - 2,SEEK_CUR) != 0) break;
00858 //        fread(data,4,1,fp);
00859 //        marker = data[0] << 8 | data[1];
00860 //        length = data[2] << 8 | data[3];
00861 //    } while(1);
00862 //    if(marker != 0xFFC0) return (-2);  // no FFC0 Marker, wrong format no baseline DCT-based JPEG
00863 //    fseek(fp, 1,SEEK_CUR);
00864 //    fread(data,4,1,fp);
00865 //    *y_size = (data[0] << 8 | data[1]);
00866 //    *x_size = (data[2] << 8 | data[3]);
00867 //
00868 //    //if(*x_size > DispWidth || *y_size > DispHeight) return (-3);  // to big to fit on screen
00869 //
00870 //    fseek(fp, 0, SEEK_SET);
00871 //    WrCmd32(CMD_LOADIMAGE);  // load a JPEG image
00872 //    WrCmd32(address);              //destination address of jpg decode
00873 //    WrCmd32(0);              //output format of the bitmap - default is rgb565
00874 //    while(filesize > 0) {
00875 //        /* download the data into the command buffer by 8kb one shot */
00876 //        blocklen = filesize>8192?8192:filesize;
00877 //        /* copy the data into pbuff and then transfter it to command buffer */
00878 //        fread(pbuff,1,blocklen,fp);
00879 //        filesize -= blocklen;
00880 //        /* copy data continuously into command memory */
00881 //        WrCmdBuf(pbuff, blocklen); //alignment is already taken care by this api
00882 //    }
00883 //    fclose(fp);
00884 ////    sd.unmount();
00885 //
00886 //    return(0);
00887 //}
00888 
00889 //int FT813::Load_raw(char* filename)
00890 //{
00891 //    ft_uint8_t imbuff[8192];
00892 //    ft_uint16_t filesize;
00893 //    ft_uint16_t blocklen;
00894 ////    ft_uint16_t ram_start = 0x00;
00895 //    
00896 ////    sd.mount();  
00897 //    FILE *fp = fopen(filename, "rb");   //  open file
00898 ////    if(fp == NULL) return (-1);       //  connot open file         
00899 //    fseek(fp, 0, SEEK_END);             //  set file position to end of file
00900 //    filesize= ftell(fp);                //  determine file size
00901 //    fseek(fp, 2, SEEK_SET);             //  return to beginning of file       
00902 //
00903 //    while(filesize > 0)
00904 //    {
00905 //        //copy the .raw file data to imbuff[8192] in 8k block
00906 //        blocklen = filesize>8192?8192:filesize;
00907 //        fread(imbuff,1,blocklen,fp);
00908 //        filesize-= blocklen;
00909 //        //write imbuff contents to graphics RAM at address ram_start = 0x00
00910 //        WrCmdBuf(imbuff, blocklen); //alignment is already taken care by this api
00911 ////        ram_start += 8192;   
00912 //    }
00913 //    fclose(fp);
00914 ////    sd.unmount();
00915 //    
00916 //    return 0;
00917 //}
00918 
00919 /* calibrate touch */
00920 ft_void_t FT813::Calibrate()
00921 {
00922     /*************************************************************************/
00923     /* Below code demonstrates the usage of calibrate function. Calibrate    */
00924     /* function will wait untill user presses all the three dots. Only way to*/
00925     /* come out of this api is to reset the coprocessor bit.                 */
00926     /*************************************************************************/
00927     DLstart();                                       // start a new display command list
00928     DL(CLEAR_COLOR_RGB(64,64,64));       // set the clear color R, G, B
00929     DL(CLEAR(1,1,1));                    // clear buffers -> color buffer,stencil buffer, tag buffer
00930     DL(COLOR_RGB(0xff,0xff,0xff));       // set the current color R, G, B
00931     Text((DispWidth/2), (DispHeight/2), 27, OPT_CENTER, "Please tap on the dot");  // draw Text at x,y, font 27, centered
00932     Calibrate(0);                                    // start the calibration of touch screen
00933     Flush_Co_Buffer();                               // download the commands into FT813 FIFO
00934     WaitCmdfifo_empty();                             // Wait till coprocessor completes the operation
00935 }
00936 
00937 
00938 /* API to give fadeout effect by changing the display PWM from 100 till 0 */
00939 ft_void_t FT813::fadeout()
00940 {
00941     ft_int32_t i;
00942     
00943     for (i = 100; i >= 0; i -= 3) 
00944     {
00945         Wr8(REG_PWM_DUTY, i);
00946         Sleep(2);//sleep for 2 ms
00947     }
00948 }
00949 
00950 /* API to perform display fadein effect by changing the display PWM from 0 till 100 and finally 128 */
00951 ft_void_t FT813::fadein()
00952 {
00953     ft_int32_t i;
00954     
00955     for (i = 0; i <=100 ; i += 3) 
00956     {
00957         Wr8(REG_PWM_DUTY,i);
00958         Sleep(2);//sleep for 2 ms
00959     }
00960     /* Finally make the PWM 100% */
00961     i = 128;
00962     Wr8(REG_PWM_DUTY,i);
00963 }
00964 
00965 ft_uint8_t FT813::read_calibrate_reg(ft_uint8_t i) {
00966     return Rd8(REG_TOUCH_TRANSFORM_A + i);
00967 }
00968 
00969 ft_uint32_t FT813::read_calibrate_reg32(ft_uint8_t i) {
00970     return (Rd8(REG_TOUCH_TRANSFORM_A + i)) +           // lsb
00971            (Rd8(REG_TOUCH_TRANSFORM_A + i+1) << 8) + 
00972            (Rd8(REG_TOUCH_TRANSFORM_A + i+2) << 16) + 
00973            (Rd8(REG_TOUCH_TRANSFORM_A + i+3) << 24);    //  msb
00974 }
00975 
00976 ft_void_t FT813::read_calibrate(ft_uint8_t data[24]) {
00977     unsigned int i;
00978     for(i = 0; i < 24; i++) {
00979         data[i] = Rd8(REG_TOUCH_TRANSFORM_A + i);
00980     }
00981 }
00982 
00983 ft_void_t FT813::write_calibrate(ft_uint8_t data[24]) {
00984     unsigned int i;
00985     for(i = 0; i < 24; i++) {
00986         Wr8(REG_TOUCH_TRANSFORM_A + i, data[i]);
00987     }
00988 }
00989 
00990 ft_void_t FT813::write_calibrate32(ft_uint32_t data[6]) {
00991     unsigned int i;
00992     for(i = 0; i < 6; i++) {
00993         Wr8(REG_TOUCH_TRANSFORM_A + i*4, (data[i]) & 0xff);       // lsb
00994         Wr8(REG_TOUCH_TRANSFORM_A + i*4 + 1, (data[i] >> 8) & 0xff);
00995         Wr8(REG_TOUCH_TRANSFORM_A + i*4 + 2, (data[i] >> 16) & 0xff);
00996         Wr8(REG_TOUCH_TRANSFORM_A + i*4 + 3, (data[i] >> 24) & 0xff);   // msb
00997     }
00998 }
00999 
01000 ft_uint32_t FT813::color_rgb(ft_uint8_t red, ft_uint8_t green, ft_uint8_t blue){
01001     return ((4UL<<24)|(((red)&255UL)<<16)|(((green)&255UL)<<8)|(((blue)&255UL)<<0));
01002 }
01003     
01004 ft_uint32_t FT813::clear_color_rgb(ft_uint8_t red, ft_uint8_t green, ft_uint8_t blue){
01005     return ((2UL<<24)|(((red)&255UL)<<16)|(((green)&255UL)<<8)|(((blue)&255UL)<<0));
01006 }    
01007 
01008 // Define the backlight PWM output duty cycle.
01009 void FT813::SetBacklight(ft_uint16_t brightness)
01010 {
01011     brightness = brightness * brightness / 255;
01012     if (brightness > 256)
01013         brightness = 256;
01014     if (brightness < 16)
01015         brightness = 16;
01016     Wr16(REG_PWM_DUTY, brightness); // Brightness
01017 }
01018 
01019 void FT813::Tag(ft_uint8_t tag)
01020 {
01021     DL(TAG(tag)); 
01022 }
01023 
01024 void FT813::ClearTag(ft_uint8_t tag)
01025 {
01026     DL(CLEAR_TAG(tag)); 
01027 }
01028 
01029 void FT813::TagMask(ft_uint8_t mask)
01030 {
01031     DL(TAG_MASK(mask)); 
01032 }
01033 
01034 void FT813::BitmapLayoutH(ft_uint8_t linestride, ft_uint8_t height)
01035 {
01036     DL((40 << 24) | (((linestride) & 3) << 2) | (((height) & 3) << 0));
01037 }
01038 
01039 void FT813::BitmapSizeH(ft_uint8_t width, ft_uint8_t height)
01040 {
01041     DL((41UL << 24) | (((width) & 3) << 2) | (((height) & 3) << 0));
01042 }
01043 
01044 ft_void_t FT813::SetLoadAddress(ft_uint32_t address)
01045 {
01046     _address = address;         // Old, try to get rid of this
01047     _bitmapAddress = address;
01048 }
01049 
01050 ft_void_t FT813::SetBitmapCount(ft_uint8_t count)
01051 {
01052     _bitmap_count = count;      // Old, try to get rid of this
01053     _bitmapCount = count;
01054 }
01055 
01056 ft_uint32_t FT813::GetBitmapAddress(ft_uint8_t bitmap_number)
01057 {
01058     return _addresses[bitmap_number];
01059 }
01060 
01061 void FT813::SetThemeDefaultColor(void)
01062 {
01063     // Default
01064     GradColor(COLOR_RGB(0xff, 0xff, 0xff)); // Default 0xffffff
01065     FgColor(COLOR_RGB(0x00, 0x38, 0x70));   // Default 0x003870    (0, 56, 112)
01066     BgColor(COLOR_RGB(0x00, 0x20, 0x40));   // Default 0x002040    (0, 32, 64)
01067 }
01068 
01069 void FT813::SetThemeColor(ft_uint32_t c)
01070 {
01071     GradColor(COLOR_RGB(0xff, 0xff, 0xff)); // Default 0xffffff
01072     ft_uint8_t r = (c >> 16) & 0xff;
01073     ft_uint8_t g = (c >> 8) & 0xff;
01074     ft_uint8_t b = c & 0xff;
01075     ft_uint8_t rfg = r * 112 / 255;
01076     ft_uint8_t gfg = g * 112 / 255;
01077     ft_uint8_t bfg = b * 112 / 255;
01078     ft_uint8_t rbg = r * 64 / 255;
01079     ft_uint8_t gbg = g * 64 / 255;
01080     ft_uint8_t bbg = b * 64 / 255;
01081     FgColor(COLOR_RGB(rfg, gfg, bfg));   // Default 0x003870
01082     BgColor(COLOR_RGB(rbg, gbg, bbg));   // Default 0x002040
01083 }
01084 
01085 // ShowCalibration
01086 void FT813::ShowCalibrationInCode(void)
01087 {
01088     // Read calibrate registers
01089     printf("// Calibration values:\n");
01090     printf("    ft_uint32_t canned_calibration_data[] = {\n");
01091     for(int i = 0; i < 24; i+=4) {
01092         printf("        ");
01093         printf("0x%08x", read_calibrate_reg32(i));
01094         if (i < 20)
01095             printf(",");
01096         printf("\n");
01097     }
01098     printf("    };\n");
01099     printf("    write_calibrate32(canned_calibration_data);\n");
01100 }
01101 
01102 // Set screen orientation and preload canned touch screen calibration values
01103 void FT813::SetOrientation(ft_uint8_t orientation)
01104 {
01105 //    TFT.SetRotate(0); // Standard landscape
01106 //    TFT.SetRotate(1); // Rotate 180 to landscape (upside down)
01107 //    TFT.SetRotate(2); // Rotate 90 CCW to portrait
01108 //    TFT.SetRotate(3); // Rotate 90 CW to portrait
01109 //    TFT.SetRotate(4); // Mirror over landscape X
01110 //    TFT.SetRotate(5); // Mirror over landscape Y
01111 //    TFT.SetRotate(6); // Rotate 90 CCW to portrait and mirror over portrait X
01112 //    TFT.SetRotate(7); // Rotate 90 CW to portrait and mirror over portrait X
01113 
01114     _orientation = orientation;
01115     
01116     SetRotate(orientation); // Standard landscape
01117     // Canned calibration for the orientation
01118     
01119     if (orientation == FT8_DISPLAY_LANDSCAPE_0)
01120     {
01121         // Landscape 0
01122         ft_uint32_t canned_calibration_data[] = {
01123             0x000109b0,   // 68016
01124             0x0000023d,   // 573
01125             0x0000fa64,   // 64100
01126             0xffffffcf,   // -49
01127             0xfffefc9a,   // -66406
01128             0x01ee8754    // 32409428
01129         };
01130         write_calibrate32(canned_calibration_data);
01131     }
01132 
01133     if (orientation == FT8_DISPLAY_PORTRAIT_90CW)
01134     {
01135         ft_uint32_t canned_calibration_data[] = {
01136             0xfffff994,
01137             0xffff07d3,
01138             0x01e4b85c,
01139             0xfffef6f5,
01140             0x000002ad,
01141             0x032eb4d4
01142         };
01143         write_calibrate32(canned_calibration_data);
01144     }
01145 
01146     if (orientation == FT8_DISPLAY_PORTRAIT_90CCW)
01147     {
01148         // Calibration rotate 90 CCW to portrait 
01149         ft_uint32_t canned_calibration_data[] = {
01150             0x00000491,
01151             0x0000fd0b,
01152             0xfff6f84b,
01153             0x00010503,
01154             0x000006b7,
01155             0xffeeb0b7
01156         };
01157         write_calibrate32(canned_calibration_data);
01158     }
01159 }
01160 
01161 void FT813::ShowBitmap(ft_uint8_t bitmap, ft_int16_t fmt, ft_uint16_t x, ft_uint16_t y, ft_uint16_t width, ft_uint16_t height)
01162 {
01163     ft_int32_t addr = GetBitmapAddress(bitmap);
01164     DL(BITMAP_SOURCE(addr));
01165 //    ft_int16_t stride = width * 2;
01166 //     1-bits/p L1
01167 //    if (fmt == L1) {
01168 //        stride = width / 8;
01169 //    }
01170 //     2-bits/p L2
01171 //    if (fmt == L2) {
01172 //        stride = width / 4;
01173 //    }
01174 //     4-bits/p L4
01175 //    if (fmt == L4) {
01176 //        stride = width / 2;
01177 //    }
01178 //     8-bits/p L8 RGB332 ARGB2 PALETTED565 PALETTED4444 PALETTED8
01179 //    if ((fmt == L8) ||
01180 //        (fmt == RGB332) ||
01181 //        (fmt == ARGB2) ||
01182 //        (fmt == PALETTED565) ||
01183 //        (fmt == PALETTED4444) ||
01184 //        (fmt == PALETTED8)) {
01185 //        stride = width;
01186 //    }
01187 //     16-bits/p ARGB1555 ARGB4 RGB565
01188 //    if ((fmt == ARGB1555) ||
01189 //        (fmt == ARGB4) ||
01190 //        (fmt == RGB565)) {
01191 //        stride = width * 2;
01192 //    }
01193 //    DL(BITMAP_LAYOUT(fmt, stride, h));              // 10-bit linestride, 9-bit height
01194 //    DL(BITMAP_LAYOUT_H(stride >> 10, h >> 9));      // msb bits
01195 //    DL(BITMAP_SIZE(NEAREST, BORDER, BORDER, w, h)); // 9-bit width, 9-bit height
01196 //    DL(BITMAP_SIZE_H(w >> 9, h >> 9));              // msb bits
01197 
01198     SetBitmap(addr, fmt, width, height);
01199 
01200 //    DL(VERTEX2II(x, y, 0, 0));
01201     DL(VERTEX2F(x * 16, y * 16));
01202 }
01203 
01204 void FT813::ShowBitmapAtAddress(ft_uint32_t addr, ft_int16_t fmt, ft_uint16_t x, ft_uint16_t y, ft_uint16_t width, ft_uint16_t height)
01205 {
01206     DL(BITMAP_SOURCE(addr));
01207 //    ft_int16_t stride = width * 2;
01208     // 1-bits/p L1
01209 //    if (fmt == L1) {
01210 //        stride = width / 8;
01211 //    }
01212     // 2-bits/p L2
01213 //    if (fmt == L2) {
01214 //        stride = width / 4;
01215 //    }
01216     // 4-bits/p L4
01217 //    if (fmt == L4) {
01218 //        stride = width / 2;
01219 //    }
01220     // 8-bits/p L8 RGB332 ARGB2 PALETTED565 PALETTED4444 PALETTED8
01221 //    if ((fmt == L8) ||
01222 //        (fmt == RGB332) ||
01223 //        (fmt == ARGB2) ||
01224 //        (fmt == PALETTED565) ||
01225 //        (fmt == PALETTED4444) ||
01226 //        (fmt == PALETTED8)) {
01227 //        stride = width;
01228 //    }
01229     // 16-bits/p ARGB1555 ARGB4 RGB565
01230 //    if ((fmt == ARGB1555) ||
01231 //        (fmt == ARGB4) ||
01232 //        (fmt == RGB565)) {
01233 //        stride = width * 2;
01234 //    }
01235 //    DL(BITMAP_LAYOUT(fmt, stride, h));              // 10-bit linestride, 9-bit height
01236 //    DL(BITMAP_LAYOUT_H(stride >> 10, h >> 9));      // msb bits
01237 //    DL(BITMAP_SIZE(NEAREST, BORDER, BORDER, w, h)); // 9-bit width, 9-bit height
01238 //    DL(BITMAP_SIZE_H(w >> 9, h >> 9));              // msb bits
01239 
01240     SetBitmap(addr, fmt, width, height);
01241     
01242 //    DL(VERTEX2II(x, y, 0, 0));
01243     DL(VERTEX2F(x * 16, y * 16));
01244 }
01245 
01246 int FT813::GetImageIndexFromName(char *name)
01247 {
01248     for (int i = 0; i < _bitmapCount; i++) {
01249         if(strstr(_bitmaps[i].name, name) != NULL) {
01250             return i;
01251         }
01252     }
01253     return -1;
01254 }
01255 
01256 int FT813::ResetInflateFileBitmap(void)
01257 {
01258     _bitmapAddress = 0;
01259     _bitmapCount = 0;
01260 }
01261 
01262 uint32_t FT813::GetRamUsage(void)
01263 {
01264     return _bitmapAddress;
01265 }
01266 
01267 uint16_t FT813::GetRamNoOfBitmaps(void)
01268 {
01269     return _bitmapCount;
01270 }
01271 
01272 int FT813::LoadInflateFileBitmap(char *name, uint16_t fmt, uint16_t w, uint16_t h)
01273 {
01274     strcpy(_bitmaps[_bitmapCount].name, name);
01275     _bitmaps[_bitmapCount].fmt = fmt;
01276     _bitmaps[_bitmapCount].w = w;
01277     _bitmaps[_bitmapCount].h = h;  
01278     _bitmaps[_bitmapCount].addr = _bitmapAddress;
01279     // 1-bits/p L1
01280     if (_bitmaps[_bitmapCount].fmt == L1) {
01281         _bitmaps[_bitmapCount].size = _bitmaps[_bitmapCount].w * _bitmaps[_bitmapCount].h / 8;
01282     }
01283     // 2-bits/p L2
01284     if (_bitmaps[_bitmapCount].fmt == L2) {
01285         _bitmaps[_bitmapCount].size = _bitmaps[_bitmapCount].w * _bitmaps[_bitmapCount].h / 4;
01286     }
01287     // 4-bits/p L4
01288     if (_bitmaps[_bitmapCount].fmt == L4) {
01289         _bitmaps[_bitmapCount].size = _bitmaps[_bitmapCount].w * _bitmaps[_bitmapCount].h / 2;
01290     }
01291     // 8-bits/p L8 RGB332 ARGB2 PALETTED565 PALETTED4444 PALETTED8
01292     if ((_bitmaps[_bitmapCount].fmt == L8) ||
01293         (_bitmaps[_bitmapCount].fmt == RGB332) || 
01294         (_bitmaps[_bitmapCount].fmt == ARGB2) ||
01295         (_bitmaps[_bitmapCount].fmt == PALETTED565) || 
01296         (_bitmaps[_bitmapCount].fmt == PALETTED4444) || 
01297         (_bitmaps[_bitmapCount].fmt == PALETTED8)) {
01298         _bitmaps[_bitmapCount].size = _bitmaps[_bitmapCount].w * _bitmaps[_bitmapCount].h;
01299     }
01300     // 16-bits/p ARGB1555 ARGB4 RGB565
01301     if ((_bitmaps[_bitmapCount].fmt == ARGB1555) || 
01302         (_bitmaps[_bitmapCount].fmt == ARGB4) || 
01303         (_bitmaps[_bitmapCount].fmt == RGB565)) {
01304         _bitmaps[_bitmapCount].size = _bitmaps[_bitmapCount].w * _bitmaps[_bitmapCount].h * 2;
01305     }
01306     LoadInflateFile(_bitmaps[_bitmapCount].addr, _bitmaps[_bitmapCount].name); // x 0, y 0, w 32, h 32, size 1024
01307     _bitmapAddress += _bitmaps[_bitmapCount].size;
01308     _bitmapCount++;
01309 }
01310 
01311 int FT813::ShowBitmapByName(char *name, uint16_t x, uint16_t y)
01312 {
01313     int index = GetImageIndexFromName(name);
01314     ShowBitmapAtAddress(_bitmaps[index].addr, _bitmaps[index].fmt, x, y, _bitmaps[index].w, _bitmaps[index].h);
01315 }
01316 
01317 uint16_t FT813::GetTouchedTag(void)
01318 {
01319     // REG_TOUCH_TAG
01320     // If the screen is being touched, the screen coordinates are looked up in the screen's tag buffer,
01321     // delivering a final 8-bit tag value, in REG_TOUCH_TAG.
01322     // REG_TOUCH_TAG_XY 
01323     // Because the tag lookup takes a full frame, and touch coordinates change continuously,
01324     // the original (x; y) used for the tag lookup is also available in REG_TOUCH_TAG_XY.
01325     uint32_t TrackRegisterVal = Rd32(REG_TRACKER);       // check if one of the tracking fields is touched
01326     return TrackRegisterVal & 0xffff;
01327 }
01328 
01329 uint16_t FT813::GetTouchedTag(uint8_t point_number)
01330 {
01331     // REG_TOUCH_TAG
01332     // If the screen is being touched, the screen coordinates are looked up in the screen's tag buffer,
01333     // delivering a final 8-bit tag value, in REG_TOUCH_TAG.
01334     // REG_TOUCH_TAG_XY 
01335     // Because the tag lookup takes a full frame, and touch coordinates change continuously,
01336     // the original (x; y) used for the tag lookup is also available in REG_TOUCH_TAG_XY.
01337     // check if one of the tracking fields is touched
01338     uint32_t TrackRegisterVal = 0;
01339     switch (point_number) {
01340         case 0:
01341             TrackRegisterVal = Rd32(REG_TRACKER);   // First point
01342             break;
01343         case 1:
01344             TrackRegisterVal = Rd32(REG_TRACKER_1); // Second point
01345             break;
01346         case 2:
01347             TrackRegisterVal = Rd32(REG_TRACKER_2); // Third point
01348             break;
01349         case 3:
01350             TrackRegisterVal = Rd32(REG_TRACKER_3); // Fourth point
01351             break;
01352         case 4:
01353             TrackRegisterVal = Rd32(REG_TRACKER_4); // Fift point
01354             break;
01355     }
01356     return TrackRegisterVal & 0xffff;
01357 }
01358 
01359 uint8_t FT813::GetTag(void)
01360 {
01361     // REG_TOUCH_TAG
01362     // If the screen is being touched, the screen coordinates are looked up in the screen's tag buffer,
01363     // delivering a final 8-bit tag value, in REG_TOUCH_TAG.
01364     // REG_TOUCH_TAG_XY 
01365     // Because the tag lookup takes a full frame, and touch coordinates change continuously,
01366     // the original (x; y) used for the tag lookup is also available in REG_TOUCH_TAG_XY.
01367     uint32_t TagRegisterVal = Rd32(REG_TAG);       // check if one of the tracking fields is touched
01368     return TagRegisterVal & 0xff;
01369 }
01370 
01371 uint16_t FT813::GetTagX(void)
01372 {
01373     // REG_TOUCH_TAG
01374     // If the screen is being touched, the screen coordinates are looked up in the screen's tag buffer,
01375     // delivering a final 8-bit tag value, in REG_TOUCH_TAG.
01376     // REG_TOUCH_TAG_XY 
01377     // Because the tag lookup takes a full frame, and touch coordinates change continuously,
01378     // the original (x; y) used for the tag lookup is also available in REG_TOUCH_TAG_XY.
01379     uint32_t TagRegisterVal = Rd32(REG_TAG_X);       // check if one of the tracking fields is touched
01380     return TagRegisterVal & 0x7ff;
01381 }
01382 
01383 uint16_t FT813::GetTagY(void)
01384 {
01385     // REG_TOUCH_TAG
01386     // If the screen is being touched, the screen coordinates are looked up in the screen's tag buffer,
01387     // delivering a final 8-bit tag value, in REG_TOUCH_TAG.
01388     // REG_TOUCH_TAG_XY 
01389     // Because the tag lookup takes a full frame, and touch coordinates change continuously,
01390     // the original (x; y) used for the tag lookup is also available in REG_TOUCH_TAG_XY.
01391     uint32_t TagRegisterVal = Rd32(REG_TAG_Y);       // check if one of the tracking fields is touched
01392     return TagRegisterVal & 0x7ff;
01393 }
01394 
01395 uint8_t FT813::GetTouchTag(void)
01396 {
01397     // REG_TOUCH_TAG
01398     // If the screen is being touched, the screen coordinates are looked up in the screen's tag buffer,
01399     // delivering a final 8-bit tag value, in REG_TOUCH_TAG.
01400     // REG_TOUCH_TAG_XY 
01401     // Because the tag lookup takes a full frame, and touch coordinates change continuously,
01402     // the original (x; y) used for the tag lookup is also available in REG_TOUCH_TAG_XY.
01403     uint32_t TagRegisterVal = Rd32(REG_TOUCH_TAG);       // check if one of the tracking fields is touched
01404     return TagRegisterVal & 0xff;
01405 }
01406 
01407 uint16_t FT813::GetTouchTagX(void)
01408 {
01409     // REG_TOUCH_TAG
01410     // If the screen is being touched, the screen coordinates are looked up in the screen's tag buffer,
01411     // delivering a final 8-bit tag value, in REG_TOUCH_TAG.
01412     // REG_TOUCH_TAG_XY 
01413     // Because the tag lookup takes a full frame, and touch coordinates change continuously,
01414     // the original (x; y) used for the tag lookup is also available in REG_TOUCH_TAG_XY.
01415     uint32_t TagRegisterVal = Rd32(REG_TOUCH_TAG_XY);       // check if one of the tracking fields is touched
01416     return (TagRegisterVal >> 16) & 0xffff;
01417 }
01418 
01419 uint16_t FT813::GetTouchTagY(void)
01420 {
01421     // REG_TOUCH_TAG
01422     // If the screen is being touched, the screen coordinates are looked up in the screen's tag buffer,
01423     // delivering a final 8-bit tag value, in REG_TOUCH_TAG.
01424     // REG_TOUCH_TAG_XY 
01425     // Because the tag lookup takes a full frame, and touch coordinates change continuously,
01426     // the original (x; y) used for the tag lookup is also available in REG_TOUCH_TAG_XY.
01427     uint32_t TagRegisterVal = Rd32(REG_TOUCH_TAG_XY);       // check if one of the tracking fields is touched
01428     return TagRegisterVal & 0xffff;
01429 }
01430 
01431 uint16_t FT813::GetTouchConfig(void)
01432 {
01433     // Read 0x0381
01434     // 0000 0011 1000 0001
01435     // bit 15 0: capacitive, 1: resistive
01436     // bit 10 - 4: I2C address of touch screen module: 0x011 1000 0x38
01437     // bit 3: 0: FocalTech, 1: Azoteq
01438     // bit 1 - 0: sampler clocks 0x01
01439     uint32_t TouchConfigVal = Rd32(REG_TOUCH_CONFIG);       // check if one of the tracking fields is touched
01440     return TouchConfigVal & 0xffff;
01441 }
01442 
01443 void FT813::SetTouchConfig(uint16_t TouchConfigVal = VAL_TOUCH_CONFIG)
01444 {
01445     Wr32(REG_TOUCH_CONFIG, (uint32_t) TouchConfigVal);
01446 }
01447 
01448 
01449 
01450 
01451 
01452 void FT813::screenShot(void)
01453 {
01454     int bufferSize = 800*480;
01455     char* pbuff = (char*)malloc(bufferSize);
01456     
01457 //    wr8(REG_SCREENSHOT_EN, 1);
01458 //    for (int ly = 0; ly < SCREEN_HEIGHT; ly++) {
01459 //     wr16(REG_SCREENSHOT_Y, ly);
01460 //     wr8(REG_SCREENSHOT_START, 1);
01461 //    
01462 //     //Read 64 bit registers to see if it is busy
01463 //     while (rd32(REG_SCREENSHOT_BUSY) | rd32(REG_SCREENSHOT_BUSY + 4));
01464 //    
01465 //     wr8(REG_SCREENSHOT_READ , 1);
01466 //     for (int lx = 0; lx < SCREEN_WIDTH; lx ++) {
01467 //    //Read 32 bit pixel value from RAM_SCREENSHOT
01468 //    //The pixel format is BGRA: Blue is in lowest address and Alpha
01469 //    is in highest address
01470 //    screenshot[ly*SCREEN_HEIGHT + lx] = rd32(RAM_SCREENSHOT + lx*4);
01471 //     }
01472 //     wr8(REG_SCREENSHOT_READ, 0);
01473 //    }
01474 //    wr8(REG_SCREENSHOT_EN, 0);
01475 
01476     free(pbuff);
01477 }