home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / REND.LZH / PIC1600 / F_RGB8.C < prev    next >
C/C++ Source or Header  |  1996-06-12  |  5KB  |  215 lines
  1. #include    <stdio.h>
  2. #include    <stdlib.h>
  3. #include    <string.h>
  4. #include    <ctype.h>
  5. #include    "piclib.h"
  6.  
  7. typedef enum {TYPE_RGB, TYPE_PPM} PicType;
  8.  
  9. typedef struct {
  10.     FILE *fp;
  11.     unsigned char buffer[BUFFERSIZE];
  12.     unsigned int nowpoint;
  13.     PicType type;
  14. }    PicWork;
  15.  
  16. int        PicReadHeader_RGB888(PicData *pd, FILE *fp, unsigned char *magic)
  17. {
  18.     int i;
  19.     FILE *hfp;
  20.     char buf[512];
  21.     char fname[512];
  22.     int x,y,px,py;
  23.     extern PicFunction PicFunction_RGB888;
  24.  
  25.     i = strlen(pd->filename);
  26. /*    if (i < 4 || strcmpi(pd->filename+i-4, ".rgb") != 0) {*/
  27.  
  28.     if (i < 4 || pd->filename[i-4] != '.') {
  29.         return FALSE;
  30.     }
  31.  
  32.     if (tolower(pd->filename[i-3]) == 'r'
  33.      && tolower(pd->filename[i-2]) == 'g'
  34.      && tolower(pd->filename[i-1]) == 'b') {
  35.         strcpy(fname, pd->filename);
  36.         i = strlen(fname);
  37.         strcpy(fname+i-3, "IPR");
  38.         if ((hfp = fopen(fname, "r")) == NULL) {
  39.             return FALSE;
  40.         }
  41.         if (fgets(buf, 512, hfp) == NULL) {
  42.             fclose(hfp);
  43.             return FALSE;
  44.         }
  45.         if (sscanf(buf, "%d %d %d %d",     &x,&y,&px,&py) != 4) {
  46.             fclose(hfp);
  47.             return FALSE;
  48.         }
  49.         if (x <= 0 || y <= 0) {
  50.             fclose(hfp);
  51.             return FALSE;
  52.         }
  53.     } else if (tolower(pd->filename[i-3]) == 'p'
  54.      && tolower(pd->filename[i-2]) == 'p'
  55.      && tolower(pd->filename[i-1]) == 'm'
  56.      && magic[0] == 'P' && magic[1] == '6') {
  57.         x = y = 0;
  58.     } else {
  59.         return FALSE;
  60.     }
  61.  
  62.     pd->func = &PicFunction_RGB888;
  63.     pd->mode = NON;
  64.     pd->pixelX = (unsigned short)x;
  65.     pd->pixelY = (unsigned short)y;
  66.     return TRUE;
  67. }
  68.  
  69.  
  70. static inline Pixel Convert_RGB888_32(unsigned char r, unsigned char g, unsigned char b)
  71. {
  72.     return ((unsigned long)r << 16L) | ((unsigned long)g << 24L) | ((unsigned long)b << 8L);
  73. }
  74.  
  75. static void SkipSpace(PicWork *work)
  76. {
  77.     int i;
  78.     i = work->nowpoint;
  79.     while (i < BUFFERSIZE) {
  80.         if (isspace(work->buffer[i])) {
  81.             i++;
  82.         } else if (work->buffer[i] == '#') {
  83.             while (i < BUFFERSIZE && work->buffer[i] != '\n') {
  84.                 i++;
  85.             }
  86.         } else {
  87.             break;
  88.         }
  89.     }
  90.     work->nowpoint = i;
  91. }
  92.  
  93. int        PicOpen_RGB888(PicData *pd, FILE *fp, int flag)
  94. {
  95.     PicWork *work;
  96.     if ((work = malloc(sizeof(PicWork))) == NULL) {
  97.         return FALSE;
  98.     }
  99.     pd->work = work;
  100.     work->fp = fp;
  101.     if (pd->flag == PIC_READ) {
  102.         fread(work->buffer, 1, BUFFERSIZE*sizeof(char), work->fp);
  103.         work->nowpoint = 0;
  104.         if (pd->pixelX == 0 && pd->pixelY == 0) {
  105.             int x, y, d;
  106.             work->nowpoint = 2;
  107.             SkipSpace(work);
  108.             x = atoi(work->buffer+work->nowpoint);
  109.             while (isdigit(work->buffer[work->nowpoint])) {
  110.                 work->nowpoint++;
  111.             }
  112.             SkipSpace(work);
  113.             y = atoi(work->buffer+work->nowpoint);
  114.             while (isdigit(work->buffer[work->nowpoint])) {
  115.                 work->nowpoint++;
  116.             }
  117.             SkipSpace(work);
  118.             d = atoi(work->buffer+work->nowpoint);
  119.             while (isdigit(work->buffer[work->nowpoint])) {
  120.                 work->nowpoint++;
  121.             }
  122.             work->nowpoint++;
  123.             pd->pixelX = (unsigned short)x;
  124.             pd->pixelY = (unsigned short)y;
  125.         }
  126.     } else {
  127.         int i;
  128.         i = strlen(pd->filename);
  129.         if (tolower(pd->filename[i-3]) == 'r'
  130.          && tolower(pd->filename[i-2]) == 'g'
  131.          && tolower(pd->filename[i-1]) == 'b') {
  132.             char fname[512];
  133.             FILE *hfp;
  134.             strcpy(fname, pd->filename);
  135.             i = strlen(fname);
  136.             strcpy(fname+i-3, "IPR");
  137.             if ((hfp = fopen(fname, "w")) == NULL) {
  138.                 return FALSE;
  139.             }
  140.             fprintf(hfp, "%d %d 0 0\n", pd->pixelX, pd->pixelY);
  141.             fclose(hfp);
  142.         } else {
  143.             fprintf(fp, "P6\n%ld %ld\n255\n", pd->pixelX, pd->pixelY);
  144.         }
  145.         pd->mode = flag;
  146.         work->nowpoint = 0;
  147.     }
  148.     return TRUE;
  149. }
  150.  
  151. int        PicOutput_RGB888(PicData *pd, Pixel *pixel)
  152. {
  153.     int pixels = pd->pixelX;
  154.     PicWork *work = pd->work;
  155.     unsigned char *nowp;
  156.     if (BUFFERSIZE - work->nowpoint < pixels*3) {
  157.         fwrite(work->buffer, 1, work->nowpoint, work->fp);
  158.         work->nowpoint = 0;
  159.     }
  160.     nowp = work->buffer+work->nowpoint;
  161.     work->nowpoint += pixels*3;
  162.     for (; pixels > 0; --pixels) {
  163.         *nowp++ = (*pixel >> 16) & 255;
  164.         *nowp++ = (*pixel >> 24) & 255;
  165.         *nowp++ = (*pixel >>  8) & 255;
  166.         pixel++;
  167.     }
  168.     return TRUE;
  169. }
  170.  
  171. int        PicInput_RGB888(PicData *pd, Pixel *pixel)
  172. {
  173.     int pixels = pd->pixelX;
  174.     PicWork *work = pd->work;
  175.     unsigned char *nowp;
  176.     nowp = work->buffer+work->nowpoint;
  177.     work->nowpoint += pixels*3;
  178.     for (; pixels > 0; --pixels) {
  179.         *pixel++ = Convert_RGB888_32(nowp[0], nowp[1], nowp[2]);
  180.         nowp+=3;
  181.     }
  182.     if (work->nowpoint > BUFFERSIZE - pd->pixelX*3) {
  183.         int rest = BUFFERSIZE - work->nowpoint;
  184.         memcpy(work->buffer, work->buffer+work->nowpoint, rest);
  185.         fread(work->buffer+rest, 1, (work->nowpoint)*sizeof(char), work->fp);
  186.         work->nowpoint = 0;
  187.     }
  188.     return TRUE;
  189. }
  190.  
  191. int        PicClose_RGB888(PicData *pd)
  192. {
  193.     PicWork *work = pd->work;
  194.     if (pd->flag == PIC_WRITE) {
  195.         if (work->nowpoint > 0) {
  196.             fwrite(work->buffer, 1, work->nowpoint, work->fp);
  197.         }
  198.     }
  199.     fclose(work->fp);
  200.     free(work);
  201.     return TRUE;
  202. }
  203.  
  204. PicFunction PicFunction_RGB888 = {
  205.     "RGB|PPM",
  206.     PicReadHeader_RGB888,
  207.     PicOpen_RGB888,
  208.     PicOutput_RGB888,
  209.     PicInput_RGB888,
  210.     PicClose_RGB888
  211. };
  212.  
  213.  
  214.  
  215.