Hello,

i've been trying to compile POV-Ray with MPW for a while. I eliminated
some problems concerning sysMacPict.cp in the makefile. But now the
linker reports these errors:

# Error:  File ":mpwobj:POVRAY.c.o"
#         Reference to unresolved symbol ".MacFile_GetFileHandle"
# Error:  File ":mpwobj:PARSTXTR.c.o"
#         Reference to unresolved symbol ".MacFile_ReadImage"

I've tried to compile other files than sysMacPict.cp with MrCpp. None of
the functions in these files can be accessed from outside.

Is there any incompatibility between MrC and MrCpp that I should be
aware of? I'm quite new to MPW and have no idea what to do. I use
version 4.1.0f1c1 of MrC and MrCpp.

Thanks in advance
	Fabian

Post a reply to this message

In article <3AB553CA.26C9387A@nexxium.de> , Fabian Herb 
<com### [at] nexxiumde>  wrote:

> i've been trying to compile POV-Ray with MPW for a while. I eliminated
> some problems concerning sysMacPict.cp in the makefile. But now the
> linker reports these errors:
>
> # Error:  File ":mpwobj:POVRAY.c.o"
> #         Reference to unresolved symbol ".MacFile_GetFileHandle"
> # Error:  File ":mpwobj:PARSTXTR.c.o"
> #         Reference to unresolved symbol ".MacFile_ReadImage"
>
> I've tried to compile other files than sysMacPict.cp with MrCpp. None of
> the functions in these files can be accessed from outside.

The MPW makefiles that come with 3.1g don't work if Mac Pict support is
enabled.  The simplest solution is to remove the following lines from
config.h:

#define GET_SYS_FILE_HANDLE() MacFile_GetFileHandle()
#define READ_SYS_IMAGE(i,n)  MacFile_ReadImage((i),(n))
#define SYS_DEF_EXT    ".pict"

and near the end

#define GET_SYS_FILE_HANDLE() MacFile_GetFileHandle()


> I'm quite new to MPW and have no idea what to do.

To be honest (and very direct), compiling POV-Ray is not an easy task
for a beginner.  The source code is complex and not well commented, and
when you run into problems you should be able to resolve them on your
own.  If you don't know how, compiling the source code will most likely
be a very frustrating and discouraging experience.

There are more rewarding, smaller programs (like the Apple sample code)
out there that can get you started to learn programming and using MPW.
If you search a bit on Apples developer website, you will probably find
some good tutorial or other information that will be really helpful
getting started, too.


    Thorsten


____________________________________________________
Thorsten Froehlich
e-mail: mac### [at] povrayorg

I am a member of the POV-Ray Team.
Visit POV-Ray on the web: http://mac.povray.org

Post a reply to this message

IMO, MPW is the hardest-to-user compiler in the world. And yes, I've used
the little UNIX command-liners.
______
David McCabe
mcc### [at] yahoocom
http://homepage.mac.com/davidmccabe/
Jesus loves you! 

> Hello,
> 
> i've been trying to compile POV-Ray with MPW for a while. I eliminated
> some problems concerning sysMacPict.cp in the makefile. But now the
> linker reports these errors:
> 
> # Error:  File ":mpwobj:POVRAY.c.o"
> #         Reference to unresolved symbol ".MacFile_GetFileHandle"
> # Error:  File ":mpwobj:PARSTXTR.c.o"
> #         Reference to unresolved symbol ".MacFile_ReadImage"
> 
> I've tried to compile other files than sysMacPict.cp with MrCpp. None of
> the functions in these files can be accessed from outside.
> 
> Is there any incompatibility between MrC and MrCpp that I should be
> aware of? I'm quite new to MPW and have no idea what to do. I use
> version 4.1.0f1c1 of MrC and MrCpp.
> 
> Thanks in advance
> Fabian

Post a reply to this message

Dear

I am also compiling POV-Ray 3.1g and MegaPOV-Ray 0.7 by MrC under MPW.
Here is my modify sysmacpict.c and sysmacpict.h.
But I get this file from old posted mail,so some part to mistake to cut  ">" or space.
To separate sysmacpict.c and sysmacpict.h and add flag in frame.h.

Best Regards

Y.Tanabe
Kobe,Japan


//in frame.h
struct file_handle_struct
{
 char *filename;
 int mode;
 int width, height;
 int buffer_size;
 char *buffer;
 FILE *file;
 int file_type;  /* What format the output file is */
 int  (*Open_File_p) (struct file_handle_struct *handle,
 char *name, int *width, int *height, int buffer_size, int mode);
 void (*Write_Line_p) (struct file_handle_struct *handle,
 COLOUR *line_data, int line_number);
 int (*Read_Line_p) (struct file_handle_struct *handle,
 COLOUR *line_data, int *line_number);
 void (*Read_Image_p) (IMAGE *Image, char *filename);
 void (*Close_File_p) (struct file_handle_struct *handle);
 Boolean flag;//add here
};


/*==============================================================================
 File:   sysMacPict.c
 ==============================================================================*/

 #undef POV_COMMENTS // turn on for internal comment stamping

 #include "sysMacPict.h"

 #include <QuicktimeComponents.h>
 #include <MoviesFormat.h>
 #include <Movies.h>
 #include <FixMath.h>
 #include <Resources.h>

 #include "frame.h"
 #include "povproto.h"
 #include "povray.h"
 #include "optout.h"

 #include "PovMacInit.h" // gHasImageCompressionMgr
 #include "AppPrefs.h"   // gAppPrefs_h
 #include "FilePrefs.h"  // gPrefs2Use_h
 #include "TextEditor.h" // gSrcWind_VRefNum
 #include "ImageUtils.h"

 extern Boolean gMapPictToMovie;
 extern Boolean gHasQuickTime;
 extern long gQTVersion;

 FSSpec gMovieFile = { 0,0,"\p" };


 #define PICTF_HEADER_SIZE               512             // old MacDraw PICTF header
size in bytes

 typedef struct
 {
         short           picSize;                // low word of size
         Rect            picFrame;               // picture bounds
 } PictFHeader,*PictFHeaderPtr;

 typedef struct MovieFile_Struct                         MOVIE_FILE;
 typedef struct PictureFile_Struct                       PICTURE_FILE;
 typedef struct PictFileHeader_Struct
 PICT_FILE_HEADER,*PICT_FILE_HEADER_PTR;

 struct MovieFile_Struct
 {
         int             fWidth;
         int             fHeight;
         int             fMode;
         GWorldPtr       fTargetGWorld;
 };

 struct PictureFile_Struct
 {
         int             fWidth;
         int             fHeight;
         int             fMode;
         int             fLastLine;
         GWorldPtr       fTargetGWorld;
         FSSpec          fFile;
 };

 struct PictFileHeader_Struct
 {
         // low word of size
         short           picSize;
         // picture bounds
         Rect            picFrame;
 };

 //PICT
 // PICT FUNCTION
 static OSErr image_compress_pict_file(ComponentInstance,FSSpec *);
 static int                      Open_MacPICT_File(FILE_HANDLE *,char *,int
 *,int *,int,int);
 static void             Write_MacPICT_Line(FILE_HANDLE *,COLOUR *,int);
 static int                      Read_MacPICT_Line(FILE_HANDLE
 *,COLOUR *,int
 *);
 static void             Close_MacPICT_File(FILE_HANDLE *handle);
 static OSErr            image_movie_create(MOVIE_FILE
 *mhandle,char *name,int
 *width,int *height,int mode);
 static void             image_movie_write_line(MOVIE_FILE *mhandle,COLOUR
 *line_data,int line_number);
 static void             image_movie_delete(MOVIE_FILE *mhandle);
 OSErr           image_picture_create(PICTURE_FILE *mhandle,char *name,int
 *width,int *height,int mode);
 static void             image_picture_write_line(PICTURE_FILE
 *mhandle,COLOUR
 *line_data,int line_number);
 static int                      image_picture_read_line(PICTURE_FILE
 *mhandle,COLOUR *line_data,int *line_number);
 static void             image_picture_read_image(PICTURE_FILE
 *mhandle,IMAGE
 *imageptr);
 static void             image_picture_delete(PICTURE_FILE *mhandle);
 static OSErr
 image_picture_gworld_from_file(PICTURE_FILE *mhandle);
 static OSErr
 image_picture_gworld_from_image(PICTURE_FILE *mhandle);

 static OSErr            image_picture_gworld_create(PICTURE_FILE
 *mhandle,int
 w,int h,int d);
 static void             image_picture_gworld_clear(PICTURE_FILE *mhandle);
 static OSErr            image_picture_new(PICTURE_FILE *mhandle);
 static OSErr            image_picture_paint(PICTURE_FILE
 *mhandle,PicHandle
 pict);
 static PicHandle
 image_picture_handle_from_file(PICTURE_FILE *mhandle);

 static OSErr            image_picture_make_file(char *name_cstring,FSSpec
 *fs);
 static void             image_picture_alpha_channel(GWorldPtr);








 static pascal void MyPutPicProc(char *dataPtr,short byteCount);

 static OSErr Mac_SpecialMakeFSSpec(ConstStr255Param name,FSSpec *fs);
 static OSErr Mac_PaintPictToGWorld(PicHandle pict,GWorldPtr
 gw_rgb,int w,int
 h);
 static OSErr Mac_ReadPictImageFromFile(FSSpec *f,PicHandle *pict);
 static void Mac_ActivateAlphaChannel(GWorldPtr gw);

 int Open_MacMovie_File(FILE_HANDLE *handle,char *name,int *width,int
 *height,int buffer_size,int mode);
 void Write_MacMovie_Line(FILE_HANDLE *handle,COLOUR *line_data,int
 line_number);
 void Close_MacMovie_File(FILE_HANDLE *handle);

 static int gMacPICTLineNumber;
 static int gMacValidLineCount;

 // These are the globals that are "weak",see the 980103 note. [trf]
 static CQDProcsPtr gMacOldQDProcsPtr;
 static CQDProcs gMacNewQDProcs;
 static QDPutPicUPP      gMacDrawProcUPP;
 static CGrafPort gMacGrafPort;
 static PicHandle gMacPicHandle;
 static FILE *gMacImagePictFile;
 static long gMacPicSize;
 // End of the "weak" globals.


 // ---------------------------------------------------------------------
 // Creates a PICT file handle for POV-Ray.

 FILE_HANDLE *Get_MacPICT_File_Handle()
 {
         FILE_HANDLE *handle;

         handle = (FILE_HANDLE *) POV_MALLOC(sizeof(FILE_HANDLE),"Mac PICT file
handle") ;

         if (handle)
                 {
                 handle->Open_File_p             = Open_MacPICT_File;
                 handle->Write_Line_p    = Write_MacPICT_Line;
                 handle->Read_Line_p             = Read_MacPICT_Line;
                 handle->Read_Image_p    = Read_MacPICT_Image;
                 handle->Close_File_p    = Close_MacPICT_File;

                 handle->file                    = NULL;
                 handle->buffer                  = NULL;
                 handle->buffer_size             = 0;
                 }

         return (handle);
 }



 // ---------------------------------------------------------------------
 static pascal void MyPutPicProc(char *dataPtr,short byteCount)
 {
         size_t  myByteCount;

         myByteCount = byteCount;
         gMacPicSize += byteCount;
         if(gMacImagePictFile)
         {
                 if(fwrite( dataPtr,1,myByteCount,gMacImagePictFile) != myByteCount)
                 {
                         fclose(gMacImagePictFile);
                         gMacImagePictFile = NULL;
                         SysBeep(3);
                 }
         }
         // we have to keep the picture handle header updated for Quickdraw!
         if(gMacPicHandle)
                 (**gMacPicHandle).picSize = gMacPicSize;
 } // MyPutPicProc







 // ---------------------------------------------------------------------
 // The same as FSMakeFSSpec,but it searches the library paths passed to
 // POV-Ray to find the file. It will only find files of type 'PICT'.
 //
 // [esp] Switched order of search,now checks scene folder first.
 static OSErr Mac_SpecialMakeFSSpec(ConstStr255Param name,FSSpec *fs)
 {
         FInfo finfo;
         OSErr err,olderr;
         Boolean b;

         // First look in the same folder as the scene file
         err = FSMakeFSSpec(gSrcWind_FSSpec.vRefNum,gSrcWind_FSSpec.parID,name,fs);
         if(err == 0)
                 err = FSpGetFInfo(fs,&finfo);
         if(err == 0)
         {
                 if(finfo.fdType == 'PICT')
                         return 0; // found
                 else
                         err = 1; // not found,but valid
         }

         olderr = err;
         // if not there,then look in include folder.
         // Note: this does not look in *all* POV-Ray library paths
         ResolveAlias(NULL,(AliasHandle)((**gAppPrefs_h).libPath[0]),fs,&b);
         err = FSMakeFSSpec(fs->vRefNum,fs->parID,name,fs);
         if(err == 0)
                 err = FSpGetFInfo(fs,&finfo);
         if(err == 0)
         {
                 if(finfo.fdType == 'PICT')
                         return 0; // found
                 else
                         err = 1; // not found,but valid
         }

         // if not there,then look in include folder.
         // Note: this does not look in *all* POV-Ray library paths
         ResolveAlias(NULL,(AliasHandle)((**gAppPrefs_h).libPath[1]),fs,&b);
         err = FSMakeFSSpec(fs->vRefNum,fs->parID,name,fs);
         if(err == 0)
                 err = FSpGetFInfo(fs,&finfo);
         if(err == 0)
         {
                 if(finfo.fdType == 'PICT')
                         return 0; // found
                 else
                         err = 1; // not found,but valid
         }
         else if(olderr == 1)
         {
                 err =
FSMakeFSSpec(gSrcWind_FSSpec.vRefNum,gSrcWind_FSSpec.parID,name,fs);
                 if(err == 0)
                         err = 1;
         }

         return err;
 }

 // ---------------------------------------------------------------------
 // Paints the PICT to an R/G/B/Alpha GWorld
 static OSErr Mac_PaintPictToGWorld(PicHandle pict,GWorldPtr gw_rgb,int w,int h)
 {
         PixMapHandle offPixMapH;
         Rect r;
         Boolean imageHasAlpha = false;
         OSErr err = 0;
         CGrafPtr oldPort;
         GDHandle oldGDev;

         if((pict == NULL) || (gw_rgb == NULL))
                 return -1;

         if(w > 2047)
         {
                 Error("PICT is to big,maximal width of PICTs to read is 2047
pixels!");
                 return -1;
         }

         if ((**gPrefs2Use_h).progress >= eProgDebug)
                 printf("PICT size is %d * %d pixel.\n",w,h);

         SetRect(&r,0,0,w,h);

         offPixMapH = GetGWorldPixMap(gw_rgb);
         if(NULL == offPixMapH)
                 return -1;
         if(!LockPixels(offPixMapH))
                 return -1;

         GetGWorld(&oldPort,&oldGDev);

         SetGWorld(gw_rgb,NULL);
         ForeColor(blackColor);
         BackColor(whiteColor);

         // copy the image into the offscreen
         EraseRect(&r);
         DrawPicture(pict,&r);
         UnlockPixels(offPixMapH);
         SetGWorld(oldPort,oldGDev);

         return err;
 }

 // ---------------------------------------------------------------------
 // The usual MacOS PICT reading code.
 //
 // [esp] Switched order of open,first tries data fork,then resource fork.
// This way  we ignore any thumbnails attached as resources & find data fork first.
 static OSErr Mac_ReadPictImageFromFile(FSSpec *f,PicHandle *pict)
 {
         const long kPictHeaderSize = 512;
         Boolean tryRsrcFork;
         long pictFileLen,headerFileLen;
         short applref,fref;
         PicHandle hPic;
         char povheader[61];

         if((f == NULL) || (pict == NULL))
                 return -1;

         *pict = NULL;
         gMacValidLineCount = -1;

         // Try to open data fork
         tryRsrcFork = true;     /* assume true until disproved */
         if(FSpOpenDF(f,fsRdPerm,&fref) == 0)
         {
                 (void)GetEOF(fref,&pictFileLen);
                 pictFileLen -= kPictHeaderSize;
                 if (pictFileLen > 0)
                 {
                         (void)SetFPos(fref,fsFromStart,0);
                         headerFileLen = 60;

 (void)FSRead(fref,&headerFileLen,(Ptr)&povheader[0]);
                         povheader[60] = 0;
                         if(strncmp("POV-Ray",povheader,7) == 0)
                         {

 sscanf(&povheader[54],"%6d",&gMacValidLineCount);
                                 opts.First_Line = gMacValidLineCount;
                         }
                         (void)SetFPos(fref,fsFromStart,kPictHeaderSize);
                         hPic = (PicHandle)NewHandleClear(pictFileLen);
                         if (hPic != NULL)
                         {
                                 HLock((Handle)hPic);

 (void)FSRead(fref,&pictFileLen,(Ptr)*hPic);
                                 HUnlock((Handle)hPic);
                                 if ((**gPrefs2Use_h).progress >= eProgDebug)
                                         puts("Reading PICT from data fork.");
                                 tryRsrcFork = false; /* successful! */
                         }
                 }
                 (void)FSClose(fref);
         }
         // Try to open as a PICT resource,data fork failed
         if (tryRsrcFork == true)
                 {
                 applref = CurResFile();
                 fref = FSpOpenResFile(f,fsRdPerm);
                 if ((ResError() == 0) && (fref != -1))
                         {
                         UseResFile(fref);
                         if(CountResources('PICT') > 0)
                                 {
                                 hPic = (PicHandle)Get1IndResource('PICT',1);
                                 if(hPic != NULL)
                                         {
                                         DetachResource((Handle)hPic);
                                         if ((**gPrefs2Use_h).progress >= eProgDebug)
                                                 puts("Reading PICT from resource
fork.");
                                         }
                                 }
                         (void)FSClose(fref);
                         UseResFile(applref);
                         }
                 }

         if(hPic == NULL)
                 return -2;

         *pict = hPic;
         return 0;
 }

 // Here's a really skanky thing to do to allow an alpha channel in offscreens
 static void Mac_ActivateAlphaChannel(GWorldPtr gw)
 {
         CGrafPtr                oldPort;
         GDHandle                oldGDev;
         PixMapHandle    aPixMapH;

         GetGWorld(&oldPort,&oldGDev);

         SetGWorld(gw,NULL);

         aPixMapH = GetGWorldPixMap(gw);
         (**aPixMapH).cmpCount = 4;      // from RGB to RGBA!
         PortChanged(qd.thePort);        // tell QD to notice the cmpCount change

         SetGWorld(oldPort,oldGDev);
 }

 int Open_MacMovie_File(FILE_HANDLE *handle,char *name,int *width,int *height,int
buffer_size,int mode)
 {
         PixMapHandle offPix;
         CGrafPtr oldPort;
         GDHandle oldGDev;
         Rect r;
         Movie movie;
         short fref;
         short resID = 128;
         Track dstTrack;
         Media dstMedia;
         OSErr err = 0,err2 = 0;
         int pixelSize;

         if(mode != WRITE_MODE) // movies are only written for now
         {
                 Error("QuickTime Movies can only be written.");
                 return 0;
         }

         // create movie once the first time,because we want animations to be saved to
ONE movie,not each frame to one movie
         if(gMovieFile.name[0] == 0)
         {
                 // Create an output movie file name from the scene name,in the same
folder as the scene file
                 gMovieFile = gSrcWind_FSSpec;
                
BlockMoveData(opts.Scene_Name,gMovieFile.name,1+strlen(opts.Scene_Name));
                 // change the output file name by adding a ".mov" on the end
                 if(strlen((char*)gMovieFile.name)+4 > 31)
                         gMovieFile.name[31-4] = 0;
                 strcat((char*)gMovieFile.name,".mov");
                 // restore it to Pascal string
                 C2PStr((char*)gMovieFile.name);

                 // create the movie file
                 err =
CreateMovieFile(&gMovieFile,'TVOD',0,createMovieFileDeleteCurFile,&fref,&movie);

                 if(err != noErr)
                 {
                         Error("Cannot open QuickTime Movie file. (Error:
%d)",(int)err);
                         return 0;
                 }

                 dstTrack = NewMovieTrack(movie,(long)(*width) << 16,(long)(*height)
<< 16,0);
                 if(GetMoviesError() == 0)
                         dstMedia = NewTrackMedia(dstTrack,VIDEO_TYPE,600,NULL,0);
                 if(GetMoviesError() != 0)
                         return GetMoviesError();
                 err = AddMovieResource(movie,fref,&resID,"\pPOV-Ray Animation");
                 if(err != noErr)
                         Error("Cannot add QuickTime Movie resource. (Error:
%d)",(int)err);
                 err2 = CloseMovieFile(fref);
                 if(err2 != noErr)
                         Error("Cannot close QuickTime Movie file.");
                 DisposeMovie(movie);
                 if((err != noErr) || (err2 != noErr))
                 {
                         gMovieFile.name[0] = 0;
                         return 0;
                 }
         }

         handle->buffer = NULL;
         handle->mode = mode;
         handle->filename = name;
         handle->width = *width;
         handle->height = *height;

         SetRect(&r,0,0,(int)(handle->width),(int)(handle->height));
         GetGWorld(&oldPort,&oldGDev);
         if(opts.OutputQuality == 8) // 8 bits per color
                 pixelSize = 32;
         else // 5 bits per color (and the rest for now)
                 pixelSize = 16;
         err = NewGWorld((GWorldPtr *)&(handle->buffer),pixelSize,&r,NULL,NULL,0);
         if((err == 0) && (opts.Options & OUTPUT_ALPHA) && (pixelSize == 32)) //
alpha-channels need 32 bits per pixel
                 Mac_ActivateAlphaChannel((GWorldPtr)(handle->buffer));
         if(err == 0)
         {
                 offPix = GetGWorldPixMap((GWorldPtr)(handle->buffer));
                 if(offPix != NULL)
                 {
                         if(LockPixels(offPix))
                         {

 SetGWorld((GWorldPtr)(handle->buffer),NULL);
                                 ForeColor(blackColor);
                                 BackColor(whiteColor);
                                 EraseRect(&r);
                         }
                         UnlockPixels(offPix);
                 }
                 SetGWorld(oldPort,oldGDev);

                 return 1;
         }

         return 0; // Something failed.
 }

 void Write_MacMovie_Line(FILE_HANDLE *handle,COLOUR *line_data,int line_number)
 {
         int i;
         unsigned char *pixPtr;
         unsigned short *bigPixPtr;
         unsigned short buf,component;
         PixMapHandle offPixMapH;

         offPixMapH = GetGWorldPixMap((GWorldPtr)(handle->buffer));
         if(NULL == offPixMapH)
                 Error("Cannot write QuickTime Movie (No GWorld).");
         LockPixels(offPixMapH);
         pixPtr = (unsigned char *)GetPixBaseAddr(offPixMapH);
         pixPtr += line_number*(((**offPixMapH).rowBytes)&0x3fff);
         if((**offPixMapH).pixelSize == 32)
         {
                 for(i = 0;i < handle->width; i++)
                 {
                         (*pixPtr++) = (unsigned char)(255.0 - (line_data[i][TRANSM] *
255.0)); // always written,but only saved if
alpha-channel output is on
                         (*pixPtr++) = (unsigned char)(line_data[i][RED] * 255.0);
                         (*pixPtr++) = (unsigned char)(line_data[i][GREEN] * 255.0);
                         (*pixPtr++) = (unsigned char)(line_data[i][BLUE] * 255.0);
                 }
         }
         else if((**offPixMapH).pixelSize == 16)
         {
                 bigPixPtr = (unsigned short *)pixPtr;
                 for(i = 0;i < handle->width; i++)
                 {
                         buf = 0;
                         component = ((unsigned char)(line_data[i][RED] * 31.0)) <<
10;
                         buf |= component;
                         component = ((unsigned char)(line_data[i][GREEN] * 31.0)) <<
5;
                         buf |= component;
                         component = ((unsigned char)(line_data[i][BLUE] * 31.0));
                         buf |= component;
                         (*bigPixPtr++) = buf;
                 }
         }

         UnlockPixels(offPixMapH);
 }

 void Close_MacMovie_File(FILE_HANDLE *handle)
 {
         Track dstTrack;
         Media dstMedia;
         OSType mediaType;
         OSErr err = 0;
         Handle compressedData = NULL;
         ImageDescriptionHandle imageDescH = NULL;
         TimeValue sampleDuration;
         short movieResRefNum;
         short actualResId;
         Movie movie;
         Rect r;
         Boolean editing = false;
         Boolean haveMovie = false;
         Fixed fval;
         TimeValue tval;

         if(gMovieFile.name[0] == 0) // there is no file open so we have to
 return
                 return;
         if(handle->buffer == NULL) // if there is no image data we return
                 return;

         err = OpenMovieFile(&gMovieFile,&movieResRefNum,fsWrPerm);
         if(err != noErr)
                 Error("Cannot open QuickTime Movie file. (Error: %d)",(int)err);
         else
         {
                 actualResId = 0;
                 err =
NewMovieFromFile(&movie,movieResRefNum,&actualResId,(StringPtr)0,newMovieActive,(Boolean
*)0);
                 if(err == noErr)
                         haveMovie = true;
         }
         if((GetMoviesError() == noErr) && (err == noErr))
                 dstTrack = GetMovieIndTrack(movie,1);
         if((GetMoviesError() == noErr) && (err == noErr))
                 dstMedia = GetTrackMedia(dstTrack);
         if((GetMoviesError() == noErr) && (err == noErr))
                 GetMediaHandlerDescription(dstMedia,&mediaType,NULL,NULL);
         if(mediaType != VideoMediaType)
         {
                 Error("Cannot find video track in movie.");
                 err = paramErr;
         }

         if((GetMoviesError() == noErr) && (err == noErr))
         {
                 BeginMediaEdits(dstMedia);
                 editing = true;
         }

         if((GetMoviesError() == noErr) && (err == noErr))
         {
                 LockPixels(GetGWorldPixMap((GWorldPtr)(handle->buffer)));

 SetRect(&r,0,0,(int)(handle->width),(int)(handle->height));
                 err =
SCCompressImage(gtheSCComponent,GetGWorldPixMap((GWorldPtr)(handle->buffer)),&r,&imageDescH,&compressedData);

         }

         if((GetMoviesError() == noErr) && (err == noErr))
         {
                 fval = (GetMediaTimeScale(dstMedia) & 0x0000ffff) << 16;
                 fval =
FixDiv(fval,(**gPrefs2Use_h).sc_TemporalDialogParams.frameRate);
                 tval = fval >> 16;
                 err =
AddMediaSample(dstMedia,compressedData,0,(**imageDescH).dataSize,tval,(SampleDescriptionHandle)imageDescH,1,0,&sampleDuration);

         }
         if((GetMoviesError() == noErr) && (err == noErr))
                 err =
InsertMediaIntoTrack(dstTrack,GetTrackDuration(dstTrack),sampleDuration,tval,0x00010000);

         if(editing == true)
                 EndMediaEdits(dstMedia);

         if((GetMoviesError() == noErr) && (err == noErr))
                 err = UpdateMovieResource(movie,movieResRefNum,actualResId,NULL);
         if((GetMoviesError() == noErr) && (err == noErr))
                 err = CloseMovieFile(movieResRefNum);

         if(haveMovie == true)
                 DisposeMovie(movie);
         if(compressedData != NULL)
                 DisposeHandle(compressedData);
         if(imageDescH != NULL)
                 DisposeHandle((Handle)imageDescH);
         DisposeGWorld((GWorldPtr)(handle->buffer));

         handle->file = NULL;
         handle->buffer = NULL;

         return;
 }


 // Opens a PICT file for read,write,or append.
 static int Open_MacPICT_File(FILE_HANDLE *handle,char *name,int *width,int
*height,int buffersize,int mode)
 {
         char            *nameptr;
         OSErr           anError = noErr;

         if(gHasQuickTime == false)
                 gMapPictToMovie = false;
         if(name == NULL)
                 return 0;
         //string.h
         nameptr = strrchr(name,':');
         if(nameptr == NULL)
                 nameptr = name;
         if((gMapPictToMovie == true) && (mode == WRITE_MODE))
         {
                 handle->flag    = 2;
                 handle->buffer  = (char *)POV_MALLOC(sizeof(MOVIE_FILE),"movie");
                 anError = image_movie_create((MOVIE_FILE
*)handle->buffer,name,width,height,mode);
         }
         else
         {
                 handle->flag    = 1;
                 handle->buffer  = (char *)POV_MALLOC(sizeof(PICTURE_FILE),"pict");
                 anError = image_picture_create((PICTURE_FILE
*)handle->buffer,name,width,height,mode);
         }
         if(anError != noErr)
                 return 0;
         else
                 return 1;
 }

 // Writes a single image line.
 static void Write_MacPICT_Line(FILE_HANDLE *handle,COLOUR *line_data,int line_number)
 {
         if(handle->buffer == NULL)
         {
                 puts("warning: got invalid mac file handle.");
                 return;
         }
         if(handle->flag == 2)
                 image_movie_write_line((MOVIE_FILE
*)handle->buffer,line_data,line_number);
         else
                 image_picture_write_line((PICTURE_FILE
*)handle->buffer,line_data,line_number);
 }

 // Reads a single image line to resuming partial renders.
 static int Read_MacPICT_Line(FILE_HANDLE *handle,COLOUR *line_data,int *line_number)
 {
         if(handle->flag == 2)
                 return 0;
         else
                 return image_picture_read_line((PICTURE_FILE
*)handle->buffer,line_data,line_number);
 }

 // Closes a PICT file.
 static void Close_MacPICT_File(FILE_HANDLE *handle)
 {
         if(handle->buffer == NULL)
                 return;
         if(handle->flag == 2)
         {
                 image_movie_delete((MOVIE_FILE *)handle->buffer);
                 POV_FREE(handle->buffer);
                 handle->buffer = NULL;
         }
         else
         {
                 image_picture_delete((PICTURE_FILE *)handle->buffer);
                 POV_FREE(handle->buffer);
                 handle->buffer = NULL;
         }
 }

 void Read_MacPICT_Image(IMAGE *imageptr,char *filename)
 {
         OSErr                   anError = noErr;
         int                             width;
         int                             height;
         PICTURE_FILE    *mhandle = NULL;

         mhandle = (PICTURE_FILE *)POV_MALLOC(sizeof(PICTURE_FILE),"pict");
         anError = image_picture_create(mhandle,filename,&width,&height,READ_MODE);
         if(anError)
                 Error("can not read pict.");
         else
         {
                 image_picture_read_image(mhandle,imageptr);
                 POV_FREE(mhandle);
         }
 }

 static void image_picture_alpha_channel(GWorldPtr gw)
 {
         CGrafPtr                keepGPtr;
         GDHandle                keepGDh;
         PixMapHandle    keepPixMapH;

         //QDOffscreen.h
         GetGWorld(&keepGPtr,&keepGDh);
         //QDOffscreen.h
         SetGWorld(gw,NULL);
         //QDOffscreen.h
         keepPixMapH = GetGWorldPixMap(gw);
         (**keepPixMapH).cmpCount = 4;
         //QDOffscreen.h
         PortChanged(qd.thePort);
         //QDOffscreen.h
         SetGWorld(keepGPtr,keepGDh);
 }


 static OSErr image_movie_create(MOVIE_FILE *mhandle,char *name,int *width,int
*height,int mode)
 {
         PixMapHandle    keepPixMapH;
         CGrafPtr                keepGPtr;
         GDHandle                keepGDh;
         OSErr                   anError = 0;
         OSErr                   anError2 = 0;
         Rect                    r;
         Movie                   keepMovie;
         short                   fref;
         short                   resID = 128;
         Track                   keepTrack;
         Media                   keepMedia;
         int                     pixelSize;

         if(mode != WRITE_MODE)
         {
                 Error("QuickTime Movies can only be written.");
                 return paramErr;
         }
         if(gMovieFile.name[0] == 0)
         {
                 gMovieFile = gSrcWind_FSSpec;
                 //MacMemory.h
                 //string.h
                 BlockMoveData(opts.Scene_Name,gMovieFile.name,1 +
strlen(opts.Scene_Name));
                 //string.h
                 if(strlen((char *)(gMovieFile.name)) + 4 > 63)
                         gMovieFile.name[63-4] = 0;
                 //string.h
                 strcat((char *)(gMovieFile.name),".mov");
                 //TextUtils.h
                 c2pstr((char *)(gMovieFile.name));
                 //Movies.h
                 anError =
CreateMovieFile(&gMovieFile,'TVOD',0,createMovieFileDeleteCurFile,&fref,&keepMovie);
                 if(anError != noErr)
                 {
                         Error("can not open QuickTime Movie file. (Error:
%d)",(int)anError);
                         return anError;
                 }
                 //Movies.h
                 keepTrack = NewMovieTrack(keepMovie,(long)(*width) <<
16,(long)(*height) << 16,0);
                 if(GetMoviesError() == noErr)
                 {
                         //Movies.h
                         keepMedia = NewTrackMedia(keepTrack,VIDEO_TYPE,600,NULL,0);
                 }
                 //Movies.h
                 if(GetMoviesError() != noErr)
                         return GetMoviesError();
                 //Movies.h
                 anError = AddMovieResource(keepMovie,fref,&resID,"\pPOV-Ray
Animation");
                 if(anError != noErr)
                         Error("can not add QuickTime Movie resource. (Error:
%d)",(int)anError);
                 //Movies.h
                 anError2 = CloseMovieFile(fref);
                 if(anError2 != noErr)
                         Error("can not close QuickTime Movie file.");
                 //Movies.h
                 DisposeMovie(keepMovie);
                 if((anError != noErr) || (anError2 != noErr))
                 {
                         gMovieFile.name[0] = 0;
                         return anError;
                 }
         }
         mhandle->fMode          = mode;
         mhandle->fWidth         = *width;
         mhandle->fHeight        = *height;
         //Quickdraw.h
         SetRect(&r,0,0,mhandle->fWidth,mhandle->fHeight);
         //QDOffscreen.h
         GetGWorld(&keepGPtr,&keepGDh);
         if(opts.OutputQuality == 8)
                 pixelSize = 32;
         else
                 pixelSize = 16;
         //QDOffscreen.h
         anError = NewGWorld(&mhandle->fTargetGWorld,pixelSize,&r,NULL,NULL,0);
         if((anError == noErr) && (opts.Options & OUTPUT_ALPHA) &&
 (pixelSize == 32)) // alpha-channels need 32 bits per pixel
                 image_picture_alpha_channel(mhandle->fTargetGWorld);
         if(anError == noErr)
         {
                 //QDOffscreen.h
                 keepPixMapH = GetGWorldPixMap(mhandle->fTargetGWorld);
                 if(keepPixMapH != NULL)
                 {
                         //QDOffscreen.h
                         if(LockPixels(keepPixMapH))
                         {
                                 //QDOffscreen.h
                                 SetGWorld(mhandle->fTargetGWorld,NULL);
                                 //Quickdraw.h
                                 ForeColor(blackColor);
                                 //Quickdraw.h
                                 BackColor(whiteColor);
                                 //Quickdraw.h
                                 EraseRect(&r);
                         }
                         //QDOffscreen.h
                         UnlockPixels(keepPixMapH);
                 }
                 //QDOffscreen.h
                 SetGWorld(keepGPtr,keepGDh);
                 anError = noErr;
         }
         return anError; // Something failed.
 }

 OSErr image_picture_create(PICTURE_FILE *mhandle,char *name,int *width,int
*height,int mode)
 {
         OSErr   anError = noErr;
         int     pixelSize;

         mhandle->fMode = mode;
         mhandle->fTargetGWorld = NULL;
         mhandle->fLastLine = 0;
         if(opts.OutputQuality == 8)
                 pixelSize = 32;
         else
                 pixelSize = 16;
         switch(mhandle->fMode)
         {
                 case READ_MODE:
                 case APPEND_MODE:
                         anError = image_picture_make_file(name,&mhandle->fFile);
                         if(anError == noErr)
                                 anError = image_picture_gworld_from_file(mhandle);
                         else
                                 if(anError == 1)
                                         anError =
image_picture_gworld_from_image(mhandle);
                         if(anError == noErr)
                         {
                                 *width = mhandle->fWidth;
                                 *height = mhandle->fHeight;
                                 if((mhandle->fLastLine == 0) || (mhandle->fLastLine >
mhandle->fHeight))
                                         mhandle->fLastLine = mhandle->fHeight;
                         }
                         break;
                 case WRITE_MODE:
                         mhandle->fWidth         = *width;
                         mhandle->fHeight        = *height;
                         //string.h
                         mhandle->fFile.name[0] = strlen(name);
                         if(mhandle->fFile.name[0] > 63)
                                 mhandle->fFile.name[0] = 63;
                         //MacMemory.h
                        
BlockMoveData(name,&mhandle->fFile.name[1],mhandle->fFile.name[0]);
                         mhandle->fFile.vRefNum  = gSrcWind_FSSpec.vRefNum;
                         mhandle->fFile.parID    = gSrcWind_FSSpec.parID;
                         if(anError == noErr)
                                 anError =
image_picture_gworld_create(mhandle,*width,*height,pixelSize);
                         if(anError == noErr)
                                 anError = image_picture_new(mhandle);
                         break;
         }
         if(anError != noErr)
                 return 1;
         else
                 return 0;
 }

 static void image_picture_write_line(PICTURE_FILE *mhandle,COLOUR *line_data,int
line_number)
 {
         int                     i;
         unsigned char   *pixPtr;
         unsigned short  *bigPixPtr;
         unsigned short  buf;
         unsigned short  component;
         PixMapHandle    keepPixMapH;

         //QDOffscreen.h
         keepPixMapH = GetGWorldPixMap(mhandle->fTargetGWorld);
         if(NULL == keepPixMapH)
                 Error("can not write Mac Picture (No GWorld PixMap).");
         //QDOffscreen.h
         if(LockPixels(keepPixMapH) == false)
                 Error("can not lock Mac Picture GWorld PixMap.");
         //QDOffscreen.h
         pixPtr = (unsigned char *)GetPixBaseAddr(keepPixMapH);
         pixPtr += line_number * (((**keepPixMapH).rowBytes) & 0x3fff); // + Y
scanline offset down
         if((**keepPixMapH).pixelSize == 32)
         {
                 for(i = 0;i < mhandle->fWidth; i++)
                 {
                         (*pixPtr++) = (unsigned char)(255.0 - (line_data[i][TRANSM] *
255.0)); // always written,but only saved if
alpha-channel output is on
                         (*pixPtr++) = (unsigned char)(line_data[i][RED] * 255.0);
                         (*pixPtr++) = (unsigned char)(line_data[i][GREEN] * 255.0);
                         (*pixPtr++) = (unsigned char)(line_data[i][BLUE] * 255.0);
                 }
         }
         else
                 if((**keepPixMapH).pixelSize == 16)
                 {
                         bigPixPtr = (unsigned short *)pixPtr;
                         for(i = 0;i < mhandle->fWidth; i++)
                         {
                                 buf = 0;
                                 component = ((unsigned short)(line_data[i][RED] *
31.0)) << 10;
                                 buf |= component;
                                 component = ((unsigned short)(line_data[i][GREEN] *
31.0)) << 5;
                                 buf |= component;
                                 component = ((unsigned short)(line_data[i][BLUE] *
31.0));
                                 buf |= component;
                                 (*bigPixPtr++) = buf;
                         }
                 }
         //QDOffscreen.h
         UnlockPixels(keepPixMapH);
         mhandle->fLastLine++;
 }

 static void image_movie_write_line(MOVIE_FILE *mhandle,COLOUR *line_data,int
line_number)
 {
         int                     i;
         unsigned char   *pixPtr;
         unsigned short  *bigPixPtr;
         unsigned short  buf;
         unsigned short  component;
         PixMapHandle    keepPixMapH;

         //QDOffscreen.h
         keepPixMapH = GetGWorldPixMap(mhandle->fTargetGWorld);
         if(NULL == keepPixMapH)
                 Error("can not write QuickTime Movie (No GWorld).");
         //QDOffscreen.h
         LockPixels(keepPixMapH);
         //QDOffscreen.h
         pixPtr = (unsigned char *)GetPixBaseAddr(keepPixMapH);
         pixPtr += line_number * (((**keepPixMapH).rowBytes) & 0x3fff);
         if((**keepPixMapH).pixelSize == 32)
         {
                 for(i = 0;i < mhandle->fWidth; i++)
                 {
                         (*pixPtr++) = (unsigned char)(255.0 - (line_data[i][TRANSM] *
255.0)); // always written,but only saved if
alpha-channel output is on
                         (*pixPtr++) = (unsigned char)(line_data[i][RED] * 255.0);
                         (*pixPtr++) = (unsigned char)(line_data[i][GREEN] * 255.0);
                         (*pixPtr++) = (unsigned char)(line_data[i][BLUE] * 255.0);
                 }
         }
         else
                 if((**keepPixMapH).pixelSize == 16)
                 {
                         bigPixPtr = (unsigned short *)pixPtr;
                         for(i = 0;i < mhandle->fWidth; i++)
                         {
                                 buf = 0;
                                 component = ((unsigned char)(line_data[i][RED] *
31.0)) << 10;
                                 buf |= component;
                                 component = ((unsigned char)(line_data[i][GREEN] *
31.0)) << 5;
                                 buf |= component;
                                 component = ((unsigned char)(line_data[i][BLUE] *
31.0));
                                 buf |= component;
                                 (*bigPixPtr++) = buf;
                         }
                 }
         //QDOffscreen.h
         UnlockPixels(keepPixMapH);
 }

 static int image_picture_read_line(PICTURE_FILE *mhandle,COLOUR *line_data,int
*line_number)
 {
         int                     x;
         unsigned char   *pixPtr;
         PixMapHandle    keepPixMapH;

         if(mhandle->fLastLine >= 0)
         {
                 if(*line_number >= mhandle->fLastLine)
                 {
                         (*line_number)--;
                         return 0;
                 }
         }
         if(*line_number >= mhandle->fHeight)
         {
                 (*line_number)--;
                 return 0;
         }
         (*line_number)++;
         if ((**gPrefs2Use_h).progress >= eProgDebug)
                 printf("reading line: %d\n",(1 + *line_number));
         //QDOffscreen.h
         keepPixMapH = GetGWorldPixMap(mhandle->fTargetGWorld);
         if(NULL == keepPixMapH)
                 Error("can not read Mac Picture (No PixMap).");
         //QDOffscreen.h
         LockPixels(keepPixMapH);
         if(NULL == keepPixMapH)
                 Error("can not lock Mac Picture GWorld PixMap.");
         //QDOffscreen.h
         pixPtr = (unsigned char *)GetPixBaseAddr(keepPixMapH); // start at base
address
         pixPtr += *line_number * (((**keepPixMapH).rowBytes) & 0x3fff);// + Y
scanline offset down
         for(x = 0; x < mhandle->fWidth; x++)
         {
                 if((**keepPixMapH).cmpCount == 4)
                         line_data[x][TRANSM] = (255.0 - (*pixPtr++)) / 255.0;
                 else
                 {
                         pixPtr++;
                         line_data[x][TRANSM] = 0.0;
                 }
                 line_data[x][RED]    = ((*pixPtr++)) / 255.0;
                 line_data[x][GREEN]  = ((*pixPtr++)) / 255.0;
                 line_data[x][BLUE]   = ((*pixPtr++)) / 255.0;
                 line_data[x][FILTER] = 0.0;
         }
         //QDOffscreen.h
         UnlockPixels(keepPixMapH);
         return 1;
 }

 static void image_picture_read_image(PICTURE_FILE *mhandle,IMAGE *imageptr)
 {
         int                     x;
         int                     y;
         unsigned char   *pixPtr;
         PixMapHandle    keepPixMapH;

         imageptr->iwidth  = mhandle->fWidth;
         imageptr->iheight = mhandle->fHeight;
         imageptr->width   = (float)mhandle->fWidth;
         imageptr->height  = (float)mhandle->fHeight;
         imageptr->Colour_Map_Size = 0;
         imageptr->Colour_Map = NULL;
         imageptr->data.rgb_lines = (IMAGE_LINE *)POV_MALLOC(mhandle->fHeight *
sizeof(IMAGE_LINE),"pict");
         if(imageptr->data.rgb_lines != NULL)
         {
                 //QDOffscreen.h
                 keepPixMapH = GetGWorldPixMap(mhandle->fTargetGWorld);
                 if(NULL == keepPixMapH)
                         Error("can not read Mac Picture (No GWorld).");
                 //QDOffscreen.h
                 if(LockPixels(keepPixMapH) == false)
                         Error("can not lock Mac Picture GWorld PixMap.");
                 for(y = 0;y < mhandle->fHeight;y++)
                 {
                         //QDOffscreen.h
                         pixPtr = (unsigned char *)GetPixBaseAddr(keepPixMapH);       
          // start at base address
                         pixPtr += y * (((**keepPixMapH).rowBytes) & 0x3fff);         
                  // + Y scanline offset down
                         imageptr->data.rgb_lines[y].red    = (unsigned char
*)POV_MALLOC(mhandle->fWidth,"red");
                         imageptr->data.rgb_lines[y].green  = (unsigned char
*)POV_MALLOC(mhandle->fWidth,"green");
                         imageptr->data.rgb_lines[y].blue   = (unsigned char
*)POV_MALLOC(mhandle->fWidth,"blue");
                         imageptr->data.rgb_lines[y].transm = (unsigned char
*)POV_MALLOC(mhandle->fWidth,"transparency");
                         for(x = 0;x < mhandle->fWidth; x++)
                         {
                                 if((**keepPixMapH).cmpCount == 4)

 imageptr->data.rgb_lines[y].transm[x] = 255 - (*pixPtr++);
                                 else
                                 {
                                         pixPtr++;

 imageptr->data.rgb_lines[y].transm[x] = 0.0;
                                 }
                                 imageptr->data.rgb_lines[y].red[x]    = (*pixPtr++);
                                 imageptr->data.rgb_lines[y].green[x]  = (*pixPtr++);
                                 imageptr->data.rgb_lines[y].blue[x]   = (*pixPtr++);
                         }
                 }
                 //QDOffscreen.h
                 UnlockPixels(keepPixMapH);
         }
         else
                 Error("can not read Mac Picture (Out of memory!).");
 }

 static void image_movie_delete(MOVIE_FILE *mhandle)
 {
         Track                                   keepTrack;
         Media                                   keepMedia;
         OSType                                  mediaType;
         OSErr                                   anError = 0;
         Handle                                  compressedData = NULL;
         ImageDescriptionHandle  imageDescH = NULL;
         short                                   movieResRefNum;
         short                                   actualResId;
         Movie                                   keepMovie;
         Rect                                    r;
         Boolean                                 editing = false;
         Boolean                                 haveMovie = false;
         Fixed                                   fval;
         TimeValue                               tval;
         TimeValue                               sampleDuration;

         if(gMovieFile.name[0] == 0)
                 return;
         //Movies.h
         anError = OpenMovieFile(&gMovieFile,&movieResRefNum,fsWrPerm);
         if(anError != noErr)
                 Error("can not open QuickTime Movie file. (Error: %d)",(int)anError);
         else
         {
                 actualResId = 0;
                 //Movies.h
                 anError =
NewMovieFromFile(&keepMovie,movieResRefNum,&actualResId,(StringPtr
)0,newMovieActive,(Boolean *)0);
                 if(anError == noErr)
                         haveMovie = true;
         }
         //Movies.h
         if((GetMoviesError() == noErr) && (anError == noErr))
                 keepTrack = GetMovieIndTrack(keepMovie,1);
         //Movies.h
         if((GetMoviesError() == noErr) && (anError == noErr))
                 keepMedia = GetTrackMedia(keepTrack);
         //Movies.h
         if((GetMoviesError() == noErr) && (anError == noErr))

 GetMediaHandlerDescription(keepMedia,&mediaType,NULL,NULL);
         if(mediaType != VideoMediaType)
         {
                 Error("can not find video track in movie.");
                 anError = paramErr;
         }
         //Movies.h
         if((GetMoviesError() == noErr) && (anError == noErr))
         {
                 //Movies.h
                 BeginMediaEdits(keepMedia);
                 editing = true;
         }
         //Movies.h
         if((GetMoviesError() == noErr) && (anError == noErr))
         {
                 //QDOffscreen.h
                 LockPixels(GetGWorldPixMap(mhandle->fTargetGWorld));
                 //Quickdraw.h
                 SetRect(&r,0,0,mhandle->fWidth,mhandle->fHeight);
                 //QuickTimeComponents.h
                 //QDOffscreen.h
                 anError =
SCCompressImage(gtheSCComponent,GetGWorldPixMap(mhandle->fTargetGWorld),&r,&imageDescH,&compressedData);
         }
         //Movies.h
         if((GetMoviesError() == noErr) && (anError == noErr))
         {
                 //Movies.h
                 fval = (GetMediaTimeScale(keepMedia) & 0x0000ffff) << 16;
                 //FixMath.h
                 fval =
FixDiv(fval,(**gPrefs2Use_h).sc_TemporalDialogParams.frameRate);
                 tval = fval >> 16;
                 //Movies.h
                 anError =
AddMediaSample(keepMedia,compressedData,0,(**imageDescH).dataSize,tval,(SampleDescriptionHandle)imageDescH,1,0,&sampleDuration);

         }
         //Movies.h
         if((GetMoviesError() == noErr) && (anError == noErr))
                 anError =
InsertMediaIntoTrack(keepTrack,GetTrackDuration(keepTrack),sampleDuration,tval,0x00010000);

         //Movies.h
         if(editing == true)
                 EndMediaEdits(keepMedia);
         //Movies.h
         if((GetMoviesError() == noErr) && (anError == noErr))
                 anError =
UpdateMovieResource(keepMovie,movieResRefNum,actualResId,NULL);
         //Movies.h
         if((GetMoviesError() == noErr) && (anError == noErr))
                 anError = CloseMovieFile(movieResRefNum);
         //Movies.h
         if(haveMovie == true)
                 DisposeMovie(keepMovie);
         //MacMemory.h
         if(compressedData != NULL)
                 DisposeHandle(compressedData);
         //MacMemory.h
         if(imageDescH != NULL)
                 DisposeHandle((Handle)imageDescH);
         //QDOffscreen.h
         DisposeGWorld(mhandle->fTargetGWorld);
         return;
 }

 static void image_picture_delete(PICTURE_FILE *mhandle)
 {
         long                    dataSize;
         int                     pixelSize;
         SInt16                  fref;
         OSErr                   anError = noErr;
         PicHandle               keepPicH = NULL;
         CGrafPtr                keepGPtr;
         GDHandle                keepGDh;
         PixMapHandle    keepPixMapH;
         Rect                    r;
         char                    headerString[PICTF_HEADER_SIZE] = "POV-Ray!";
         PICT_FILE_HEADER                myPictFHeader;

         if(opts.OutputQuality == 8)
                 pixelSize = 32;
         else
                 pixelSize = 16;
         switch(mhandle->fMode)
         {
                 case WRITE_MODE:
                 case APPEND_MODE:
                         //QDOffscreen.h
                         GetGWorld(&keepGPtr,&keepGDh);
                         //QDOffscreen.h
                         SetGWorld(mhandle->fTargetGWorld,NULL);
                         //Quickdraw.h
                         keepPicH = OpenPicture(&r);
                         //Quickdraw.h
                         anError = QDError();
                         if(keepPicH == NULL)
                                 anError = mFulErr;
                         else
                                 if(anError == noErr)
                                 {
                                         //Quickdraw.h
                                        
SetRect(&r,0,0,mhandle->fWidth,mhandle->fHeight);
                                         //Quickdraw.h
                                         ClipRect(&r);
                                         //Quickdraw.h
                                         ForeColor(blackColor);
                                         //Quickdraw.h
                                         BackColor(whiteColor);
                                         //QDOffscreen.h
                                         keepPixMapH =
GetGWorldPixMap(mhandle->fTargetGWorld);
                                         //QDOffscreen.h

 if(LockPixels(keepPixMapH) == false)
                                                 Error("can not lock Mac Picture
GWorld PixMap.");
                                         //Quickdraw.h
                                         CopyBits((BitMap *)(*keepPixMapH),(BitMap
*)(*keepPixMapH),&r,&r,srcCopy | ditherCopy,NULL);
                                         anError = QDError();
                                         //QDOffscreen.h
                                         UnlockPixels(keepPixMapH);
                                         //Quickdraw.h
                                         ClosePicture();
                                         //MacMemory.h
                                         HLock((Handle)keepPicH);
                                         //Files.h
                                         if(anError == noErr)
                                                 anError =
FSpOpenDF(&mhandle->fFile,fsWrPerm,&fref);
                                         if(anError == noErr)
                                         {
                                                 //MacMemory.h

 BlockMoveData(&mhandle->fLastLine,&headerString[9],sizeof(mhandle->fLastLine));
                                                 dataSize = PICTF_HEADER_SIZE;
                                                 //Files.h
                                                 anError =
FSWrite(fref,&dataSize,&headerString[0]);
                                                 //MacMemory.h
                                                 dataSize =
GetHandleSize((Handle)keepPicH);
                                                 //Files.h
                                                 anError =
FSWrite(fref,&dataSize,(Ptr)(*keepPicH));
                                                 myPictFHeader.picSize =
(short)(dataSize & 0x7fff);
                                                 //Quickdraw.h

 SetRect(&myPictFHeader.picFrame,0,0,mhandle->fWidth,mhandle->fHeight);
                                                 //Files.h
                                                
(void)SetFPos(fref,fsFromStart,PICTF_HEADER_SIZE);
                                                 dataSize = sizeof(PICT_FILE_HEADER);
                                                 //Files.h
                                                 anError =
FSWrite(fref,&dataSize,(Ptr)(&myPictFHeader));
                                                 //Files.h
                                                 (void)FSClose(fref);
                                         }
                                         //MacMemory.h
                                         HUnlock((Handle)keepPicH);
                                         //Quickdraw.h
                                         KillPicture(keepPicH);
                                         if ((anError == noErr) &&
(gHasImageCompressionMgr == true) && ((**gPrefs2Use_h).doCompression))
                                         {

 (void)image_compress_pict_file(gtheSCComponent,&mhandle->fFile);
                                         }
                                         if ((anError == noErr) &&
(gHasImageCompressionMgr == true) &&
(APGetDataAccessor(kAPData_AddCustomIcons,NULL) != 0))
                                         {
                                                 anError =
AppendFinderIcons2PictF(&mhandle->fFile,&r,eAFI_ShrinkWholeImage);
                                         }
                                 }
                         //QDOffscreen.h
                         SetGWorld(keepGPtr,keepGDh);
                         break;
         }
         //QDOffscreen.h
         if(mhandle->fTargetGWorld != NULL)
                 DisposeGWorld(mhandle->fTargetGWorld);
         if(anError != noErr)
                 Error("can not write Mac Picture file (MacOS returned error
%d).",(int)anError);
 }

 static OSErr image_picture_make_file(char *name_cstring,FSSpec *fs)
 {
         FInfo           keepFileInfo;
         OSErr           anError;
         OSErr           anError2;
         Boolean         b;
         Str255          name;

         //MacMemory.h
         //string.h
         BlockMoveData(name_cstring,&name[1],strlen(name_cstring));
         //string.h
         name[0] = strlen(name_cstring);
         //Files.h
         anError =
FSMakeFSSpec(gSrcWind_FSSpec.vRefNum,gSrcWind_FSSpec.parID,name,fs);
         //Files.h
         if(anError == noErr)
                 anError = FSpGetFInfo(fs,&keepFileInfo);
         if(anError == noErr)
         {
                 if(keepFileInfo.fdType == 'PICT')
                         return noErr; // found
                 else
                         anError = 1; // not found,but valid
         }
         anError2 = anError;
         //Aliases.h
         ResolveAlias(NULL,(AliasHandle)((**gAppPrefs_h).libPath[0]),fs,&b);
         //Files.h
         anError = FSMakeFSSpec(fs->vRefNum,fs->parID,name,fs);
         //Files.h
         if(anError == noErr)
                 anError = FSpGetFInfo(fs,&keepFileInfo);
         if(anError == noErr)
         {
                 if(keepFileInfo.fdType == 'PICT')
                         return noErr; // found
                 else
                         anError = 1; // not found,but valid
         }
         //Aliases.h
         ResolveAlias(NULL,(AliasHandle)((**gAppPrefs_h).libPath[1]),fs,&b);
         //Files.h
         anError = FSMakeFSSpec(fs->vRefNum,fs->parID,name,fs);
         //Files.h
         if(anError == noErr)
                 anError = FSpGetFInfo(fs,&keepFileInfo);
         if(anError == noErr)
         {
                 if(keepFileInfo.fdType == 'PICT')
                         return noErr; // found
                 else
                         anError = 1; // not found,but valid
         }
         else
                 if(anError2 == 1)
                 {
                         //Files.h
                         anError =
FSMakeFSSpec(gSrcWind_FSSpec.vRefNum,gSrcWind_FSSpec.parID,name,fs);
                         if(anError == noErr)
                                 anError = 1;
                 }
         return anError;
 }

 static OSErr image_picture_gworld_from_file(PICTURE_FILE *mhandle)
 {
         PicHandle       keepPicH = NULL;
         OSErr           anError = noErr;
         Rect            r = { 0,0,0,0 };

         keepPicH = image_picture_handle_from_file(mhandle);
         if(keepPicH == NULL)
                 anError = mFulErr;
         if(anError == noErr)
         {
                 r = (**keepPicH).picFrame;
                 r.right         -= r.left;
                 r.bottom        -= r.top;
                 r.left  = 0;
                 r.top   = 0;
                 mhandle->fWidth         = r.right;
                 mhandle->fHeight        = r.bottom;
                 anError =
image_picture_gworld_create(mhandle,mhandle->fWidth,mhandle->fHeight,32);
         }
         if(anError == noErr)
                 anError = image_picture_paint(mhandle,keepPicH);
         //Quickdraw.h
         if(keepPicH != NULL)
                 KillPicture(keepPicH);
         return anError;
 }

 static OSErr image_picture_gworld_from_image(PICTURE_FILE *mhandle)
 {
         OSErr   anError = paramErr;
         Rect    r;
         GraphicsImportComponent gi;

         if(gHasQuickTime == true)
         {
                 //ImageCompression.h
                 anError = GetGraphicsImporterForFile(&mhandle->fFile,&gi);
                 //ImageCompression.h
                 if(anError == noErr)
                         anError = GraphicsImportGetNaturalBounds(gi,&r);
                 if(anError == noErr)
                 {
                         r.right         -= r.left;
                         r.bottom        -= r.top;
                         r.left  = 0;
                         r.top   = 0;
                         mhandle->fWidth         = r.right;
                         mhandle->fHeight        = r.bottom;
                         //ImageCompression.h
                         anError = GraphicsImportSetBoundsRect(gi,&r);
                 }
                 if(anError == noErr)
                         anError =
image_picture_gworld_create(mhandle,mhandle->fWidth,mhandle->fHeight,32);
                 //ImageCompression.h
                 //QDOffscreen.h
                 if(anError == noErr)
                         anError =
GraphicsImportSetGWorld(gi,mhandle->fTargetGWorld,GetGWorldDevice(mhandle->fTargetGWorld));
                 //ImageCompression.h
                 if(anError == noErr)
                         anError = GraphicsImportDraw(gi);
                 //Components.h
                 CloseComponent(gi);
         }
         return anError;
 }

 static OSErr image_picture_gworld_create(PICTURE_FILE *mhandle,int w,int h,int d)
 {
         OSErr   anError;
         Rect    r;

         //Quickdraw.h
         SetRect(&r,0,0,w,h);
         //QDOffscreen.h
         anError = NewGWorld(&mhandle->fTargetGWorld,d,&r,NULL,NULL,0);
         if((mhandle->fTargetGWorld == NULL) && (anError == noErr))
                 anError = mFulErr;
         if(anError == noErr)
                 image_picture_gworld_clear(mhandle);
         return anError;
 }

 static OSErr image_picture_new(PICTURE_FILE *mhandle)
 {
         OSErr   anError = noErr;
         OSType  *keepType;

         keepType = FilePrefs_GetFCPtr(*gPrefs2Use_h,eOutfSystem);
         //Files.h
         anError = FSpCreate(&mhandle->fFile,*keepType,'PICT',smSystemScript);
         if(anError == dupFNErr)
                 anError = noErr;
         return anError;
 }

 static void image_picture_gworld_clear(PICTURE_FILE *mhandle)
 {
         int                     i;
         int                     l;
         unsigned char   *pixPtr;
         unsigned short  *bigPixPtr;
         unsigned short  buf;
         PixMapHandle    keepPixMapH;

         //QDOffscreen.h
         keepPixMapH = GetGWorldPixMap(mhandle->fTargetGWorld);
         if(NULL == keepPixMapH)
                 Error("can not write Mac Picture (No GWorld PixMap).");
         //QDOffscreen.h
         if(LockPixels(keepPixMapH) == false)
                 Error("can not lock Mac Picture GWorld PixMap.");
         for(l = 0;l < mhandle->fHeight; l++)
         {
                 //QDOffscreen.h
                 pixPtr = (unsigned char *)GetPixBaseAddr(keepPixMapH);
                 pixPtr += l * (((**keepPixMapH).rowBytes) & 0x3fff); // + Y scanline
offset down
                 if((**keepPixMapH).pixelSize == 32)
                 {
                         for(i = 0;i < mhandle->fWidth; i++)
                         {
                                 (*pixPtr++) = (unsigned char)0;
                                 (*pixPtr++) = (unsigned char)0;
                                 (*pixPtr++) = (unsigned char)0;
                                 (*pixPtr++) = (unsigned char)0;
                         }
                 }
                 else
                         if((**keepPixMapH).pixelSize == 16)
                         {
                                 bigPixPtr = (unsigned short *)pixPtr;
                                 for(i = 0;i < mhandle->fWidth; i++)
                                 {
                                         buf = 0;
                                         (*bigPixPtr++) = buf;
                                 }
                         }
         }
         //QDOffscreen.h
         UnlockPixels(keepPixMapH);
 }

 // Paints the PICT to an R/G/B/Alpha GWorld
 static OSErr image_picture_paint(PICTURE_FILE *mhandle,PicHandle pict)
 {
         PixMapHandle    keepPixMapH;
         Rect                    r;
         Boolean                 imageHasAlpha = false;
         OSErr                   anError = 0;
         CGrafPtr                keepGPtr;
         GDHandle                keepGDh;

         if((pict == NULL) || (mhandle->fTargetGWorld == NULL))
                 return paramErr;
         if(mhandle->fWidth > 2047)
         {
                 Error("pict is too big,maximal width of picture to read is 2047
pixels!");
                 return mFulErr;
         }
         if((**gPrefs2Use_h).progress >= eProgDebug)
                 printf("picture size is %d * %d
pixel.\n",mhandle->fWidth,mhandle->fHeight);
         //Quickdraw.h
         SetRect(&r,0,0,mhandle->fWidth,mhandle->fHeight);
         //QDOffscreen.h
         keepPixMapH = GetGWorldPixMap(mhandle->fTargetGWorld);
         if(NULL == keepPixMapH)
                 return -1;
         //QDOffscreen.h
         if(!LockPixels(keepPixMapH))
                 return -1;
         //QDOffscreen.h
         GetGWorld(&keepGPtr,&keepGDh);
         //QDOffscreen.h
         SetGWorld(mhandle->fTargetGWorld,NULL);
         //Quickdraw.h
         ForeColor(blackColor);
         //Quickdraw.h
         BackColor(whiteColor);
         //Quickdraw.h
         EraseRect(&r);
         //Quickdraw.h
         DrawPicture(pict,&r);
         //QDOffscreen.h
         UnlockPixels(keepPixMapH);
         //QDOffscreen.h
         SetGWorld(keepGPtr,keepGDh);
         return anError;
 }

 // Mac Picture reading code
 static PicHandle image_picture_handle_from_file(PICTURE_FILE *mhandle)
 {
         const long      kPictHeaderSize = PICTF_HEADER_SIZE;
         Boolean         tryRsrcFork;
         long            pictFileLen;
         long            headerFileLen;
         short           applref;
         short           fref;
         PicHandle       keepPicH;
         char            headerString[PICTF_HEADER_SIZE];

         tryRsrcFork = true;
         //Files.h
         if(FSpOpenDF(&mhandle->fFile,fsRdPerm,&fref) == 0)
         {
                 //Files.h
                 (void)GetEOF(fref,&pictFileLen);
                 pictFileLen -= kPictHeaderSize;
                 if(pictFileLen > 0)
                 {
                         //Files.h
                         (void)SetFPos(fref,fsFromStart,0);
                         headerFileLen = PICTF_HEADER_SIZE;
                         //Files.h
                         (void)FSRead(fref,&headerFileLen,(Ptr)(&headerString[0]));
                         headerString[8] = 0;
                         //string.h
                         //MacMemory.h
                         if(strcmp(headerString,"POV-Ray!") == 0)
                                
BlockMoveData(&headerString[9],&mhandle->fLastLine,sizeof(mhandle->fLastLine));
                         //Files.h
                         (void)SetFPos(fref,fsFromStart,PICTF_HEADER_SIZE);
                         //MacMemory.h
                         keepPicH = (PicHandle)NewHandleClear(pictFileLen);
                         if (keepPicH != NULL)
                         {
                                 //MacMemory.h
                                 HLock((Handle)keepPicH);
                                 //Files.h
                                 (void)FSRead(fref,&pictFileLen,(Ptr)(*keepPicH));
                                 //MacMemory.h
                                 HUnlock((Handle)keepPicH);
                                 if((**gPrefs2Use_h).progress >= eProgDebug)
                                         puts("Reading PICT from data fork.");
                                 tryRsrcFork = false;
                         }
                 }
                 //Files.h
                 (void)FSClose(fref);
         }
         if(tryRsrcFork == true)
         {
                 //Resources.h
                 applref = CurResFile();
                 //Resources.h
                 fref = FSpOpenResFile(&mhandle->fFile,fsRdPerm);
                 //Resources.h
                 if((ResError() == 0) && (fref != -1))
                 {
                         //Resources.h
                         UseResFile(fref);
                         //Resources.h
                         if(CountResources('PICT') > 0)
                         {
                                 //Resources.h
                                 keepPicH = (PicHandle)Get1IndResource('PICT',1);
                                 if(keepPicH != NULL)
                                 {
                                         //Resources.h
                                         DetachResource((Handle)keepPicH);
                                         if((**gPrefs2Use_h).progress >= eProgDebug)
                                                 puts("Reading PICT from resource
fork.");
                                 }
                         }
                         //Files.h
                         (void)FSClose(fref);
                         //Resources.h
                         UseResFile(applref);
                 }
         }
         return keepPicH;
 }

 static OSErr image_compress_pict_file(ComponentInstance ci,FSSpec *theImageFile)
 {
         OSErr   anError;
         short   theFileRefNum;

         //Files.h
         anError = FSpOpenDF(theImageFile,fsRdWrPerm,&theFileRefNum);
         if(!anError)
         {
                 //QuickTimeComponents.h
                 anError = SCCompressPictureFile(ci,theFileRefNum,theFileRefNum);
                 //Files.h
                 FSClose(theFileRefNum);
         }
         return(anError);
 }




/*==============================================================================
 File:   sysMacPict.h
==============================================================================*/

 #ifndef SYSMACPICT_H
 #define SYSMACPICT_H

 #include "frame.h"      // FILE_HANDLE

 #include <Types.h>
 #include <Files.h>

 extern FSSpec gMovieFile;


 FILE_HANDLE *Get_MacPICT_File_Handle(void);
 int             Open_MacPICT_File(FILE_HANDLE *handle,char *name,int *width,
int *height,int buffer_size,int mode);
 void            Write_MacPICT_Line(FILE_HANDLE *handle,COLOUR *line_data,int
line_number);
 int             Read_MacPICT_Line(FILE_HANDLE *handle,COLOUR *line_data,int
*line_number);
 void            Read_MacPICT_Image(IMAGE *imageptr,char *filename);
 void            Close_MacPICT_File(FILE_HANDLE *handle);

 #endif


Fabian Herb wrote:

> Hello,
>
> i've been trying to compile POV-Ray with MPW for a while. I eliminated
> some problems concerning sysMacPict.cp in the makefile. But now the
> linker reports these errors:
>
> # Error:  File ":mpwobj:POVRAY.c.o"
> #         Reference to unresolved symbol ".MacFile_GetFileHandle"
> # Error:  File ":mpwobj:PARSTXTR.c.o"
> #         Reference to unresolved symbol ".MacFile_ReadImage"
>
> I've tried to compile other files than sysMacPict.cp with MrCpp. None of
> the functions in these files can be accessed from outside.
>
> Is there any incompatibility between MrC and MrCpp that I should be
> aware of? I'm quite new to MPW and have no idea what to do. I use
> version 4.1.0f1c1 of MrC and MrCpp.
>
> Thanks in advance
>         Fabian

Post a reply to this message

Thanks for the quick help. 

I'm sorry for the misunderstanding: I'm not a beginner in programming.
I've been coding in C and C++ for some time now. I'm also familar with
command-line basing platforms such as Linux (so I have a basic
understanding of how to use MPW). But I tried to compile the POV Code
with CW Pro 3 (I don't have 5.2 or something), which made a lot more
trouble. So I tried MPW.

Fabian

Thorsten Froehlich wrote:
> 
> The MPW makefiles that come with 3.1g don't work if Mac Pict support is
> enabled.  The simplest solution is to remove the following lines from
> config.h:
> 
> #define GET_SYS_FILE_HANDLE() MacFile_GetFileHandle()
> #define READ_SYS_IMAGE(i,n)  MacFile_ReadImage((i),(n))
> #define SYS_DEF_EXT    ".pict"
> 
> and near the end
> 
> #define GET_SYS_FILE_HANDLE() MacFile_GetFileHandle()
> 
> > I'm quite new to MPW and have no idea what to do.
> 
> To be honest (and very direct), compiling POV-Ray is not an easy task
> for a beginner.  The source code is complex and not well commented, and
> when you run into problems you should be able to resolve them on your
> own.  If you don't know how, compiling the source code will most likely
> be a very frustrating and discouraging experience.
> 
> There are more rewarding, smaller programs (like the Apple sample code)
> out there that can get you started to learn programming and using MPW.
> If you search a bit on Apples developer website, you will probably find
> some good tutorial or other information that will be really helpful
> getting started, too..

Post a reply to this message

In article <3AB62970.C1350BBA@nexxium.de> , Fabian Herb 
<com### [at] nexxiumde>  wrote:

> I'm sorry for the misunderstanding: I'm not a beginner in programming.

Oh, I am sorry.  I assumed you are because a lot of beginners seem to be
playing around with MPW because it is free (at least that is the
impression I get on the MPW mailing list).   Basically 3.1g does not
compile out of the box because I changed the Pict image support in the
for 3.1g and did not adjust the makefile.  It would be possible without
messing around with frame.h, but there seems to be too little interest
for an MPW makefile so I never completed it...

> But I tried to compile the POV Code
> with CW Pro 3 (I don't have 5.2 or something), which made a lot more
> trouble. So I tried MPW.

The reason is simply that you CW Pro 3 comes with older header files for
the operating system.  You can get Universal headers 3.1 from Apple and
merge them with the ones of CW Pro 3 and all will work.  You should not
use the Universal headers 3.3 because POV-Ray will not compile with
those (because of some Carbon header change issues).


    Thorsten


____________________________________________________
Thorsten Froehlich, Duisburg, Germany
e-mail: tho### [at] trfde

Visit POV-Ray on the web: http://mac.povray.org

Post a reply to this message

Do you know of any other free MacOS complilers?
______
David McCabe
mcc### [at] yahoocom
http://homepage.mac.com/davidmccabe/
Jesus loves you! 


> 
> Oh, I am sorry.  I assumed you are because a lot of beginners seem to be
> playing around with MPW because it is free (at least that is the
> impression I get on the MPW mailing list).

Post a reply to this message

I believe MPW is the only free compiler... But if you contact Metrowerks they
will send a promo demo of CW5 that you can use for a few weeks... Learning CW
is also a fairly cheap version for about $50 if you use it for personal
use... I do not think you need a license to "share" code just finished
product... The Educational license is around $100 if you plan to make your
application available to others...

David wrote:

> Do you know of any other free MacOS complilers?
> ______
> David McCabe
> mcc### [at] yahoocom
> http://homepage.mac.com/davidmccabe/
> Jesus loves you!
>
> >
> > Oh, I am sorry.  I assumed you are because a lot of beginners seem to be
> > playing around with MPW because it is free (at least that is the
> > impression I get on the MPW mailing list).

Post a reply to this message

In article <B6DCD8F3.4E7A%mcc### [at] yahoocom>, David <mcc### [at] yahoocom> 
wrote:

> Do you know of any other free MacOS complilers?

Well, there is the developer toolkit for Mac OS X...but you need OS X, 
of course. The developer tools are free, and use a version of gcc for 
the compiler.
Maybe CodeWarrior Lite would do what you need...
I remember seeing something called "Leonardo", which was some kind of C 
interpreter/compiler, but I don't think it would handle POV, and lots of 
other compilers for odd languages...I assume you meant C/C++ compilers 
capable of compiling POV-Ray... ;-)

-- 
Christopher James Huff
Personal: chr### [at] maccom, http://homepage.mac.com/chrishuff/
TAG: chr### [at] tagpovrayorg, http://tag.povray.org/

<><

Post a reply to this message

Yes, C++, but I'm really not all that interested in compiling POV.
______
David McCabe
mcc### [at] yahoocom
http://homepage.mac.com/davidmccabe/
Jesus loves you! 


> I remember seeing something called "Leonardo", which was some kind of C
> interpreter/compiler, but I don't think it would handle POV, and lots of
> other compilers for odd languages...I assume you meant C/C++ compilers
> capable of compiling POV-Ray... ;-)

Post a reply to this message