home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 12 / MA_Cover_12.iso / libs / prooflibrary_21 / examples / create / main.c next >
Encoding:
C/C++ Source or Header  |  1999-03-12  |  6.8 KB  |  249 lines
  1. /* In the SaveProof call, starting on line 195, you can swap the commented
  2.    line to enable saving non-linked proofs */
  3.  
  4. #include <stdio.h>
  5. #include <string.h>
  6.  
  7. #include <exec/execbase.h>
  8. #include <exec/memory.h>
  9. #include <exec/types.h>
  10. #include <intuition/intuition.h>
  11. #include <intuition/intuitionbase.h>
  12. #include <cybergraphics/cybergraphics.h>
  13.  
  14. #include <proof/proof.h>
  15. #include <proof/proof_protos.h>
  16. #include <proof/proof_pragmas.h>
  17.  
  18. #include <clib/exec_protos.h>
  19. #include <clib/dos_protos.h>
  20. #include <clib/intuition_protos.h>
  21. #include <clib/cybergraphics_protos.h>
  22.  
  23. #include <pragmas/exec_pragmas.h>
  24. #include <pragmas/dos_pragmas.h>
  25. #include <pragmas/intuition_pragmas.h>
  26. #include <pragmas/cybergraphics_pragmas.h>
  27.  
  28. #include <jpeg/jpeg.h>
  29. #include <jpeg/jpeg_protos.h>
  30. #include <jpeg/jpeg_pragmas.h>
  31.  
  32. #include "scale.h"
  33.  
  34. /* Function prototypes */
  35. extern void scale_region( struct PixelRegion *srcPR, struct PixelRegion *destPR, BOOL cubic_interpolation );
  36.  
  37. /* Global variables */
  38. extern struct Library *DOSBase;
  39. struct Library *ProofBase, *JpegBase;
  40.  
  41. char *version = "$VER: ProofCreate 1.1 (25.2.99)";
  42.  
  43. void main( int argc, char **argv )
  44. {
  45.     LONG width = 80, height = 65, jpegquality = 85;
  46.     void *mempool = NULL;
  47.  
  48.     mempool = CreatePool( MEMF_PUBLIC | MEMF_CLEAR, 8000, 4000 );
  49.     ProofBase = OpenLibrary( "proof.library", NULL );
  50.     JpegBase = OpenLibrary( "jpeg.library", NULL );
  51.     if ( ProofBase != NULL && JpegBase != NULL && mempool != NULL )
  52.     {
  53.         if ( argc > 1 )
  54.         {
  55.             struct Proof *pf = NULL;
  56.  
  57.             UBYTE *rgbBuffer = NULL, *scaledBuffer = NULL;
  58.             UBYTE depth, dflags = NULL;
  59.             DOUBLE xzoom, yzoom;
  60.             LONG fileSize;
  61.             ULONG err = 0, scaledWidth, scaledHeight, finalWidth, finalHeight;
  62.             ULONG x, y, denom;
  63.             struct JPEGDecHandle *jph;
  64.             UBYTE *jstream;
  65.             ULONG jstreamsize;
  66.             struct FileInfoBlock *fib;
  67.             BPTR lock, fp;
  68.             UBYTE colourspace;
  69.             ULONG bpp;
  70.  
  71.             /* Get the size of the original image file */
  72.             fib = AllocDosObject ( DOS_FIB, NULL );
  73.  
  74.             /* Place a lock on the file */
  75.             lock = Lock( argv[1], ACCESS_READ );
  76.  
  77.             if ( lock )
  78.             {
  79.                 if ( Examine( lock, fib ) != NULL )
  80.                 {
  81.                     fileSize = fib->fib_Size;
  82.                 }
  83.                 jstreamsize = fileSize;
  84.                 jstream = AllocVec( jstreamsize, MEMF_PUBLIC | MEMF_CLEAR );
  85.                 if ( jstream != NULL )
  86.                 {
  87.                     fp = OpenFromLock( lock );
  88.                     if ( fp != NULL )
  89.                     {
  90.                         /* Spool file into memory */
  91.                         Read( fp, jstream, jstreamsize );
  92.  
  93.                         Close( fp );
  94.  
  95.                         err = AllocJPEGDecompress( &jph, JPG_SrcMemStream, jstream,
  96.                             JPG_SrcMemStreamSize, jstreamsize, TAG_DONE );
  97.                         if ( !err )
  98.                         {
  99.                             err = GetJPEGInfo( (struct JPEGHandle *)jph, JPG_Width, &x, JPG_Height, &y,
  100.                                 JPG_ColourSpace, &colourspace,
  101.                                 JPG_BytesPerPixel, &bpp,
  102.                                 JPG_ScaleNum, 1, JPG_ScaleDenom, 1, TAG_DONE );
  103.                             if ( !err )
  104.                             {
  105.                                 if ( colourspace == JPCS_GRAYSCALE )
  106.                                 {
  107.                                     dflags = PDFF_24BIT | PDFF_GREY;
  108.  
  109.                                     depth = 8;
  110.                                 }
  111.                                 else
  112.                                 {
  113.                                     dflags = PDFF_24BIT | PDFF_CHUNKY;
  114.  
  115.                                     depth = 24;
  116.                                 }
  117.  
  118.                                 err = AllocProof( &pf,
  119.                                     PFN_ImageWidth, x,
  120.                                     PFN_ImageHeight, y,
  121.                                     PFN_ImageDepth, depth,
  122.                                     PFN_ImageType, PDIV_JPEG,
  123.                                     PFN_ImageFormat, dflags,
  124.                                     PFN_ImageFileSize, fileSize,
  125.                                     PFN_CategoryOwner, 87,
  126.                                     PFN_ImageGroup, 1,
  127.                                     PFN_ImageCategory, 47,
  128.                                     PFN_ProofQuestionable, TRUE,
  129.                                     PFN_ProofAspectX, 22,
  130.                                     PFN_ProofAspectY, 22,
  131.                                     PFN_MemoryPool, mempool,
  132.                                     TAG_DONE );
  133.                                 if ( ! err )
  134.                                 {
  135.                                     /* This is divided by 2 on each pass of the loop.*/
  136.                                     denom = 16;
  137.  
  138.                                     /* Now check what scale factor is required by the jpeg loader.*/
  139.                                     do
  140.                                     {
  141.                                         denom /= 2;
  142.  
  143.                                         err = GetJPEGInfo( (struct JPEGHandle *)jph, JPG_Width, &scaledWidth, JPG_Height, &scaledHeight,
  144.                                             JPG_ScaleNum, 1, JPG_ScaleDenom, denom, TAG_DONE );
  145.  
  146.                                     } while( scaledWidth < width || scaledHeight < height );
  147.  
  148.                                     rgbBuffer = AllocVec( scaledWidth * scaledHeight * 3, MEMF_PUBLIC | MEMF_CLEAR );
  149.                                     if ( rgbBuffer )
  150.                                     {
  151.                                         err = DecompressJPEG( jph, JPG_DestRGBBuffer, rgbBuffer,
  152.                                             JPG_ScaleNum, 1, JPG_ScaleDenom, denom,
  153.                                             TAG_DONE );
  154.                                         if ( !err )
  155.                                         {
  156.                                             /* Now calculate the required zoom factor to scale the image to the exact size.*/
  157.                                             xzoom = ( double ) width / ( double ) scaledWidth;
  158.  
  159.                                             yzoom = ( double ) height / ( double ) scaledHeight;
  160.  
  161.                                             if ( xzoom < yzoom )
  162.                                             {
  163.                                                 finalWidth = xzoom * scaledWidth;
  164.                                                 finalHeight = xzoom * scaledHeight;
  165.  
  166.                                                 yzoom = ( double ) finalHeight / ( double ) scaledHeight;
  167.                                             }
  168.                                             else
  169.                                             {
  170.                                                 finalHeight = yzoom * scaledHeight;
  171.                                                 finalWidth = yzoom * scaledWidth;
  172.  
  173.                                                 xzoom = ( double ) finalWidth / ( double ) scaledWidth;
  174.                                             }
  175.  
  176.                                             scaledBuffer = AllocVec( finalWidth * finalHeight * bpp, MEMF_PUBLIC | MEMF_CLEAR );
  177.                                             if ( scaledBuffer != NULL )
  178.                                             {
  179.                                                 struct PixelRegion src, dest;
  180.  
  181.                                                 src.buf = rgbBuffer;
  182.                                                 src.w = scaledWidth;
  183.                                                 src.h = scaledHeight;
  184.                                                 src.bytes = bpp;
  185.  
  186.                                                 dest.buf = scaledBuffer;
  187.                                                 dest.w = finalWidth;
  188.                                                 dest.h = finalHeight;
  189.                                                 dest.bytes = bpp;
  190.  
  191.                                                 scale_region( &src, &dest, TRUE );
  192.  
  193.                                                 err = SaveProof( &pf,
  194.                                                     PFN_ImagePathName, argv[1],
  195. //                                                    PFN_ProofPath, "", // Nonlinked
  196.                                                     PFN_ProofPath, "RAM:", // Linked
  197.                                                     PFN_ProofWidth, finalWidth,
  198.                                                     PFN_ProofHeight, finalHeight,
  199.                                                     PFN_ProofBodyType, PHBV_JFIF,
  200.                                                     PFN_RGBTripletBuffer, scaledBuffer,
  201.                                                     PFN_JFIFQuality, jpegquality,
  202.                                                     PFN_MemoryPool, mempool,
  203.                                                     TAG_DONE );
  204.                                                 if ( err == PFERR_NONE )
  205.                                                 {
  206.                                                     printf("proof saved\n");
  207.                                                 }
  208.                                                 else printf("proof error 2=%d\n",err);
  209.  
  210.                                                 FreeVec( scaledBuffer );
  211.                                             }
  212.                                             else printf("cant allocate scaled buffer\n");
  213.                                         }
  214.                                         else printf("jpeg error 3=%d\n",err);
  215.  
  216.                                         FreeVec( rgbBuffer );
  217.                                     }
  218.                                     else printf("cant allocate load jpeg buffer");
  219.  
  220.                                     FreeProof( &pf, PFN_MemoryPool, mempool, TAG_DONE );
  221.                                 }
  222.                                 else printf("proof error 1=%d\n",err);
  223.                             }
  224.                             else printf("jpeg error 2=%d\n",err);
  225.  
  226.                             FreeJPEGDecompress( jph );
  227.                         }
  228.                         else printf("jpeg error 1=%d\n",err);
  229.                     }
  230.                     else UnLock( lock );
  231.  
  232.                     FreeVec( jstream );
  233.                 }
  234.                 else printf("cant allocate source file memory");
  235.             }
  236.             else printf("cant lock file");
  237.  
  238.  
  239.             if ( fib ) FreeDosObject( DOS_FIB, fib );
  240.         }
  241.     }
  242.  
  243.     if ( ProofBase != NULL ) CloseLibrary( ProofBase );
  244.     if ( JpegBase != NULL ) CloseLibrary( JpegBase );
  245.  
  246.     if ( mempool != NULL ) DeletePool( mempool );
  247.     else printf("cant allocate memory pool\n");
  248. }
  249.