Quicktime : make dna codecType data store the quicktime codecType value instead of a proxy value

Quicktime codecType data is a 32 bit value (4 chars coded).

Implemented RNA set/get functions for codecType enum to cope with RNA enum values 24bit precision limitation
Implemented dynamic codecType enum list creation

Carbon quicktime now stores codec settings in "clear" in the QuicktimeCodecSettings dna struct (in addition to the closed atom container in QuicktimeCodecData) to be compatible with the QTKit version

+fixed some warnings

4 files changed, 294 insertions, 82 deletions

diff --git a/source/blender/quicktime/apple/qtkit_export.m b/source/blender/quicktime/apple/qtkit_export.m
index 6788c22d9a1..59cd669d738 100644
--- a/source/blender/quicktime/apple/qtkit_export.m
+++ b/source/blender/quicktime/apple/qtkit_export.m
@@ -49,10 +49,6 @@
 
 #include "MEM_guardedalloc.h"
 
-#include "quicktime_import.h"
-#include "quicktime_export.h"
-
-
 #ifdef __APPLE__
 /* evil */
 #ifndef __AIFF__
@@ -65,6 +61,9 @@
 #error OSX 10.5 minimum is needed for QTKit
 #endif
 
+#include "quicktime_import.h"
+#include "quicktime_export.h"
+
 #endif /* __APPLE__ */
 
 typedef struct QuicktimeExport {
@@ -78,36 +77,65 @@ typedef struct QuicktimeExport {
 
 static struct QuicktimeExport *qtexport;
 
+#pragma mark rna helper functions
 
-static NSString *stringWithCodecType(int codecType) {
-	switch (codecType) {
-		case QT_CODECTYPE_RAW:
-			return @"raw ";
-		case QT_CODECTYPE_MJPEGA:
-			return @"mjpa";
-		case QT_CODECTYPE_MJPEGB:
-			return @"mjpb";
-		case QT_CODECTYPE_DVCPAL:
-			return @"dvcp";
-		case QT_CODECTYPE_DVCNTSC:
-			return @"dvc ";
-		case QT_CODECTYPE_MPEG4:
-			return @"mp4v";
-		case QT_CODECTYPE_H263:
-			return @"h263";
-		case QT_CODECTYPE_H264:
-			return @"avc1";
-		case QT_CODECTYPE_DVCPROHD720p:
-			return @"dvhp";
-		case QT_CODECTYPE_DVCPROHD1080i50:
-			return @"dvh5";
-		case QT_CODECTYPE_DVCPROHD1080i60:
-			return @"dvh6";
-			
-		case QT_CODECTYPE_JPEG:
-		default:
-			return @"jpeg";	
+
+static QuicktimeCodecTypeDesc qtCodecList[] = {
+	{kRawCodecType, 1, "Uncompressed"},
+	{kJPEGCodecType, 2, "JPEG"},
+	{kMotionJPEGACodecType, 3, "M-JPEG A"},
+	{kMotionJPEGBCodecType, 4, "M-JPEG B"},
+	{kDVCPALCodecType, 5, "DV PAL"},
+	{kDVCNTSCCodecType, 6, "DV/DVCPRO NTSC"},
+	{kDVCPROHD720pCodecType, 7, "DVCPRO HD 720p"},
+	{kDVCPROHD1080i50CodecType, 8, "DVCPRO HD 1080i50"},
+	{kDVCPROHD1080i60CodecType, 9, "DVCPRO HD 1080i60"},
+	{kMPEG4VisualCodecType, 10, "MPEG4"},
+	{kH263CodecType, 11, "H.263"},
+	{kH264CodecType, 12, "H.264"},
+	{0,0,NULL}};
+
+static int qtCodecCount = 12;
+
+int quicktime_get_num_codecs() {
+	return qtCodecCount;
+}
+
+QuicktimeCodecTypeDesc* quicktime_get_codecType_desc(int indexValue) {
+	if ((indexValue>=0) && (indexValue < qtCodecCount))
+		return &qtCodecList[indexValue];
+	else
+		return NULL;
+}
+
+int quicktime_rnatmpvalue_from_codectype(int codecType) {
+	int i;
+	for (i=0;i<qtCodecCount;i++) {
+		if (qtCodecList[i].codecType == codecType)
+			return qtCodecList[i].rnatmpvalue;
 	}
+
+	return 0;
+}
+
+int quicktime_codecType_from_rnatmpvalue(int rnatmpvalue) {
+	int i;
+	for (i=0;i<qtCodecCount;i++) {
+		if (qtCodecList[i].rnatmpvalue == rnatmpvalue)
+			return qtCodecList[i].codecType;
+	}
+	
+	return 0;	
+}
+
+
+static NSString *stringWithCodecType(int codecType) {
+	char str[5];
+	
+	*((int*)str) = EndianU32_NtoB(codecType);
+	str[4] = 0;
+	
+	return [NSString stringWithCString:str encoding:NSASCIIStringEncoding];
 }
 
 void makeqtstring (RenderData *rd, char *string) {
@@ -124,6 +152,7 @@ void makeqtstring (RenderData *rd, char *string) {
 	}
 }
 
+#pragma mark export functions
 
 void start_qt(struct Scene *scene, struct RenderData *rd, int rectx, int recty)
 {
@@ -264,7 +293,7 @@ void quicktime_verify_image_type(RenderData *rd)
 			(rd->qtcodecsettings.codecSpatialQuality <0) ||
 			(rd->qtcodecsettings.codecSpatialQuality > 100)) {
 			
-			rd->qtcodecsettings.codecType = QT_CODECTYPE_JPEG;
+			rd->qtcodecsettings.codecType = kJPEGCodecType;
 			rd->qtcodecsettings.codecSpatialQuality = (codecHighQuality*100)/codecLosslessQuality;
 		}
 	}
diff --git a/source/blender/quicktime/apple/qtkit_import.m b/source/blender/quicktime/apple/qtkit_import.m
index 500ee13330d..31a6ca71259 100644
--- a/source/blender/quicktime/apple/qtkit_import.m
+++ b/source/blender/quicktime/apple/qtkit_import.m
@@ -137,7 +137,7 @@ static ImBuf * nsImageToiBuf(NSImage *sourceImage, int width, int height)
 	uchar *toIBuf = NULL;
 	int x, y, to_i, from_i;
 	NSSize bitmapSize;
-	NSBitmapImageRep *blBitmapFormatImageRGB,*blBitmapFormatImageRGBA,*bitmapImage;
+	NSBitmapImageRep *blBitmapFormatImageRGB,*blBitmapFormatImageRGBA,*bitmapImage=nil;
 	NSEnumerator *enumerator;
 	NSImageRep *representation;
 	
@@ -150,12 +150,13 @@ static ImBuf * nsImageToiBuf(NSImage *sourceImage, int width, int height)
 	
 	/*Get the bitmap of the image*/
 	enumerator = [[sourceImage representations] objectEnumerator];
-	while (representation = [enumerator nextObject]) {
+	while ((representation = [enumerator nextObject])) {
         if ([representation isKindOfClass:[NSBitmapImageRep class]]) {
             bitmapImage = (NSBitmapImageRep *)representation;
 			break;
         }
     }
+	if (bitmapImage == nil) return NULL;
 
 	if (([bitmapImage bitsPerPixel] == 32) && (([bitmapImage bitmapFormat] & 0x5) == 0)
 		&& ![bitmapImage isPlanar]) {
diff --git a/source/blender/quicktime/apple/quicktime_export.c b/source/blender/quicktime/apple/quicktime_export.c
index 851b3c5b245..c6c412ae24b 100644
--- a/source/blender/quicktime/apple/quicktime_export.c
+++ b/source/blender/quicktime/apple/quicktime_export.c
@@ -77,6 +77,7 @@ static void QT_EndAddVideoSamplesToMedia (void);
 static void QT_CreateMyVideoTrack (int rectx, int recty);
 static void QT_EndCreateMyVideoTrack (void);
 static void check_renderbutton_framerate(struct RenderData *rd);
+static int get_qtcodec_settings(struct RenderData *rd);
 
 typedef struct QuicktimeExport {
 
@@ -113,6 +114,57 @@ static struct QuicktimeComponentData *qtdata;
 
 static int	sframe;
 
+/* RNA functions */
+
+static QuicktimeCodecTypeDesc qtCodecList[] = {
+	{kRawCodecType, 1, "Uncompressed"},
+	{kJPEGCodecType, 2, "JPEG"},
+	{kMotionJPEGACodecType, 3, "M-JPEG A"},
+	{kMotionJPEGBCodecType, 4, "M-JPEG B"},
+	{kDVCPALCodecType, 5, "DV PAL"},
+	{kDVCNTSCCodecType, 6, "DV/DVCPRO NTSC"},
+	{kDVCPROHD720pCodecType, 7, "DVCPRO HD 720p"},
+	{kDVCPROHD1080i50CodecType, 8, "DVCPRO HD 1080i50"},
+	{kDVCPROHD1080i60CodecType, 9, "DVCPRO HD 1080i60"},
+	{kMPEG4VisualCodecType, 10, "MPEG4"},
+	{kH263CodecType, 11, "H.263"},
+	{kH264CodecType, 12, "H.264"},
+	{0,0,NULL}};
+
+static int qtCodecCount = 12;
+
+int quicktime_get_num_codecs() {
+	return qtCodecCount;
+}
+
+QuicktimeCodecTypeDesc* quicktime_get_codecType_desc(int indexValue) {
+	if ((indexValue>=0) && (indexValue < qtCodecCount))
+		return &qtCodecList[indexValue];
+	else
+		return NULL;
+}
+
+int quicktime_rnatmpvalue_from_codectype(int codecType) {
+	int i;
+	for (i=0;i<qtCodecCount;i++) {
+		if (qtCodecList[i].codecType == codecType)
+			return qtCodecList[i].rnatmpvalue;
+	}
+	
+	return 0;
+}
+
+int quicktime_codecType_from_rnatmpvalue(int rnatmpvalue) {
+	int i;
+	for (i=0;i<qtCodecCount;i++) {
+		if (qtCodecList[i].rnatmpvalue == rnatmpvalue)
+			return qtCodecList[i].codecType;
+	}
+	
+	return 0;	
+}
+
+
 
 static void CheckError(OSErr err, char *msg)
 {
@@ -128,10 +180,9 @@ static OSErr QT_SaveCodecSettingsToScene(RenderData *rd)
 	long				mySize = 0;
 
 	CodecInfo			ci;
-	char str[255];
 
 	QuicktimeCodecData *qcd = rd->qtcodecdata;
-
+	
 	// check if current scene already has qtcodec settings, and clear them
 	if (qcd) {
 		free_qtcodecdata(qcd);
@@ -183,8 +234,6 @@ static OSErr QT_GetCodecSettingsFromScene(RenderData *rd)
 {	
 	Handle				myHandle = NULL;
 	ComponentResult		myErr = noErr;
-//	CodecInfo ci;
-//	char str[255];
 
 	QuicktimeCodecData *qcd = rd->qtcodecdata;
 
@@ -207,9 +256,22 @@ static OSErr QT_GetCodecSettingsFromScene(RenderData *rd)
 		SCGetInfo(qtdata->theComponent, scSpatialSettingsType,	&qtdata->gSpatialSettings);
 		SCGetInfo(qtdata->theComponent, scTemporalSettingsType,	&qtdata->gTemporalSettings);
 
-//		GetCodecInfo (&ci, qtdata->gSpatialSettings.codecType, 0);
-//		CopyPascalStringToC(ci.typeName, str);
-//		printf("restored Codec: %s\n", str);
+
+		//Fill the render QuicktimeCodecSettigns struct
+		rd->qtcodecsettings.codecTemporalQuality = (qtdata->gTemporalSettings.temporalQuality * 100) / codecLosslessQuality;
+		//Do not override scene frame rate (qtdata->gTemporalSettings.framerate)
+		rd->qtcodecsettings.keyFrameRate = qtdata->gTemporalSettings.keyFrameRate;
+		
+		rd->qtcodecsettings.codecType = qtdata->gSpatialSettings.codecType;
+		rd->qtcodecsettings.codec = (int)qtdata->gSpatialSettings.codec;
+		rd->qtcodecsettings.colorDepth = qtdata->gSpatialSettings.depth;
+		rd->qtcodecsettings.codecSpatialQuality = (qtdata->gSpatialSettings.spatialQuality * 100) / codecLosslessQuality;
+		
+		rd->qtcodecsettings.bitRate = qtdata->aDataRateSetting.dataRate;
+		rd->qtcodecsettings.minSpatialQuality = (qtdata->aDataRateSetting.minSpatialQuality * 100) / codecLosslessQuality;
+		rd->qtcodecsettings.minTemporalQuality = (qtdata->aDataRateSetting.minTemporalQuality * 100) / codecLosslessQuality;
+		//Frame duration is already known (qtdata->aDataRateSetting.frameDuration)
+		
 	} else {
 		printf("Quicktime: QT_GetCodecSettingsFromScene failed\n"); 
 	}
@@ -473,6 +535,7 @@ void start_qt(struct Scene *scene, struct RenderData *rd, int rectx, int recty)
 		makeqtstring(rd, name);
 
 #ifdef __APPLE__
+		EnterMoviesOnThread(0);
 		sprintf(theFullPath, "%s", name);
 
 		/* hack: create an empty file to make FSPathMakeRef() happy */
@@ -508,6 +571,9 @@ void start_qt(struct Scene *scene, struct RenderData *rd, int rectx, int recty)
 		if(err != noErr) {
 			G.afbreek = 1;
 // XXX			error("Unable to create Quicktime movie: %s", name);
+#ifdef __APPLE__
+			ExitMoviesOnThread();
+#endif
 		} else {
 			printf("Created QuickTime movie: %s\n", name);
 
@@ -545,6 +611,8 @@ void end_qt(void) {
 		printf("Finished QuickTime movie.\n");
 	}
 
+	ExitMoviesOnThread();
+	
 	if(qtexport) {
 		MEM_freeN(qtexport);
 		qtexport = NULL;
@@ -576,7 +644,7 @@ static void check_renderbutton_framerate(RenderData *rd)
 	else {
 		if (rd->frs_sec_base > 0)
 			qtdata->gTemporalSettings.frameRate = 
-			(rd->frs_sec << 16) / rd->frs_sec_base ;
+			((float)(rd->frs_sec << 16) / rd->frs_sec_base) ;
 	}
 	
 	err = SCSetInfo(qtdata->theComponent, scTemporalSettingsType,	&qtdata->gTemporalSettings);
@@ -600,21 +668,24 @@ static void check_renderbutton_framerate(RenderData *rd)
 void quicktime_verify_image_type(RenderData *rd)
 {
 	if (rd->imtype == R_QUICKTIME) {
-		if ((rd->qtcodecsettings.codecType<= 0) ||
+		if ((rd->qtcodecsettings.codecType== 0) ||
 			(rd->qtcodecsettings.codecSpatialQuality <0) ||
 			(rd->qtcodecsettings.codecSpatialQuality > 100)) {
 			
-			rd->qtcodecsettings.codecType = QT_CODECTYPE_JPEG;
+			rd->qtcodecsettings.codecType = kJPEGCodecType;
+			rd->qtcodecsettings.codec = (int)anyCodec;
 			rd->qtcodecsettings.codecSpatialQuality = (codecHighQuality*100)/codecLosslessQuality;
+			rd->qtcodecsettings.codecTemporalQuality = (codecHighQuality*100)/codecLosslessQuality;
+			rd->qtcodecsettings.keyFrameRate = 25;
+			rd->qtcodecsettings.bitRate = 5000000; //5 Mbps
 		}
 	}
 }
 
 int get_qtcodec_settings(RenderData *rd) 
 {
-	OSErr	err = noErr;
-
-	// erase any existing codecsetting
+	OSErr err = noErr;
+		// erase any existing codecsetting
 	if(qtdata) {
 		if(qtdata->theComponent) CloseComponent(qtdata->theComponent);
 		free_qtcomponentdata();
@@ -624,20 +695,28 @@ int get_qtcodec_settings(RenderData *rd)
 	qtdata = MEM_callocN(sizeof(QuicktimeComponentData), "QuicktimeComponentData");
 	qtdata->theComponent = OpenDefaultComponent(StandardCompressionType, StandardCompressionSubType);
 
-	// get previous selected codecsetting, if any 
+	// get previous selected codecsetting, from qtatom or detailed settings
 	if(rd->qtcodecdata && rd->qtcodecdata->cdParms) {
 		QT_GetCodecSettingsFromScene(rd);
-		check_renderbutton_framerate(rd);
 	} else {
-		// configure the standard image compression dialog box
-		// set some default settings: codec=jpeg, quality = max
-		qtdata->gSpatialSettings.codecType = kJPEGCodecType;
-		qtdata->gSpatialSettings.codec = anyCodec;         
-		qtdata->gSpatialSettings.spatialQuality = codecHighQuality;
-		qtdata->gTemporalSettings.temporalQuality = codecHighQuality;
-		qtdata->gTemporalSettings.keyFrameRate = 25;   
-		qtdata->aDataRateSetting.dataRate = 5 * 1024 * 1024;          
+		SCGetInfo(qtdata->theComponent, scDataRateSettingsType,	&qtdata->aDataRateSetting);
+		SCGetInfo(qtdata->theComponent, scSpatialSettingsType,	&qtdata->gSpatialSettings);
+		SCGetInfo(qtdata->theComponent, scTemporalSettingsType,	&qtdata->gTemporalSettings);
 
+		qtdata->gSpatialSettings.codecType = rd->qtcodecsettings.codecType;
+		qtdata->gSpatialSettings.codec = (CodecComponent)rd->qtcodecsettings.codec;      
+		qtdata->gSpatialSettings.spatialQuality = (rd->qtcodecsettings.codecSpatialQuality * codecLosslessQuality) /100;
+		qtdata->gTemporalSettings.temporalQuality = (rd->qtcodecsettings.codecTemporalQuality * codecLosslessQuality) /100;
+		qtdata->gTemporalSettings.keyFrameRate = rd->qtcodecsettings.keyFrameRate;   
+		qtdata->aDataRateSetting.dataRate = rd->qtcodecsettings.bitRate;
+		qtdata->gSpatialSettings.depth = rd->qtcodecsettings.colorDepth;
+		qtdata->aDataRateSetting.minSpatialQuality = (rd->qtcodecsettings.minSpatialQuality * codecLosslessQuality) / 100;
+		qtdata->aDataRateSetting.minTemporalQuality = (rd->qtcodecsettings.minTemporalQuality * codecLosslessQuality) / 100;
+		
+		qtdata->aDataRateSetting.frameDuration = rd->frs_sec;
+		SetMovieTimeScale(qtexport->theMovie, rd->frs_sec_base*1000);
+		
+		
 		err = SCSetInfo(qtdata->theComponent, scTemporalSettingsType,	&qtdata->gTemporalSettings);
 		CheckError(err, "SCSetInfo1 error");
 		err = SCSetInfo(qtdata->theComponent, scSpatialSettingsType,	&qtdata->gSpatialSettings);
@@ -647,22 +726,42 @@ int get_qtcodec_settings(RenderData *rd)
 	}
 
 	check_renderbutton_framerate(rd);
+	
+	return err;
+}
 
-	/* Remove this dialog box pop up as this function is called from the render thread
-	 Anyway, all config should be done inside blender ui before starting render.
-	// put up the dialog box - it needs to be called from the main thread
+int request_qtcodec_settings(RenderData *rd)
+{
+	OSErr	err = noErr;
+
+		// put up the dialog box - it needs to be called from the main thread
 	err = SCRequestSequenceSettings(qtdata->theComponent);
  
 	if (err == scUserCancelled) {
-		G.afbreek = 1;
 		return 0;
 	}
 
-	// get user selected data
-	SCGetInfo(qtdata->theComponent, scTemporalSettingsType,	&qtdata->gTemporalSettings);
+		// update runtime codecsettings for use with the codec dialog
+	SCGetInfo(qtdata->theComponent, scDataRateSettingsType,	&qtdata->aDataRateSetting);
 	SCGetInfo(qtdata->theComponent, scSpatialSettingsType,	&qtdata->gSpatialSettings);
-	SCGetInfo(qtdata->theComponent, scDataRateSettingsType,	&qtdata->aDataRateSetting);*/
-
+	SCGetInfo(qtdata->theComponent, scTemporalSettingsType,	&qtdata->gTemporalSettings);
+	
+	
+		//Fill the render QuicktimeCodecSettings struct
+	rd->qtcodecsettings.codecTemporalQuality = (qtdata->gTemporalSettings.temporalQuality * 100) / codecLosslessQuality;
+		//Do not override scene frame rate (qtdata->gTemporalSettings.framerate)
+	rd->qtcodecsettings.keyFrameRate = qtdata->gTemporalSettings.keyFrameRate;
+	
+	rd->qtcodecsettings.codecType = qtdata->gSpatialSettings.codecType;
+	rd->qtcodecsettings.codec = (int)qtdata->gSpatialSettings.codec;
+	rd->qtcodecsettings.colorDepth = qtdata->gSpatialSettings.depth;
+	rd->qtcodecsettings.codecSpatialQuality = (qtdata->gSpatialSettings.spatialQuality * 100) / codecLosslessQuality;
+	
+	rd->qtcodecsettings.bitRate = qtdata->aDataRateSetting.dataRate;
+	rd->qtcodecsettings.minSpatialQuality = (qtdata->aDataRateSetting.minSpatialQuality * 100) / codecLosslessQuality;
+	rd->qtcodecsettings.minTemporalQuality = (qtdata->aDataRateSetting.minTemporalQuality * 100) / codecLosslessQuality;
+		//Frame duration is already known (qtdata->aDataRateSetting.frameDuration)
+	
 	QT_SaveCodecSettingsToScene(rd);
 
 	// framerate jugglin'
@@ -692,11 +791,11 @@ int get_qtcodec_settings(RenderData *rd)
 
 		if ((qtdata->gTemporalSettings.frameRate & 0xffff) == 0) {
 			rd->frs_sec = fps / 65536;
-			rd->frs_sec_base = 1;
+			rd->frs_sec_base = 1.0;
 		} else {
 			/* we do our very best... */
-			rd->frs_sec = (fps * 10000 / 65536);
-			rd->frs_sec_base = 10000;
+			rd->frs_sec = fps  / 65536;
+			rd->frs_sec_base = 1.0;
 		}
 	}
 
diff --git a/source/blender/quicktime/quicktime_export.h b/source/blender/quicktime/quicktime_export.h
index 7972c826190..61153ff91d2 100644
--- a/source/blender/quicktime/quicktime_export.h
+++ b/source/blender/quicktime/quicktime_export.h
@@ -33,19 +33,13 @@
 
 #define __AIFF__
 
-/* Quicktime codec types defines */
-#define QT_CODECTYPE_JPEG				1
-#define QT_CODECTYPE_MJPEGA				2
-#define QT_CODECTYPE_MJPEGB				3
-#define QT_CODECTYPE_DVCPAL				4
-#define QT_CODECTYPE_DVCNTSC			5
-#define QT_CODECTYPE_MPEG4				6
-#define QT_CODECTYPE_H263				7
-#define QT_CODECTYPE_H264				8
-#define QT_CODECTYPE_RAW				9
-#define QT_CODECTYPE_DVCPROHD720p		10
-#define	QT_CODECTYPE_DVCPROHD1080i50	11
-#define QT_CODECTYPE_DVCPROHD1080i60	12
+
+/*Codec list*/
+typedef struct QuicktimeCodecTypeDesc {
+	int codecType;
+	int rnatmpvalue;
+	char * codecName;
+} QuicktimeCodecTypeDesc ;
 
 // quicktime movie output functions
 struct RenderData;
@@ -55,11 +49,100 @@ void start_qt(struct Scene *scene, struct RenderData *rd, int rectx, int recty);
 void append_qt(struct RenderData *rd, int frame, int *pixels, int rectx, int recty);
 void end_qt(void);
 
+/*RNA helper functions */
 void quicktime_verify_image_type(struct RenderData *rd); //used by RNA for defaults values init, if needed
+int quicktime_get_num_codecs();
+QuicktimeCodecTypeDesc* quicktime_get_codecType_desc(int indexValue);
+int quicktime_rnatmpvalue_from_codectype(int codecType);
+int quicktime_codecType_from_rnatmpvalue(int rnatmpvalue);
+
+#ifndef USE_QTKIT
+int request_qtcodec_settings(struct RenderData *rd); //Raise quicktime standard dialog to request codec settings
+#endif
+
 
 void free_qtcomponentdata(void);
 void makeqtstring(struct RenderData *rd, char *string);		//for playanim.c
 
+
+
+#if (defined(USE_QTKIT) && defined(MAC_OS_X_VERSION_10_6) && __LP64__)
+//Include the quicktime codec types constants that are missing in QTKitDefines.h in 10.6 / 64bit
+enum {
+	kRawCodecType						= 'raw ',
+	kCinepakCodecType 					= 'cvid',
+	kGraphicsCodecType					= 'smc ',
+	kAnimationCodecType 				= 'rle ',
+	kVideoCodecType 					= 'rpza',
+	kComponentVideoCodecType			= 'yuv2',
+	kJPEGCodecType						= 'jpeg',
+	kMotionJPEGACodecType 				= 'mjpa',
+	kMotionJPEGBCodecType 				= 'mjpb',
+	kSGICodecType 						= '.SGI',
+	kPlanarRGBCodecType 				= '8BPS',
+	kMacPaintCodecType					= 'PNTG',
+	kGIFCodecType 						= 'gif ',
+	kPhotoCDCodecType 					= 'kpcd',
+	kQuickDrawGXCodecType 				= 'qdgx',
+	kAVRJPEGCodecType 					= 'avr ',
+	kOpenDMLJPEGCodecType 				= 'dmb1',
+	kBMPCodecType 						= 'WRLE',
+	kWindowsRawCodecType				= 'WRAW',
+	kVectorCodecType					= 'path',
+	kQuickDrawCodecType 				= 'qdrw',
+	kWaterRippleCodecType 				= 'ripl',
+	kFireCodecType						= 'fire',
+	kCloudCodecType 					= 'clou',
+	kH261CodecType						= 'h261',
+	kH263CodecType						= 'h263',
+	kDVCNTSCCodecType					= 'dvc ',	/* DV - NTSC and DVCPRO NTSC (available in QuickTime 6.0 or later)*/
+	/* NOTE: kDVCProNTSCCodecType is deprecated.	*/
+	/* Use kDVCNTSCCodecType instead -- as far as the codecs are concerned, */
+	/* the two data formats are identical.*/
+	kDVCPALCodecType					= 'dvcp',
+	kDVCProPALCodecType 				= 'dvpp',	/* available in QuickTime 6.0 or later*/
+	kDVCPro50NTSCCodecType				= 'dv5n',
+	kDVCPro50PALCodecType 				= 'dv5p',
+	kDVCPro100NTSCCodecType 			= 'dv1n',
+	kDVCPro100PALCodecType				= 'dv1p',
+	kDVCPROHD720pCodecType				= 'dvhp',
+	kDVCPROHD1080i60CodecType			= 'dvh6',
+	kDVCPROHD1080i50CodecType			= 'dvh5',
+	kBaseCodecType						= 'base',
+	kFLCCodecType 						= 'flic',
+	kTargaCodecType 					= 'tga ',
+	kPNGCodecType 						= 'png ',
+	kTIFFCodecType						= 'tiff',	/* NOTE: despite what might seem obvious from the two constants*/
+	/* below and their names, they really are correct. 'yuvu' really */
+	/* does mean signed, and 'yuvs' really does mean unsigned. Really. */
+	kComponentVideoSigned 				= 'yuvu',
+	kComponentVideoUnsigned 			= 'yuvs',
+	kCMYKCodecType						= 'cmyk',
+	kMicrosoftVideo1CodecType			= 'msvc',
+	kSorensonCodecType					= 'SVQ1',
+	kSorenson3CodecType 				= 'SVQ3',	/* available in QuickTime 5 and later*/
+	kIndeo4CodecType					= 'IV41',
+	kMPEG4VisualCodecType 				= 'mp4v',
+	k64ARGBCodecType					= 'b64a',
+	k48RGBCodecType 					= 'b48r',
+	k32AlphaGrayCodecType 				= 'b32a',
+	k16GrayCodecType					= 'b16g',
+	kMpegYUV420CodecType				= 'myuv',
+	kYUV420CodecType					= 'y420',
+	kSorensonYUV9CodecType				= 'syv9',
+	k422YpCbCr8CodecType				= '2vuy',	/* Component Y'CbCr 8-bit 4:2:2	*/
+	k444YpCbCr8CodecType				= 'v308',	/* Component Y'CbCr 8-bit 4:4:4	*/
+	k4444YpCbCrA8CodecType				= 'v408',	/* Component Y'CbCrA 8-bit 4:4:4:4 */
+	k422YpCbCr16CodecType 				= 'v216',	/* Component Y'CbCr 10,12,14,16-bit 4:2:2*/
+	k422YpCbCr10CodecType 				= 'v210',	/* Component Y'CbCr 10-bit 4:2:2 */
+	k444YpCbCr10CodecType 				= 'v410',	/* Component Y'CbCr 10-bit 4:4:4 */
+	k4444YpCbCrA8RCodecType 			= 'r408',	/* Component Y'CbCrA 8-bit 4:4:4:4, rendering format. full range alpha, zero biased yuv*/
+	kJPEG2000CodecType					= 'mjp2',
+	kPixletCodecType					= 'pxlt',
+	kH264CodecType						= 'avc1'
+};
+#endif
+
 #endif //(_WIN32) || (__APPLE__)
 
 #endif  // __QUICKTIME_IMP_H__