home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 4 / DATAFILE_PDCD4.iso / utilities / utilsm / netpbmsca / ppm / c / rawtoppm < prev    next >
Encoding:
Text File  |  1993-10-04  |  5.5 KB  |  245 lines
  1. /* rawtoppm.c - convert raw RGB bytes into a portable pixmap
  2. **
  3. ** Copyright (C) 1991 by Jef Poskanzer.
  4. **
  5. ** Permission to use, copy, modify, and distribute this software and its
  6. ** documentation for any purpose and without fee is hereby granted, provided
  7. ** that the above copyright notice appear in all copies and that both that
  8. ** copyright notice and this permission notice appear in supporting
  9. ** documentation.  This software is provided "as is" without express or
  10. ** implied warranty.
  11. */
  12.  
  13. #include <math.h>
  14. #include "ppm.h"
  15.  
  16. static void dorowskip ARGS(( FILE* ifp, int rowskip ));
  17.  
  18. int
  19. main( argc, argv )
  20.     int argc;
  21.     char* argv[];
  22.     {
  23.     FILE* ifp;
  24.     pixel* pixrow;
  25.     register pixel* pP;
  26.     int argn, headerskip, rowskip, rows, cols, row, i;
  27.     register int col;
  28.     int order;
  29. #define ORD_RGB 1
  30. #define ORD_RBG 2
  31. #define ORD_GRB 3
  32. #define ORD_GBR 4
  33. #define ORD_BRG 5
  34. #define ORD_BGR 6
  35. int interleave;
  36. #define INT_PIX 1
  37. #define INT_ROW 2
  38.     int val1, val2, val3;
  39.     gray* grow1;
  40.     gray* grow2;
  41.     gray* grow3;
  42.     register gray* g1P;
  43.     register gray* g2P;
  44.     register gray* g3P;
  45.     char* usage = "[-headerskip N] [-rowskip N] [-rgb|-rbg|-grb|-gbr|-brg|-bgr] [-interpixel|-interrow] <width> <height> [rawfile]";
  46.  
  47.  
  48.     ppm_init( &argc, argv );
  49.  
  50.     argn = 1;
  51.     headerskip = 0;
  52.     rowskip = 0;
  53.     order = ORD_RGB;
  54.     interleave = INT_PIX;
  55.  
  56.     while ( argn < argc && argv[argn][0] == '-' && argv[argn][1] != '\0' )
  57.     {
  58.     if ( pm_keymatch( argv[argn], "-headerskip", 2 ) )
  59.         {
  60.         ++argn;
  61.         if ( argn >= argc )
  62.         pm_usage( usage );
  63.         headerskip = atoi( argv[argn] );
  64.         }
  65.     else if ( pm_keymatch( argv[argn], "-rowskip", 3 ) )
  66.         {
  67.         ++argn;
  68.         if ( argn >= argc )
  69.         pm_usage( usage );
  70.         rowskip = atoi( argv[argn] );
  71.         }
  72.     else if ( pm_keymatch( argv[argn], "-rgb", 3 ) )
  73.         order = ORD_RGB;
  74.     else if ( pm_keymatch( argv[argn], "-rbg", 3 ) )
  75.         order = ORD_RBG;
  76.     else if ( pm_keymatch( argv[argn], "-grb", 3 ) )
  77.         order = ORD_GRB;
  78.     else if ( pm_keymatch( argv[argn], "-gbr", 3 ) )
  79.         order = ORD_GBR;
  80.     else if ( pm_keymatch( argv[argn], "-brg", 3 ) )
  81.         order = ORD_BRG;
  82.     else if ( pm_keymatch( argv[argn], "-bgr", 3 ) )
  83.         order = ORD_BGR;
  84.     else if ( pm_keymatch( argv[argn], "-interpixel", 7 ) )
  85.         interleave = INT_PIX;
  86.     else if ( pm_keymatch( argv[argn], "-interrow", 7 ) )
  87.         interleave = INT_ROW;
  88.     else
  89.         pm_usage( usage );
  90.     ++argn;
  91.     }
  92.  
  93.     if ( argn + 2 > argc )
  94.     pm_usage( usage );
  95.  
  96.     cols = atoi( argv[argn++] );
  97.     rows = atoi( argv[argn++] );
  98.     if ( cols <= 0 || rows <= 0 )
  99.     pm_usage( usage );
  100.  
  101.     if ( argn < argc )
  102.     {
  103.     ifp = pm_openr( argv[argn] );
  104.     ++argn;
  105.     }
  106.     else
  107.     ifp = stdin;
  108.  
  109.     if ( argn != argc )
  110.     pm_usage( usage );
  111.  
  112.     ppm_writeppminit( stdout, cols, rows, (pixval) 255, 0 );
  113.     pixrow = ppm_allocrow( cols );
  114.  
  115.     if ( interleave == INT_ROW )
  116.     {
  117.     grow1 = pgm_allocrow( cols );
  118.     grow2 = pgm_allocrow( cols );
  119.     grow3 = pgm_allocrow( cols );
  120.     }
  121.  
  122.     for ( i = 0; i < headerskip; ++i )
  123.     {
  124.     val1 = getc( ifp );
  125.     if ( val1 == EOF )
  126.         pm_error( "EOF / read error" );
  127.     }
  128.  
  129.     for ( row = 0; row < rows; ++row)
  130.     {
  131.     switch ( interleave )
  132.         {
  133.         case INT_PIX:
  134.         for ( col = 0, pP = pixrow; col < cols; ++col, ++pP )
  135.         {
  136.         val1 = getc( ifp );
  137.         if ( val1 == EOF )
  138.             pm_error( "EOF / read error" );
  139.         val2 = getc( ifp );
  140.         if ( val2 == EOF )
  141.             pm_error( "EOF / read error" );
  142.         val3 = getc( ifp );
  143.         if ( val3 == EOF )
  144.             pm_error( "EOF / read error" );
  145.         switch ( order )
  146.             {
  147.             case ORD_RGB:
  148.             PPM_ASSIGN( *pP, val1, val2, val3 );
  149.             break;
  150.             case ORD_RBG:
  151.             PPM_ASSIGN( *pP, val1, val3, val2 );
  152.             break;
  153.             case ORD_GRB:
  154.             PPM_ASSIGN( *pP, val2, val1, val3 );
  155.             break;
  156.             case ORD_GBR:
  157.             PPM_ASSIGN( *pP, val3, val1, val2 );
  158.             break;
  159.             case ORD_BRG:
  160.             PPM_ASSIGN( *pP, val2, val3, val1 );
  161.             break;
  162.             case ORD_BGR:
  163.             PPM_ASSIGN( *pP, val3, val2, val1 );
  164.             break;
  165.             }
  166.         }
  167.         dorowskip( ifp, rowskip );
  168.         break;
  169.  
  170.         case INT_ROW:
  171.         for ( col = 0, g1P = grow1; col < cols; ++col, ++g1P )
  172.         {
  173.         val1 = getc( ifp );
  174.         if ( val1 == EOF )
  175.             pm_error( "EOF / read error" );
  176.         *g1P = val1;
  177.         }
  178.         dorowskip( ifp, rowskip );
  179.         for ( col = 0, g2P = grow2; col < cols; ++col, ++g2P )
  180.         {
  181.         val2 = getc( ifp );
  182.         if ( val2 == EOF )
  183.             pm_error( "EOF / read error" );
  184.         *g2P = val2;
  185.         }
  186.         dorowskip( ifp, rowskip );
  187.         for ( col = 0, g3P = grow3; col < cols; ++col, ++g3P )
  188.         {
  189.         val3 = getc( ifp );
  190.         if ( val3 == EOF )
  191.             pm_error( "EOF / read error" );
  192.         *g3P = val3;
  193.         }
  194.         dorowskip( ifp, rowskip );
  195.         for ( col = 0, pP = pixrow, g1P = grow1, g2P = grow2, g3P = grow3;
  196.           col < cols; ++col, ++pP, ++g1P, ++g2P, ++g3P )
  197.         {
  198.         switch ( order )
  199.             {
  200.             case ORD_RGB:
  201.             PPM_ASSIGN( *pP, *g1P, *g2P, *g3P );
  202.             break;
  203.             case ORD_RBG:
  204.             PPM_ASSIGN( *pP, *g1P, *g3P, *g2P );
  205.             break;
  206.             case ORD_GRB:
  207.             PPM_ASSIGN( *pP, *g2P, *g1P, *g3P );
  208.             break;
  209.             case ORD_GBR:
  210.             PPM_ASSIGN( *pP, *g3P, *g1P, *g2P );
  211.             break;
  212.             case ORD_BRG:
  213.             PPM_ASSIGN( *pP, *g2P, *g3P, *g1P );
  214.             break;
  215.             case ORD_BGR:
  216.             PPM_ASSIGN( *pP, *g3P, *g2P, *g1P );
  217.             break;
  218.             }
  219.         }
  220.         break;
  221.         }
  222.     ppm_writeppmrow( stdout, pixrow, cols, (pixval) 255, 0 );
  223.     }
  224.  
  225.     pm_close( ifp );
  226.     pm_close( stdout );
  227.  
  228.     exit( 0 );
  229.     }
  230.  
  231. static void
  232. dorowskip( ifp, rowskip )
  233.     FILE* ifp;
  234.     int rowskip;
  235.     {
  236.     int i, val;
  237.  
  238.     for ( i = 0; i < rowskip; ++i )
  239.     {
  240.     val = getc( ifp );
  241.     if ( val == EOF )
  242.         pm_error( "EOF / read error" );
  243.     }
  244.     }
  245.