/* This example use of imageio.library loads the image file specified
		on the command line at half size, converts it to a memory based buffer
		(for demonstrating the use of memory buffers) and saves it to the file
		'ram:test'.
*/

#include <stdio.h>

#include <dos/dos.h>
#include <exec/memory.h>
#include <exec/types.h>

#include <clib/dos_protos.h>
#include <clib/exec_protos.h>
#include <clib/cybergraphics_protos.h>
#include <clib/intuition_protos.h>

#include <pragmas/dos_pragmas.h>
#include <pragmas/exec_pragmas.h>
#include <pragmas/intuition_pragmas.h>
#include <pragmas/cybergraphics_pragmas.h>

#include <cybergraphics/cybergraphics.h>

#include <imageio/imageio.h>
#include <imageio/imageio_protos.h>
#include <imageio/imageio_pragmas.h>

#include <guigfx/guigfx.h>
#include <pragmas/guigfx_pragmas.h>
#include <guigfx/guigfx_protos.h>

/* Function prototypes */
__saveds __asm ULONG progressFunc( register __d0 ULONG curr, register __d1 ULONG lines, register __a0 void *userdata );

extern struct Library *DOSBase;
struct Library *ImageIOBase, *IntuitionBase;

void main( int argc, char **argv )
{
	ImageIOBase = OpenLibrary( "imageio.library", 2 );
	IntuitionBase = OpenLibrary( "intuition.library", NULL );
	if ( IntuitionBase && ImageIOBase )
	{
		struct ImageHandle *ih;
		ULONG err;
		BPTR fp;

		fp = Open( argv[1], MODE_OLDFILE );
		if ( fp != NULL )
		{
			err = AllocImage( &ih, IMG_SrcFile, fp, TAG_DONE );
			if ( !err )
			{
				ULONG num = 1, denom = 2;
				ULONG x, y, bpp, rs;
				UBYTE *buffer, cs, it;

				err = GetImageAttrs( ih,
					IMG_Width, &x,
					IMG_Height,&y,
					IMG_BytesPerPixel, &bpp,
					IMG_ColourSpace, &cs,
					IMG_RowSize, &rs,
					IMG_TestScaleNum, num,
					IMG_TestScaleDenom, denom,
					TAG_DONE );
				if ( !err )
				{
					printf( "width=%ld, height=%ld\n", x, y );
					printf( "bytes per pixel=%ld, colourspace=%d\n", bpp, cs );
					printf( "row size=%ld\n", rs );

					err = ReadImage( ih,
						IMG_ScaleNum, num,
						IMG_ScaleDenom, denom,
						IMG_ImageBuffer, &buffer,
						IMG_ProgressHook, progressFunc,
						TAG_DONE );
					if ( !err )
					{
						err = GetImageAttrs( ih,
							IMG_ImageType, &it,
							TAG_DONE );
						if ( !err )
						{
							printf("Image type=%d\n",it);
							printf("Image buffer=%ld\n",buffer);
						}

						/* Create a memory based image */
						{
							UBYTE saveable;
							struct ImageHandle *memih;
							UBYTE *newbuffer;

							err = AllocImage( &memih,
								IMG_RGBBuffer, buffer,
								IMG_Width, x,
								IMG_Height, x,
								IMG_ColourSpace, IRCS_RGB,
								IMG_BytesPerPixel, 3,
								TAG_DONE );
							if ( !err )
							{
								saveable = IMGF_JPEG;
								err = GetImageAttrs( memih,
									IMG_QuerySaveable, &saveable,
									TAG_DONE );
								if ( !err )
								{
									printf( "can save in JPEG: %s\n", saveable == 1 ? "Yes" : "No" );
								}

								if ( saveable == 1 )
								{
									err = GetImageAttrs( memih,
										IMG_Width, &x,
										IMG_Height,&y,
										IMG_BytesPerPixel, &bpp,
										IMG_ColourSpace, &cs,
										IMG_RowSize, &rs,
										IMG_ImageBuffer, &newbuffer,
										TAG_DONE );
									if ( !err )
									{
										printf( "width=%ld, height=%ld\n", x, y );
										printf( "bytes per pixel=%ld, colourspace=%d\n", bpp, cs );
										printf( "row size=%ld\n", rs );
										printf( "new buffer=%ld\n", newbuffer );
									}

									err = WriteImage( memih, IMGF_JPEG, "ram:test",
										IMG_ProgressHook, progressFunc,
										IMG_JPEG_Quality, 90,
										TAG_DONE );
									if ( !err )
									{
										printf("Image saved\n");
									}
									else printf( "write image error:%d\n", err );
								}

								FreeImage( memih );
							}
						}
					}
					else printf( "read image error:%d\n", err );
				}
				else printf( "get image attrs error:%d\n", err );

				FreeImage( ih );
			}
			else printf( "alloc image error:%d\n", err );

			Close( fp );
		}
		else printf( "cant open file\n" );
	}

	if ( ImageIOBase ) CloseLibrary( ImageIOBase );
	if ( IntuitionBase ) CloseLibrary ( IntuitionBase );
}

__saveds __asm ULONG progressFunc( register __d0 ULONG curr, register __d1 ULONG lines, register __a0 void *userdata )
{
	static int prevpercent = 0;

	int percent = ( curr * 100 ) / lines;

	if ( prevpercent != percent )
	{
		if ( percent % 10 == 0 ) printf( "%d%%\n", percent );
	}

	prevpercent = percent;

	return NULL;
}