Max5 API Reference

00001 /* 
00002     jit.qt.codec.c
00003 
00004     Copyright 2001-2005 - Cycling '74
00005     Joshua Kit Clayton jkc@cycling74.com
00006     //added audio codec Jeremy Bernstein jeremy@bootsquad.com
00007     
00008 */
00009 
00010 #if TARGET_RT_MAC_MACHO
00011 #include <QuickTime/ImageCompression.h>
00012 #else
00013 #include <ImageCompression.h>
00014 #include <Sound.h>
00015 #endif
00016 #include "jit.common.h"
00017 #include "jit.qt.codec.h"
00018 #include "ext_obex.h"
00019 
00020 /**
00021  *  @defgroup qtcodecmod QuickTime Codec Module
00022     @ingroup jitter
00023  */
00024 
00025 void jit_qt_codec_init(void);
00026 void jit_qt_codec_free(void);
00027 void jit_qt_codec_gensymbols(void);
00028 void jit_qt_codec_hashtab_create(void);
00029 void jit_qt_codec_jitter_video_hashtab_create(void);
00030 void jit_qt_codec_system_video_hashtab_create(void);
00031 void jit_qt_codec_jitter_audio_hashtab_create(void);
00032 void jit_qt_codec_system_audio_hashtab_create(void);
00033 void jit_qt_codec_jitter_gfx_hashtab_create(void);
00034 void jit_qt_codec_system_gfx_hashtab_create(void);
00035 
00036 t_max_err hashtab_store_safe(t_hashtab *x, t_symbol *key, t_object *val);
00037 
00038 static t_symbol *_jit_sym_codec_nothing;
00039 //type
00040 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_raw;
00041 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_cinepak;
00042 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_graphics;
00043 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_animation;
00044 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_video;
00045 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_componentvideo;
00046 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_jpeg;
00047 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_mjpega;
00048 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_mjpegb;
00049 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_sgi;
00050 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_planarrgb;
00051 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_macpaint;
00052 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_gif;
00053 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_photocd;
00054 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_qdgx;
00055 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_avrjpeg;
00056 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_opendmljpeg;
00057 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_bmp;
00058 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_winraw;
00059 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_vector;
00060 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_qd;
00061 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_h261;
00062 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_h263;
00063 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_dvntsc;
00064 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_dvpal;
00065 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_dvprontsc;
00066 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_dvpropal;
00067 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_flc;
00068 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_targa;
00069 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_png;
00070 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_tiff;
00071 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_componentvideosigned;
00072 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_componentvideounsigned;
00073 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_cmyk;
00074 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_microsoft;
00075 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_sorenson;
00076 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_sorenson3;
00077 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_indeo4;
00078 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_argb64;
00079 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_rgb48;
00080 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_alphagrey32;
00081 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_grey16;
00082 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_mpegyuv420;
00083 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_yuv420;
00084 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_sorensonyuv9;
00085 // qt 6
00086 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_mpeg4;
00087 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_dvcntsc;
00088 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_dvcpal;
00089 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_dvcprontsc;
00090 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_dvcpropal;
00091 // qt 7
00092 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_yuv422;
00093 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_v308;
00094 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_v408;
00095 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_v216;
00096 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_v210;
00097 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_v410;
00098 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_r408;
00099 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_jpeg2000;
00100 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_pixlet;
00101 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_h264;
00102 
00103 //quality
00104 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_lossless;
00105 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_max;
00106 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_min;
00107 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_low;
00108 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_normal;
00109 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_high;
00110 
00111 //audio
00112 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_none;
00113 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_raw;
00114 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_big16;
00115 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_little16;
00116 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_float32;
00117 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_float64;
00118 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_24bit;
00119 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_32bit;
00120 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_little32;
00121 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_mace3;
00122 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_mace6;
00123 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_cdxa4;
00124 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_cdxa2;
00125 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_ima;
00126 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_ulaw;
00127 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_alaw;
00128 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_adpcm;
00129 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_dviima;
00130 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_dvaudio;
00131 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_qdesign;
00132 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_qdesign2;
00133 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_qualcomm;
00134 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_mp3;
00135 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_vdva;
00136 JIT_EX_DATA_DECL t_symbol *_jit_sym_codec_a_mpeg4;
00137 
00138 t_hashtab *_jit_qt_codecs_jitter_gfx = NULL;
00139 t_hashtab *_jit_qt_codecs_system_gfx = NULL;
00140 t_hashtab *_jit_qt_codecs_jitter_video = NULL;
00141 t_hashtab *_jit_qt_codecs_system_video = NULL;
00142 t_hashtab *_jit_qt_codecs_jitter_audio = NULL;
00143 t_hashtab *_jit_qt_codecs_system_audio = NULL;
00144 t_hashtab *_jit_qt_codecs_jitter_gfx_r = NULL;
00145 t_hashtab *_jit_qt_codecs_system_gfx_r = NULL;
00146 t_hashtab *_jit_qt_codecs_jitter_video_r = NULL;
00147 t_hashtab *_jit_qt_codecs_system_video_r = NULL;
00148 t_hashtab *_jit_qt_codecs_jitter_audio_r = NULL;
00149 t_hashtab *_jit_qt_codecs_system_audio_r = NULL;
00150 
00151 void jit_qt_codec_init(void)
00152 {
00153     _jit_qt_codecs_jitter_video = hashtab_new(0);
00154     _jit_qt_codecs_system_video = hashtab_new(0);
00155     _jit_qt_codecs_jitter_audio = hashtab_new(0);
00156     _jit_qt_codecs_system_audio = hashtab_new(0);
00157     _jit_qt_codecs_jitter_gfx = hashtab_new(0);
00158     _jit_qt_codecs_system_gfx = hashtab_new(0);
00159     // reverse-lookup as well
00160     _jit_qt_codecs_jitter_video_r = hashtab_new(0);
00161     _jit_qt_codecs_system_video_r = hashtab_new(0);
00162     _jit_qt_codecs_jitter_audio_r = hashtab_new(0);
00163     _jit_qt_codecs_system_audio_r = hashtab_new(0);
00164     _jit_qt_codecs_jitter_gfx_r = hashtab_new(0);
00165     _jit_qt_codecs_system_gfx_r = hashtab_new(0);
00166 
00167     jit_qt_codec_gensymbols();
00168     jit_qt_codec_hashtab_create();
00169 }
00170 
00171 void jit_qt_codec_free(void)
00172 {
00173     hashtab_chuck(_jit_qt_codecs_jitter_video);
00174     hashtab_chuck(_jit_qt_codecs_system_video);
00175     hashtab_chuck(_jit_qt_codecs_jitter_audio);
00176     hashtab_chuck(_jit_qt_codecs_system_audio);
00177     hashtab_chuck(_jit_qt_codecs_jitter_gfx);
00178     hashtab_chuck(_jit_qt_codecs_system_gfx);
00179     // reverse-lookup as well
00180     hashtab_chuck(_jit_qt_codecs_jitter_video_r);
00181     hashtab_chuck(_jit_qt_codecs_system_video_r);
00182     hashtab_chuck(_jit_qt_codecs_jitter_audio_r);
00183     hashtab_chuck(_jit_qt_codecs_system_audio_r);
00184     hashtab_chuck(_jit_qt_codecs_jitter_gfx_r);
00185     hashtab_chuck(_jit_qt_codecs_system_gfx_r);
00186 }
00187 
00188 void jit_qt_codec_video_hashtab_test(void)
00189 {
00190     Component c;
00191     t_symbol **names = NULL;
00192     long count = 0;
00193     long i;
00194     OSType ctype;
00195     
00196     hashtab_getkeys(_jit_qt_codecs_system_video, &count, &names);
00197     if (count && names) {
00198         for (i = 0; i < count; i++) {
00199             hashtab_lookup(_jit_qt_codecs_system_video, *(names + i), (t_object **)&ctype); 
00200             post("testing %s", (*(names + i))->s_name);
00201             FindCodec(ctype, anyCodec, &c, NULL);
00202             if (!c)
00203                 error("jit.qt.codec: %s is unsupported by the operating system", (*(names + i))->s_name);
00204         }
00205         freebytes(names, sizeof(t_symbol *) * count);
00206     }
00207     count = 0;
00208     names = NULL;
00209     hashtab_getkeys(_jit_qt_codecs_jitter_video, &count, &names);
00210     if (count && names) {
00211         for (i = 0; i < count; i++) {
00212             hashtab_lookup(_jit_qt_codecs_jitter_video, *(names + i), (t_object **)&ctype); 
00213             post("testing %s", (*(names + i))->s_name);
00214             FindCodec(ctype, anyCodec, &c, NULL);
00215             if (!c)
00216                 error("jit.qt.codec: %s is unsupported by the operating system", (*(names + i))->s_name);
00217         }
00218         freebytes(names, sizeof(t_symbol *) * count);
00219     }
00220 }
00221 
00222 void jit_qt_codec_hashtab_create(void)
00223 {
00224     jit_qt_codec_jitter_video_hashtab_create();
00225     jit_qt_codec_system_video_hashtab_create();
00226     jit_qt_codec_jitter_gfx_hashtab_create();
00227     jit_qt_codec_system_gfx_hashtab_create();
00228     jit_qt_codec_jitter_audio_hashtab_create();
00229     jit_qt_codec_system_audio_hashtab_create();
00230 }
00231 
00232 void jit_qt_codec_hashtab_store(t_hashtab *a, t_hashtab *b, void *one, void *two)
00233 {
00234     hashtab_store_safe(a, one, two);
00235     hashtab_store_safe(b, two, one);
00236 }
00237 
00238 void jit_qt_codec_jitter_video_hashtab_create(void)
00239 {
00240     // first, add all of the "known" codecs - we're just using the FOUR_CHAR_CODE in the thing field
00241     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_raw, (void *)kRawCodecType);
00242     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_bmp, (void *)kBMPCodecType);
00243     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_cinepak, (void *)kCinepakCodecType);
00244     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_graphics, (void *)kGraphicsCodecType);
00245     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_animation, (void *)kAnimationCodecType);
00246     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_video, (void *)kVideoCodecType);
00247     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_componentvideo, (void *)kComponentVideoCodecType);
00248     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_jpeg, (void *)kJPEGCodecType);
00249     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_mjpega, (void *)kMotionJPEGACodecType);
00250     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_mjpegb, (void *)kMotionJPEGBCodecType);
00251     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_sgi, (void *)kSGICodecType);
00252     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_planarrgb, (void *)kPlanarRGBCodecType);
00253     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_macpaint, (void *)kMacPaintCodecType);
00254     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_gif, (void *)kGIFCodecType);
00255     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_photocd, (void *)kPhotoCDCodecType);
00256     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_qdgx, (void *)kQuickDrawGXCodecType);
00257     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_avrjpeg, (void *)kAVRJPEGCodecType);
00258     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_opendmljpeg, (void *)kOpenDMLJPEGCodecType);
00259     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_winraw, (void *)kWindowsRawCodecType);
00260     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_vector, (void *)kVectorCodecType);
00261     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_qd, (void *)kQuickDrawCodecType);
00262     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_h261, (void *)kH261CodecType);
00263     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_h263, (void *)kH263CodecType);
00264     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_dvntsc, (void *)kDVCNTSCCodecType);
00265     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_dvpal, (void *)kDVCPALCodecType);
00266 //  jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_dvprontsc, (void *)kDVCProNTSCCodecType);
00267     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_dvpropal, (void *)kDVCProPALCodecType);
00268     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_flc, (void *)kFLCCodecType);
00269     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_targa, (void *)kTargaCodecType);
00270     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_png, (void *)kPNGCodecType);
00271     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_tiff, (void *)kTIFFCodecType);
00272     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_componentvideosigned, (void *)kComponentVideoSigned);
00273     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_componentvideounsigned, (void *)kComponentVideoUnsigned);
00274     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_cmyk, (void *)kCMYKCodecType);
00275     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_microsoft, (void *)kMicrosoftVideo1CodecType);
00276     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_sorenson, (void *)kSorensonCodecType);
00277     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_sorenson3, (void *)kSorenson3CodecType);
00278     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_indeo4, (void *)kIndeo4CodecType);
00279     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_argb64, (void *)k64ARGBCodecType);
00280     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_rgb48, (void *)k48RGBCodecType);
00281     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_alphagrey32, (void *)k32AlphaGrayCodecType);
00282     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_grey16, (void *)k16GrayCodecType);
00283     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_mpegyuv420, (void *)kMpegYUV420CodecType);
00284     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_yuv420, (void *)kYUV420CodecType);
00285     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_sorensonyuv9, (void *)kSorensonYUV9CodecType);
00286     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_mpeg4, (void *)/*kMPEG4VisualCodecType*/FOUR_CHAR_CODE('mp4v'));
00287     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_yuv422, (void *)k422YpCbCr8CodecType);
00288     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_v308, (void *)k444YpCbCr8CodecType);
00289     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_v408, (void *)k4444YpCbCrA8CodecType);
00290     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_v216, (void *)k422YpCbCr16CodecType);
00291     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_v210, (void *)k422YpCbCr10CodecType);
00292     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_v410, (void *)k444YpCbCr10CodecType);
00293     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_r408, (void *)k4444YpCbCrA8RCodecType);
00294     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_jpeg2000, (void *)/*kJPEG2000CodecType*/FOUR_CHAR_CODE('mjp2'));
00295 //  disabled until we can support frame-reordered video
00296 //  jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_pixlet, (void *)/*kPixletCodecType*/FOUR_CHAR_CODE('pxlt'));
00297 //  jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_video, _jit_qt_codecs_jitter_video_r, _jit_sym_codec_h264, (void *)/*kH264CodecType*/FOUR_CHAR_CODE('avc1'));
00298 }
00299 
00300 void jit_qt_codec_name_format(char *cstr)
00301 {
00302     char tmp[32];
00303     char *ptmp = tmp;
00304 
00305     strcpy(tmp, cstr);
00306     *cstr = 0;
00307     while (*ptmp) {
00308         if (*ptmp >= 65 && *ptmp <= 90)
00309             *cstr++ = *ptmp + 32;
00310         else if (*ptmp == 32) {
00311             if (*(ptmp + 1) == '-' && *(ptmp + 2) == 32) {
00312                 *cstr = '_';
00313                 ptmp += 2;
00314             }
00315             else
00316                 *cstr++ = '_';
00317         }
00318         else if (*ptmp == '-' || *ptmp == '.' || *ptmp == ':')
00319             ;
00320         else
00321             *cstr++ = *ptmp;
00322         ptmp++;
00323     }
00324     *cstr = 0;
00325 }
00326 
00327 void jit_qt_codec_system_video_hashtab_create(void)
00328 {
00329     CodecNameSpecListPtr list;
00330     char cstr[32];
00331     long i;
00332     
00333     GetCodecNameList(&list, 1);
00334     for (i = 0; i < list->count; i++) {
00335         ptoccpy(cstr, list->list[i].typeName);
00336         jit_qt_codec_name_format(cstr);
00337         jit_qt_codec_hashtab_store(_jit_qt_codecs_system_video, _jit_qt_codecs_system_video_r, gensym(cstr), (void *)list->list[i].cType);
00338     }
00339     DisposeCodecNameList(list);
00340 }
00341 
00342 void jit_qt_codec_system_gfx_hashtab_create(void)
00343 {
00344     char cstr[256];
00345     ComponentDescription cd;
00346     Component c = NULL;
00347     Handle h;
00348     
00349     cd.componentType            = GraphicsExporterComponentType;
00350     cd.componentSubType         = 0;
00351     cd.componentManufacturer    = 0;
00352     cd.componentFlags           = 0;
00353     cd.componentFlagsMask       = 0;
00354     
00355     h = NewHandle(0);
00356     while (c = FindNextComponent(c,&cd)) {
00357         GetComponentInfo(c, &cd, h, NULL, NULL);
00358         ptoccpy(cstr, (unsigned char *)*h);
00359         jit_qt_codec_name_format(cstr);
00360         jit_qt_codec_hashtab_store(_jit_qt_codecs_system_gfx, _jit_qt_codecs_system_gfx_r, gensym(cstr), (void *)cd.componentSubType);
00361         cd.componentSubType         = 0;
00362         cd.componentManufacturer    = 0;
00363         cd.componentFlags           = 0;
00364         cd.componentFlagsMask       = 0;
00365     }
00366     DisposeHandle(h);   
00367 }
00368 
00369 void jit_qt_codec_jitter_gfx_hashtab_create(void)
00370 {
00371 
00372 }
00373 
00374 void jit_qt_codec_jitter_audio_hashtab_create(void)
00375 {
00376     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_none, (void *)kSoundNotCompressed);
00377     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_raw, (void *)k8BitOffsetBinaryFormat);
00378     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_big16, (void *)k16BitBigEndianFormat);
00379     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_little16, (void *)k16BitLittleEndianFormat);
00380     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_float32, (void *)kFloat32Format);
00381     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_float64, (void *)kFloat64Format);
00382     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_24bit, (void *)k24BitFormat);
00383     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_32bit, (void *)k32BitFormat);
00384     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_little32, (void *)k32BitLittleEndianFormat);
00385     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_mace3, (void *)kMACE3Compression);
00386     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_mace6, (void *)kMACE6Compression);
00387     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_cdxa4, (void *)kCDXA4Compression);
00388     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_cdxa2, (void *)kCDXA2Compression);
00389     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_ima, (void *)kIMACompression);
00390     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_ulaw, (void *)kULawCompression);
00391     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_alaw, (void *)kALawCompression);
00392     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_adpcm, (void *)kMicrosoftADPCMFormat);
00393     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_dviima, (void *)kDVIIntelIMAFormat);
00394     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_dvaudio, (void *)kDVAudioFormat);
00395     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_qdesign, (void *)kQDesignCompression);
00396     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_qdesign2, (void *)kQDesign2Compression);
00397     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_qualcomm, (void *)kQUALCOMMCompression);
00398     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_mp3, (void *)kFullMPEGLay3Format);
00399     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_vdva, (void *)/*kVariableDurationDVAudioFormat*/FOUR_CHAR_CODE('vdva'));
00400     jit_qt_codec_hashtab_store(_jit_qt_codecs_jitter_audio, _jit_qt_codecs_jitter_audio_r, _jit_sym_codec_a_mpeg4, (void *)/*kMPEG4AudioFormat*/FOUR_CHAR_CODE('mp4a'));
00401 }
00402 
00403 void jit_qt_codec_system_audio_hashtab_create(void)
00404 {
00405     char cstr[256];
00406     ComponentDescription cd;
00407     Component c = NULL;
00408     Handle h;
00409     
00410     cd.componentType            = kSoundCompressor;
00411     cd.componentSubType         = 0;
00412     cd.componentManufacturer    = 0;
00413     cd.componentFlags           = 0;
00414     cd.componentFlagsMask       = 0;
00415     
00416     h = NewHandle(0);
00417     while (c = FindNextComponent(c,&cd)) {
00418         GetComponentInfo(c, &cd, h, NULL, NULL);
00419         if (*h) {       // rbs -- was crashing due to NULL in (*h) here, possibly started after installing ffdshow codecs
00420             ptoccpy(cstr, (unsigned char *)*h);
00421             jit_qt_codec_name_format(cstr);
00422             jit_qt_codec_hashtab_store(_jit_qt_codecs_system_audio, _jit_qt_codecs_system_audio_r, gensym(cstr), (void *)cd.componentSubType);
00423             cd.componentSubType         = 0;
00424             cd.componentManufacturer    = 0;
00425             cd.componentFlags           = 0;
00426             cd.componentFlagsMask       = 0;
00427         }
00428     }
00429     DisposeHandle(h);
00430 }
00431 
00432 /**
00433  * Drop-in getter function for "codeclist"-type attribute, returns the list of 
00434  * valid video codecs installed on the system.
00435  *
00436  * @ingroup qtcodecmod 
00437  *
00438  * @param   x           undocumented
00439  * @param   attr        undocumented
00440  * @param   ac          undocumented
00441  * @param   av          undocumented
00442  * 
00443  * @return  t_jit_err error code
00444  *
00445  */
00446 t_jit_err jit_qt_codec_getcodeclist_video(void *x, void *attr, long *ac, t_atom **av)
00447 {
00448 //  jit_qt_codec_video_hashtab_test();
00449     if (ac && av) {
00450         if ((*ac) && (*av)) {
00451             // use incoming memory
00452         } else {
00453             t_symbol **names = NULL;
00454             long count = 0;
00455             long i;
00456             
00457             hashtab_getkeys(_jit_qt_codecs_system_video, &count, &names);
00458             if (count && names) {
00459                 *ac = count;
00460                 if (!(*av = jit_getbytes(sizeof(t_atom) * (*ac)))) {
00461                     *ac = 0;
00462                     freebytes(names, sizeof(t_symbol *) * count);
00463                     return JIT_ERR_OUT_OF_MEM;
00464                 }
00465                 symbolarray_sort(count, names);
00466                 for (i = 0; i < count; i++) {
00467                     jit_atom_setsym(*av + i, names[i]);
00468                 }
00469                 freebytes(names, sizeof(t_symbol *) * count);
00470             }
00471         }
00472     }
00473     return JIT_ERR_NONE;
00474 }
00475 
00476 /**
00477  * Drop-in getter function for "codeclist"-type attribute, returns the list of 
00478  * valid sound compressor codecs installed on the system.
00479  *
00480  * @ingroup qtcodecmod 
00481  *
00482  * @param   x           undocumented
00483  * @param   attr        undocumented
00484  * @param   ac          undocumented
00485  * @param   av          undocumented
00486  * 
00487  * @return  t_jit_err error code
00488  *
00489  */
00490 t_jit_err jit_qt_codec_getcodeclist_audio(void *x, void *attr, long *ac, t_atom **av)
00491 {
00492     if (ac && av) {
00493         if ((*ac) && (*av)) {
00494             // use incoming memory
00495         } else {
00496             t_symbol **names = NULL;
00497             long count = 0;
00498             long i;
00499             
00500             hashtab_getkeys(_jit_qt_codecs_system_audio, &count, &names);
00501             if (count && names) {
00502                 *ac = count;
00503                 if (!(*av = jit_getbytes(sizeof(t_atom) * (*ac)))) {
00504                     *ac = 0;
00505                     freebytes(names, sizeof(t_symbol *) * count);
00506                     return JIT_ERR_OUT_OF_MEM;
00507                 }
00508                 symbolarray_sort(count, names);
00509                 for (i = 0; i < count; i++) {
00510                     jit_atom_setsym(*av + i, names[i]);
00511                 }
00512                 freebytes(names, sizeof(t_symbol *) * count);
00513             }
00514         }
00515     }
00516     return JIT_ERR_NONE;
00517 }
00518 
00519 /**
00520  * Drop-in getter function for "codeclist"-type attribute, returns the list of 
00521  * valid graphic exporter codecs installed on the system.
00522  *
00523  * @ingroup qtcodecmod 
00524  *
00525  * @param   x           undocumented
00526  * @param   attr        undocumented
00527  * @param   ac          undocumented
00528  * @param   av          undocumented
00529  * 
00530  * @return  t_jit_err error code
00531  *
00532  */
00533 t_jit_err jit_qt_codec_getcodeclist_gfx(void *x, void *attr, long *ac, t_atom **av)
00534 {
00535     if (ac && av) {
00536         if ((*ac) && (*av)) {
00537             // use incoming memory
00538         } else {
00539             t_symbol **names = NULL;
00540             long count = 0;
00541             long i;
00542             
00543             hashtab_getkeys(_jit_qt_codecs_system_gfx, &count, &names);
00544             if (count && names) {
00545                 *ac = count;
00546                 if (!(*av = jit_getbytes(sizeof(t_atom) * (*ac)))) {
00547                     *ac = 0;
00548                     freebytes(names, sizeof(t_symbol *) * count);
00549                     return JIT_ERR_OUT_OF_MEM;
00550                 }
00551                 symbolarray_sort(count, names);
00552                 for (i = 0; i < count; i++) {
00553                     jit_atom_setsym(*av + i, names[i]);
00554                 }
00555                 freebytes(names, sizeof(t_symbol *) * count);
00556             }
00557         }
00558     }
00559     return JIT_ERR_NONE;
00560 }
00561 
00562 /**
00563  * Returns the list of valid video codecs installed on the system.
00564  *
00565  * @ingroup qtcodecmod 
00566  *
00567  * @param   count       (on output) number of codec names returned
00568  * @param   names       (on output) t_symbol pointer array of (count) length, containing
00569  *                      the names of valid installed codecs
00570  * 
00571  */
00572 void jit_qt_codec_getcodeclist_video_raw(long *count, t_symbol ***names)
00573 {
00574     hashtab_getkeys(_jit_qt_codecs_system_video, count, names);
00575 /*  
00576     long tmpcount_j = 0, tmpcount_s = 0;
00577     t_symbol **tmpnames_j = NULL, **tmpnames_s = NULL;
00578     long i, j;
00579     long type;
00580     char *ctype;
00581     
00582     if (count && names) {
00583         hashtab_getkeys(_jit_qt_codecs_system_video, &tmpcount_s, &tmpnames_s);
00584         hashtab_getkeys(_jit_qt_codecs_jitter_video, &tmpcount_j, &tmpnames_j);
00585         symbolarray_sort(tmpcount_s, tmpnames_s);
00586         symbolarray_sort(tmpcount_j, tmpnames_j);
00587         *count = tmpcount_s + tmpcount_j;
00588         *names = (t_symbol **)jit_getbytes(sizeof(t_symbol *) * (*count));
00589         for (i = 0, j = 0; i < tmpcount_s; i++, j++) {
00590             hashtab_lookup(_jit_qt_codecs_system_video, tmpnames_s[i], (t_object **)&type);
00591 //          ctype = (char *)&type;
00592 //          jit_object_post((t_object *)x,"%s (%c%c%c%c)", tmpnames_s[i]->s_name, *ctype, *(ctype + 1), *(ctype + 2), *(ctype + 3));
00593             (*names)[j] = tmpnames_s[i];
00594         }
00595         for (i = 0; i < tmpcount_j; i++, j++) {
00596             hashtab_lookup(_jit_qt_codecs_jitter_video, tmpnames_j[i], (t_object **)&type);
00597 //          ctype = (char *)&type;
00598 //          jit_object_post((t_object *)x,"%s (%c%c%c%c)", tmpnames_j[i]->s_name, *ctype, *(ctype + 1), *(ctype + 2), *(ctype + 3));
00599             (*names)[j] = tmpnames_j[i];
00600         }
00601         freebytes(tmpnames_s, sizeof(t_symbol *) * tmpcount_s);
00602         freebytes(tmpnames_j, sizeof(t_symbol *) * tmpcount_j);
00603     } */
00604 }
00605 
00606 /**
00607  * Returns the list of valid sound compressor codecs installed on the system.
00608  *
00609  * @ingroup qtcodecmod 
00610  *
00611  * @param   count       (on output) number of codec names returned
00612  * @param   names       (on output) t_symbol pointer array of (count) length, containing
00613  *                      the names of valid installed codecs
00614  * 
00615  */
00616 void jit_qt_codec_getcodeclist_audio_raw(long *count, t_symbol ***names)
00617 {
00618     hashtab_getkeys(_jit_qt_codecs_system_audio, count, names);
00619 /*
00620     long tmpcount_j = 0, tmpcount_s = 0;
00621     t_symbol **tmpnames_j = NULL, **tmpnames_s = NULL;
00622     long i, j;
00623     long type;
00624     char *ctype;
00625     
00626     if (count && names) {
00627         hashtab_getkeys(_jit_qt_codecs_system_audio, &tmpcount_s, &tmpnames_s);
00628         hashtab_getkeys(_jit_qt_codecs_jitter_audio, &tmpcount_j, &tmpnames_j);
00629         symbolarray_sort(tmpcount_s, tmpnames_s);
00630         symbolarray_sort(tmpcount_j, tmpnames_j);
00631         *count = tmpcount_s + tmpcount_j;
00632         *names = (t_symbol **)jit_getbytes(sizeof(t_symbol *) * (*count));
00633         for (i = 0, j = 0; i < tmpcount_s; i++, j++) {
00634             hashtab_lookup(_jit_qt_codecs_system_audio, tmpnames_s[i], (t_object **)&type);
00635 //          ctype = (char *)&type;
00636 //          jit_object_post((t_object *)x,"%s (%c%c%c%c)", tmpnames_s[i]->s_name, *ctype, *(ctype + 1), *(ctype + 2), *(ctype + 3));
00637             (*names)[j] = tmpnames_s[i];
00638         }
00639         for (i = 0; i < tmpcount_j; i++, j++) {
00640             hashtab_lookup(_jit_qt_codecs_jitter_audio, tmpnames_j[i], (t_object **)&type);
00641 //          ctype = (char *)&type;
00642 //          jit_object_post((t_object *)x,"%s (%c%c%c%c)", tmpnames_j[i]->s_name, *ctype, *(ctype + 1), *(ctype + 2), *(ctype + 3));
00643             (*names)[j] = tmpnames_j[i];
00644         }
00645         freebytes(tmpnames_s, sizeof(t_symbol *) * tmpcount_s);
00646         freebytes(tmpnames_j, sizeof(t_symbol *) * tmpcount_j);
00647     } */
00648 }
00649 
00650 /**
00651  * Returns the list of valid graphic exporter codecs installed on the system.
00652  *
00653  * @ingroup qtcodecmod 
00654  *
00655  * @param   count       (on output) number of codec names returned
00656  * @param   names       (on output) t_symbol pointer array of (count) length, containing
00657  *                      the names of valid installed codecs
00658  * 
00659  */
00660 void jit_qt_codec_getcodeclist_gfx_raw(long *count, t_symbol ***names)
00661 {
00662     hashtab_getkeys(_jit_qt_codecs_system_gfx, count, names);
00663 /*
00664     long tmpcount_j = 0, tmpcount_s = 0;
00665     t_symbol **tmpnames_j = NULL, **tmpnames_s = NULL;
00666     long i, j;
00667     long type;
00668     char *ctype;
00669     
00670     if (count && names) {
00671         *count = 0;
00672         *names = NULL;
00673         hashtab_getkeys(_jit_qt_codecs_system_gfx, &tmpcount_s, &tmpnames_s);
00674         hashtab_getkeys(_jit_qt_codecs_jitter_gfx, &tmpcount_j, &tmpnames_j);
00675         symbolarray_sort(tmpcount_s, tmpnames_s);
00676         symbolarray_sort(tmpcount_j, tmpnames_j);
00677 //      *count = tmpcount_s + tmpcount_j;
00678 //      *names = (t_symbol **)jit_getbytes(sizeof(t_symbol *) * (*count));
00679         for (i = 0, j = 0; i < tmpcount_s; i++, j++) {
00680             hashtab_lookup(_jit_qt_codecs_system_gfx, tmpnames_s[i], (t_object **)&type);
00681             ctype = (char *)&type;
00682             jit_object_post((t_object *)x,"%s (%c%c%c%c)", tmpnames_s[i]->s_name, *ctype, *(ctype + 1), *(ctype + 2), *(ctype + 3));
00683 //          (*names)[j] = tmpnames_s[i];
00684         }
00685         for (i = 0; i < tmpcount_j; i++, j++) {
00686             hashtab_lookup(_jit_qt_codecs_jitter_gfx, tmpnames_j[i], (t_object **)&type);
00687             ctype = (char *)&type;
00688             jit_object_post((t_object *)x,"%s (%c%c%c%c)", tmpnames_j[i]->s_name, *ctype, *(ctype + 1), *(ctype + 2), *(ctype + 3));
00689 //          (*names)[j] = tmpnames_j[i];
00690         }
00691         freebytes(tmpnames_s, sizeof(t_symbol *) * tmpcount_s);
00692         freebytes(tmpnames_j, sizeof(t_symbol *) * tmpcount_j);
00693     } */
00694 }
00695 
00696 void jit_qt_codec_gensymbols(void)
00697 {
00698     _jit_sym_codec_nothing              = gensym("");
00699     _jit_sym_codec_raw                  = gensym("raw");
00700     _jit_sym_codec_cinepak              = gensym("cinepak");
00701     _jit_sym_codec_graphics             = gensym("graphics");
00702     _jit_sym_codec_animation            = gensym("animation");  
00703     _jit_sym_codec_video                = gensym("video");
00704     _jit_sym_codec_componentvideo       = gensym("componentvideo");
00705     _jit_sym_codec_jpeg                 = gensym("jpeg");
00706     _jit_sym_codec_mjpega               = gensym("mjpega");
00707     _jit_sym_codec_mjpegb               = gensym("mjpegb");
00708     _jit_sym_codec_sgi                  = gensym("sgi");
00709     _jit_sym_codec_planarrgb            = gensym("planarrgb");
00710     _jit_sym_codec_macpaint             = gensym("macpaint");
00711     _jit_sym_codec_gif                  = gensym("gif");    
00712     _jit_sym_codec_photocd              = gensym("photocd");
00713     _jit_sym_codec_qdgx                 = gensym("qdgx");
00714     _jit_sym_codec_avrjpeg              = gensym("avrjpeg");
00715     _jit_sym_codec_opendmljpeg          = gensym("opendmljpeg");
00716     _jit_sym_codec_bmp                  = gensym("bmp");
00717     _jit_sym_codec_winraw               = gensym("winraw");
00718     _jit_sym_codec_vector               = gensym("vector");
00719     _jit_sym_codec_qd                   = gensym("qd");
00720     _jit_sym_codec_h261                 = gensym("h261");
00721     _jit_sym_codec_h263                 = gensym("h263");
00722     _jit_sym_codec_dvntsc               = gensym("dvntsc");
00723     _jit_sym_codec_dvpal                = gensym("dvpal");
00724     _jit_sym_codec_dvprontsc            = gensym("dvprontsc");
00725     _jit_sym_codec_dvpropal             = gensym("dvpropal");
00726     _jit_sym_codec_flc                  = gensym("flc");
00727     _jit_sym_codec_targa                = gensym("targa");
00728     _jit_sym_codec_png                  = gensym("png");
00729     _jit_sym_codec_tiff                 = gensym("tiff");
00730     _jit_sym_codec_componentvideosigned = gensym("componentvideosigned");
00731     _jit_sym_codec_componentvideounsigned = gensym("componentvideounsigned");
00732     _jit_sym_codec_cmyk                 = gensym("cmyk");
00733     _jit_sym_codec_microsoft            = gensym("microsoft");
00734     _jit_sym_codec_sorenson             = gensym("sorenson");
00735     _jit_sym_codec_sorenson3            = gensym("sorenson3");
00736     _jit_sym_codec_indeo4               = gensym("indeo4");
00737     _jit_sym_codec_argb64               = gensym("argb64");
00738     _jit_sym_codec_rgb48                = gensym("rgb48");
00739     _jit_sym_codec_alphagrey32          = gensym("alphagrey32");
00740     _jit_sym_codec_grey16               = gensym("grey16");
00741     _jit_sym_codec_mpegyuv420           = gensym("mpegyuv420");
00742     _jit_sym_codec_yuv420               = gensym("yuv420");
00743     _jit_sym_codec_sorensonyuv9         = gensym("sorensonyuv9");
00744     _jit_sym_codec_mpeg4                = gensym("mpeg4");
00745     _jit_sym_codec_dvcntsc              = gensym("dvcntsc");
00746     _jit_sym_codec_dvcpal               = gensym("dvcpal");
00747     _jit_sym_codec_dvcprontsc           = gensym("dvcprontsc");
00748     _jit_sym_codec_dvcpropal            = gensym("dvcpropal");
00749     _jit_sym_codec_yuv422               = gensym("yuv422");
00750     _jit_sym_codec_v308                 = gensym("v308");
00751     _jit_sym_codec_v408                 = gensym("v408");   
00752     _jit_sym_codec_v216                 = gensym("v216");
00753     _jit_sym_codec_v210                 = gensym("v210");
00754     _jit_sym_codec_v410                 = gensym("v410");
00755     _jit_sym_codec_r408                 = gensym("r408");
00756     _jit_sym_codec_jpeg2000             = gensym("jpeg2000");
00757     _jit_sym_codec_pixlet               = gensym("pixlet");
00758     _jit_sym_codec_h264                 = gensym("h264");
00759 
00760     //quality
00761     _jit_sym_codec_lossless             = gensym("lossless");
00762     _jit_sym_codec_max                  = gensym("max");
00763     _jit_sym_codec_min                  = gensym("min");
00764     _jit_sym_codec_low                  = gensym("low");
00765     _jit_sym_codec_normal               = gensym("normal");
00766     _jit_sym_codec_high                 = gensym("high");
00767     
00768     //audio
00769     _jit_sym_codec_a_none               = gensym("none");
00770     _jit_sym_codec_a_raw                = gensym("raw");
00771     _jit_sym_codec_a_big16              = gensym("big16");
00772     _jit_sym_codec_a_little16           = gensym("little16");
00773     _jit_sym_codec_a_float32            = gensym("float32");
00774     _jit_sym_codec_a_float64            = gensym("float64");
00775     _jit_sym_codec_a_24bit              = gensym("24bit");
00776     _jit_sym_codec_a_32bit              = gensym("32bit");
00777     _jit_sym_codec_a_little32           = gensym("little32");
00778     _jit_sym_codec_a_mace3              = gensym("mace3");
00779     _jit_sym_codec_a_mace6              = gensym("mace6");
00780     _jit_sym_codec_a_cdxa4              = gensym("cdxa4");
00781     _jit_sym_codec_a_cdxa2              = gensym("cdxa2");
00782     _jit_sym_codec_a_ima                = gensym("ima");
00783     _jit_sym_codec_a_ulaw               = gensym("ulaw");
00784     _jit_sym_codec_a_alaw               = gensym("alaw");
00785     _jit_sym_codec_a_adpcm              = gensym("adpcm");
00786     _jit_sym_codec_a_dviima             = gensym("dviima");
00787     _jit_sym_codec_a_dvaudio            = gensym("dvaudio");
00788     _jit_sym_codec_a_qdesign            = gensym("qdesign");
00789     _jit_sym_codec_a_qdesign2           = gensym("qdesign2");
00790     _jit_sym_codec_a_qualcomm           = gensym("qualcomm");
00791     _jit_sym_codec_a_mp3                = gensym("mp3");
00792     _jit_sym_codec_a_vdva               = gensym("vdva");
00793     _jit_sym_codec_a_mpeg4              = gensym("mpeg4");
00794 }
00795 
00796 /**
00797  * Convert a QuickTime Codec Quality value to a human-readable symbol
00798  *
00799  * @ingroup qtcodecmod 
00800  *
00801  * @param   qual        QuickTime Codec Quality
00802  *
00803  * @return  t_symbol pointer containing a human-readable quality name
00804  *          (lossless, min, low, normal, high, max)
00805  * 
00806  */
00807 t_symbol *jit_qt_codec_qual2sym(long qual) 
00808 {
00809     t_symbol *s=_jit_sym_codec_max;
00810     
00811     switch (qual) {
00812     case codecLosslessQuality:  s = _jit_sym_codec_lossless;    break;
00813     case codecMinQuality:       s = _jit_sym_codec_min;         break;
00814     case codecLowQuality:       s = _jit_sym_codec_low;         break;
00815     case codecNormalQuality:    s = _jit_sym_codec_normal;      break;
00816     case codecHighQuality:      s = _jit_sym_codec_high;        break;
00817     case codecMaxQuality:       s = _jit_sym_codec_max;         break;
00818     }   
00819     
00820     return s;
00821 }
00822 
00823 /**
00824  * Convert a codec quality symbol to a valid QuickTime Codec Quality value
00825  *
00826  * @ingroup qtcodecmod 
00827  *
00828  * @param   s       codec quality name
00829  *                  (lossless, min, low, normal, high, max)
00830  *
00831  * @return  QuickTime Codec Quality
00832  * 
00833  */
00834 long jit_qt_codec_sym2qual(t_symbol *s) 
00835 {
00836     long qual=codecMaxQuality;
00837     
00838     if (s == _jit_sym_codec_nothing)
00839         qual = codecMaxQuality;
00840     else if (s == _jit_sym_codec_lossless)
00841         qual = codecLosslessQuality;
00842     else if (s == _jit_sym_codec_max)
00843         qual = codecMaxQuality;
00844     else if (s == _jit_sym_codec_min)
00845         qual = codecMinQuality;
00846     else if (s == _jit_sym_codec_low)
00847         qual = codecLowQuality;
00848     else if (s == _jit_sym_codec_normal)
00849         qual = codecNormalQuality;
00850     else if (s == _jit_sym_codec_high)
00851         qual = codecHighQuality;
00852 
00853     return qual;
00854 }
00855 
00856 /*
00857 codecLosslessQuality        = 0x00000400,
00858 codecMaxQuality             = 0x000003FF,
00859 codecMinQuality             = 0x00000000,
00860 codecLowQuality             = 0x00000100,
00861 codecNormalQuality          = 0x00000200,
00862 codecHighQuality            = 0x00000300
00863 */
00864 
00865 
00866 /**
00867  * Given the four-char type code of a QuickTime video codec, returns a human-readable
00868  * name, assuming that the codec is installed _and_ is supported by Jitter.
00869  *
00870  * @ingroup qtcodecmod 
00871  *
00872  * @param   type        four-char type code of a QuickTime Codec
00873  *
00874  * @return  t_symbol pointer containing a human-readable codec name
00875  * 
00876  */
00877 t_symbol *jit_qt_codec_type2sym_valid(long type) 
00878 {
00879     t_symbol *s = _jit_sym_codec_nothing;
00880     CodecInfo cinfo;
00881     Component c = NULL;
00882     OSErr err;
00883     
00884     hashtab_lookup(_jit_qt_codecs_system_video_r, (t_symbol *)type, (t_object **)&s);
00885 
00886     if (s != _jit_sym_codec_nothing) {
00887         // test the codec actual has a compressor
00888         FindCodec(type, anyCodec, &c, NULL);
00889         if (!c) {
00890 //          error("jit.qt.codec: chosen codec is unsupported by the operating system");
00891             return _jit_sym_codec_nothing;
00892         }
00893         // make sure that the codec doesn't do frame reordering
00894         err = GetCodecInfo(&cinfo, type, c);
00895         if (err) {
00896 //          error("jit.qt.codec: error %d getting codec info", err);
00897             return _jit_sym_codec_nothing;
00898         }   
00899         if (cinfo.compressFlags & codecInfoDoesBlend) { //  codecInfoDoesReorder          = (1L << 19), /* codec can rearrange frames during compression */
00900 //          error("jit.qt.codec: chosen codec is unsupported by Jitter");
00901             return _jit_sym_codec_nothing;
00902         }
00903 //      if (cinfo.compressFlags & codecInfoDoesWarp) //   codecInfoDoesMultiPass        = (1L << 20), /* codec can perform multi-pass compression */
00904 //          jit_object_post((t_object *)x,"codec does multipass");
00905 //      if (cinfo.formatFlags & codecInfoSequenceSensitive)
00906 //          jit_object_post((t_object *)x,"codec is sequence sensitive");
00907     }
00908     return ((s) ? s : _jit_sym_codec_nothing);
00909 }
00910 
00911 /**
00912  * Given the four-char type code of a QuickTime video codec, returns a human-readable
00913  * name, assuming that the codec is installed.
00914  *
00915  * @ingroup qtcodecmod 
00916  *
00917  * @param   type        four-char type code of a QuickTime Codec
00918  *
00919  * @return  t_symbol pointer containing a human-readable codec name
00920  * 
00921  */
00922 t_symbol *jit_qt_codec_type2sym(long type) 
00923 {
00924     t_symbol *s = _jit_sym_codec_nothing;
00925     
00926     if (hashtab_lookup(_jit_qt_codecs_system_video_r, (t_symbol *)type, (t_object **)&s))
00927         hashtab_lookup(_jit_qt_codecs_jitter_video_r, (t_symbol *)type, (t_object **)&s);
00928 
00929     return ((s) ? s : _jit_sym_codec_nothing);
00930 }
00931 
00932 /**
00933  * Given the human-readable name of a QuickTime video codec, returns a four-char code, 
00934  * assuming that the codec is installed _and_ is supported by Jitter.
00935  *
00936  * @ingroup qtcodecmod 
00937  *
00938  * @param   s       human-readable name of a QuickTime Codec (as returned by 
00939  *                  "jit_qt_codec_getcodeclist_video_raw" or similar)
00940  *
00941  * @return  long four-char code
00942  * 
00943  */
00944 long jit_qt_codec_sym2type_valid(t_symbol *s) 
00945 {
00946     long type = 0L;
00947     CodecInfo cinfo;
00948     Component c = NULL;
00949     OSErr err;
00950     
00951     hashtab_lookup(_jit_qt_codecs_system_video, s, (t_object **)&type);
00952     if (!type)
00953         hashtab_lookup(_jit_qt_codecs_jitter_video, s, (t_object **)&type);
00954     
00955     if (type) {
00956         // test the codec actual has a compressor
00957         FindCodec(type, anyCodec, &c, NULL);
00958         if (!c) {
00959 //          error("jit.qt.codec: chosen codec is unsupported by the operating system");
00960             return 0L;
00961         }
00962         // make sure that the codec doesn't do frame reordering
00963         err = GetCodecInfo(&cinfo, type, c);
00964         if (err) {
00965 //          error("jit.qt.codec: error %d getting codec info", err);
00966             return 0L;
00967         }   
00968         if (cinfo.compressFlags & codecInfoDoesBlend) { //  codecInfoDoesReorder          = (1L << 19), /* codec can rearrange frames during compression */
00969 //          error("jit.qt.codec: chosen codec is unsupported by Jitter");
00970             return 0L;
00971         }
00972 //      if (cinfo.compressFlags & codecInfoDoesWarp) //   codecInfoDoesMultiPass        = (1L << 20), /* codec can perform multi-pass compression */
00973 //          jit_object_post((t_object *)x,"codec does multipass");
00974 //      if (cinfo.formatFlags & codecInfoSequenceSensitive)
00975 //          jit_object_post((t_object *)x,"codec is sequence sensitive");
00976     }
00977     return type; //((type) ? type : kRawCodecType);
00978 }
00979 
00980 /**
00981  * Given the human-readable name of a QuickTime video codec, returns a four-char code, 
00982  * assuming that the codec is installed.
00983  *
00984  * @ingroup qtcodecmod 
00985  *
00986  * @param   s       human-readable name of a QuickTime Codec (as returned by 
00987  *                  "jit_qt_codec_getcodeclist_video_raw" or similar)
00988  *
00989  * @return  long four-char code
00990  * 
00991  */
00992 long jit_qt_codec_sym2type(t_symbol *s) 
00993 {
00994     long type = 0L;
00995 
00996     if (hashtab_lookup(_jit_qt_codecs_system_video, s, (t_object **)&type))
00997         hashtab_lookup(_jit_qt_codecs_jitter_video, s, (t_object **)&type);
00998         
00999     return type; //((type) ? type : kRawCodecType);
01000 }
01001 
01002 /**
01003  * Given the four-char type code of a QuickTime audio codec, returns a human-readable
01004  * name, assuming that the codec is installed.
01005  *
01006  * @ingroup qtcodecmod 
01007  *
01008  * @param   type        four-char type code of a QuickTime Codec
01009  *
01010  * @return  t_symbol pointer containing a human-readable codec name
01011  * 
01012  */
01013 t_symbol *jit_qt_codec_acodec2sym(long type)
01014 {
01015     t_symbol *s;
01016     
01017 //  disabled until we can support QT7   
01018 //  if (hashtab_lookup(_jit_qt_codecs_system_audio_r, (t_symbol *)type, (t_object **)&s))
01019         hashtab_lookup(_jit_qt_codecs_jitter_audio_r, (t_symbol *)type, (t_object **)&s);
01020 
01021     return ((s) ? s : _jit_sym_codec_nothing);
01022 }
01023 
01024 /**
01025  * Given the human-readable name of a QuickTime audio codec, returns a four-char code, 
01026  * assuming that the codec is installed.
01027  *
01028  * @ingroup qtcodecmod 
01029  *
01030  * @param   s       human-readable name of a QuickTime Codec (as returned by 
01031  *                  "jit_qt_codec_getcodeclist_video_raw" or similar)
01032  *
01033  * @return  long four-char code
01034  * 
01035  */
01036 long jit_qt_codec_sym2acodec(t_symbol *s) 
01037 {
01038     long type;
01039     
01040 //  disabled until we can support QT7   
01041 //  if (hashtab_lookup(_jit_qt_codecs_system_audio, s, (t_object **)&type))
01042         hashtab_lookup(_jit_qt_codecs_jitter_audio, s, (t_object **)&type);
01043         
01044     return ((type) ? type : kSoundNotCompressed);
01045 }
01046 
01047 #ifdef OBSOLETE
01048 t_symbol *jit_qt_codec_type2sym(long type) 
01049 {
01050     t_symbol *s = _jit_sym_codec_nothing;
01051     
01052     switch (type) {
01053     case kRawCodecType:             s = _jit_sym_codec_raw;             break;
01054     case kCinepakCodecType:         s = _jit_sym_codec_cinepak;         break;
01055     case kGraphicsCodecType:        s = _jit_sym_codec_graphics;        break;
01056     case kAnimationCodecType:       s = _jit_sym_codec_animation;       break;
01057     case kVideoCodecType:           s = _jit_sym_codec_video;           break;
01058     case kComponentVideoCodecType:  s = _jit_sym_codec_componentvideo;  break;
01059     case kJPEGCodecType:            s = _jit_sym_codec_jpeg;            break;
01060     case kMotionJPEGACodecType:     s = _jit_sym_codec_mjpega;          break;
01061     case kMotionJPEGBCodecType:     s = _jit_sym_codec_mjpegb;          break;
01062     case kSGICodecType:             s = _jit_sym_codec_sgi;             break;
01063     case kPlanarRGBCodecType:       s = _jit_sym_codec_planarrgb;       break;
01064     case kMacPaintCodecType:        s = _jit_sym_codec_macpaint;        break;
01065     case kGIFCodecType:             s = _jit_sym_codec_gif;             break;
01066     case kPhotoCDCodecType:         s = _jit_sym_codec_photocd;         break;
01067     case kQuickDrawGXCodecType:     s = _jit_sym_codec_qdgx;            break;
01068     case kAVRJPEGCodecType:         s = _jit_sym_codec_avrjpeg;         break;
01069     case kOpenDMLJPEGCodecType:     s = _jit_sym_codec_opendmljpeg;     break;
01070     case kWindowsRawCodecType:      s = _jit_sym_codec_winraw;          break;
01071     case kVectorCodecType:          s = _jit_sym_codec_vector;          break;
01072     case kQuickDrawCodecType:       s = _jit_sym_codec_qd;              break;
01073     case kH261CodecType:            s = _jit_sym_codec_h261;            break;
01074     case kH263CodecType:            s = _jit_sym_codec_h263;            break;
01075     case kDVCNTSCCodecType:         s = _jit_sym_codec_dvntsc;          break;
01076     case kDVCPALCodecType:          s = _jit_sym_codec_dvpal;           break;
01077 //  case kDVCProNTSCCodecType:      s = _jit_sym_codec_dvprontsc;       break;
01078     case kDVCProPALCodecType:       s = _jit_sym_codec_dvpropal;        break;
01079     case kFLCCodecType:             s = _jit_sym_codec_flc;             break;
01080     case kTargaCodecType:           s = _jit_sym_codec_targa;           break;
01081     case kPNGCodecType:             s = _jit_sym_codec_png;             break;
01082     case kTIFFCodecType:            s = _jit_sym_codec_tiff;            break;
01083     case kComponentVideoSigned:     s = _jit_sym_codec_componentvideosigned;    break;
01084     case kComponentVideoUnsigned:   s = _jit_sym_codec_componentvideounsigned;  break;
01085     case kCMYKCodecType:            s = _jit_sym_codec_cmyk;            break;
01086     case kMicrosoftVideo1CodecType: s = _jit_sym_codec_microsoft;       break;
01087     case kSorensonCodecType:        s = _jit_sym_codec_sorenson;        break;
01088     case kSorenson3CodecType:       s = _jit_sym_codec_sorenson3;       break;
01089     case kIndeo4CodecType:          s = _jit_sym_codec_indeo4;          break;
01090     case k64ARGBCodecType:          s = _jit_sym_codec_argb64;          break;
01091     case k48RGBCodecType:           s = _jit_sym_codec_rgb48;           break;
01092     case k32AlphaGrayCodecType:     s = _jit_sym_codec_alphagrey32;     break;
01093     case k16GrayCodecType:          s = _jit_sym_codec_grey16;          break;
01094     case kMpegYUV420CodecType:      s = _jit_sym_codec_mpegyuv420;      break;
01095     case kYUV420CodecType:          s = _jit_sym_codec_yuv420;          break;
01096     case kSorensonYUV9CodecType:    s = _jit_sym_codec_sorensonyuv9;    break;
01097     case /*kMPEG4VisualCodecType*/FOUR_CHAR_CODE('mp4v'):   s = _jit_sym_codec_mpeg4; break;
01098     case k422YpCbCr8CodecType:      s = _jit_sym_codec_yuv422;          break;
01099     case k444YpCbCr8CodecType:      s = _jit_sym_codec_v308;            break;
01100     case k4444YpCbCrA8CodecType:    s = _jit_sym_codec_v408;            break;
01101     case k422YpCbCr16CodecType:     s = _jit_sym_codec_v216;            break;
01102     case k422YpCbCr10CodecType:     s = _jit_sym_codec_v210;            break;
01103     case k444YpCbCr10CodecType:     s = _jit_sym_codec_v410;            break;
01104     case k4444YpCbCrA8RCodecType:   s = _jit_sym_codec_r408;            break;
01105     case /*kJPEG2000CodecType*/FOUR_CHAR_CODE('mjp2'):  s = _jit_sym_codec_jpeg2000; break;
01106     case /*kPixletCodecType*/FOUR_CHAR_CODE('pxlt'):    s = _jit_sym_codec_pixlet; break;
01107     case /*kH264CodecType*/FOUR_CHAR_CODE('avc1'):  s = _jit_sym_codec_h264; break;
01108     }   
01109     return s;
01110 }
01111 
01112 long jit_qt_codec_sym2type(t_symbol *s) 
01113 {
01114     long type=kRawCodecType;
01115     
01116     if (s == _jit_sym_codec_nothing)
01117         type = kRawCodecType;
01118     else if (s == _jit_sym_codec_raw)
01119         type = kRawCodecType;
01120     else if (s == _jit_sym_codec_cinepak)
01121         type = kCinepakCodecType;
01122     else if (s == _jit_sym_codec_graphics)
01123         type = kGraphicsCodecType;
01124     else if (s == _jit_sym_codec_animation)
01125         type = kAnimationCodecType;
01126     else if (s == _jit_sym_codec_video)
01127         type = kVideoCodecType;
01128     else if (s == _jit_sym_codec_componentvideo)
01129         type = kComponentVideoCodecType;
01130     else if (s == _jit_sym_codec_jpeg)
01131         type = kJPEGCodecType;
01132     else if (s == _jit_sym_codec_mjpega)
01133         type = kMotionJPEGACodecType;
01134     else if (s == _jit_sym_codec_mjpegb)
01135         type = kMotionJPEGBCodecType;
01136     else if (s == _jit_sym_codec_sgi)
01137         type = kSGICodecType;
01138     else if (s == _jit_sym_codec_planarrgb)
01139         type = kPlanarRGBCodecType;
01140     else if (s == _jit_sym_codec_macpaint)
01141         type = kMacPaintCodecType;
01142     else if (s == _jit_sym_codec_gif)
01143         type = kGIFCodecType;
01144     else if (s == _jit_sym_codec_photocd)
01145         type = kPhotoCDCodecType;
01146     else if (s == _jit_sym_codec_qdgx)
01147         type = kQuickDrawGXCodecType;
01148     else if (s == _jit_sym_codec_avrjpeg)
01149         type = kAVRJPEGCodecType;
01150     else if (s == _jit_sym_codec_opendmljpeg)
01151         type = kOpenDMLJPEGCodecType;
01152     else if (s == _jit_sym_codec_bmp)
01153         type = kBMPCodecType;
01154     else if (s == _jit_sym_codec_winraw)
01155         type = kWindowsRawCodecType;
01156     else if (s == _jit_sym_codec_vector)
01157         type = kVectorCodecType;
01158     else if (s == _jit_sym_codec_qd)
01159         type = kQuickDrawCodecType;
01160     else if (s == _jit_sym_codec_h261)
01161         type = kH261CodecType;
01162     else if (s == _jit_sym_codec_h263)
01163         type = kH263CodecType;
01164     else if (s == _jit_sym_codec_dvntsc)
01165         type = kDVCNTSCCodecType;
01166     else if (s == _jit_sym_codec_dvpal)
01167         type = kDVCPALCodecType;
01168 //  else if (s == _jit_sym_codec_dvprontsc)
01169 //      type = kDVCProNTSCCodecType;
01170     else if (s == _jit_sym_codec_dvpropal)
01171         type = kDVCProPALCodecType;
01172     else if (s == _jit_sym_codec_flc)
01173         type = kFLCCodecType;
01174     else if (s == _jit_sym_codec_targa)
01175         type = kTargaCodecType;
01176     else if (s == _jit_sym_codec_png)
01177         type = kPNGCodecType;
01178     else if (s == _jit_sym_codec_tiff)
01179         type = kTIFFCodecType;
01180     else if (s == _jit_sym_codec_componentvideosigned)
01181         type = kComponentVideoSigned;
01182     else if (s == _jit_sym_codec_componentvideounsigned)
01183         type = kComponentVideoUnsigned;
01184     else if (s == _jit_sym_codec_cmyk)
01185         type = kCMYKCodecType;
01186     else if (s == _jit_sym_codec_microsoft)
01187         type = kMicrosoftVideo1CodecType;
01188     else if (s == _jit_sym_codec_sorenson)
01189         type = kSorensonCodecType;
01190     else if (s == _jit_sym_codec_sorenson3)
01191         type = kSorenson3CodecType;
01192     else if (s == _jit_sym_codec_indeo4)
01193         type = kIndeo4CodecType;
01194     else if (s == _jit_sym_codec_argb64)
01195         type = k64ARGBCodecType;
01196     else if (s == _jit_sym_codec_rgb48)
01197         type = k48RGBCodecType;
01198     else if (s == _jit_sym_codec_alphagrey32)
01199         type = k32AlphaGrayCodecType;
01200     else if (s == _jit_sym_codec_grey16)
01201         type = k16GrayCodecType;
01202     else if (s == _jit_sym_codec_mpegyuv420)
01203         type = kMpegYUV420CodecType;
01204     else if (s == _jit_sym_codec_yuv420)
01205         type = kYUV420CodecType;
01206     else if (s == _jit_sym_codec_sorensonyuv9)
01207         type = kSorensonYUV9CodecType;
01208     else if (s == _jit_sym_codec_mpeg4)
01209         type = /*kMPEG4VisualCodecType*/FOUR_CHAR_CODE('mp4v');
01210     else if (s == _jit_sym_codec_yuv422)
01211         type = k422YpCbCr8CodecType;
01212     else if (s == _jit_sym_codec_v308)
01213         type = k444YpCbCr8CodecType;
01214     else if (s == _jit_sym_codec_v408)
01215         type = k4444YpCbCrA8CodecType;
01216     else if (s == _jit_sym_codec_v216)
01217         type = k422YpCbCr16CodecType;
01218     else if (s == _jit_sym_codec_v210)
01219         type = k422YpCbCr10CodecType;
01220     else if (s == _jit_sym_codec_v410)
01221         type = k444YpCbCr10CodecType;
01222     else if (s == _jit_sym_codec_r408)
01223         type = k4444YpCbCrA8RCodecType;
01224     else if (s == _jit_sym_codec_jpeg2000)
01225         type = /*kJPEG2000CodecType*/FOUR_CHAR_CODE('mjp2');
01226     else if (s == _jit_sym_codec_pixlet)
01227         type = /*kPixletCodecType*/FOUR_CHAR_CODE('pxlt');
01228     else if (s == _jit_sym_codec_h264)
01229         type = /*kH264CodecType*/FOUR_CHAR_CODE('avc1');
01230     // would like to come up with a way for users to define their own codecs
01231     // @codeccustom?    
01232     return type;
01233 }
01234 
01235 t_symbol *jit_qt_codec_acodec2sym(long acodec)
01236 {
01237     t_symbol *s = _jit_sym_codec_nothing;
01238     
01239     switch(acodec) {
01240         case kSoundNotCompressed: s = _jit_sym_codec_a_none; break;
01241         case k8BitOffsetBinaryFormat: s = _jit_sym_codec_a_raw; break;
01242         case k16BitBigEndianFormat: s = _jit_sym_codec_a_big16; break;
01243         case k16BitLittleEndianFormat: s = _jit_sym_codec_a_little16; break;
01244         case kFloat32Format: s = _jit_sym_codec_a_float32; break;
01245         case kFloat64Format: s = _jit_sym_codec_a_float64; break;
01246         case k24BitFormat: s = _jit_sym_codec_a_24bit; break;
01247         case k32BitFormat: s = _jit_sym_codec_a_32bit; break;
01248         case k32BitLittleEndianFormat: s = _jit_sym_codec_a_little32; break;
01249         case kMACE3Compression: s = _jit_sym_codec_a_mace3; break;
01250         case kMACE6Compression: s = _jit_sym_codec_a_mace6; break;
01251         case kCDXA4Compression: s = _jit_sym_codec_a_cdxa4; break;
01252         case kCDXA2Compression: s = _jit_sym_codec_a_cdxa2; break;
01253         case kIMACompression: s = _jit_sym_codec_a_ima; break;
01254         case kULawCompression: s = _jit_sym_codec_a_ulaw; break;
01255         case kALawCompression: s = _jit_sym_codec_a_alaw; break;
01256         case kMicrosoftADPCMFormat: s = _jit_sym_codec_a_adpcm; break;
01257         case kDVIIntelIMAFormat: s = _jit_sym_codec_a_dviima; break;
01258         case kDVAudioFormat: s = _jit_sym_codec_a_dvaudio; break;
01259         case kQDesignCompression: s = _jit_sym_codec_a_qdesign; break;
01260         case kQDesign2Compression: s = _jit_sym_codec_a_qdesign2; break;
01261         case kQUALCOMMCompression: s = _jit_sym_codec_a_qualcomm; break;
01262         case kMPEGLayer3Format:
01263         case kFullMPEGLay3Format: s = _jit_sym_codec_a_mp3; break;
01264         case /*kVariableDurationDVAudioFormat*/FOUR_CHAR_CODE('vdva'): s = _jit_sym_codec_a_vdva; break;
01265         case /*kMPEG4AudioFormat*/FOUR_CHAR_CODE('mp4a'): s = _jit_sym_codec_a_mpeg4; break;
01266     }
01267     return s;
01268 }
01269 
01270 long jit_qt_codec_sym2acodec(t_symbol *s) 
01271 {
01272     long acodec = kSoundNotCompressed;
01273 
01274     if (s == _jit_sym_codec_a_none)
01275         acodec = kSoundNotCompressed;
01276     else if (s == _jit_sym_codec_a_raw)
01277         acodec = k8BitOffsetBinaryFormat;
01278     else if (s == _jit_sym_codec_a_big16)
01279         acodec = k16BitBigEndianFormat;
01280     else if (s == _jit_sym_codec_a_little16)
01281         acodec = k16BitLittleEndianFormat;
01282     else if (s == _jit_sym_codec_a_float32)
01283         acodec = kFloat32Format;
01284     else if (s == _jit_sym_codec_a_float64)
01285         acodec = kFloat64Format;
01286     else if (s == _jit_sym_codec_a_24bit)
01287         acodec = k24BitFormat;
01288     else if (s == _jit_sym_codec_a_32bit)
01289         acodec = k32BitFormat;
01290     else if (s == _jit_sym_codec_a_little32)
01291         acodec = k32BitLittleEndianFormat;
01292     else if (s == _jit_sym_codec_a_mace3)
01293         acodec = kMACE3Compression;
01294     else if (s == _jit_sym_codec_a_mace6)
01295         acodec = kMACE6Compression;
01296     else if (s == _jit_sym_codec_a_cdxa4)
01297         acodec = kCDXA4Compression;
01298     else if (s == _jit_sym_codec_a_cdxa2)
01299         acodec = kCDXA2Compression;
01300     else if (s == _jit_sym_codec_a_ima)
01301         acodec = kIMACompression;
01302     else if (s == _jit_sym_codec_a_ulaw)
01303         acodec = kULawCompression;
01304     else if (s == _jit_sym_codec_a_alaw)
01305         acodec = kALawCompression;
01306     else if (s == _jit_sym_codec_a_adpcm)
01307         acodec = kMicrosoftADPCMFormat;
01308     else if (s == _jit_sym_codec_a_dviima)
01309         acodec = kDVIIntelIMAFormat;
01310     else if (s == _jit_sym_codec_a_dvaudio)
01311         acodec = kDVAudioFormat;
01312     else if (s == _jit_sym_codec_a_qdesign)
01313         acodec = kQDesignCompression;
01314     else if (s == _jit_sym_codec_a_qdesign2)
01315         acodec = kQDesign2Compression;
01316     else if (s == _jit_sym_codec_a_qualcomm)
01317         acodec = kQUALCOMMCompression;
01318     else if (s == _jit_sym_codec_a_mp3)
01319         acodec = kFullMPEGLay3Format;
01320     else if (s == _jit_sym_codec_a_vdva)
01321         acodec = /*kVariableDurationDVAudioFormat*/FOUR_CHAR_CODE('vdva');
01322     else if (s == _jit_sym_codec_a_mpeg4)
01323         acodec = /*kMPEG4AudioFormat*/FOUR_CHAR_CODE('mp4a');
01324 
01325     return acodec;
01326 }
01327 
01328 #endif // OBSOLETE
01329 
01330 
01331 /*
01332     kRawCodecType               = FOUR_CHAR_CODE('raw '),
01333     kCinepakCodecType           = FOUR_CHAR_CODE('cvid'),
01334     kGraphicsCodecType          = FOUR_CHAR_CODE('smc '),
01335     kAnimationCodecType         = FOUR_CHAR_CODE('rle '),
01336     kVideoCodecType             = FOUR_CHAR_CODE('rpza'),
01337     kComponentVideoCodecType    = FOUR_CHAR_CODE('yuv2'),
01338     kJPEGCodecType              = FOUR_CHAR_CODE('jpeg'),
01339     kMotionJPEGACodecType       = FOUR_CHAR_CODE('mjpa'),
01340     kMotionJPEGBCodecType       = FOUR_CHAR_CODE('mjpb'),
01341     kSGICodecType               = FOUR_CHAR_CODE('.SGI'),
01342     kPlanarRGBCodecType         = FOUR_CHAR_CODE('8BPS'),
01343     kMacPaintCodecType          = FOUR_CHAR_CODE('PNTG'),
01344     kGIFCodecType               = FOUR_CHAR_CODE('gif '),
01345     kPhotoCDCodecType           = FOUR_CHAR_CODE('kpcd'),
01346     kQuickDrawGXCodecType       = FOUR_CHAR_CODE('qdgx'),
01347     kAVRJPEGCodecType           = FOUR_CHAR_CODE('avr '),
01348     kOpenDMLJPEGCodecType       = FOUR_CHAR_CODE('dmb1'),
01349     kBMPCodecType               = FOUR_CHAR_CODE('WRLE'),
01350     kWindowsRawCodecType        = FOUR_CHAR_CODE('WRAW'),
01351     kVectorCodecType            = FOUR_CHAR_CODE('path'),
01352     kQuickDrawCodecType         = FOUR_CHAR_CODE('qdrw'),
01353     kWaterRippleCodecType       = FOUR_CHAR_CODE('ripl'),
01354     kFireCodecType              = FOUR_CHAR_CODE('fire'),
01355     kCloudCodecType             = FOUR_CHAR_CODE('clou'),
01356     kH261CodecType              = FOUR_CHAR_CODE('h261'),
01357     kH263CodecType              = FOUR_CHAR_CODE('h263'),
01358     kDVCNTSCCodecType           = FOUR_CHAR_CODE('dvc '),
01359     kDVCPALCodecType            = FOUR_CHAR_CODE('dvcp'),
01360     kDVCProNTSCCodecType        = FOUR_CHAR_CODE('dvpn'),
01361     kDVCProPALCodecType         = FOUR_CHAR_CODE('dvpp'),
01362     kBaseCodecType              = FOUR_CHAR_CODE('base'),
01363     kFLCCodecType               = FOUR_CHAR_CODE('flic'),
01364     kTargaCodecType             = FOUR_CHAR_CODE('tga '),
01365     kPNGCodecType               = FOUR_CHAR_CODE('png '),
01366     kTIFFCodecType              = FOUR_CHAR_CODE('tiff'),                                                                       
01367     kComponentVideoSigned       = FOUR_CHAR_CODE('yuvu'), //yuvu is correct for signed
01368     kComponentVideoUnsigned     = FOUR_CHAR_CODE('yuvs'), //yuvs is correct for unsigned
01369     kCMYKCodecType              = FOUR_CHAR_CODE('cmyk'),
01370     kMicrosoftVideo1CodecType   = FOUR_CHAR_CODE('msvc'),
01371     kSorensonCodecType          = FOUR_CHAR_CODE('SVQ1'),
01372     kIndeo4CodecType            = FOUR_CHAR_CODE('IV41'),
01373     k64ARGBCodecType            = FOUR_CHAR_CODE('b64a'),
01374     k48RGBCodecType             = FOUR_CHAR_CODE('b48r'),
01375     k32AlphaGrayCodecType       = FOUR_CHAR_CODE('b32a'),
01376     k16GrayCodecType            = FOUR_CHAR_CODE('b16g'),
01377     kMpegYUV420CodecType        = FOUR_CHAR_CODE('myuv'),
01378     kYUV420CodecType            = FOUR_CHAR_CODE('y420'),
01379     kSorensonYUV9CodecType      = FOUR_CHAR_CODE('syv9')
01380 
01381 */