HeptaCamera.cpp

00001 #include "HeptaCamera.h"
00002 #include "mbed.h"
00003 
00004 int sizex = 0;
00005 int sizey = 0;
00006 
00007 #if defined(BITMAPFILE) || defined(BAYERBITMAPFILE)
00008 
00009 #define FILEHEADERSIZE 14                   //ファイルヘッダのサイズ
00010 #define INFOHEADERSIZE 40                   //情報ヘッダのサイズ
00011 #define HEADERSIZE (FILEHEADERSIZE+INFOHEADERSIZE)
00012 
00013 int create_header(FILE *fp, int width, int height) {
00014     int real_width;
00015     unsigned char header_buf[HEADERSIZE]; //ヘッダを格納する
00016     unsigned int file_size;
00017     unsigned int offset_to_data;
00018     unsigned long info_header_size;
00019     unsigned int planes;
00020     unsigned int color;
00021     unsigned long compress;
00022     unsigned long data_size;
00023     long xppm;
00024     long yppm;
00025 
00026     real_width = width*3 + width%4;
00027 
00028     //ここからヘッダ作成
00029     file_size = height * real_width + HEADERSIZE;
00030     offset_to_data = HEADERSIZE;
00031     info_header_size = INFOHEADERSIZE;
00032     planes = 1;
00033     color = 24;
00034     compress = 0;
00035     data_size = height * real_width;
00036     xppm = 1;
00037     yppm = 1;
00038 
00039     header_buf[0] = 'B';
00040     header_buf[1] = 'M';
00041     memcpy(header_buf + 2, &file_size, sizeof(file_size));
00042     header_buf[6] = 0;
00043     header_buf[7] = 0;
00044     header_buf[8] = 0;
00045     header_buf[9] = 0;
00046     memcpy(header_buf + 10, &offset_to_data, sizeof(offset_to_data));
00047     memcpy(header_buf + 14, &info_header_size, sizeof(info_header_size));
00048     memcpy(header_buf + 18, &width, sizeof(width));
00049     height = height * -1; // データ格納順が逆なので、高さをマイナスとしている
00050     memcpy(header_buf + 22, &height, sizeof(height));
00051     memcpy(header_buf + 26, &planes, sizeof(planes));
00052     memcpy(header_buf + 28, &color, sizeof(color));
00053     memcpy(header_buf + 30, &compress, sizeof(compress));
00054     memcpy(header_buf + 34, &data_size, sizeof(data_size));
00055     memcpy(header_buf + 38, &xppm, sizeof(xppm));
00056     memcpy(header_buf + 42, &yppm, sizeof(yppm));
00057     header_buf[46] = 0;
00058     header_buf[47] = 0;
00059     header_buf[48] = 0;
00060     header_buf[49] = 0;
00061     header_buf[50] = 0;
00062     header_buf[51] = 0;
00063     header_buf[52] = 0;
00064     header_buf[53] = 0;
00065 
00066     //ヘッダの書き込み
00067     fwrite(header_buf, sizeof(unsigned char), HEADERSIZE, fp);
00068 
00069     return 0;
00070 }
00071 #endif
00072 
00073 HeptaCamera::HeptaCamera(PinName sda, PinName scl, PinName vs, PinName hr,PinName we, PinName d7, PinName d6, PinName d5, PinName d4,
00074  PinName d3, PinName d2, PinName d1, PinName d0, PinName rt, PinName o, PinName rc ) : camera(sda,scl),vsync(vs),href(hr),wen(we),data(d0,d1,d2,d3,d4,d5,d6,d7),rrst(rt),oe(o),rclk(rc)
00075 {
00076     camera.stop();
00077     camera.frequency(OV7670_I2CFREQ);
00078     vsync.fall(this,&HeptaCamera::VsyncHandler);
00079     href.rise(this,&HeptaCamera::HrefHandler);
00080     CaptureReq = false;
00081     Busy = false;
00082     Done = false;
00083     LineCounter = 0;
00084     rrst = 1;
00085     oe = 1;
00086     rclk = 1;
00087     wen = 0;
00088 }
00089     // capture request
00090     void HeptaCamera::CaptureNext(void)
00091     {
00092         CaptureReq = true;
00093         Busy = true;
00094     }
00095     
00096     // capture done? (with clear)
00097     bool HeptaCamera::CaptureDone(void)
00098     {
00099         bool result;
00100         if (Busy) {
00101             result = false;
00102         } else {
00103             result = Done;
00104             Done = false;
00105         }
00106         return result;
00107     }
00108 
00109     // write to camera
00110     void HeptaCamera::WriteReg(int addr,int data)
00111     {
00112         // WRITE 0x42,ADDR,DATA
00113         camera.start();
00114         camera.write(OV7670_WRITE);
00115         wait_us(OV7670_WRITEWAIT);
00116         camera.write(addr);
00117         wait_us(OV7670_WRITEWAIT);
00118         camera.write(data);
00119         camera.stop();
00120     }
00121 
00122     // read from camera
00123     int HeptaCamera::ReadReg(int addr)
00124     {
00125         int data;
00126 
00127         // WRITE 0x42,ADDR
00128         camera.start();
00129         camera.write(OV7670_WRITE);
00130         wait_us(OV7670_WRITEWAIT);
00131         camera.write(addr);
00132         camera.stop();
00133         wait_us(OV7670_WRITEWAIT);    
00134 
00135         // WRITE 0x43,READ
00136         camera.start();
00137         camera.write(OV7670_READ);
00138         wait_us(OV7670_WRITEWAIT);
00139         data = camera.read(OV7670_NOACK);
00140         camera.stop();
00141     
00142         return data;
00143     }
00144 
00145     // print register
00146     void HeptaCamera::PrintRegister(void) {   
00147         printf("AD : +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F");
00148         for (int i=0;i<OV7670_REGMAX;i++) {
00149             int data;
00150             data = ReadReg(i); // READ REG
00151             if ((i & 0x0F) == 0) {
00152                 printf("\r\n%02X : ",i);
00153             }
00154             printf("%02X ",data);
00155         }
00156         printf("\r\n");
00157     }
00158 
00159     void HeptaCamera::Reset(void) {    
00160         WriteReg(REG_COM7,COM7_RESET); // RESET CAMERA
00161         wait_ms(200);
00162     }
00163 
00164     void HeptaCamera::InitForFIFOWriteReset(void) {
00165         WriteReg(REG_COM10, COM10_VS_NEG);
00166     }
00167 
00168     void HeptaCamera::InitSetColorbar(void)  {
00169         int reg_com7 = ReadReg(REG_COM7);
00170         // color bar
00171         WriteReg(REG_COM17, reg_com7|COM17_CBAR);
00172     }
00173 
00174     void HeptaCamera::InitDefaultReg(void) {
00175         // Gamma curve values
00176         WriteReg(0x7a, 0x20);
00177         WriteReg(0x7b, 0x10);
00178         WriteReg(0x7c, 0x1e);
00179         WriteReg(0x7d, 0x35);
00180         WriteReg(0x7e, 0x5a);
00181         WriteReg(0x7f, 0x69);
00182         WriteReg(0x80, 0x76);
00183         WriteReg(0x81, 0x80);
00184         WriteReg(0x82, 0x88);
00185         WriteReg(0x83, 0x8f);
00186         WriteReg(0x84, 0x96);
00187         WriteReg(0x85, 0xa3);
00188         WriteReg(0x86, 0xaf);
00189         WriteReg(0x87, 0xc4);
00190         WriteReg(0x88, 0xd7);
00191         WriteReg(0x89, 0xe8);
00192         
00193         // AGC and AEC parameters.  Note we start by disabling those features,
00194         //then turn them only after tweaking the values.
00195         WriteReg(REG_COM8, COM8_FASTAEC | COM8_AECSTEP | COM8_BFILT);
00196         WriteReg(REG_GAIN, 0);
00197         WriteReg(REG_AECH, 0);
00198         WriteReg(REG_COM4, 0x40);
00199         // magic reserved bit
00200         WriteReg(REG_COM9, 0x18);
00201         // 4x gain + magic rsvd bit
00202         WriteReg(REG_BD50MAX, 0x05);
00203         WriteReg(REG_BD60MAX, 0x07);
00204         WriteReg(REG_AEW, 0x95);
00205         WriteReg(REG_AEB, 0x33);
00206         WriteReg(REG_VPT, 0xe3);
00207         WriteReg(REG_HAECC1, 0x78);
00208         WriteReg(REG_HAECC2, 0x68);
00209         WriteReg(0xa1, 0x03);
00210         // magic
00211         WriteReg(REG_HAECC3, 0xd8);
00212         WriteReg(REG_HAECC4, 0xd8);
00213         WriteReg(REG_HAECC5, 0xf0);
00214         WriteReg(REG_HAECC6, 0x90);
00215         WriteReg(REG_HAECC7, 0x94);
00216         WriteReg(REG_COM8, COM8_FASTAEC|COM8_AECSTEP|COM8_BFILT|COM8_AGC|COM8_AEC);
00217         
00218         // Almost all of these are magic "reserved" values.
00219         WriteReg(REG_COM5, 0x61);
00220         WriteReg(REG_COM6, 0x4b);
00221         WriteReg(0x16, 0x02);
00222         WriteReg(REG_MVFP, 0x07);
00223         WriteReg(0x21, 0x02);
00224         WriteReg(0x22, 0x91);
00225         WriteReg(0x29, 0x07);
00226         WriteReg(0x33, 0x0b);
00227         WriteReg(0x35, 0x0b);
00228         WriteReg(0x37, 0x1d);
00229         WriteReg(0x38, 0x71);
00230         WriteReg(0x39, 0x2a);
00231         WriteReg(REG_COM12, 0x78);
00232         WriteReg(0x4d, 0x40);
00233         WriteReg(0x4e, 0x20);
00234         WriteReg(REG_GFIX, 0);
00235         WriteReg(0x6b, 0x0a);
00236         WriteReg(0x74, 0x10);
00237         WriteReg(0x8d, 0x4f);
00238         WriteReg(0x8e, 0);
00239         WriteReg(0x8f, 0);
00240         WriteReg(0x90, 0);
00241         WriteReg(0x91, 0);
00242         WriteReg(0x96, 0);
00243         WriteReg(0x9a, 0);
00244         WriteReg(0xb0, 0x84);
00245         WriteReg(0xb1, 0x0c);
00246         WriteReg(0xb2, 0x0e);
00247         WriteReg(0xb3, 0x82);
00248         WriteReg(0xb8, 0x0a);
00249         
00250         // More reserved magic, some of which tweaks white balance
00251         WriteReg(0x43, 0x0a);
00252         WriteReg(0x44, 0xf0);
00253         WriteReg(0x45, 0x34);
00254         WriteReg(0x46, 0x58);
00255         WriteReg(0x47, 0x28);
00256         WriteReg(0x48, 0x3a);
00257         WriteReg(0x59, 0x88);
00258         WriteReg(0x5a, 0x88);
00259         WriteReg(0x5b, 0x44);
00260         WriteReg(0x5c, 0x67);
00261         WriteReg(0x5d, 0x49);
00262         WriteReg(0x5e, 0x0e);
00263         WriteReg(0x6c, 0x0a);
00264         WriteReg(0x6d, 0x55);
00265         WriteReg(0x6e, 0x11);
00266         WriteReg(0x6f, 0x9f);
00267         // "9e for advance AWB"
00268         WriteReg(0x6a, 0x40);
00269         WriteReg(REG_BLUE, 0x40);
00270         WriteReg(REG_RED, 0x60);
00271         WriteReg(REG_COM8, COM8_FASTAEC|COM8_AECSTEP|COM8_BFILT|COM8_AGC|COM8_AEC|COM8_AWB);
00272         
00273         // Matrix coefficients
00274         WriteReg(0x4f, 0x80);
00275         WriteReg(0x50, 0x80);
00276         WriteReg(0x51, 0);
00277         WriteReg(0x52, 0x22);
00278         WriteReg(0x53, 0x5e);
00279         WriteReg(0x54, 0x80);
00280         WriteReg(0x58, 0x9e);
00281         
00282         WriteReg(REG_COM16, COM16_AWBGAIN);
00283         WriteReg(REG_EDGE, 0);
00284         WriteReg(0x75, 0x05);
00285         WriteReg(0x76, 0xe1);
00286         WriteReg(0x4c, 0);
00287         WriteReg(0x77, 0x01);
00288         WriteReg(0x4b, 0x09);
00289         WriteReg(0xc9, 0x60);
00290         WriteReg(REG_COM16, 0x38);
00291         WriteReg(0x56, 0x40);
00292         
00293         WriteReg(0x34, 0x11);
00294         WriteReg(REG_COM11, COM11_EXP|COM11_HZAUTO_ON);
00295         WriteReg(0xa4, 0x88);
00296         WriteReg(0x96, 0);
00297         WriteReg(0x97, 0x30);
00298         WriteReg(0x98, 0x20);
00299         WriteReg(0x99, 0x30);
00300         WriteReg(0x9a, 0x84);
00301         WriteReg(0x9b, 0x29);
00302         WriteReg(0x9c, 0x03);
00303         WriteReg(0x9d, 0x4c);
00304         WriteReg(0x9e, 0x3f);
00305         WriteReg(0x78, 0x04);
00306         
00307         // Extra-weird stuff.  Some sort of multiplexor register
00308         WriteReg(0x79, 0x01);
00309         WriteReg(0xc8, 0xf0);
00310         WriteReg(0x79, 0x0f);
00311         WriteReg(0xc8, 0x00);
00312         WriteReg(0x79, 0x10);
00313         WriteReg(0xc8, 0x7e);
00314         WriteReg(0x79, 0x0a);
00315         WriteReg(0xc8, 0x80);
00316         WriteReg(0x79, 0x0b);
00317         WriteReg(0xc8, 0x01);
00318         WriteReg(0x79, 0x0c);
00319         WriteReg(0xc8, 0x0f);
00320         WriteReg(0x79, 0x0d);
00321         WriteReg(0xc8, 0x20);
00322         WriteReg(0x79, 0x09);
00323         WriteReg(0xc8, 0x80);
00324         WriteReg(0x79, 0x02);
00325         WriteReg(0xc8, 0xc0);
00326         WriteReg(0x79, 0x03);
00327         WriteReg(0xc8, 0x40);
00328         WriteReg(0x79, 0x05);
00329         WriteReg(0xc8, 0x30);
00330         WriteReg(0x79, 0x26);
00331     }
00332 
00333     void HeptaCamera::InitRGB444(void){
00334         int reg_com7 = ReadReg(REG_COM7);
00335 
00336         WriteReg(REG_COM7, reg_com7|COM7_RGB);
00337         WriteReg(REG_RGB444, RGB444_ENABLE|RGB444_XBGR);
00338         WriteReg(REG_COM15, COM15_R01FE|COM15_RGB444);
00339 
00340         WriteReg(REG_COM1, 0x40);                          // Magic reserved bit
00341         WriteReg(REG_COM9, 0x38);                          // 16x gain ceiling; 0x8 is reserved bit
00342         WriteReg(0x4f, 0xb3);                              // "matrix coefficient 1"
00343         WriteReg(0x50, 0xb3);                              // "matrix coefficient 2"
00344         WriteReg(0x51, 0x00);                              // vb
00345         WriteReg(0x52, 0x3d);                              // "matrix coefficient 4"
00346         WriteReg(0x53, 0xa7);                              // "matrix coefficient 5"
00347         WriteReg(0x54, 0xe4);                              // "matrix coefficient 6"
00348         WriteReg(REG_COM13, COM13_GAMMA|COM13_UVSAT|0x2);  // Magic rsvd bit
00349 
00350         WriteReg(REG_TSLB, 0x04);
00351     }
00352 
00353     void HeptaCamera::InitRGB555(void){
00354         int reg_com7 = ReadReg(REG_COM7);
00355 
00356         WriteReg(REG_COM7, reg_com7|COM7_RGB);
00357         WriteReg(REG_RGB444, RGB444_DISABLE);
00358         WriteReg(REG_COM15, COM15_RGB555|COM15_R00FF);
00359 
00360         WriteReg(REG_TSLB, 0x04);
00361 
00362         WriteReg(REG_COM1, 0x00);
00363         WriteReg(REG_COM9, 0x38);      // 16x gain ceiling; 0x8 is reserved bit
00364         WriteReg(0x4f, 0xb3);          // "matrix coefficient 1"
00365         WriteReg(0x50, 0xb3);          // "matrix coefficient 2"
00366         WriteReg(0x51, 0x00);          // vb
00367         WriteReg(0x52, 0x3d);          // "matrix coefficient 4"
00368         WriteReg(0x53, 0xa7);          // "matrix coefficient 5"
00369         WriteReg(0x54, 0xe4);          // "matrix coefficient 6"
00370         WriteReg(REG_COM13, COM13_GAMMA|COM13_UVSAT);
00371     }
00372 
00373     void HeptaCamera::InitRGB565(void){
00374         int reg_com7 = ReadReg(REG_COM7);
00375 
00376         WriteReg(REG_COM7, reg_com7|COM7_RGB);
00377         WriteReg(REG_RGB444, RGB444_DISABLE);
00378         WriteReg(REG_COM15, COM15_R00FF|COM15_RGB565);
00379 
00380         WriteReg(REG_TSLB, 0x04);
00381 
00382         WriteReg(REG_COM1, 0x00);
00383         WriteReg(REG_COM9, 0x38);      // 16x gain ceiling; 0x8 is reserved bit
00384         WriteReg(0x4f, 0xb3);          // "matrix coefficient 1"
00385         WriteReg(0x50, 0xb3);          // "matrix coefficient 2"
00386         WriteReg(0x51, 0x00);          // vb
00387         WriteReg(0x52, 0x3d);          // "matrix coefficient 4"
00388         WriteReg(0x53, 0xa7);          // "matrix coefficient 5"
00389         WriteReg(0x54, 0xe4);          // "matrix coefficient 6"
00390         WriteReg(REG_COM13, COM13_GAMMA|COM13_UVSAT);
00391     }
00392 
00393     void HeptaCamera::InitYUV(void){
00394         int reg_com7 = ReadReg(REG_COM7);
00395 
00396         WriteReg(REG_COM7, reg_com7|COM7_YUV);
00397         WriteReg(REG_RGB444, RGB444_DISABLE);
00398         WriteReg(REG_COM15, COM15_R00FF);
00399 
00400         WriteReg(REG_TSLB, 0x04);
00401 //       WriteReg(REG_TSLB, 0x14);
00402 //       WriteReg(REG_MANU, 0x00);
00403 //       WriteReg(REG_MANV, 0x00);
00404         
00405         WriteReg(REG_COM1, 0x00);
00406         WriteReg(REG_COM9, 0x18);     // 4x gain ceiling; 0x8 is reserved bit
00407         WriteReg(0x4f, 0x80);         // "matrix coefficient 1"
00408         WriteReg(0x50, 0x80);         // "matrix coefficient 2"
00409         WriteReg(0x51, 0x00);         // vb
00410         WriteReg(0x52, 0x22);         // "matrix coefficient 4"
00411         WriteReg(0x53, 0x5e);         // "matrix coefficient 5"
00412         WriteReg(0x54, 0x80);         // "matrix coefficient 6"
00413         WriteReg(REG_COM13, COM13_GAMMA|COM13_UVSAT|COM13_UVSWAP);
00414     }
00415 
00416     void HeptaCamera::InitBayerRGB(void){
00417         int reg_com7 = ReadReg(REG_COM7);
00418 
00419         // odd line BGBG... even line GRGR...
00420         WriteReg(REG_COM7, reg_com7|COM7_BAYER);
00421         // odd line GBGB... even line RGRG...
00422         //WriteReg(REG_COM7, reg_com7|COM7_PBAYER);
00423 
00424         WriteReg(REG_RGB444, RGB444_DISABLE);
00425         WriteReg(REG_COM15, COM15_R00FF);
00426 
00427         WriteReg(REG_COM13, 0x08); /* No gamma, magic rsvd bit */
00428         WriteReg(REG_COM16, 0x3d); /* Edge enhancement, denoise */
00429         WriteReg(REG_REG76, 0xe1); /* Pix correction, magic rsvd */
00430 
00431         WriteReg(REG_TSLB, 0x04);
00432     }
00433 
00434     void HeptaCamera::InitVGA(void) {
00435         // VGA
00436         int reg_com7 = ReadReg(REG_COM7);
00437 
00438         WriteReg(REG_COM7,reg_com7|COM7_VGA);
00439 
00440         WriteReg(REG_HSTART,HSTART_VGA);
00441         WriteReg(REG_HSTOP,HSTOP_VGA);
00442         WriteReg(REG_HREF,HREF_VGA);
00443         WriteReg(REG_VSTART,VSTART_VGA);
00444         WriteReg(REG_VSTOP,VSTOP_VGA);
00445         WriteReg(REG_VREF,VREF_VGA);
00446         WriteReg(REG_COM3, COM3_VGA);
00447         WriteReg(REG_COM14, COM14_VGA);
00448         WriteReg(REG_SCALING_XSC, SCALING_XSC_VGA);
00449         WriteReg(REG_SCALING_YSC, SCALING_YSC_VGA);
00450         WriteReg(REG_SCALING_DCWCTR, SCALING_DCWCTR_VGA);
00451         WriteReg(REG_SCALING_PCLK_DIV, SCALING_PCLK_DIV_VGA);
00452         WriteReg(REG_SCALING_PCLK_DELAY, SCALING_PCLK_DELAY_VGA);
00453     }
00454 
00455     void HeptaCamera::InitFIFO_2bytes_color_nealy_limit_size(void) {
00456         // nealy FIFO limit 544x360
00457         int reg_com7 = ReadReg(REG_COM7);
00458 
00459         WriteReg(REG_COM7,reg_com7|COM7_VGA);
00460 
00461         WriteReg(REG_HSTART,HSTART_VGA);
00462         WriteReg(REG_HSTOP,HSTOP_VGA);
00463         WriteReg(REG_HREF,HREF_VGA);
00464         WriteReg(REG_VSTART,VSTART_VGA);
00465         WriteReg(REG_VSTOP,VSTOP_VGA);
00466         WriteReg(REG_VREF,VREF_VGA);
00467         WriteReg(REG_COM3, COM3_VGA);
00468         WriteReg(REG_COM14, COM14_VGA);
00469         WriteReg(REG_SCALING_XSC, SCALING_XSC_VGA);
00470         WriteReg(REG_SCALING_YSC, SCALING_YSC_VGA);
00471         WriteReg(REG_SCALING_DCWCTR, SCALING_DCWCTR_VGA);
00472         WriteReg(REG_SCALING_PCLK_DIV, SCALING_PCLK_DIV_VGA);
00473         WriteReg(REG_SCALING_PCLK_DELAY, SCALING_PCLK_DELAY_VGA);
00474 
00475         WriteReg(REG_HSTART, 0x17);
00476         WriteReg(REG_HSTOP, 0x5b);
00477         WriteReg(REG_VSTART, 0x12);
00478         WriteReg(REG_VSTOP, 0x6c);
00479     }
00480 
00481     void HeptaCamera::InitVGA_3_4(void) {
00482         // VGA 3/4 -> 480x360
00483         int reg_com7 = ReadReg(REG_COM7);
00484 
00485         WriteReg(REG_COM7,reg_com7|COM7_VGA);
00486 
00487         WriteReg(REG_HSTART,HSTART_VGA);
00488         WriteReg(REG_HSTOP,HSTOP_VGA);
00489         WriteReg(REG_HREF,HREF_VGA);
00490         WriteReg(REG_VSTART,VSTART_VGA);
00491         WriteReg(REG_VSTOP,VSTOP_VGA);
00492         WriteReg(REG_VREF,VREF_VGA);
00493         WriteReg(REG_COM3, COM3_VGA);
00494         WriteReg(REG_COM14, COM14_VGA);
00495         WriteReg(REG_SCALING_XSC, SCALING_XSC_VGA);
00496         WriteReg(REG_SCALING_YSC, SCALING_YSC_VGA);
00497         WriteReg(REG_SCALING_DCWCTR, SCALING_DCWCTR_VGA);
00498         WriteReg(REG_SCALING_PCLK_DIV, SCALING_PCLK_DIV_VGA);
00499         WriteReg(REG_SCALING_PCLK_DELAY, SCALING_PCLK_DELAY_VGA);
00500 
00501         WriteReg(REG_HSTART, 0x1b);
00502         WriteReg(REG_HSTOP, 0x57);
00503         WriteReg(REG_VSTART, 0x12);
00504         WriteReg(REG_VSTOP, 0x6c);
00505     }
00506 
00507     void HeptaCamera::InitQVGA(void) {
00508         // QQVGA
00509         int reg_com7 = ReadReg(REG_COM7);
00510         
00511         WriteReg(REG_COM7,reg_com7|COM7_QVGA);
00512         
00513         WriteReg(REG_HSTART,HSTART_QVGA);
00514         WriteReg(REG_HSTOP,HSTOP_QVGA);
00515         WriteReg(REG_HREF,HREF_QVGA);
00516         WriteReg(REG_VSTART,VSTART_QVGA);
00517         WriteReg(REG_VSTOP,VSTOP_QVGA);
00518         WriteReg(REG_VREF,VREF_QVGA);
00519         WriteReg(REG_COM3, COM3_QVGA);
00520         WriteReg(REG_COM14, COM14_QVGA);
00521         WriteReg(REG_SCALING_XSC, SCALING_XSC_QVGA);
00522         WriteReg(REG_SCALING_YSC, SCALING_YSC_QVGA);
00523         WriteReg(REG_SCALING_DCWCTR, SCALING_DCWCTR_QVGA);
00524         WriteReg(REG_SCALING_PCLK_DIV, SCALING_PCLK_DIV_QVGA);
00525         WriteReg(REG_SCALING_PCLK_DELAY, SCALING_PCLK_DELAY_QVGA);
00526     }
00527 
00528     void HeptaCamera::InitQQVGA(void) {
00529         // QQVGA
00530         int reg_com7 = ReadReg(REG_COM7);
00531         
00532         WriteReg(REG_COM7,reg_com7|COM7_QQVGA);
00533 
00534         WriteReg(REG_HSTART,HSTART_QQVGA);
00535         WriteReg(REG_HSTOP,HSTOP_QQVGA);
00536         WriteReg(REG_HREF,HREF_QQVGA);
00537         WriteReg(REG_VSTART,VSTART_QQVGA);
00538         WriteReg(REG_VSTOP,VSTOP_QQVGA);
00539         WriteReg(REG_VREF,VREF_QQVGA);
00540         WriteReg(REG_COM3, COM3_QQVGA);
00541         WriteReg(REG_COM14, COM14_QQVGA);
00542         WriteReg(REG_SCALING_XSC, SCALING_XSC_QQVGA);
00543         WriteReg(REG_SCALING_YSC, SCALING_YSC_QQVGA);
00544         WriteReg(REG_SCALING_DCWCTR, SCALING_DCWCTR_QQVGA);
00545         WriteReg(REG_SCALING_PCLK_DIV, SCALING_PCLK_DIV_QQVGA);
00546         WriteReg(REG_SCALING_PCLK_DELAY, SCALING_PCLK_DELAY_QQVGA);
00547     }
00548 
00549     // vsync handler
00550     void HeptaCamera::VsyncHandler(void)
00551     {
00552         // Capture Enable
00553         if (CaptureReq) {
00554             wen = 1;
00555             Done = false;
00556             CaptureReq = false;
00557         } else {
00558             wen = 0;
00559             if (Busy) {
00560                 Busy = false;
00561                 Done = true;
00562             }
00563         }
00564 
00565         // Hline Counter
00566         LastLines = LineCounter;
00567         LineCounter = 0;
00568     }
00569     
00570     // href handler
00571     void HeptaCamera::HrefHandler(void)
00572     {
00573         LineCounter++;
00574     }
00575     
00576     // Data Read
00577     int HeptaCamera::ReadOneByte(void)
00578     {
00579         int result;
00580         rclk = 1;
00581 //        wait_us(1);
00582         result = data;
00583         rclk = 0;
00584         return result;
00585     }
00586     
00587     // Data Start
00588     void HeptaCamera::ReadStart(void)
00589     {        
00590         rrst = 0;
00591         oe = 0;
00592         wait_us(1);
00593         rclk = 0;
00594         wait_us(1);
00595         rclk = 1;
00596         wait_us(1);        
00597         rrst = 1;
00598     }
00599     
00600     // Data Stop
00601     void HeptaCamera::ReadStop(void)
00602     {
00603         oe = 1;
00604         ReadOneByte();
00605         rclk = 1;
00606     }
00607 
00608 void HeptaCamera::shoot()
00609 {
00610        //pc.baud(115200);
00611 
00612     //pc.printf("Camera resetting..\r\n");
00613     HeptaCamera::Reset();
00614 
00615     //pc.printf("Before Init...\r\n");
00616     HeptaCamera::PrintRegister();
00617     char color_format = '1';
00618     /*pc.printf("Select color format.\r\n") ;
00619     pc.printf("1: RGB444.\r\n");
00620     pc.printf("2: RGB555.\r\n");
00621     pc.printf("3: RGB565.\r\n");
00622     pc.printf("4: YUV(UYVY).\r\n");
00623     pc.printf("5: Bayer RGB(BGBG... GRGR...).\r\n");*/
00624 
00625     /*while(!pc.readable());
00626     char color_format = pc.getc();
00627     switch (color_format) {
00628         case '1':
00629             camera.InitRGB444();
00630             break;
00631         case '2':
00632             camera.InitRGB555();
00633             break;
00634         case '3':
00635             camera.InitRGB565();
00636             break;
00637         case '4':
00638             camera.InitYUV();
00639             break;
00640         case '5':
00641             camera.InitBayerRGB();
00642             break;
00643     }
00644     pc.printf("select %c\r\n", color_format);
00645 
00646     pc.printf("Select screen size.\r\n") ;
00647     switch (color_format) {
00648         case '5':
00649             pc.printf("1: VGA(640x480).\r\n");
00650         case '1':
00651         case '2':
00652         case '3':
00653         case '4':
00654             pc.printf("2: FIFO nealy limit(544x360).\r\n");
00655             pc.printf("3: VGA*3/4(480x360).\r\n");
00656             pc.printf("4: QVGA(320x240).\r\n");
00657             pc.printf("5: QQVGA(160x120).\r\n");
00658             break;
00659     }
00660     char screen_size = 4;
00661     while(!pc.readable());
00662     char screen_size = pc.getc() ;
00663     switch (screen_size) {
00664         case '1':
00665             sizex = 640;
00666             sizey = 480;
00667             camera.InitVGA();
00668             break;
00669         case '2':
00670             sizex = 544;
00671             sizey = 360;
00672             camera.InitFIFO_2bytes_color_nealy_limit_size();
00673             break;
00674         case '3':
00675             sizex = 480;
00676             sizey = 360;
00677             camera.InitVGA_3_4();
00678             break;
00679         case '4':
00680             sizex = 320;
00681             sizey = 240;
00682             camera.InitQVGA();
00683             break;
00684         case '5':
00685             sizex = 160;
00686             sizey = 120;
00687             camera.InitQQVGA();
00688             break;
00689     }
00690     pc.printf("select %c\r\n", screen_size);*/
00691     char screen_size = '4';
00692     HeptaCamera::InitRGB444();
00693     sizex = 320;
00694     sizey = 240;
00695     HeptaCamera::InitQVGA();
00696     HeptaCamera::InitForFIFOWriteReset();
00697     HeptaCamera::InitDefaultReg();
00698 
00699 #ifdef COLORBAR
00700     HeptaCamera::InitSetColorbar();
00701 #endif
00702 
00703     //pc.printf("After Init...\r\n");
00704     HeptaCamera::PrintRegister();
00705 
00706     // CAPTURE and SEND LOOP
00707 
00708 #if defined(BITMAPFILE) || defined(BAYERBITMAPFILE) || defined(HEXFILE)
00709         //pc.printf("Hit Any Key %dx%d Capture Data.\r\n", sizex, sizey) ;
00710         //while(!pc.readable());
00711         //pc.printf("*\r\n");
00712         //pc.getc();
00713 
00714         int real_width = sizex*3 + sizey%4;
00715 
00716         unsigned char *bmp_line_data; //画像1行分のRGB情報を格納する
00717         if((bmp_line_data = (unsigned char *)malloc(sizeof(unsigned char)*real_width)) == NULL){
00718            fprintf(stderr, "Error: Allocation error.\n");
00719            //return 1;
00720         }
00721 
00722         //RGB情報を4バイトの倍数に合わせている
00723         for(int i=sizex*3; i<real_width; i++){
00724             bmp_line_data[i] = 0;
00725         }
00726 #endif
00727 #if defined(BITMAPFILE) || defined(BAYERBITMAPFILE)
00728         FILE *fp;
00729         char *filename = "/local/test.bmp";
00730         if((fp = fopen(filename, "wb")) == NULL){
00731             //pc.printf("Error: %s could not open.", filename);
00732             //return 1;
00733         }
00734 
00735         create_header(fp, sizex, sizey);
00736 #endif
00737 #ifdef HEXFILE
00738         FILE *fp2;
00739         char *filename2 = "/local/test.txt";
00740         if((fp2 = fopen(filename2, "w")) == NULL){
00741             pc.printf("Error: %s could not open.", filename2);
00742             return 1;
00743         }
00744 #endif
00745 
00746         HeptaCamera::CaptureNext();
00747         while(HeptaCamera::CaptureDone() == false);
00748         HeptaCamera::ReadStart();
00749 
00750         int r=0, g=0, b=0, d1, d2;
00751 
00752         switch (color_format) {
00753             case '1':
00754             case '2':
00755             case '3':
00756 
00757                 for (int y=0; y<sizey; y++) {
00758                     for (int x=0; x<sizex; x++) {
00759                         d1 = HeptaCamera::ReadOneByte();
00760                         d2 = HeptaCamera::ReadOneByte();
00761 
00762                         switch (color_format) {
00763                             case '1':
00764                                 // RGB444 to RGB888
00765                                 b = (d1 & 0x0F) << 4;
00766                                 g = (d2 & 0xF0);
00767                                 r = (d2 & 0x0F) << 4;
00768                                 break;
00769                             case '2':
00770                                 // RGB555 to RGB888
00771                                 b = (d1 & 0x1F) << 3;
00772                                 g = (((d1 & 0xE0) >> 2) | ((d2 & 0x03) << 6));
00773                                 r = (d2 & 0x7c) << 1;
00774                                 break;
00775                             case '3':
00776                                 // RGB565 to RGB888
00777                                 b = (d1 & 0x1F) << 3;
00778                                 g = (((d1 & 0xE0) >> 3) | ((d2 & 0x07) << 5));
00779                                 r = (d2 & 0xF8);
00780                                 break;                                
00781                         }
00782 #if defined(BITMAPFILE) || defined(HEXFILE)
00783                         bmp_line_data[x*3]     = (unsigned char)b;
00784                         bmp_line_data[x*3 + 1] = (unsigned char)g;
00785                         bmp_line_data[x*3 + 2] = (unsigned char)r;
00786 #endif
00787 /*
00788                         // RGB
00789                         pc.printf ("%2X%2X%2X", r, g, b) ;
00790 */
00791                     }
00792 #ifdef BITMAPFILE
00793                     fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
00794 #endif
00795 #ifdef HEXFILE
00796                     for(int i=0; i<sizex*3; i++){
00797                         fprintf(fp2, "%02X", bmp_line_data[i]);
00798                     }
00799 #endif
00800 //                    pc.printf("\r\n") ;
00801                 }
00802                 break;
00803 
00804             case '4':
00805                 int index = 0;
00806                 for (int y=0; y<sizey; y++) {
00807                     int U0=0, Y0=0, V0=0, Y1=0;
00808                     for (int x=0; x<sizex; x++) {
00809                         if(index%2 == 0) {
00810                             U0 = HeptaCamera::ReadOneByte();
00811                             Y0 = HeptaCamera::ReadOneByte();
00812                             V0 = HeptaCamera::ReadOneByte();
00813                             Y1 = HeptaCamera::ReadOneByte();
00814 
00815                             b = Y0 + 1.77200 * (U0 - 128);
00816                             g = Y0 - 0.34414 * (U0 - 128) - 0.71414 * (V0 - 128);
00817                             r = Y0 + 1.40200 * (V0 - 128);
00818                         } else {
00819                             b = Y1 + 1.77200 * (U0 - 128);
00820                             g = Y1 - 0.34414 * (U0 - 128) - 0.71414 * (V0 - 128);
00821                             r = Y1 + 1.40200 * (V0 - 128);
00822                         }
00823 
00824                         b = min(max(b, 0), 255);
00825                         g = min(max(g, 0), 255);
00826                         r = min(max(r, 0), 255);
00827 
00828 #if defined(BITMAPFILE) || defined(HEXFILE)
00829                         bmp_line_data[x*3]     = (unsigned char)b;
00830                         bmp_line_data[x*3 + 1] = (unsigned char)g;
00831                         bmp_line_data[x*3 + 2] = (unsigned char)r;
00832 #endif
00833 /*
00834                         // RGB
00835                         pc.printf ("%2X%2X%2X", r, g, b) ;
00836 */
00837                         index++;
00838                     }
00839 #ifdef BITMAPFILE
00840                     fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
00841 #endif
00842 #ifdef HEXFILE
00843                     for(int i=0; i<sizex*3; i++){
00844                         fprintf(fp2, "%02X", bmp_line_data[i]);
00845                     }
00846 #endif
00847 //                    pc.printf("\r\n") ;
00848                 }
00849                 break;
00850 
00851             case '5':
00852                 unsigned char *bayer_line[2];
00853                 unsigned char *bayer_line_data[2]; //画像1行分のRGB情報を格納する2行分
00854                 for(int i=0; i<2; i++) {
00855                     if((bayer_line_data[i] = (unsigned char *)malloc(sizeof(unsigned char)*sizex)) == NULL){
00856                        fprintf(stderr, "Error: Allocation error.\n");
00857                        //return 1;
00858                     }
00859                 }
00860 
00861                 for (int x=0; x<sizex; x++) {
00862                     // odd line BGBG... even line GRGR...
00863                     bayer_line_data[0][x] = (unsigned char)HeptaCamera::ReadOneByte();
00864 #ifdef BAYERBITMAPFILE
00865                     bmp_line_data[x*3]     = (unsigned char)bayer_line_data[0][x];
00866                     bmp_line_data[x*3 + 1] = (unsigned char)bayer_line_data[0][x];
00867                     bmp_line_data[x*3 + 2] = (unsigned char)bayer_line_data[0][x];
00868 #endif
00869                 }
00870 #ifdef BAYERBITMAPFILE
00871                 fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
00872 #endif
00873                 bayer_line[1] = bayer_line_data[0];
00874 
00875                 for (int y=1; y<sizey; y++) {
00876                     int line = y%2;
00877 
00878                     for (int x=0; x<sizex; x++) {
00879                         // odd line BGBG... even line GRGR...
00880                         bayer_line_data[line][x] = (unsigned char)HeptaCamera::ReadOneByte();
00881 #ifdef BAYERBITMAPFILE
00882                         bmp_line_data[x*3]     = (unsigned char)bayer_line_data[line][x];
00883                         bmp_line_data[x*3 + 1] = (unsigned char)bayer_line_data[line][x];
00884                         bmp_line_data[x*3 + 2] = (unsigned char)bayer_line_data[line][x];
00885 #endif
00886                     }
00887 #ifdef BAYERBITMAPFILE
00888                     fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
00889 #endif
00890                     bayer_line[0] = bayer_line[1];
00891                     bayer_line[1] = bayer_line_data[line];
00892 
00893                     for (int x=0; x<sizex - 1; x++) {
00894                         if(y%2==1) {
00895                             if(x%2==0) {
00896                                 // BG
00897                                 // GR
00898                                 b = bayer_line[0][x];
00899                                 g = ((int)bayer_line[0][x+1] + bayer_line[1][x])>>1;
00900                                 r = bayer_line[1][x+1];
00901                             } else {
00902                                 // GB
00903                                 // RG
00904                                 b = bayer_line[0][x+1];
00905                                 g = ((int)bayer_line[0][x] + bayer_line[1][x+1])>>1;
00906                                 r = bayer_line[1][x];
00907                             }
00908                         } else {
00909                             if(x%2==0) {
00910                                 // GR
00911                                 // BG
00912                                 b = bayer_line[1][x];
00913                                 g = ((int)bayer_line[0][x] + bayer_line[1][x+1])>>1;
00914                                 r = bayer_line[0][x+1];
00915                             } else {
00916                                 // RG
00917                                 // GB
00918                                 b = bayer_line[1][x+1];
00919                                 g = ((int)bayer_line[0][x+1] + bayer_line[1][x])>>1;
00920                                 r = bayer_line[0][x];
00921                             }
00922                         }
00923 #if defined(BITMAPFILE) || defined(HEXFILE)
00924                         bmp_line_data[x*3]     = (unsigned char)b;
00925                         bmp_line_data[x*3 + 1] = (unsigned char)g;
00926                         bmp_line_data[x*3 + 2] = (unsigned char)r;
00927 #endif
00928                     }
00929 
00930 #ifdef BITMAPFILE
00931                     fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
00932 #endif
00933 
00934 #ifdef HEXFILE
00935                     for(int i=0; i<sizex*3; i++){
00936                         fprintf(fp2, "%02X", bmp_line_data[i]);
00937                     }
00938 #endif
00939                 }
00940 
00941                 for(int i=0; i<2; i++) {
00942                     free(bayer_line_data[i]);
00943                 }
00944 #ifdef BITMAPFILE
00945                 fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
00946 #endif
00947                 break;
00948         }
00949         HeptaCamera::ReadStop();
00950 
00951 #if defined(BITMAPFILE) || defined(BAYERBITMAPFILE)
00952         free(bmp_line_data);
00953         fclose(fp);
00954 #endif
00955 #ifdef HEXFILE
00956         fclose(fp2);
00957 #endif
00958    
00959 }
00960 
00961 void HeptaCamera::shoot2()
00962 {
00963        //pc.baud(115200);
00964 
00965     //pc.printf("Camera resetting..\r\n");
00966     HeptaCamera::Reset();
00967 
00968     //pc.printf("Before Init...\r\n");
00969     HeptaCamera::PrintRegister();
00970     char color_format = '1';
00971     /*pc.printf("Select color format.\r\n") ;
00972     pc.printf("1: RGB444.\r\n");
00973     pc.printf("2: RGB555.\r\n");
00974     pc.printf("3: RGB565.\r\n");
00975     pc.printf("4: YUV(UYVY).\r\n");
00976     pc.printf("5: Bayer RGB(BGBG... GRGR...).\r\n");*/
00977 
00978     /*while(!pc.readable());
00979     char color_format = pc.getc();
00980     switch (color_format) {
00981         case '1':
00982             camera.InitRGB444();
00983             break;
00984         case '2':
00985             camera.InitRGB555();
00986             break;
00987         case '3':
00988             camera.InitRGB565();
00989             break;
00990         case '4':
00991             camera.InitYUV();
00992             break;
00993         case '5':
00994             camera.InitBayerRGB();
00995             break;
00996     }
00997     pc.printf("select %c\r\n", color_format);
00998 
00999     pc.printf("Select screen size.\r\n") ;
01000     switch (color_format) {
01001         case '5':
01002             pc.printf("1: VGA(640x480).\r\n");
01003         case '1':
01004         case '2':
01005         case '3':
01006         case '4':
01007             pc.printf("2: FIFO nealy limit(544x360).\r\n");
01008             pc.printf("3: VGA*3/4(480x360).\r\n");
01009             pc.printf("4: QVGA(320x240).\r\n");
01010             pc.printf("5: QQVGA(160x120).\r\n");
01011             break;
01012     }
01013     char screen_size = 4;
01014     while(!pc.readable());
01015     char screen_size = pc.getc() ;
01016     switch (screen_size) {
01017         case '1':
01018             sizex = 640;
01019             sizey = 480;
01020             camera.InitVGA();
01021             break;
01022         case '2':
01023             sizex = 544;
01024             sizey = 360;
01025             camera.InitFIFO_2bytes_color_nealy_limit_size();
01026             break;
01027         case '3':
01028             sizex = 480;
01029             sizey = 360;
01030             camera.InitVGA_3_4();
01031             break;
01032         case '4':
01033             sizex = 320;
01034             sizey = 240;
01035             camera.InitQVGA();
01036             break;
01037         case '5':
01038             sizex = 160;
01039             sizey = 120;
01040             camera.InitQQVGA();
01041             break;
01042     }
01043     pc.printf("select %c\r\n", screen_size);*/
01044     char screen_size = '4';
01045     HeptaCamera::InitRGB444();
01046     sizex = 320;
01047     sizey = 240;
01048     HeptaCamera::InitQVGA();
01049     HeptaCamera::InitForFIFOWriteReset();
01050     HeptaCamera::InitDefaultReg();
01051 
01052 #ifdef COLORBAR
01053     HeptaCamera::InitSetColorbar();
01054 #endif
01055 
01056     //pc.printf("After Init...\r\n");
01057     HeptaCamera::PrintRegister();
01058 
01059     // CAPTURE and SEND LOOP
01060 
01061 #if defined(BITMAPFILE) || defined(BAYERBITMAPFILE) || defined(HEXFILE)
01062         //pc.printf("Hit Any Key %dx%d Capture Data.\r\n", sizex, sizey) ;
01063         //while(!pc.readable());
01064         //pc.printf("*\r\n");
01065         //pc.getc();
01066 
01067         int real_width = sizex*3 + sizey%4;
01068 
01069         unsigned char *bmp_line_data; //画像1行分のRGB情報を格納する
01070         if((bmp_line_data = (unsigned char *)malloc(sizeof(unsigned char)*real_width)) == NULL){
01071            fprintf(stderr, "Error: Allocation error.\n");
01072            //return 1;
01073         }
01074 
01075         //RGB情報を4バイトの倍数に合わせている
01076         for(int i=sizex*3; i<real_width; i++){
01077             bmp_line_data[i] = 0;
01078         }
01079 #endif
01080 #if defined(BITMAPFILE) || defined(BAYERBITMAPFILE)
01081         mkdir("/sd/mydir", 0777);
01082         FILE *fp = fopen("/sd/mydir/picture.bmp","w");
01083         if(fp == NULL) {
01084             error("Could not open file for write\r\n");
01085         }
01086 
01087         create_header(fp, sizex, sizey);
01088 #endif
01089 #ifdef HEXFILE
01090         FILE *fp2;
01091         char *filename2 = "/local/test.txt";
01092         if((fp2 = fopen(filename2, "w")) == NULL){
01093             pc.printf("Error: %s could not open.", filename2);
01094             return 1;
01095         }
01096 #endif
01097 
01098         HeptaCamera::CaptureNext();
01099         while(HeptaCamera::CaptureDone() == false);
01100         HeptaCamera::ReadStart();
01101 
01102         int r=0, g=0, b=0, d1, d2;
01103 
01104         switch (color_format) {
01105             case '1':
01106             case '2':
01107             case '3':
01108 
01109                 for (int y=0; y<sizey; y++) {
01110                     for (int x=0; x<sizex; x++) {
01111                         d1 = HeptaCamera::ReadOneByte();
01112                         d2 = HeptaCamera::ReadOneByte();
01113 
01114                         switch (color_format) {
01115                             case '1':
01116                                 // RGB444 to RGB888
01117                                 b = (d1 & 0x0F) << 4;
01118                                 g = (d2 & 0xF0);
01119                                 r = (d2 & 0x0F) << 4;
01120                                 break;
01121                             case '2':
01122                                 // RGB555 to RGB888
01123                                 b = (d1 & 0x1F) << 3;
01124                                 g = (((d1 & 0xE0) >> 2) | ((d2 & 0x03) << 6));
01125                                 r = (d2 & 0x7c) << 1;
01126                                 break;
01127                             case '3':
01128                                 // RGB565 to RGB888
01129                                 b = (d1 & 0x1F) << 3;
01130                                 g = (((d1 & 0xE0) >> 3) | ((d2 & 0x07) << 5));
01131                                 r = (d2 & 0xF8);
01132                                 break;                                
01133                         }
01134 #if defined(BITMAPFILE) || defined(HEXFILE)
01135                         bmp_line_data[x*3]     = (unsigned char)b;
01136                         bmp_line_data[x*3 + 1] = (unsigned char)g;
01137                         bmp_line_data[x*3 + 2] = (unsigned char)r;
01138 #endif
01139 /*
01140                         // RGB
01141                         pc.printf ("%2X%2X%2X", r, g, b) ;
01142 */
01143                     }
01144 #ifdef BITMAPFILE
01145                     fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
01146 #endif
01147 #ifdef HEXFILE
01148                     for(int i=0; i<sizex*3; i++){
01149                         fprintf(fp2, "%02X", bmp_line_data[i]);
01150                     }
01151 #endif
01152 //                    pc.printf("\r\n") ;
01153                 }
01154                 break;
01155 
01156             case '4':
01157                 int index = 0;
01158                 for (int y=0; y<sizey; y++) {
01159                     int U0=0, Y0=0, V0=0, Y1=0;
01160                     for (int x=0; x<sizex; x++) {
01161                         if(index%2 == 0) {
01162                             U0 = HeptaCamera::ReadOneByte();
01163                             Y0 = HeptaCamera::ReadOneByte();
01164                             V0 = HeptaCamera::ReadOneByte();
01165                             Y1 = HeptaCamera::ReadOneByte();
01166 
01167                             b = Y0 + 1.77200 * (U0 - 128);
01168                             g = Y0 - 0.34414 * (U0 - 128) - 0.71414 * (V0 - 128);
01169                             r = Y0 + 1.40200 * (V0 - 128);
01170                         } else {
01171                             b = Y1 + 1.77200 * (U0 - 128);
01172                             g = Y1 - 0.34414 * (U0 - 128) - 0.71414 * (V0 - 128);
01173                             r = Y1 + 1.40200 * (V0 - 128);
01174                         }
01175 
01176                         b = min(max(b, 0), 255);
01177                         g = min(max(g, 0), 255);
01178                         r = min(max(r, 0), 255);
01179 
01180 #if defined(BITMAPFILE) || defined(HEXFILE)
01181                         bmp_line_data[x*3]     = (unsigned char)b;
01182                         bmp_line_data[x*3 + 1] = (unsigned char)g;
01183                         bmp_line_data[x*3 + 2] = (unsigned char)r;
01184 #endif
01185 /*
01186                         // RGB
01187                         pc.printf ("%2X%2X%2X", r, g, b) ;
01188 */
01189                         index++;
01190                     }
01191 #ifdef BITMAPFILE
01192                     fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
01193 #endif
01194 #ifdef HEXFILE
01195                     for(int i=0; i<sizex*3; i++){
01196                         fprintf(fp2, "%02X", bmp_line_data[i]);
01197                     }
01198 #endif
01199 //                    pc.printf("\r\n") ;
01200                 }
01201                 break;
01202 
01203             case '5':
01204                 unsigned char *bayer_line[2];
01205                 unsigned char *bayer_line_data[2]; //画像1行分のRGB情報を格納する2行分
01206                 for(int i=0; i<2; i++) {
01207                     if((bayer_line_data[i] = (unsigned char *)malloc(sizeof(unsigned char)*sizex)) == NULL){
01208                        fprintf(stderr, "Error: Allocation error.\n");
01209                        //return 1;
01210                     }
01211                 }
01212 
01213                 for (int x=0; x<sizex; x++) {
01214                     // odd line BGBG... even line GRGR...
01215                     bayer_line_data[0][x] = (unsigned char)HeptaCamera::ReadOneByte();
01216 #ifdef BAYERBITMAPFILE
01217                     bmp_line_data[x*3]     = (unsigned char)bayer_line_data[0][x];
01218                     bmp_line_data[x*3 + 1] = (unsigned char)bayer_line_data[0][x];
01219                     bmp_line_data[x*3 + 2] = (unsigned char)bayer_line_data[0][x];
01220 #endif
01221                 }
01222 #ifdef BAYERBITMAPFILE
01223                 fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
01224 #endif
01225                 bayer_line[1] = bayer_line_data[0];
01226 
01227                 for (int y=1; y<sizey; y++) {
01228                     int line = y%2;
01229 
01230                     for (int x=0; x<sizex; x++) {
01231                         // odd line BGBG... even line GRGR...
01232                         bayer_line_data[line][x] = (unsigned char)HeptaCamera::ReadOneByte();
01233 #ifdef BAYERBITMAPFILE
01234                         bmp_line_data[x*3]     = (unsigned char)bayer_line_data[line][x];
01235                         bmp_line_data[x*3 + 1] = (unsigned char)bayer_line_data[line][x];
01236                         bmp_line_data[x*3 + 2] = (unsigned char)bayer_line_data[line][x];
01237 #endif
01238                     }
01239 #ifdef BAYERBITMAPFILE
01240                     fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
01241 #endif
01242                     bayer_line[0] = bayer_line[1];
01243                     bayer_line[1] = bayer_line_data[line];
01244 
01245                     for (int x=0; x<sizex - 1; x++) {
01246                         if(y%2==1) {
01247                             if(x%2==0) {
01248                                 // BG
01249                                 // GR
01250                                 b = bayer_line[0][x];
01251                                 g = ((int)bayer_line[0][x+1] + bayer_line[1][x])>>1;
01252                                 r = bayer_line[1][x+1];
01253                             } else {
01254                                 // GB
01255                                 // RG
01256                                 b = bayer_line[0][x+1];
01257                                 g = ((int)bayer_line[0][x] + bayer_line[1][x+1])>>1;
01258                                 r = bayer_line[1][x];
01259                             }
01260                         } else {
01261                             if(x%2==0) {
01262                                 // GR
01263                                 // BG
01264                                 b = bayer_line[1][x];
01265                                 g = ((int)bayer_line[0][x] + bayer_line[1][x+1])>>1;
01266                                 r = bayer_line[0][x+1];
01267                             } else {
01268                                 // RG
01269                                 // GB
01270                                 b = bayer_line[1][x+1];
01271                                 g = ((int)bayer_line[0][x+1] + bayer_line[1][x])>>1;
01272                                 r = bayer_line[0][x];
01273                             }
01274                         }
01275 #if defined(BITMAPFILE) || defined(HEXFILE)
01276                         bmp_line_data[x*3]     = (unsigned char)b;
01277                         bmp_line_data[x*3 + 1] = (unsigned char)g;
01278                         bmp_line_data[x*3 + 2] = (unsigned char)r;
01279 #endif
01280                     }
01281 
01282 #ifdef BITMAPFILE
01283                     fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
01284 #endif
01285 
01286 #ifdef HEXFILE
01287                     for(int i=0; i<sizex*3; i++){
01288                         fprintf(fp2, "%02X", bmp_line_data[i]);
01289                     }
01290 #endif
01291                 }
01292 
01293                 for(int i=0; i<2; i++) {
01294                     free(bayer_line_data[i]);
01295                 }
01296 #ifdef BITMAPFILE
01297                 fwrite(bmp_line_data, sizeof(unsigned char), real_width, fp);
01298 #endif
01299                 break;
01300         }
01301         HeptaCamera::ReadStop();
01302 
01303 #if defined(BITMAPFILE) || defined(BAYERBITMAPFILE)
01304         free(bmp_line_data);
01305         fclose(fp);
01306 #endif
01307 #ifdef HEXFILE
01308         fclose(fp2);
01309 #endif
01310    
01311 }