This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
blender-archive/source/blender/quicktime/apple/quicktime_import.c
Stefan Gartner 723b84c79c fun with quicktime:
#include <QuickTime/Movies.h> instead of #include <Movies.h> on OS X to
avoid having to specify the full path to the QT headers in the Makefiles

#undef NDEBUG on OS X to avoid errors about ID being declared twice

enable support for QuickTime in the original Makefiles on OS X
2003-05-02 13:36:56 +00:00

654 lines
16 KiB
C

/**
* $Id$
*
* quicktime_import.c
*
* Code to use Quicktime to load images/movies as texture.
*
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version. The Blender
* Foundation also sells licenses for use in proprietary software under
* the Blender License. See http://www.blender.org/BL/ for information
* about this.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
*
* The Original Code is written by Rob Haarsma (phase)
*
* Contributor(s): Stefan Gartner (sgefant)
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#ifdef WITH_QUICKTIME
#if defined(_WIN32) || defined(__APPLE__)
#include "IMB_anim.h"
#include "BLO_sys_types.h"
#ifdef __APPLE__
#include <QuickTime/Movies.h>
#include <QuickTime/QuickTimeComponents.h>
#endif
#ifdef _WIN32
#include <Movies.h>
#include <QTML.h>
#include <TextUtils.h>
#include <QuickTimeComponents.h>
#endif /* _WIN32 */
#include "quicktime_import.h"
#define RECT_WIDTH(r) (r.right-r.left)
#define RECT_HEIGHT(r) (r.bottom-r.top)
#define QTIME_DEBUG 0
int anim_is_quicktime (char *name)
{
FSSpec theFSSpec;
Str255 dst;
char theFullPath[255];
Boolean isMovieFile = false;
AliasHandle myAlias = NULL;
Component myImporter = NULL;
#ifdef __APPLE__
FInfo myFinderInfo;
FSRef myRef;
#endif
OSErr err = noErr;
// dont let quicktime movie import handle these
if( BLI_testextensie(name, ".swf") ||
BLI_testextensie(name, ".txt") ||
BLI_testextensie(name, ".mpg") ||
BLI_testextensie(name, ".avi") || // wouldnt be appropriate ;)
BLI_testextensie(name, ".wav") ||
BLI_testextensie(name, ".zip") ||
BLI_testextensie(name, ".mp3")) return 0;
if(QTIME_DEBUG) printf("qt: checking as movie\n");
sprintf(theFullPath, "%s", name);
#ifdef __APPLE__
err = FSPathMakeRef(theFullPath, &myRef, 0);
err = FSGetCatalogInfo(&myRef, kFSCatInfoNone, NULL, NULL, &theFSSpec, NULL);
#else
CopyCStringToPascal(theFullPath, dst);
err = FSMakeFSSpec(0, 0L, dst, &theFSSpec);
#endif
#ifdef __APPLE__
// see whether the file type is MovieFileType; to do this, get the Finder information
err = FSpGetFInfo(&theFSSpec, &myFinderInfo);
if (err == noErr) {
if (myFinderInfo.fdType == kQTFileTypeMovie) {
return(true);
}
}
#endif
/* on mac os x this results in using quicktime for other formats as well
* not sure whether this is intended
*/
// if it isn't a movie file, see whether the file can be imported as a movie
err = QTNewAlias(&theFSSpec, &myAlias, true);
if (err == noErr) {
if (myAlias != NULL) {
err = GetMovieImporterForDataRef(rAliasType, (Handle)myAlias, kGetMovieImporterDontConsiderGraphicsImporters, &myImporter);
DisposeHandle((Handle)myAlias);
}
}
if ((err == noErr) && (myImporter != NULL)) { // this file is a movie file
isMovieFile = true;
}
return(isMovieFile);
}
void free_anim_quicktime (struct anim *anim) {
if (anim == NULL) return;
if (anim->qtime == NULL) return;
UnlockPixels(anim->qtime->offscreenPixMap);
if(anim->qtime->have_gw)
DisposeGWorld( anim->qtime->offscreenGWorld );
if(anim->qtime->ibuf)
IMB_freeImBuf(anim->qtime->ibuf);
DisposeMovie( anim->qtime->movie );
CloseMovieFile( anim->qtime->movieRefNum );
if(anim->qtime->frameIndex) MEM_freeN (anim->qtime->frameIndex);
if(anim->qtime) MEM_freeN (anim->qtime);
anim->qtime = NULL;
anim->duration = 0;
}
OSErr QT_get_frameIndexes(struct anim *anim)
{
int i;
OSErr anErr = noErr;
OSType media = VideoMediaType;
TimeValue nextTime = 0;
TimeValue startPoint;
TimeValue tmpstartPoint;
startPoint = -1;
GetMovieNextInterestingTime(anim->qtime->movie, nextTimeMediaSample+nextTimeEdgeOK, (TimeValue)1, &media, 0,
1, &startPoint, NULL);
tmpstartPoint = startPoint;
anim->qtime->framecount = 0;
while(tmpstartPoint != -1) {
nextTime = 0;
GetMovieNextInterestingTime(anim->qtime->movie, nextTimeMediaSample, 1, &media, tmpstartPoint, 0, &nextTime, NULL);
tmpstartPoint = nextTime;
anim->qtime->framecount ++;
}
anim->qtime->frameIndex = (TimeValue *) MEM_callocN(sizeof(TimeValue) * anim->qtime->framecount, "qtframeindex");
//rewind
GetMovieNextInterestingTime(anim->qtime->movie, nextTimeMediaSample, 1, &media, (TimeValue)1, 0, &tmpstartPoint, NULL);
anim->qtime->frameIndex[0] = startPoint;
for(i = 1; i < anim->qtime->framecount; i++) {
nextTime = 0;
GetMovieNextInterestingTime(anim->qtime->movie, nextTimeMediaSample, 1, &media, startPoint, 0, &nextTime, NULL);
startPoint = nextTime;
anim->qtime->frameIndex[i] = nextTime;
}
anErr = GetMoviesError();
return anErr;
}
ImBuf * qtime_fetchibuf (struct anim *anim, int position)
{
PixMapHandle myPixMap = NULL;
Ptr myPtr;
register int index;
register int boxsize;
register uint32_t *readPos;
register uint32_t *changePos;
ImBuf *ibuf = NULL;
unsigned int *rect;
unsigned char *crect;
if (anim == NULL) {
return (NULL);
}
ibuf = IMB_allocImBuf (anim->x, anim->y, 32, IB_rect, 0);
rect = ibuf->rect;
SetMovieTimeValue(anim->qtime->movie, anim->qtime->frameIndex[position]);
UpdateMovie(anim->qtime->movie);
MoviesTask(anim->qtime->movie, 0);
myPixMap = GetGWorldPixMap(anim->qtime->offscreenGWorld);
myPtr = GetPixBaseAddr(myPixMap);
if (myPtr == NULL) {
printf ("Error reading frame from Quicktime");
IMB_freeImBuf (ibuf);
return NULL;
}
boxsize = anim->x * anim->y;
readPos = (uint32_t *) myPtr;
changePos = (uint32_t *) rect; //textureIMBuf *THE* data pointerrr
#ifdef __APPLE__
// Swap alpha byte to the end, so ARGB become RGBA; note this is
// big endian-centric.
for( index = 0; index < boxsize; index++, changePos++, readPos++ )
*( changePos ) = ( ( *readPos & 0xFFFFFF ) << 8 ) |
( ( *readPos >> 24 ) & 0xFF );
#endif
#ifdef _WIN32
for( index = 0; index < boxsize; index++, changePos++, readPos++ )
*( changePos ) = *(readPos );
if(anim->qtime->depth < 32) {
//add alpha to ibuf
boxsize = anim->x * anim->y * 4;
crect = (unsigned char *) rect;
for( index = 0; index < boxsize; index+=4, crect+=4 )
crect[3] = 0xFF;
}
#endif
IMB_flipy(ibuf);
return ibuf;
}
// following two functions only here to get movie pixeldepth
int GetFirstVideoMedia(struct anim *anim)
{
long numTracks;
OSType mediaType;
numTracks = GetMovieTrackCount(anim->qtime->movie);
for (anim->qtime->trackIndex=1; anim->qtime->trackIndex<=numTracks; (anim->qtime->trackIndex)++) {
anim->qtime->theTrack = GetMovieIndTrack(anim->qtime->movie, anim->qtime->trackIndex);
if (anim->qtime->theTrack)
anim->qtime->theMedia = GetTrackMedia(anim->qtime->theTrack);
if (anim->qtime->theMedia)
GetMediaHandlerDescription(anim->qtime->theMedia,&mediaType, nil, nil);
if (mediaType = VideoMediaType) return 1;
}
anim->qtime->trackIndex = 0; // trackIndex can't be 0
return 0; // went through all tracks and no video
}
short GetFirstVideoTrackPixelDepth(struct anim *anim)
{
SampleDescriptionHandle imageDescH = (SampleDescriptionHandle)NewHandle(sizeof(Handle));
long trackIndex = 0;
if(!GetFirstVideoMedia(anim))
return -1;
if (!anim->qtime->trackIndex || !anim->qtime->theMedia) return -1; // we need both
GetMediaSampleDescription(anim->qtime->theMedia, anim->qtime->trackIndex, imageDescH);
return (*(ImageDescriptionHandle)imageDescH)->depth;
}
int startquicktime (struct anim *anim)
{
FSSpec theFSSpec;
OSErr err = noErr;
Str255 dst;
char theFullPath[255];
#ifdef __APPLE__
FSRef myRef;
#endif
anim->qtime = MEM_callocN (sizeof(QuicktimeMovie),"animqt");
anim->qtime->have_gw = FALSE;
if (anim->qtime == NULL) {
if(QTIME_DEBUG) printf("Can't alloc qtime: %s\n", anim->name);
return -1;
}
if(QTIME_DEBUG) printf("qt: attempting to load as movie %s\n", anim->name);
sprintf(theFullPath, "%s", anim->name);
#ifdef __APPLE__
err = FSPathMakeRef(theFullPath, &myRef, 0);
err = FSGetCatalogInfo(&myRef, kFSCatInfoNone, NULL, NULL, &theFSSpec, NULL);
#else
CopyCStringToPascal(theFullPath, dst);
FSMakeFSSpec(0, 0L, dst, &theFSSpec);
#endif
err = OpenMovieFile(&theFSSpec, &anim->qtime->movieRefNum, fsRdPerm);
if (err == noErr) {
if(QTIME_DEBUG) printf("qt: movie opened\n");
err = NewMovieFromFile(&anim->qtime->movie,
anim->qtime->movieRefNum,
&anim->qtime->movieResId, NULL, newMovieActive, NULL);
}
if (err) {
if(QTIME_DEBUG) printf("qt: bad movie\n", anim->name);
if (anim->qtime->movie) {
DisposeMovie(anim->qtime->movie);
MEM_freeN(anim->qtime);
if(QTIME_DEBUG) printf("qt: can't load %s\n", anim->name);
return -1;
}
}
GetMovieBox(anim->qtime->movie, &anim->qtime->movieBounds);
anim->x = anim->qtime->movWidth = RECT_WIDTH(anim->qtime->movieBounds);
anim->y = anim->qtime->movHeight = RECT_HEIGHT(anim->qtime->movieBounds);
if(QTIME_DEBUG) printf("qt: got bounds\n", anim->name);
if(anim->x == 0 && anim->y == 0) {
if(QTIME_DEBUG) printf("qt: error, no dimensions\n");
free_anim_quicktime(anim);
return -1;
}
anim->qtime->ibuf = IMB_allocImBuf (anim->x, anim->y, 32, IB_rect, 0);
#ifdef _WIN32
err = NewGWorldFromPtr(&anim->qtime->offscreenGWorld,
k32RGBAPixelFormat,
&anim->qtime->movieBounds,
NULL, NULL, 0,
(unsigned char *)anim->qtime->ibuf->rect,
anim->x * 4);
#else
err = NewGWorldFromPtr(&anim->qtime->offscreenGWorld,
k32ARGBPixelFormat,
&anim->qtime->movieBounds,
NULL, NULL, 0,
(unsigned char *)anim->qtime->ibuf->rect,
anim->x * 4);
#endif /* _WIN32 */
if(err == noErr) {
anim->qtime->have_gw = TRUE;
SetMovieGWorld(anim->qtime->movie,
anim->qtime->offscreenGWorld,
GetGWorldDevice(anim->qtime->offscreenGWorld));
QT_get_frameIndexes(anim);
}
anim->qtime->offscreenPixMap = GetGWorldPixMap(anim->qtime->offscreenGWorld);
LockPixels(anim->qtime->offscreenPixMap);
//fill blender's anim struct
anim->qtime->depth = GetFirstVideoTrackPixelDepth(anim);
anim->duration = anim->qtime->framecount;
anim->params = 0;
anim->interlacing = 0;
anim->orientation = 0;
anim->framesize = anim->x * anim->y * 4;
anim->curposition = 0;
if(QTIME_DEBUG) printf("qt: load %s %dx%dx%d frames %d\n", anim->name, anim->qtime->movWidth,
anim->qtime->movHeight, anim->qtime->depth, anim->qtime->framecount);
return 0;
}
int imb_is_a_quicktime (char *name)
{
GraphicsImportComponent theImporter = NULL;
FSSpec theFSSpec;
Str255 dst;
char theFullPath[255];
Boolean isMovieFile = false;
AliasHandle myAlias = NULL;
Component myImporter = NULL;
#ifdef __APPLE__
FInfo myFinderInfo;
FSRef myRef;
#endif
OSErr err = noErr;
if(QTIME_DEBUG) printf("qt: checking as image %s\n", name);
// dont let quicktime image import handle these
if( BLI_testextensie(name, ".swf") ||
BLI_testextensie(name, ".txt") ||
BLI_testextensie(name, ".mpg") ||
BLI_testextensie(name, ".wav") ||
BLI_testextensie(name, ".mov") || // not as image, doesn't work
BLI_testextensie(name, ".avi") ||
BLI_testextensie(name, ".mp3")) return 0;
sprintf(theFullPath, "%s", name);
#ifdef __APPLE__
err = FSPathMakeRef(theFullPath, &myRef, 0);
err = FSGetCatalogInfo(&myRef, kFSCatInfoNone, NULL, NULL, &theFSSpec, NULL);
#else
CopyCStringToPascal(theFullPath, dst);
err = FSMakeFSSpec(0, 0L, dst, &theFSSpec);
#endif
GetGraphicsImporterForFile(&theFSSpec, &theImporter);
if (theImporter != NULL) {
if(QTIME_DEBUG) printf("qt: %s valid\n", name);
CloseComponent(theImporter);
return 1;
}
return 0;
}
ImBuf *imb_quicktime_decode(unsigned char *mem, int size, int flags)
{
Rect myRect;
OSErr err = noErr;
GraphicsImportComponent gImporter = NULL;
ImageDescriptionHandle desc;
ComponentInstance dataHandler;
PointerDataRef dataref = (PointerDataRef)NewHandle(sizeof(PointerDataRefRecord));
int x, y, depth;
int have_gw = FALSE;
ImBuf *ibuf = NULL;
ImBuf *imbuf = NULL;
GWorldPtr offGWorld;
PixMapHandle myPixMap = NULL;
#ifdef __APPLE__
Ptr myPtr;
register int index;
register int boxsize;
register uint32_t *readPos;
register uint32_t *changePos;
ImBuf *wbuf = NULL;
unsigned int *rect;
#endif
if (mem == NULL)
goto bail;
if(QTIME_DEBUG) printf("qt: attempt to load mem as image\n");
(**dataref).data = mem;
(**dataref).dataLength = size;
err = OpenADataHandler(dataref,
PointerDataHandlerSubType,
nil,
(OSType)0,
nil,
kDataHCanRead,
&dataHandler);
if (err != noErr) {
if(QTIME_DEBUG) printf("no datahandler\n");
goto bail;
}
err = GetGraphicsImporterForDataRef(dataref, PointerDataHandlerSubType, &gImporter);
if (err != noErr) {
if(QTIME_DEBUG) printf("no graphimport\n");
goto bail;
}
err = GraphicsImportGetNaturalBounds(gImporter, &myRect);
if (err != noErr) {
if(QTIME_DEBUG) printf("no bounds\n");
goto bail;
}
err = GraphicsImportGetImageDescription (gImporter, &desc );
if (err != noErr) {
if(QTIME_DEBUG) printf("no imagedescription\n");
goto bail;
}
x = RECT_WIDTH(myRect);
y = RECT_HEIGHT(myRect);
depth = (**desc).depth;
if (flags & IB_test) {
ibuf = IMB_allocImBuf(x, y, depth, 0, 0);
ibuf->ftype = QUICKTIME;
DisposeHandle((Handle)dataref);
if (gImporter != NULL) CloseComponent(gImporter);
return ibuf;
}
#ifdef __APPLE__
ibuf = IMB_allocImBuf (x, y, 32, IB_rect, 0);
wbuf = IMB_allocImBuf (x, y, 32, IB_rect, 0);
err = NewGWorldFromPtr(&offGWorld,
k32ARGBPixelFormat,
&myRect, NULL, NULL, 0,
(unsigned char *)wbuf->rect, x * 4);
#else
ibuf = IMB_allocImBuf (x, y, 32, IB_rect, 0);
err = NewGWorldFromPtr(&offGWorld,
k32RGBAPixelFormat,
&myRect, NULL, NULL, 0,
(unsigned char *)ibuf->rect, x * 4);
#endif
if (err != noErr) {
if(QTIME_DEBUG) printf("no newgworld\n");
goto bail;
} else {
have_gw = TRUE;
}
GraphicsImportSetGWorld(gImporter, offGWorld, NULL);
GraphicsImportDraw(gImporter);
#ifdef __APPLE__
rect = ibuf->rect;
myPixMap = GetGWorldPixMap(offGWorld);
LockPixels(myPixMap);
myPtr = GetPixBaseAddr(myPixMap);
if (myPtr == NULL) {
printf ("Error reading frame from Quicktime");
IMB_freeImBuf (ibuf);
return NULL;
}
boxsize = x * y;
readPos = (uint32_t *) myPtr;
changePos = (uint32_t *) rect;
for( index = 0; index < boxsize; index++, changePos++, readPos++ )
*( changePos ) = ( ( *readPos & 0xFFFFFF ) << 8 ) |
( ( *readPos >> 24 ) & 0xFF );
#endif
bail:
DisposeHandle((Handle)dataref);
UnlockPixels(myPixMap);
if(have_gw) DisposeGWorld(offGWorld);
#ifdef __APPLE__
if (wbuf) {
IMB_freeImBuf (wbuf);
wbuf = NULL;
}
#endif
if (gImporter != NULL) CloseComponent(gImporter);
if (err != noErr) {
if(QTIME_DEBUG) printf("quicktime import unsuccesfull\n");
if (ibuf) {
IMB_freeImBuf (ibuf);
ibuf = NULL;
}
}
if(ibuf) {
#ifdef _WIN32
// add alpha layer, might also be nescessary for OSX
int i;
int box = x * y;
unsigned char *arect = (unsigned char *) ibuf->rect;
if(depth < 32)
for(i = 0; i < box; i++, arect+=4)
arect[3] = 0xFF;
#endif
IMB_flipy(ibuf);
ibuf->ftype = QUICKTIME;
}
return ibuf;
}
#endif /* _WIN32 || __APPLE__ */
#endif /* WITH_QUICKTIME */
#if 0
struct ImageDescription {
long idSize;
CodecType cType;
long resvd1;
short resvd2;
short dataRefIndex;
short version;
short revisionLevel;
long vendor;
CodecQ temporalQuality;
CodecQ spatialQuality;
short width;
short height;
Fixed hRes;
Fixed vRes;
long dataSize;
short frameCount;
Str31 name;
short depth;
short clutID;
};
#endif // 0