|
1 |
|
2 |
|
3 /* Cl objects */ |
|
4 |
|
5 #define CLDEBUG |
|
6 |
|
7 #include <stdarg.h> |
|
8 #include <cl.h> |
|
9 #if defined(CL_JPEG_SOFTWARE) && !defined(CL_JPEG_COSMO) |
|
10 #include <dmedia/cl_cosmo.h> |
|
11 #endif |
|
12 #include "Python.h" |
|
13 |
|
14 typedef struct { |
|
15 PyObject_HEAD |
|
16 int ob_isCompressor; /* Compressor or Decompressor */ |
|
17 CL_Handle ob_compressorHdl; |
|
18 int *ob_paramtypes; |
|
19 int ob_nparams; |
|
20 } clobject; |
|
21 |
|
22 static PyObject *ClError; /* exception cl.error */ |
|
23 |
|
24 static int error_handler_called = 0; |
|
25 |
|
26 /* |
|
27 * We want to use the function prototypes that are available in the C |
|
28 * compiler on the SGI. Because of that, we need to declare the first |
|
29 * argument of the compressor and decompressor methods as "object *", |
|
30 * even though they are really "clobject *". Therefore we cast the |
|
31 * argument to the proper type using this macro. |
|
32 */ |
|
33 #define SELF ((clobject *) self) |
|
34 |
|
35 /******************************************************************** |
|
36 Utility routines. |
|
37 ********************************************************************/ |
|
38 static void |
|
39 cl_ErrorHandler(CL_Handle handle, int code, const char *fmt, ...) |
|
40 { |
|
41 va_list ap; |
|
42 char errbuf[BUFSIZ]; /* hopefully big enough */ |
|
43 char *p; |
|
44 |
|
45 if (PyErr_Occurred()) /* don't change existing error */ |
|
46 return; |
|
47 error_handler_called = 1; |
|
48 va_start(ap, fmt); |
|
49 vsprintf(errbuf, fmt, ap); |
|
50 va_end(ap); |
|
51 p = &errbuf[strlen(errbuf) - 1]; /* swat the line feed */ |
|
52 if (*p == '\n') |
|
53 *p = 0; |
|
54 PyErr_SetString(ClError, errbuf); |
|
55 } |
|
56 |
|
57 /* |
|
58 * This assumes that params are always in the range 0 to some maximum. |
|
59 */ |
|
60 static int |
|
61 param_type_is_float(clobject *self, int param) |
|
62 { |
|
63 int bufferlength; |
|
64 |
|
65 if (self->ob_paramtypes == NULL) { |
|
66 error_handler_called = 0; |
|
67 bufferlength = clQueryParams(self->ob_compressorHdl, 0, 0); |
|
68 if (error_handler_called) |
|
69 return -1; |
|
70 |
|
71 self->ob_paramtypes = PyMem_NEW(int, bufferlength); |
|
72 if (self->ob_paramtypes == NULL) |
|
73 return -1; |
|
74 self->ob_nparams = bufferlength / 2; |
|
75 |
|
76 (void) clQueryParams(self->ob_compressorHdl, |
|
77 self->ob_paramtypes, bufferlength); |
|
78 if (error_handler_called) { |
|
79 PyMem_DEL(self->ob_paramtypes); |
|
80 self->ob_paramtypes = NULL; |
|
81 return -1; |
|
82 } |
|
83 } |
|
84 |
|
85 if (param < 0 || param >= self->ob_nparams) |
|
86 return -1; |
|
87 |
|
88 if (self->ob_paramtypes[param*2 + 1] == CL_FLOATING_ENUM_VALUE || |
|
89 self->ob_paramtypes[param*2 + 1] == CL_FLOATING_RANGE_VALUE) |
|
90 return 1; |
|
91 else |
|
92 return 0; |
|
93 } |
|
94 |
|
95 /******************************************************************** |
|
96 Single image compression/decompression. |
|
97 ********************************************************************/ |
|
98 static PyObject * |
|
99 cl_CompressImage(PyObject *self, PyObject *args) |
|
100 { |
|
101 int compressionScheme, width, height, originalFormat; |
|
102 float compressionRatio; |
|
103 int frameBufferSize, compressedBufferSize; |
|
104 char *frameBuffer; |
|
105 PyObject *compressedBuffer; |
|
106 |
|
107 if (!PyArg_ParseTuple(args, "iiiifs#", &compressionScheme, |
|
108 &width, &height, |
|
109 &originalFormat, &compressionRatio, &frameBuffer, |
|
110 &frameBufferSize)) |
|
111 return NULL; |
|
112 |
|
113 retry: |
|
114 compressedBuffer = PyString_FromStringAndSize(NULL, frameBufferSize); |
|
115 if (compressedBuffer == NULL) |
|
116 return NULL; |
|
117 |
|
118 compressedBufferSize = frameBufferSize; |
|
119 error_handler_called = 0; |
|
120 if (clCompressImage(compressionScheme, width, height, originalFormat, |
|
121 compressionRatio, (void *) frameBuffer, |
|
122 &compressedBufferSize, |
|
123 (void *) PyString_AsString(compressedBuffer)) |
|
124 == FAILURE || error_handler_called) { |
|
125 Py_DECREF(compressedBuffer); |
|
126 if (!error_handler_called) |
|
127 PyErr_SetString(ClError, "clCompressImage failed"); |
|
128 return NULL; |
|
129 } |
|
130 |
|
131 if (compressedBufferSize > frameBufferSize) { |
|
132 frameBufferSize = compressedBufferSize; |
|
133 Py_DECREF(compressedBuffer); |
|
134 goto retry; |
|
135 } |
|
136 |
|
137 if (compressedBufferSize < frameBufferSize) |
|
138 _PyString_Resize(&compressedBuffer, compressedBufferSize); |
|
139 |
|
140 return compressedBuffer; |
|
141 } |
|
142 |
|
143 static PyObject * |
|
144 cl_DecompressImage(PyObject *self, PyObject *args) |
|
145 { |
|
146 int compressionScheme, width, height, originalFormat; |
|
147 char *compressedBuffer; |
|
148 int compressedBufferSize, frameBufferSize; |
|
149 PyObject *frameBuffer; |
|
150 |
|
151 if (!PyArg_ParseTuple(args, "iiiis#", &compressionScheme, &width, &height, |
|
152 &originalFormat, &compressedBuffer, |
|
153 &compressedBufferSize)) |
|
154 return NULL; |
|
155 |
|
156 frameBufferSize = width * height * CL_BytesPerPixel(originalFormat); |
|
157 |
|
158 frameBuffer = PyString_FromStringAndSize(NULL, frameBufferSize); |
|
159 if (frameBuffer == NULL) |
|
160 return NULL; |
|
161 |
|
162 error_handler_called = 0; |
|
163 if (clDecompressImage(compressionScheme, width, height, originalFormat, |
|
164 compressedBufferSize, compressedBuffer, |
|
165 (void *) PyString_AsString(frameBuffer)) |
|
166 == FAILURE || error_handler_called) { |
|
167 Py_DECREF(frameBuffer); |
|
168 if (!error_handler_called) |
|
169 PyErr_SetString(ClError, "clDecompressImage failed"); |
|
170 return NULL; |
|
171 } |
|
172 |
|
173 return frameBuffer; |
|
174 } |
|
175 |
|
176 /******************************************************************** |
|
177 Sequential compression/decompression. |
|
178 ********************************************************************/ |
|
179 #define CheckCompressor(self) if ((self)->ob_compressorHdl == NULL) { \ |
|
180 PyErr_SetString(PyExc_RuntimeError, "(de)compressor not active"); \ |
|
181 return NULL; \ |
|
182 } |
|
183 |
|
184 static PyObject * |
|
185 doClose(clobject *self, int (*close_func)(CL_Handle)) |
|
186 { |
|
187 CheckCompressor(self); |
|
188 |
|
189 error_handler_called = 0; |
|
190 if ((*close_func)(self->ob_compressorHdl) == FAILURE || |
|
191 error_handler_called) { |
|
192 if (!error_handler_called) |
|
193 PyErr_SetString(ClError, "close failed"); |
|
194 return NULL; |
|
195 } |
|
196 |
|
197 self->ob_compressorHdl = NULL; |
|
198 |
|
199 if (self->ob_paramtypes) |
|
200 PyMem_DEL(self->ob_paramtypes); |
|
201 self->ob_paramtypes = NULL; |
|
202 |
|
203 Py_INCREF(Py_None); |
|
204 return Py_None; |
|
205 } |
|
206 |
|
207 static PyObject * |
|
208 clm_CloseCompressor(PyObject *self) |
|
209 { |
|
210 return doClose(SELF, clCloseCompressor); |
|
211 } |
|
212 |
|
213 static PyObject * |
|
214 clm_CloseDecompressor(PyObject *self) |
|
215 { |
|
216 return doClose(SELF, clCloseDecompressor); |
|
217 } |
|
218 |
|
219 static PyObject * |
|
220 clm_Compress(PyObject *self, PyObject *args) |
|
221 { |
|
222 int numberOfFrames; |
|
223 int frameBufferSize, compressedBufferSize, size; |
|
224 char *frameBuffer; |
|
225 PyObject *data; |
|
226 |
|
227 CheckCompressor(SELF); |
|
228 |
|
229 if (!PyArg_Parse(args, "(is#)", &numberOfFrames, |
|
230 &frameBuffer, &frameBufferSize)) |
|
231 return NULL; |
|
232 |
|
233 error_handler_called = 0; |
|
234 size = clGetParam(SELF->ob_compressorHdl, CL_COMPRESSED_BUFFER_SIZE); |
|
235 compressedBufferSize = size; |
|
236 if (error_handler_called) |
|
237 return NULL; |
|
238 |
|
239 data = PyString_FromStringAndSize(NULL, size); |
|
240 if (data == NULL) |
|
241 return NULL; |
|
242 |
|
243 error_handler_called = 0; |
|
244 if (clCompress(SELF->ob_compressorHdl, numberOfFrames, |
|
245 (void *) frameBuffer, &compressedBufferSize, |
|
246 (void *) PyString_AsString(data)) == FAILURE || |
|
247 error_handler_called) { |
|
248 Py_DECREF(data); |
|
249 if (!error_handler_called) |
|
250 PyErr_SetString(ClError, "compress failed"); |
|
251 return NULL; |
|
252 } |
|
253 |
|
254 if (compressedBufferSize < size) |
|
255 if (_PyString_Resize(&data, compressedBufferSize)) |
|
256 return NULL; |
|
257 |
|
258 if (compressedBufferSize > size) { |
|
259 /* we didn't get all "compressed" data */ |
|
260 Py_DECREF(data); |
|
261 PyErr_SetString(ClError, |
|
262 "compressed data is more than fitted"); |
|
263 return NULL; |
|
264 } |
|
265 |
|
266 return data; |
|
267 } |
|
268 |
|
269 static PyObject * |
|
270 clm_Decompress(PyObject *self, PyObject *args) |
|
271 { |
|
272 PyObject *data; |
|
273 int numberOfFrames; |
|
274 char *compressedData; |
|
275 int compressedDataSize, dataSize; |
|
276 |
|
277 CheckCompressor(SELF); |
|
278 |
|
279 if (!PyArg_Parse(args, "(is#)", &numberOfFrames, &compressedData, |
|
280 &compressedDataSize)) |
|
281 return NULL; |
|
282 |
|
283 error_handler_called = 0; |
|
284 dataSize = clGetParam(SELF->ob_compressorHdl, CL_FRAME_BUFFER_SIZE); |
|
285 if (error_handler_called) |
|
286 return NULL; |
|
287 |
|
288 data = PyString_FromStringAndSize(NULL, dataSize); |
|
289 if (data == NULL) |
|
290 return NULL; |
|
291 |
|
292 error_handler_called = 0; |
|
293 if (clDecompress(SELF->ob_compressorHdl, numberOfFrames, |
|
294 compressedDataSize, (void *) compressedData, |
|
295 (void *) PyString_AsString(data)) == FAILURE || |
|
296 error_handler_called) { |
|
297 Py_DECREF(data); |
|
298 if (!error_handler_called) |
|
299 PyErr_SetString(ClError, "decompress failed"); |
|
300 return NULL; |
|
301 } |
|
302 |
|
303 return data; |
|
304 } |
|
305 |
|
306 static PyObject * |
|
307 doParams(clobject *self, PyObject *args, int (*func)(CL_Handle, int *, int), |
|
308 int modified) |
|
309 { |
|
310 PyObject *list, *v; |
|
311 int *PVbuffer; |
|
312 int length; |
|
313 int i; |
|
314 float number; |
|
315 |
|
316 CheckCompressor(self); |
|
317 |
|
318 if (!PyArg_Parse(args, "O", &list)) |
|
319 return NULL; |
|
320 if (!PyList_Check(list)) { |
|
321 PyErr_BadArgument(); |
|
322 return NULL; |
|
323 } |
|
324 length = PyList_Size(list); |
|
325 PVbuffer = PyMem_NEW(int, length); |
|
326 if (PVbuffer == NULL) |
|
327 return PyErr_NoMemory(); |
|
328 for (i = 0; i < length; i++) { |
|
329 v = PyList_GetItem(list, i); |
|
330 if (PyFloat_Check(v)) { |
|
331 number = PyFloat_AsDouble(v); |
|
332 PVbuffer[i] = CL_TypeIsInt(number); |
|
333 } else if (PyInt_Check(v)) { |
|
334 PVbuffer[i] = PyInt_AsLong(v); |
|
335 if ((i & 1) && |
|
336 param_type_is_float(self, PVbuffer[i-1]) > 0) { |
|
337 number = PVbuffer[i]; |
|
338 PVbuffer[i] = CL_TypeIsInt(number); |
|
339 } |
|
340 } else { |
|
341 PyMem_DEL(PVbuffer); |
|
342 PyErr_BadArgument(); |
|
343 return NULL; |
|
344 } |
|
345 } |
|
346 |
|
347 error_handler_called = 0; |
|
348 (*func)(self->ob_compressorHdl, PVbuffer, length); |
|
349 if (error_handler_called) { |
|
350 PyMem_DEL(PVbuffer); |
|
351 return NULL; |
|
352 } |
|
353 |
|
354 if (modified) { |
|
355 for (i = 0; i < length; i++) { |
|
356 if ((i & 1) && |
|
357 param_type_is_float(self, PVbuffer[i-1]) > 0) { |
|
358 number = CL_TypeIsFloat(PVbuffer[i]); |
|
359 v = PyFloat_FromDouble(number); |
|
360 } else |
|
361 v = PyInt_FromLong(PVbuffer[i]); |
|
362 PyList_SetItem(list, i, v); |
|
363 } |
|
364 } |
|
365 |
|
366 PyMem_DEL(PVbuffer); |
|
367 |
|
368 Py_INCREF(Py_None); |
|
369 return Py_None; |
|
370 } |
|
371 |
|
372 static PyObject * |
|
373 clm_GetParams(PyObject *self, PyObject *args) |
|
374 { |
|
375 return doParams(SELF, args, clGetParams, 1); |
|
376 } |
|
377 |
|
378 static PyObject * |
|
379 clm_SetParams(PyObject *self, PyObject *args) |
|
380 { |
|
381 return doParams(SELF, args, clSetParams, 0); |
|
382 } |
|
383 |
|
384 static PyObject * |
|
385 do_get(clobject *self, PyObject *args, int (*func)(CL_Handle, int)) |
|
386 { |
|
387 int paramID, value; |
|
388 float fvalue; |
|
389 |
|
390 CheckCompressor(self); |
|
391 |
|
392 if (!PyArg_Parse(args, "i", ¶mID)) |
|
393 return NULL; |
|
394 |
|
395 error_handler_called = 0; |
|
396 value = (*func)(self->ob_compressorHdl, paramID); |
|
397 if (error_handler_called) |
|
398 return NULL; |
|
399 |
|
400 if (param_type_is_float(self, paramID) > 0) { |
|
401 fvalue = CL_TypeIsFloat(value); |
|
402 return PyFloat_FromDouble(fvalue); |
|
403 } |
|
404 |
|
405 return PyInt_FromLong(value); |
|
406 } |
|
407 |
|
408 static PyObject * |
|
409 clm_GetParam(PyObject *self, PyObject *args) |
|
410 { |
|
411 return do_get(SELF, args, clGetParam); |
|
412 } |
|
413 |
|
414 static PyObject * |
|
415 clm_GetDefault(PyObject *self, PyObject *args) |
|
416 { |
|
417 return do_get(SELF, args, clGetDefault); |
|
418 } |
|
419 |
|
420 static PyObject * |
|
421 clm_SetParam(PyObject *self, PyObject *args) |
|
422 { |
|
423 int paramID, value; |
|
424 float fvalue; |
|
425 |
|
426 CheckCompressor(SELF); |
|
427 |
|
428 if (!PyArg_Parse(args, "(ii)", ¶mID, &value)) { |
|
429 PyErr_Clear(); |
|
430 if (!PyArg_Parse(args, "(if)", ¶mID, &fvalue)) { |
|
431 PyErr_Clear(); |
|
432 PyErr_SetString(PyExc_TypeError, |
|
433 "bad argument list (format '(ii)' or '(if)')"); |
|
434 return NULL; |
|
435 } |
|
436 value = CL_TypeIsInt(fvalue); |
|
437 } else { |
|
438 if (param_type_is_float(SELF, paramID) > 0) { |
|
439 fvalue = value; |
|
440 value = CL_TypeIsInt(fvalue); |
|
441 } |
|
442 } |
|
443 |
|
444 error_handler_called = 0; |
|
445 value = clSetParam(SELF->ob_compressorHdl, paramID, value); |
|
446 if (error_handler_called) |
|
447 return NULL; |
|
448 |
|
449 if (param_type_is_float(SELF, paramID) > 0) |
|
450 return PyFloat_FromDouble(CL_TypeIsFloat(value)); |
|
451 else |
|
452 return PyInt_FromLong(value); |
|
453 } |
|
454 |
|
455 static PyObject * |
|
456 clm_GetParamID(PyObject *self, PyObject *args) |
|
457 { |
|
458 char *name; |
|
459 int value; |
|
460 |
|
461 CheckCompressor(SELF); |
|
462 |
|
463 if (!PyArg_Parse(args, "s", &name)) |
|
464 return NULL; |
|
465 |
|
466 error_handler_called = 0; |
|
467 value = clGetParamID(SELF->ob_compressorHdl, name); |
|
468 if (value == FAILURE || error_handler_called) { |
|
469 if (!error_handler_called) |
|
470 PyErr_SetString(ClError, "getparamid failed"); |
|
471 return NULL; |
|
472 } |
|
473 |
|
474 return PyInt_FromLong(value); |
|
475 } |
|
476 |
|
477 static PyObject * |
|
478 clm_QueryParams(PyObject *self) |
|
479 { |
|
480 int bufferlength; |
|
481 int *PVbuffer; |
|
482 PyObject *list; |
|
483 int i; |
|
484 |
|
485 CheckCompressor(SELF); |
|
486 |
|
487 error_handler_called = 0; |
|
488 bufferlength = clQueryParams(SELF->ob_compressorHdl, 0, 0); |
|
489 if (error_handler_called) |
|
490 return NULL; |
|
491 |
|
492 PVbuffer = PyMem_NEW(int, bufferlength); |
|
493 if (PVbuffer == NULL) |
|
494 return PyErr_NoMemory(); |
|
495 |
|
496 bufferlength = clQueryParams(SELF->ob_compressorHdl, PVbuffer, |
|
497 bufferlength); |
|
498 if (error_handler_called) { |
|
499 PyMem_DEL(PVbuffer); |
|
500 return NULL; |
|
501 } |
|
502 |
|
503 list = PyList_New(bufferlength); |
|
504 if (list == NULL) { |
|
505 PyMem_DEL(PVbuffer); |
|
506 return NULL; |
|
507 } |
|
508 |
|
509 for (i = 0; i < bufferlength; i++) { |
|
510 if (i & 1) |
|
511 PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i])); |
|
512 else if (PVbuffer[i] == 0) { |
|
513 Py_INCREF(Py_None); |
|
514 PyList_SetItem(list, i, Py_None); |
|
515 } else |
|
516 PyList_SetItem(list, i, |
|
517 PyString_FromString((char *) PVbuffer[i])); |
|
518 } |
|
519 |
|
520 PyMem_DEL(PVbuffer); |
|
521 |
|
522 return list; |
|
523 } |
|
524 |
|
525 static PyObject * |
|
526 clm_GetMinMax(PyObject *self, PyObject *args) |
|
527 { |
|
528 int param, min, max; |
|
529 float fmin, fmax; |
|
530 |
|
531 CheckCompressor(SELF); |
|
532 |
|
533 if (!PyArg_Parse(args, "i", ¶m)) |
|
534 return NULL; |
|
535 |
|
536 clGetMinMax(SELF->ob_compressorHdl, param, &min, &max); |
|
537 |
|
538 if (param_type_is_float(SELF, param) > 0) { |
|
539 fmin = CL_TypeIsFloat(min); |
|
540 fmax = CL_TypeIsFloat(max); |
|
541 return Py_BuildValue("(ff)", fmin, fmax); |
|
542 } |
|
543 |
|
544 return Py_BuildValue("(ii)", min, max); |
|
545 } |
|
546 |
|
547 static PyObject * |
|
548 clm_GetName(PyObject *self, PyObject *args) |
|
549 { |
|
550 int param; |
|
551 char *name; |
|
552 |
|
553 CheckCompressor(SELF); |
|
554 |
|
555 if (!PyArg_Parse(args, "i", ¶m)) |
|
556 return NULL; |
|
557 |
|
558 error_handler_called = 0; |
|
559 name = clGetName(SELF->ob_compressorHdl, param); |
|
560 if (name == NULL || error_handler_called) { |
|
561 if (!error_handler_called) |
|
562 PyErr_SetString(ClError, "getname failed"); |
|
563 return NULL; |
|
564 } |
|
565 |
|
566 return PyString_FromString(name); |
|
567 } |
|
568 |
|
569 static PyObject * |
|
570 clm_QuerySchemeFromHandle(PyObject *self) |
|
571 { |
|
572 CheckCompressor(SELF); |
|
573 return PyInt_FromLong(clQuerySchemeFromHandle(SELF->ob_compressorHdl)); |
|
574 } |
|
575 |
|
576 static PyObject * |
|
577 clm_ReadHeader(PyObject *self, PyObject *args) |
|
578 { |
|
579 char *header; |
|
580 int headerSize; |
|
581 |
|
582 CheckCompressor(SELF); |
|
583 |
|
584 if (!PyArg_Parse(args, "s#", &header, &headerSize)) |
|
585 return NULL; |
|
586 |
|
587 return PyInt_FromLong(clReadHeader(SELF->ob_compressorHdl, |
|
588 headerSize, header)); |
|
589 } |
|
590 |
|
591 static PyMethodDef compressor_methods[] = { |
|
592 {"close", clm_CloseCompressor, METH_NOARGS}, /* alias */ |
|
593 {"CloseCompressor", clm_CloseCompressor, METH_NOARGS}, |
|
594 {"Compress", clm_Compress, METH_OLDARGS}, |
|
595 {"GetDefault", clm_GetDefault, METH_OLDARGS}, |
|
596 {"GetMinMax", clm_GetMinMax, METH_OLDARGS}, |
|
597 {"GetName", clm_GetName, METH_OLDARGS}, |
|
598 {"GetParam", clm_GetParam, METH_OLDARGS}, |
|
599 {"GetParamID", clm_GetParamID, METH_OLDARGS}, |
|
600 {"GetParams", clm_GetParams, METH_OLDARGS}, |
|
601 {"QueryParams", clm_QueryParams, METH_NOARGS}, |
|
602 {"QuerySchemeFromHandle",clm_QuerySchemeFromHandle, METH_NOARGS}, |
|
603 {"SetParam", clm_SetParam, METH_OLDARGS}, |
|
604 {"SetParams", clm_SetParams, METH_OLDARGS}, |
|
605 {NULL, NULL} /* sentinel */ |
|
606 }; |
|
607 |
|
608 static PyMethodDef decompressor_methods[] = { |
|
609 {"close", clm_CloseDecompressor, METH_NOARGS}, /* alias */ |
|
610 {"CloseDecompressor", clm_CloseDecompressor, METH_NOARGS}, |
|
611 {"Decompress", clm_Decompress, METH_OLDARGS}, |
|
612 {"GetDefault", clm_GetDefault, METH_OLDARGS}, |
|
613 {"GetMinMax", clm_GetMinMax, METH_OLDARGS}, |
|
614 {"GetName", clm_GetName, METH_OLDARGS}, |
|
615 {"GetParam", clm_GetParam, METH_OLDARGS}, |
|
616 {"GetParamID", clm_GetParamID, METH_OLDARGS}, |
|
617 {"GetParams", clm_GetParams, METH_OLDARGS}, |
|
618 {"ReadHeader", clm_ReadHeader, METH_OLDARGS}, |
|
619 {"QueryParams", clm_QueryParams, METH_NOARGS}, |
|
620 {"QuerySchemeFromHandle",clm_QuerySchemeFromHandle, METH_NOARGS}, |
|
621 {"SetParam", clm_SetParam, METH_OLDARGS}, |
|
622 {"SetParams", clm_SetParams, METH_OLDARGS}, |
|
623 {NULL, NULL} /* sentinel */ |
|
624 }; |
|
625 |
|
626 static void |
|
627 cl_dealloc(PyObject *self) |
|
628 { |
|
629 if (SELF->ob_compressorHdl) { |
|
630 if (SELF->ob_isCompressor) |
|
631 clCloseCompressor(SELF->ob_compressorHdl); |
|
632 else |
|
633 clCloseDecompressor(SELF->ob_compressorHdl); |
|
634 } |
|
635 PyObject_Del(self); |
|
636 } |
|
637 |
|
638 static PyObject * |
|
639 cl_getattr(PyObject *self, char *name) |
|
640 { |
|
641 if (SELF->ob_isCompressor) |
|
642 return Py_FindMethod(compressor_methods, self, name); |
|
643 else |
|
644 return Py_FindMethod(decompressor_methods, self, name); |
|
645 } |
|
646 |
|
647 static PyTypeObject Cltype = { |
|
648 PyObject_HEAD_INIT(&PyType_Type) |
|
649 0, /*ob_size*/ |
|
650 "cl.cl", /*tp_name*/ |
|
651 sizeof(clobject), /*tp_size*/ |
|
652 0, /*tp_itemsize*/ |
|
653 /* methods */ |
|
654 (destructor)cl_dealloc, /*tp_dealloc*/ |
|
655 0, /*tp_print*/ |
|
656 (getattrfunc)cl_getattr, /*tp_getattr*/ |
|
657 0, /*tp_setattr*/ |
|
658 0, /*tp_compare*/ |
|
659 0, /*tp_repr*/ |
|
660 0, /*tp_as_number*/ |
|
661 0, /*tp_as_sequence*/ |
|
662 0, /*tp_as_mapping*/ |
|
663 }; |
|
664 |
|
665 static PyObject * |
|
666 doOpen(PyObject *self, PyObject *args, int (*open_func)(int, CL_Handle *), |
|
667 int iscompressor) |
|
668 { |
|
669 int scheme; |
|
670 clobject *new; |
|
671 |
|
672 if (!PyArg_ParseTuple(args, "i", &scheme)) |
|
673 return NULL; |
|
674 |
|
675 new = PyObject_New(clobject, &Cltype); |
|
676 if (new == NULL) |
|
677 return NULL; |
|
678 |
|
679 new->ob_compressorHdl = NULL; |
|
680 new->ob_isCompressor = iscompressor; |
|
681 new->ob_paramtypes = NULL; |
|
682 |
|
683 error_handler_called = 0; |
|
684 if ((*open_func)(scheme, &new->ob_compressorHdl) == FAILURE || |
|
685 error_handler_called) { |
|
686 Py_DECREF(new); |
|
687 if (!error_handler_called) |
|
688 PyErr_SetString(ClError, "Open(De)Compressor failed"); |
|
689 return NULL; |
|
690 } |
|
691 return (PyObject *)new; |
|
692 } |
|
693 |
|
694 static PyObject * |
|
695 cl_OpenCompressor(PyObject *self, PyObject *args) |
|
696 { |
|
697 return doOpen(self, args, clOpenCompressor, 1); |
|
698 } |
|
699 |
|
700 static PyObject * |
|
701 cl_OpenDecompressor(PyObject *self, PyObject *args) |
|
702 { |
|
703 return doOpen(self, args, clOpenDecompressor, 0); |
|
704 } |
|
705 |
|
706 static PyObject * |
|
707 cl_QueryScheme(PyObject *self, PyObject *args) |
|
708 { |
|
709 char *header; |
|
710 int headerlen; |
|
711 int scheme; |
|
712 |
|
713 if (!PyArg_ParseTuple(args, "s#", &header, &headerlen)) |
|
714 return NULL; |
|
715 |
|
716 scheme = clQueryScheme(header); |
|
717 if (scheme < 0) { |
|
718 PyErr_SetString(ClError, "unknown compression scheme"); |
|
719 return NULL; |
|
720 } |
|
721 |
|
722 return PyInt_FromLong(scheme); |
|
723 } |
|
724 |
|
725 static PyObject * |
|
726 cl_QueryMaxHeaderSize(PyObject *self, PyObject *args) |
|
727 { |
|
728 int scheme; |
|
729 |
|
730 if (!PyArg_ParseTuple(args, "i", &scheme)) |
|
731 return NULL; |
|
732 |
|
733 return PyInt_FromLong(clQueryMaxHeaderSize(scheme)); |
|
734 } |
|
735 |
|
736 static PyObject * |
|
737 cl_QueryAlgorithms(PyObject *self, PyObject *args) |
|
738 { |
|
739 int algorithmMediaType; |
|
740 int bufferlength; |
|
741 int *PVbuffer; |
|
742 PyObject *list; |
|
743 int i; |
|
744 |
|
745 if (!PyArg_ParseTuple(args, "i", &algorithmMediaType)) |
|
746 return NULL; |
|
747 |
|
748 error_handler_called = 0; |
|
749 bufferlength = clQueryAlgorithms(algorithmMediaType, 0, 0); |
|
750 if (error_handler_called) |
|
751 return NULL; |
|
752 |
|
753 PVbuffer = PyMem_NEW(int, bufferlength); |
|
754 if (PVbuffer == NULL) |
|
755 return PyErr_NoMemory(); |
|
756 |
|
757 bufferlength = clQueryAlgorithms(algorithmMediaType, PVbuffer, |
|
758 bufferlength); |
|
759 if (error_handler_called) { |
|
760 PyMem_DEL(PVbuffer); |
|
761 return NULL; |
|
762 } |
|
763 |
|
764 list = PyList_New(bufferlength); |
|
765 if (list == NULL) { |
|
766 PyMem_DEL(PVbuffer); |
|
767 return NULL; |
|
768 } |
|
769 |
|
770 for (i = 0; i < bufferlength; i++) { |
|
771 if (i & 1) |
|
772 PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i])); |
|
773 else if (PVbuffer[i] == 0) { |
|
774 Py_INCREF(Py_None); |
|
775 PyList_SetItem(list, i, Py_None); |
|
776 } else |
|
777 PyList_SetItem(list, i, |
|
778 PyString_FromString((char *) PVbuffer[i])); |
|
779 } |
|
780 |
|
781 PyMem_DEL(PVbuffer); |
|
782 |
|
783 return list; |
|
784 } |
|
785 |
|
786 static PyObject * |
|
787 cl_QuerySchemeFromName(PyObject *self, PyObject *args) |
|
788 { |
|
789 int algorithmMediaType; |
|
790 char *name; |
|
791 int scheme; |
|
792 |
|
793 if (!PyArg_ParseTuple(args, "is", &algorithmMediaType, &name)) |
|
794 return NULL; |
|
795 |
|
796 error_handler_called = 0; |
|
797 scheme = clQuerySchemeFromName(algorithmMediaType, name); |
|
798 if (error_handler_called) { |
|
799 PyErr_SetString(ClError, "unknown compression scheme"); |
|
800 return NULL; |
|
801 } |
|
802 |
|
803 return PyInt_FromLong(scheme); |
|
804 } |
|
805 |
|
806 static PyObject * |
|
807 cl_GetAlgorithmName(PyObject *self, PyObject *args) |
|
808 { |
|
809 int scheme; |
|
810 char *name; |
|
811 |
|
812 if (!PyArg_ParseTuple(args, "i", &scheme)) |
|
813 return NULL; |
|
814 |
|
815 name = clGetAlgorithmName(scheme); |
|
816 if (name == 0) { |
|
817 PyErr_SetString(ClError, "unknown compression scheme"); |
|
818 return NULL; |
|
819 } |
|
820 |
|
821 return PyString_FromString(name); |
|
822 } |
|
823 |
|
824 static PyObject * |
|
825 do_set(PyObject *self, PyObject *args, int (*func)(int, int, int)) |
|
826 { |
|
827 int scheme, paramID, value; |
|
828 float fvalue; |
|
829 int is_float = 0; |
|
830 |
|
831 if (!PyArg_ParseTuple(args, "iii", &scheme, ¶mID, &value)) { |
|
832 PyErr_Clear(); |
|
833 if (!PyArg_ParseTuple(args, "iif", &scheme, ¶mID, &fvalue)) { |
|
834 PyErr_Clear(); |
|
835 PyErr_SetString(PyExc_TypeError, |
|
836 "bad argument list (format '(iii)' or '(iif)')"); |
|
837 return NULL; |
|
838 } |
|
839 value = CL_TypeIsInt(fvalue); |
|
840 is_float = 1; |
|
841 } else { |
|
842 /* check some parameters which we know to be floats */ |
|
843 switch (scheme) { |
|
844 case CL_COMPRESSION_RATIO: |
|
845 case CL_SPEED: |
|
846 fvalue = value; |
|
847 value = CL_TypeIsInt(fvalue); |
|
848 is_float = 1; |
|
849 break; |
|
850 } |
|
851 } |
|
852 |
|
853 error_handler_called = 0; |
|
854 value = (*func)(scheme, paramID, value); |
|
855 if (error_handler_called) |
|
856 return NULL; |
|
857 |
|
858 if (is_float) |
|
859 return PyFloat_FromDouble(CL_TypeIsFloat(value)); |
|
860 else |
|
861 return PyInt_FromLong(value); |
|
862 } |
|
863 |
|
864 static PyObject * |
|
865 cl_SetDefault(PyObject *self, PyObject *args) |
|
866 { |
|
867 return do_set(self, args, clSetDefault); |
|
868 } |
|
869 |
|
870 static PyObject * |
|
871 cl_SetMin(PyObject *self, PyObject *args) |
|
872 { |
|
873 return do_set(self, args, clSetMin); |
|
874 } |
|
875 |
|
876 static PyObject * |
|
877 cl_SetMax(PyObject *self, PyObject *args) |
|
878 { |
|
879 return do_set(self, args, clSetMax); |
|
880 } |
|
881 |
|
882 #define func(name, handler) \ |
|
883 static PyObject *cl_##name(PyObject *self, PyObject *args) \ |
|
884 { \ |
|
885 int x; \ |
|
886 if (!PyArg_ParseTuple(args, "i", &x)) return NULL; \ |
|
887 return Py##handler(CL_##name(x)); \ |
|
888 } |
|
889 |
|
890 #define func2(name, handler) \ |
|
891 static PyObject *cl_##name(PyObject *self, PyObject *args) \ |
|
892 { \ |
|
893 int a1, a2; \ |
|
894 if (!PyArg_ParseTuple(args, "ii", &a1, &a2)) return NULL; \ |
|
895 return Py##handler(CL_##name(a1, a2)); \ |
|
896 } |
|
897 |
|
898 func(BytesPerSample, Int_FromLong) |
|
899 func(BytesPerPixel, Int_FromLong) |
|
900 func(AudioFormatName, String_FromString) |
|
901 func(VideoFormatName, String_FromString) |
|
902 func(AlgorithmNumber, Int_FromLong) |
|
903 func(AlgorithmType, Int_FromLong) |
|
904 func2(Algorithm, Int_FromLong) |
|
905 func(ParamNumber, Int_FromLong) |
|
906 func(ParamType, Int_FromLong) |
|
907 func2(ParamID, Int_FromLong) |
|
908 |
|
909 #ifdef CLDEBUG |
|
910 static PyObject * |
|
911 cvt_type(PyObject *self, PyObject *args) |
|
912 { |
|
913 int number; |
|
914 float fnumber; |
|
915 |
|
916 if (PyArg_Parse(args, "i", &number)) |
|
917 return PyFloat_FromDouble(CL_TypeIsFloat(number)); |
|
918 else { |
|
919 PyErr_Clear(); |
|
920 if (PyArg_Parse(args, "f", &fnumber)) |
|
921 return PyInt_FromLong(CL_TypeIsInt(fnumber)); |
|
922 return NULL; |
|
923 } |
|
924 } |
|
925 #endif |
|
926 |
|
927 static PyMethodDef cl_methods[] = { |
|
928 {"CompressImage", cl_CompressImage, METH_VARARGS}, |
|
929 {"DecompressImage", cl_DecompressImage, METH_VARARGS}, |
|
930 {"GetAlgorithmName", cl_GetAlgorithmName, METH_VARARGS}, |
|
931 {"OpenCompressor", cl_OpenCompressor, METH_VARARGS}, |
|
932 {"OpenDecompressor", cl_OpenDecompressor, METH_VARARGS}, |
|
933 {"QueryAlgorithms", cl_QueryAlgorithms, METH_VARARGS}, |
|
934 {"QueryMaxHeaderSize", cl_QueryMaxHeaderSize, METH_VARARGS}, |
|
935 {"QueryScheme", cl_QueryScheme, METH_VARARGS}, |
|
936 {"QuerySchemeFromName", cl_QuerySchemeFromName, METH_VARARGS}, |
|
937 {"SetDefault", cl_SetDefault, METH_VARARGS}, |
|
938 {"SetMax", cl_SetMax, METH_VARARGS}, |
|
939 {"SetMin", cl_SetMin, METH_VARARGS}, |
|
940 {"BytesPerSample", cl_BytesPerSample, METH_VARARGS}, |
|
941 {"BytesPerPixel", cl_BytesPerPixel, METH_VARARGS}, |
|
942 {"AudioFormatName", cl_AudioFormatName, METH_VARARGS}, |
|
943 {"VideoFormatName", cl_VideoFormatName, METH_VARARGS}, |
|
944 {"AlgorithmNumber", cl_AlgorithmNumber, METH_VARARGS}, |
|
945 {"AlgorithmType", cl_AlgorithmType, METH_VARARGS}, |
|
946 {"Algorithm", cl_Algorithm, METH_VARARGS}, |
|
947 {"ParamNumber", cl_ParamNumber, METH_VARARGS}, |
|
948 {"ParamType", cl_ParamType, METH_VARARGS}, |
|
949 {"ParamID", cl_ParamID, METH_VARARGS}, |
|
950 #ifdef CLDEBUG |
|
951 {"cvt_type", cvt_type, METH_VARARGS}, |
|
952 #endif |
|
953 {NULL, NULL} /* Sentinel */ |
|
954 }; |
|
955 |
|
956 #ifdef CL_JPEG_SOFTWARE |
|
957 #define IRIX_5_3_LIBRARY |
|
958 #endif |
|
959 |
|
960 void |
|
961 initcl(void) |
|
962 { |
|
963 PyObject *m, *d, *x; |
|
964 |
|
965 if (PyErr_WarnPy3k("the cl module has been removed in " |
|
966 "Python 3.0", 2) < 0) |
|
967 return; |
|
968 |
|
969 m = Py_InitModule("cl", cl_methods); |
|
970 if (m == NULL) |
|
971 return; |
|
972 d = PyModule_GetDict(m); |
|
973 |
|
974 ClError = PyErr_NewException("cl.error", NULL, NULL); |
|
975 (void) PyDict_SetItemString(d, "error", ClError); |
|
976 |
|
977 #ifdef CL_ADDED_ALGORITHM_ERROR |
|
978 x = PyInt_FromLong(CL_ADDED_ALGORITHM_ERROR); |
|
979 if (x == NULL || PyDict_SetItemString(d, "ADDED_ALGORITHM_ERROR", x) < 0) |
|
980 return; |
|
981 Py_DECREF(x); |
|
982 #endif |
|
983 #ifdef CL_ALAW |
|
984 x = PyInt_FromLong(CL_ALAW); |
|
985 if (x == NULL || PyDict_SetItemString(d, "ALAW", x) < 0) |
|
986 return; |
|
987 Py_DECREF(x); |
|
988 #endif |
|
989 #ifdef CL_ALGORITHM_ID |
|
990 x = PyInt_FromLong(CL_ALGORITHM_ID); |
|
991 if (x == NULL || PyDict_SetItemString(d, "ALGORITHM_ID", x) < 0) |
|
992 return; |
|
993 Py_DECREF(x); |
|
994 #endif |
|
995 #ifdef CL_ALGORITHM_TABLE_FULL |
|
996 x = PyInt_FromLong(CL_ALGORITHM_TABLE_FULL); |
|
997 if (x == NULL || PyDict_SetItemString(d, "ALGORITHM_TABLE_FULL", x) < 0) |
|
998 return; |
|
999 Py_DECREF(x); |
|
1000 #endif |
|
1001 #ifdef CL_ALGORITHM_VERSION |
|
1002 x = PyInt_FromLong(CL_ALGORITHM_VERSION); |
|
1003 if (x == NULL || PyDict_SetItemString(d, "ALGORITHM_VERSION", x) < 0) |
|
1004 return; |
|
1005 Py_DECREF(x); |
|
1006 #endif |
|
1007 #ifdef CL_ALG_AUDIO |
|
1008 x = PyInt_FromLong(CL_ALG_AUDIO); |
|
1009 if (x == NULL || PyDict_SetItemString(d, "ALG_AUDIO", x) < 0) |
|
1010 return; |
|
1011 Py_DECREF(x); |
|
1012 #endif |
|
1013 #ifdef CL_ALG_VIDEO |
|
1014 x = PyInt_FromLong(CL_ALG_VIDEO); |
|
1015 if (x == NULL || PyDict_SetItemString(d, "ALG_VIDEO", x) < 0) |
|
1016 return; |
|
1017 Py_DECREF(x); |
|
1018 #endif |
|
1019 #ifdef CL_AUDIO |
|
1020 x = PyInt_FromLong(CL_AUDIO); |
|
1021 if (x == NULL || PyDict_SetItemString(d, "AUDIO", x) < 0) |
|
1022 return; |
|
1023 Py_DECREF(x); |
|
1024 #endif |
|
1025 #ifdef CL_AWARE_BITRATE_POLICY |
|
1026 x = PyInt_FromLong(CL_AWARE_BITRATE_POLICY); |
|
1027 if (x == NULL || PyDict_SetItemString(d, "AWARE_BITRATE_POLICY", x) < 0) |
|
1028 return; |
|
1029 Py_DECREF(x); |
|
1030 #endif |
|
1031 #ifdef CL_AWARE_BITRATE_TARGET |
|
1032 x = PyInt_FromLong(CL_AWARE_BITRATE_TARGET); |
|
1033 if (x == NULL || PyDict_SetItemString(d, "AWARE_BITRATE_TARGET", x) < 0) |
|
1034 return; |
|
1035 Py_DECREF(x); |
|
1036 #endif |
|
1037 #ifdef CL_AWARE_CHANNEL_POLICY |
|
1038 x = PyInt_FromLong(CL_AWARE_CHANNEL_POLICY); |
|
1039 if (x == NULL || PyDict_SetItemString(d, "AWARE_CHANNEL_POLICY", x) < 0) |
|
1040 return; |
|
1041 Py_DECREF(x); |
|
1042 #endif |
|
1043 #ifdef CL_AWARE_CONST_QUAL |
|
1044 x = PyInt_FromLong(CL_AWARE_CONST_QUAL); |
|
1045 if (x == NULL || PyDict_SetItemString(d, "AWARE_CONST_QUAL", x) < 0) |
|
1046 return; |
|
1047 Py_DECREF(x); |
|
1048 #endif |
|
1049 #ifdef CL_AWARE_ERROR |
|
1050 x = PyInt_FromLong(CL_AWARE_ERROR); |
|
1051 if (x == NULL || PyDict_SetItemString(d, "AWARE_ERROR", x) < 0) |
|
1052 return; |
|
1053 Py_DECREF(x); |
|
1054 #endif |
|
1055 #ifdef CL_AWARE_FIXED_RATE |
|
1056 x = PyInt_FromLong(CL_AWARE_FIXED_RATE); |
|
1057 if (x == NULL || PyDict_SetItemString(d, "AWARE_FIXED_RATE", x) < 0) |
|
1058 return; |
|
1059 Py_DECREF(x); |
|
1060 #endif |
|
1061 #ifdef CL_AWARE_INDEPENDENT |
|
1062 x = PyInt_FromLong(CL_AWARE_INDEPENDENT); |
|
1063 if (x == NULL || PyDict_SetItemString(d, "AWARE_INDEPENDENT", x) < 0) |
|
1064 return; |
|
1065 Py_DECREF(x); |
|
1066 #endif |
|
1067 #ifdef CL_AWARE_JOINT_STEREO |
|
1068 x = PyInt_FromLong(CL_AWARE_JOINT_STEREO); |
|
1069 if (x == NULL || PyDict_SetItemString(d, "AWARE_JOINT_STEREO", x) < 0) |
|
1070 return; |
|
1071 Py_DECREF(x); |
|
1072 #endif |
|
1073 #ifdef CL_AWARE_LAYER |
|
1074 x = PyInt_FromLong(CL_AWARE_LAYER); |
|
1075 if (x == NULL || PyDict_SetItemString(d, "AWARE_LAYER", x) < 0) |
|
1076 return; |
|
1077 Py_DECREF(x); |
|
1078 #endif |
|
1079 #ifdef CL_AWARE_LOSSLESS |
|
1080 x = PyInt_FromLong(CL_AWARE_LOSSLESS); |
|
1081 if (x == NULL || PyDict_SetItemString(d, "AWARE_LOSSLESS", x) < 0) |
|
1082 return; |
|
1083 Py_DECREF(x); |
|
1084 #endif |
|
1085 #ifdef CL_AWARE_MPEG_AUDIO |
|
1086 x = PyInt_FromLong(CL_AWARE_MPEG_AUDIO); |
|
1087 if (x == NULL || PyDict_SetItemString(d, "AWARE_MPEG_AUDIO", x) < 0) |
|
1088 return; |
|
1089 Py_DECREF(x); |
|
1090 #endif |
|
1091 #ifdef CL_AWARE_MPEG_LAYER_I |
|
1092 x = PyInt_FromLong(CL_AWARE_MPEG_LAYER_I); |
|
1093 if (x == NULL || PyDict_SetItemString(d, "AWARE_MPEG_LAYER_I", x) < 0) |
|
1094 return; |
|
1095 Py_DECREF(x); |
|
1096 #endif |
|
1097 #ifdef CL_AWARE_MPEG_LAYER_II |
|
1098 x = PyInt_FromLong(CL_AWARE_MPEG_LAYER_II); |
|
1099 if (x == NULL || PyDict_SetItemString(d, "AWARE_MPEG_LAYER_II", x) < 0) |
|
1100 return; |
|
1101 Py_DECREF(x); |
|
1102 #endif |
|
1103 #ifdef CL_AWARE_MULTIRATE |
|
1104 x = PyInt_FromLong(CL_AWARE_MULTIRATE); |
|
1105 if (x == NULL || PyDict_SetItemString(d, "AWARE_MULTIRATE", x) < 0) |
|
1106 return; |
|
1107 Py_DECREF(x); |
|
1108 #endif |
|
1109 #ifdef CL_AWARE_NOISE_MARGIN |
|
1110 x = PyInt_FromLong(CL_AWARE_NOISE_MARGIN); |
|
1111 if (x == NULL || PyDict_SetItemString(d, "AWARE_NOISE_MARGIN", x) < 0) |
|
1112 return; |
|
1113 Py_DECREF(x); |
|
1114 #endif |
|
1115 #ifdef CL_AWARE_STEREO |
|
1116 x = PyInt_FromLong(CL_AWARE_STEREO); |
|
1117 if (x == NULL || PyDict_SetItemString(d, "AWARE_STEREO", x) < 0) |
|
1118 return; |
|
1119 Py_DECREF(x); |
|
1120 #endif |
|
1121 #ifdef CL_BAD_ALGORITHM_NAME |
|
1122 x = PyInt_FromLong(CL_BAD_ALGORITHM_NAME); |
|
1123 if (x == NULL || PyDict_SetItemString(d, "BAD_ALGORITHM_NAME", x) < 0) |
|
1124 return; |
|
1125 Py_DECREF(x); |
|
1126 #endif |
|
1127 #ifdef CL_BAD_ALGORITHM_TYPE |
|
1128 x = PyInt_FromLong(CL_BAD_ALGORITHM_TYPE); |
|
1129 if (x == NULL || PyDict_SetItemString(d, "BAD_ALGORITHM_TYPE", x) < 0) |
|
1130 return; |
|
1131 Py_DECREF(x); |
|
1132 #endif |
|
1133 #ifdef CL_BAD_BLOCK_SIZE |
|
1134 x = PyInt_FromLong(CL_BAD_BLOCK_SIZE); |
|
1135 if (x == NULL || PyDict_SetItemString(d, "BAD_BLOCK_SIZE", x) < 0) |
|
1136 return; |
|
1137 Py_DECREF(x); |
|
1138 #endif |
|
1139 #ifdef CL_BAD_BOARD |
|
1140 x = PyInt_FromLong(CL_BAD_BOARD); |
|
1141 if (x == NULL || PyDict_SetItemString(d, "BAD_BOARD", x) < 0) |
|
1142 return; |
|
1143 Py_DECREF(x); |
|
1144 #endif |
|
1145 #ifdef CL_BAD_BUFFERING |
|
1146 x = PyInt_FromLong(CL_BAD_BUFFERING); |
|
1147 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERING", x) < 0) |
|
1148 return; |
|
1149 Py_DECREF(x); |
|
1150 #endif |
|
1151 #ifdef CL_BAD_BUFFERLENGTH_NEG |
|
1152 x = PyInt_FromLong(CL_BAD_BUFFERLENGTH_NEG); |
|
1153 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", x) < 0) |
|
1154 return; |
|
1155 Py_DECREF(x); |
|
1156 #endif |
|
1157 #ifdef CL_BAD_BUFFERLENGTH_ODD |
|
1158 x = PyInt_FromLong(CL_BAD_BUFFERLENGTH_ODD); |
|
1159 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", x) < 0) |
|
1160 return; |
|
1161 Py_DECREF(x); |
|
1162 #endif |
|
1163 #ifdef CL_BAD_BUFFER_EXISTS |
|
1164 x = PyInt_FromLong(CL_BAD_BUFFER_EXISTS); |
|
1165 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_EXISTS", x) < 0) |
|
1166 return; |
|
1167 Py_DECREF(x); |
|
1168 #endif |
|
1169 #ifdef CL_BAD_BUFFER_HANDLE |
|
1170 x = PyInt_FromLong(CL_BAD_BUFFER_HANDLE); |
|
1171 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_HANDLE", x) < 0) |
|
1172 return; |
|
1173 Py_DECREF(x); |
|
1174 #endif |
|
1175 #ifdef CL_BAD_BUFFER_POINTER |
|
1176 x = PyInt_FromLong(CL_BAD_BUFFER_POINTER); |
|
1177 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_POINTER", x) < 0) |
|
1178 return; |
|
1179 Py_DECREF(x); |
|
1180 #endif |
|
1181 #ifdef CL_BAD_BUFFER_QUERY_SIZE |
|
1182 x = PyInt_FromLong(CL_BAD_BUFFER_QUERY_SIZE); |
|
1183 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_QUERY_SIZE", x) < 0) |
|
1184 return; |
|
1185 Py_DECREF(x); |
|
1186 #endif |
|
1187 #ifdef CL_BAD_BUFFER_SIZE |
|
1188 x = PyInt_FromLong(CL_BAD_BUFFER_SIZE); |
|
1189 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_SIZE", x) < 0) |
|
1190 return; |
|
1191 Py_DECREF(x); |
|
1192 #endif |
|
1193 #ifdef CL_BAD_BUFFER_SIZE_POINTER |
|
1194 x = PyInt_FromLong(CL_BAD_BUFFER_SIZE_POINTER); |
|
1195 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_SIZE_POINTER", x) < 0) |
|
1196 return; |
|
1197 Py_DECREF(x); |
|
1198 #endif |
|
1199 #ifdef CL_BAD_BUFFER_TYPE |
|
1200 x = PyInt_FromLong(CL_BAD_BUFFER_TYPE); |
|
1201 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_TYPE", x) < 0) |
|
1202 return; |
|
1203 Py_DECREF(x); |
|
1204 #endif |
|
1205 #ifdef CL_BAD_COMPRESSION_SCHEME |
|
1206 x = PyInt_FromLong(CL_BAD_COMPRESSION_SCHEME); |
|
1207 if (x == NULL || PyDict_SetItemString(d, "BAD_COMPRESSION_SCHEME", x) < 0) |
|
1208 return; |
|
1209 Py_DECREF(x); |
|
1210 #endif |
|
1211 #ifdef CL_BAD_COMPRESSOR_HANDLE |
|
1212 x = PyInt_FromLong(CL_BAD_COMPRESSOR_HANDLE); |
|
1213 if (x == NULL || PyDict_SetItemString(d, "BAD_COMPRESSOR_HANDLE", x) < 0) |
|
1214 return; |
|
1215 Py_DECREF(x); |
|
1216 #endif |
|
1217 #ifdef CL_BAD_COMPRESSOR_HANDLE_POINTER |
|
1218 x = PyInt_FromLong(CL_BAD_COMPRESSOR_HANDLE_POINTER); |
|
1219 if (x == NULL || PyDict_SetItemString(d, "BAD_COMPRESSOR_HANDLE_POINTER", x) < 0) |
|
1220 return; |
|
1221 Py_DECREF(x); |
|
1222 #endif |
|
1223 #ifdef CL_BAD_FRAME_SIZE |
|
1224 x = PyInt_FromLong(CL_BAD_FRAME_SIZE); |
|
1225 if (x == NULL || PyDict_SetItemString(d, "BAD_FRAME_SIZE", x) < 0) |
|
1226 return; |
|
1227 Py_DECREF(x); |
|
1228 #endif |
|
1229 #ifdef CL_BAD_FUNCTIONALITY |
|
1230 x = PyInt_FromLong(CL_BAD_FUNCTIONALITY); |
|
1231 if (x == NULL || PyDict_SetItemString(d, "BAD_FUNCTIONALITY", x) < 0) |
|
1232 return; |
|
1233 Py_DECREF(x); |
|
1234 #endif |
|
1235 #ifdef CL_BAD_FUNCTION_POINTER |
|
1236 x = PyInt_FromLong(CL_BAD_FUNCTION_POINTER); |
|
1237 if (x == NULL || PyDict_SetItemString(d, "BAD_FUNCTION_POINTER", x) < 0) |
|
1238 return; |
|
1239 Py_DECREF(x); |
|
1240 #endif |
|
1241 #ifdef CL_BAD_HEADER_SIZE |
|
1242 x = PyInt_FromLong(CL_BAD_HEADER_SIZE); |
|
1243 if (x == NULL || PyDict_SetItemString(d, "BAD_HEADER_SIZE", x) < 0) |
|
1244 return; |
|
1245 Py_DECREF(x); |
|
1246 #endif |
|
1247 #ifdef CL_BAD_INITIAL_VALUE |
|
1248 x = PyInt_FromLong(CL_BAD_INITIAL_VALUE); |
|
1249 if (x == NULL || PyDict_SetItemString(d, "BAD_INITIAL_VALUE", x) < 0) |
|
1250 return; |
|
1251 Py_DECREF(x); |
|
1252 #endif |
|
1253 #ifdef CL_BAD_INTERNAL_FORMAT |
|
1254 x = PyInt_FromLong(CL_BAD_INTERNAL_FORMAT); |
|
1255 if (x == NULL || PyDict_SetItemString(d, "BAD_INTERNAL_FORMAT", x) < 0) |
|
1256 return; |
|
1257 Py_DECREF(x); |
|
1258 #endif |
|
1259 #ifdef CL_BAD_LICENSE |
|
1260 x = PyInt_FromLong(CL_BAD_LICENSE); |
|
1261 if (x == NULL || PyDict_SetItemString(d, "BAD_LICENSE", x) < 0) |
|
1262 return; |
|
1263 Py_DECREF(x); |
|
1264 #endif |
|
1265 #ifdef CL_BAD_MIN_GT_MAX |
|
1266 x = PyInt_FromLong(CL_BAD_MIN_GT_MAX); |
|
1267 if (x == NULL || PyDict_SetItemString(d, "BAD_MIN_GT_MAX", x) < 0) |
|
1268 return; |
|
1269 Py_DECREF(x); |
|
1270 #endif |
|
1271 #ifdef CL_BAD_NO_BUFFERSPACE |
|
1272 x = PyInt_FromLong(CL_BAD_NO_BUFFERSPACE); |
|
1273 if (x == NULL || PyDict_SetItemString(d, "BAD_NO_BUFFERSPACE", x) < 0) |
|
1274 return; |
|
1275 Py_DECREF(x); |
|
1276 #endif |
|
1277 #ifdef CL_BAD_NUMBER_OF_BLOCKS |
|
1278 x = PyInt_FromLong(CL_BAD_NUMBER_OF_BLOCKS); |
|
1279 if (x == NULL || PyDict_SetItemString(d, "BAD_NUMBER_OF_BLOCKS", x) < 0) |
|
1280 return; |
|
1281 Py_DECREF(x); |
|
1282 #endif |
|
1283 #ifdef CL_BAD_PARAM |
|
1284 x = PyInt_FromLong(CL_BAD_PARAM); |
|
1285 if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM", x) < 0) |
|
1286 return; |
|
1287 Py_DECREF(x); |
|
1288 #endif |
|
1289 #ifdef CL_BAD_PARAM_ID_POINTER |
|
1290 x = PyInt_FromLong(CL_BAD_PARAM_ID_POINTER); |
|
1291 if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM_ID_POINTER", x) < 0) |
|
1292 return; |
|
1293 Py_DECREF(x); |
|
1294 #endif |
|
1295 #ifdef CL_BAD_PARAM_TYPE |
|
1296 x = PyInt_FromLong(CL_BAD_PARAM_TYPE); |
|
1297 if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM_TYPE", x) < 0) |
|
1298 return; |
|
1299 Py_DECREF(x); |
|
1300 #endif |
|
1301 #ifdef CL_BAD_POINTER |
|
1302 x = PyInt_FromLong(CL_BAD_POINTER); |
|
1303 if (x == NULL || PyDict_SetItemString(d, "BAD_POINTER", x) < 0) |
|
1304 return; |
|
1305 Py_DECREF(x); |
|
1306 #endif |
|
1307 #ifdef CL_BAD_PVBUFFER |
|
1308 x = PyInt_FromLong(CL_BAD_PVBUFFER); |
|
1309 if (x == NULL || PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0) |
|
1310 return; |
|
1311 Py_DECREF(x); |
|
1312 #endif |
|
1313 #ifdef CL_BAD_SCHEME_POINTER |
|
1314 x = PyInt_FromLong(CL_BAD_SCHEME_POINTER); |
|
1315 if (x == NULL || PyDict_SetItemString(d, "BAD_SCHEME_POINTER", x) < 0) |
|
1316 return; |
|
1317 Py_DECREF(x); |
|
1318 #endif |
|
1319 #ifdef CL_BAD_STREAM_HEADER |
|
1320 x = PyInt_FromLong(CL_BAD_STREAM_HEADER); |
|
1321 if (x == NULL || PyDict_SetItemString(d, "BAD_STREAM_HEADER", x) < 0) |
|
1322 return; |
|
1323 Py_DECREF(x); |
|
1324 #endif |
|
1325 #ifdef CL_BAD_STRING_POINTER |
|
1326 x = PyInt_FromLong(CL_BAD_STRING_POINTER); |
|
1327 if (x == NULL || PyDict_SetItemString(d, "BAD_STRING_POINTER", x) < 0) |
|
1328 return; |
|
1329 Py_DECREF(x); |
|
1330 #endif |
|
1331 #ifdef CL_BAD_TEXT_STRING_PTR |
|
1332 x = PyInt_FromLong(CL_BAD_TEXT_STRING_PTR); |
|
1333 if (x == NULL || PyDict_SetItemString(d, "BAD_TEXT_STRING_PTR", x) < 0) |
|
1334 return; |
|
1335 Py_DECREF(x); |
|
1336 #endif |
|
1337 #ifdef CL_BEST_FIT |
|
1338 x = PyInt_FromLong(CL_BEST_FIT); |
|
1339 if (x == NULL || PyDict_SetItemString(d, "BEST_FIT", x) < 0) |
|
1340 return; |
|
1341 Py_DECREF(x); |
|
1342 #endif |
|
1343 #ifdef CL_BIDIRECTIONAL |
|
1344 x = PyInt_FromLong(CL_BIDIRECTIONAL); |
|
1345 if (x == NULL || PyDict_SetItemString(d, "BIDIRECTIONAL", x) < 0) |
|
1346 return; |
|
1347 Py_DECREF(x); |
|
1348 #endif |
|
1349 #ifdef CL_BITRATE |
|
1350 x = PyInt_FromLong(CL_BITRATE); |
|
1351 if (x == NULL || PyDict_SetItemString(d, "BITRATE", x) < 0) |
|
1352 return; |
|
1353 Py_DECREF(x); |
|
1354 #endif |
|
1355 #ifdef CL_BITRATE_POLICY |
|
1356 x = PyInt_FromLong(CL_BITRATE_POLICY); |
|
1357 if (x == NULL || PyDict_SetItemString(d, "BITRATE_POLICY", x) < 0) |
|
1358 return; |
|
1359 Py_DECREF(x); |
|
1360 #endif |
|
1361 #ifdef CL_BITRATE_TARGET |
|
1362 x = PyInt_FromLong(CL_BITRATE_TARGET); |
|
1363 if (x == NULL || PyDict_SetItemString(d, "BITRATE_TARGET", x) < 0) |
|
1364 return; |
|
1365 Py_DECREF(x); |
|
1366 #endif |
|
1367 #ifdef CL_BITS_PER_COMPONENT |
|
1368 x = PyInt_FromLong(CL_BITS_PER_COMPONENT); |
|
1369 if (x == NULL || PyDict_SetItemString(d, "BITS_PER_COMPONENT", x) < 0) |
|
1370 return; |
|
1371 Py_DECREF(x); |
|
1372 #endif |
|
1373 #ifdef CL_BLENDING |
|
1374 x = PyInt_FromLong(CL_BLENDING); |
|
1375 if (x == NULL || PyDict_SetItemString(d, "BLENDING", x) < 0) |
|
1376 return; |
|
1377 Py_DECREF(x); |
|
1378 #endif |
|
1379 #ifdef CL_BLOCK_SIZE |
|
1380 x = PyInt_FromLong(CL_BLOCK_SIZE); |
|
1381 if (x == NULL || PyDict_SetItemString(d, "BLOCK_SIZE", x) < 0) |
|
1382 return; |
|
1383 Py_DECREF(x); |
|
1384 #endif |
|
1385 #ifdef CL_BOTTOM_UP |
|
1386 x = PyInt_FromLong(CL_BOTTOM_UP); |
|
1387 if (x == NULL || PyDict_SetItemString(d, "BOTTOM_UP", x) < 0) |
|
1388 return; |
|
1389 Py_DECREF(x); |
|
1390 #endif |
|
1391 #ifdef CL_BUFFER_NOT_CREATED |
|
1392 x = PyInt_FromLong(CL_BUFFER_NOT_CREATED); |
|
1393 if (x == NULL || PyDict_SetItemString(d, "BUFFER_NOT_CREATED", x) < 0) |
|
1394 return; |
|
1395 Py_DECREF(x); |
|
1396 #endif |
|
1397 #ifdef CL_BUF_COMPRESSED |
|
1398 x = PyInt_FromLong(CL_BUF_COMPRESSED); |
|
1399 if (x == NULL || PyDict_SetItemString(d, "BUF_COMPRESSED", x) < 0) |
|
1400 return; |
|
1401 Py_DECREF(x); |
|
1402 #endif |
|
1403 #ifdef CL_BUF_DATA |
|
1404 x = PyInt_FromLong(CL_BUF_DATA); |
|
1405 if (x == NULL || PyDict_SetItemString(d, "BUF_DATA", x) < 0) |
|
1406 return; |
|
1407 Py_DECREF(x); |
|
1408 #endif |
|
1409 #ifdef CL_BUF_FRAME |
|
1410 x = PyInt_FromLong(CL_BUF_FRAME); |
|
1411 if (x == NULL || PyDict_SetItemString(d, "BUF_FRAME", x) < 0) |
|
1412 return; |
|
1413 Py_DECREF(x); |
|
1414 #endif |
|
1415 #ifdef CL_CHANNEL_POLICY |
|
1416 x = PyInt_FromLong(CL_CHANNEL_POLICY); |
|
1417 if (x == NULL || PyDict_SetItemString(d, "CHANNEL_POLICY", x) < 0) |
|
1418 return; |
|
1419 Py_DECREF(x); |
|
1420 #endif |
|
1421 #ifdef CL_CHROMA_THRESHOLD |
|
1422 x = PyInt_FromLong(CL_CHROMA_THRESHOLD); |
|
1423 if (x == NULL || PyDict_SetItemString(d, "CHROMA_THRESHOLD", x) < 0) |
|
1424 return; |
|
1425 Py_DECREF(x); |
|
1426 #endif |
|
1427 #ifdef CL_CODEC |
|
1428 x = PyInt_FromLong(CL_CODEC); |
|
1429 if (x == NULL || PyDict_SetItemString(d, "CODEC", x) < 0) |
|
1430 return; |
|
1431 Py_DECREF(x); |
|
1432 #endif |
|
1433 #ifdef CL_COMPONENTS |
|
1434 x = PyInt_FromLong(CL_COMPONENTS); |
|
1435 if (x == NULL || PyDict_SetItemString(d, "COMPONENTS", x) < 0) |
|
1436 return; |
|
1437 Py_DECREF(x); |
|
1438 #endif |
|
1439 #ifdef CL_COMPRESSED_BUFFER_SIZE |
|
1440 x = PyInt_FromLong(CL_COMPRESSED_BUFFER_SIZE); |
|
1441 if (x == NULL || PyDict_SetItemString(d, "COMPRESSED_BUFFER_SIZE", x) < 0) |
|
1442 return; |
|
1443 Py_DECREF(x); |
|
1444 #endif |
|
1445 #ifdef CL_COMPRESSION_RATIO |
|
1446 x = PyInt_FromLong(CL_COMPRESSION_RATIO); |
|
1447 if (x == NULL || PyDict_SetItemString(d, "COMPRESSION_RATIO", x) < 0) |
|
1448 return; |
|
1449 Py_DECREF(x); |
|
1450 #endif |
|
1451 #ifdef CL_COMPRESSOR |
|
1452 x = PyInt_FromLong(CL_COMPRESSOR); |
|
1453 if (x == NULL || PyDict_SetItemString(d, "COMPRESSOR", x) < 0) |
|
1454 return; |
|
1455 Py_DECREF(x); |
|
1456 #endif |
|
1457 #ifdef CL_CONTINUOUS_BLOCK |
|
1458 x = PyInt_FromLong(CL_CONTINUOUS_BLOCK); |
|
1459 if (x == NULL || PyDict_SetItemString(d, "CONTINUOUS_BLOCK", x) < 0) |
|
1460 return; |
|
1461 Py_DECREF(x); |
|
1462 #endif |
|
1463 #ifdef CL_CONTINUOUS_NONBLOCK |
|
1464 x = PyInt_FromLong(CL_CONTINUOUS_NONBLOCK); |
|
1465 if (x == NULL || PyDict_SetItemString(d, "CONTINUOUS_NONBLOCK", x) < 0) |
|
1466 return; |
|
1467 Py_DECREF(x); |
|
1468 #endif |
|
1469 #ifdef CL_COSMO_CODEC_CONTROL |
|
1470 x = PyInt_FromLong(CL_COSMO_CODEC_CONTROL); |
|
1471 if (x == NULL || PyDict_SetItemString(d, "COSMO_CODEC_CONTROL", x) < 0) |
|
1472 return; |
|
1473 Py_DECREF(x); |
|
1474 #endif |
|
1475 #ifdef CL_COSMO_NUM_PARAMS |
|
1476 x = PyInt_FromLong(CL_COSMO_NUM_PARAMS); |
|
1477 if (x == NULL || PyDict_SetItemString(d, "COSMO_NUM_PARAMS", x) < 0) |
|
1478 return; |
|
1479 Py_DECREF(x); |
|
1480 #endif |
|
1481 #ifdef CL_COSMO_VALUE_BASE |
|
1482 x = PyInt_FromLong(CL_COSMO_VALUE_BASE); |
|
1483 if (x == NULL || PyDict_SetItemString(d, "COSMO_VALUE_BASE", x) < 0) |
|
1484 return; |
|
1485 Py_DECREF(x); |
|
1486 #endif |
|
1487 #ifdef CL_COSMO_VIDEO_MANUAL_CONTROL |
|
1488 x = PyInt_FromLong(CL_COSMO_VIDEO_MANUAL_CONTROL); |
|
1489 if (x == NULL || PyDict_SetItemString(d, "COSMO_VIDEO_MANUAL_CONTROL", x) < 0) |
|
1490 return; |
|
1491 Py_DECREF(x); |
|
1492 #endif |
|
1493 #ifdef CL_COSMO_VIDEO_TRANSFER_MODE |
|
1494 x = PyInt_FromLong(CL_COSMO_VIDEO_TRANSFER_MODE); |
|
1495 if (x == NULL || PyDict_SetItemString(d, "COSMO_VIDEO_TRANSFER_MODE", x) < 0) |
|
1496 return; |
|
1497 Py_DECREF(x); |
|
1498 #endif |
|
1499 #ifdef CL_DATA |
|
1500 x = PyInt_FromLong(CL_DATA); |
|
1501 if (x == NULL || PyDict_SetItemString(d, "DATA", x) < 0) |
|
1502 return; |
|
1503 Py_DECREF(x); |
|
1504 #endif |
|
1505 #ifdef CL_DECOMPRESSOR |
|
1506 x = PyInt_FromLong(CL_DECOMPRESSOR); |
|
1507 if (x == NULL || PyDict_SetItemString(d, "DECOMPRESSOR", x) < 0) |
|
1508 return; |
|
1509 Py_DECREF(x); |
|
1510 #endif |
|
1511 #ifdef CL_DSO_ERROR |
|
1512 x = PyInt_FromLong(CL_DSO_ERROR); |
|
1513 if (x == NULL || PyDict_SetItemString(d, "DSO_ERROR", x) < 0) |
|
1514 return; |
|
1515 Py_DECREF(x); |
|
1516 #endif |
|
1517 #ifdef CL_EDGE_THRESHOLD |
|
1518 x = PyInt_FromLong(CL_EDGE_THRESHOLD); |
|
1519 if (x == NULL || PyDict_SetItemString(d, "EDGE_THRESHOLD", x) < 0) |
|
1520 return; |
|
1521 Py_DECREF(x); |
|
1522 #endif |
|
1523 #ifdef CL_ENABLE_IMAGEINFO |
|
1524 x = PyInt_FromLong(CL_ENABLE_IMAGEINFO); |
|
1525 if (x == NULL || PyDict_SetItemString(d, "ENABLE_IMAGEINFO", x) < 0) |
|
1526 return; |
|
1527 Py_DECREF(x); |
|
1528 #endif |
|
1529 #ifdef CL_END_OF_SEQUENCE |
|
1530 x = PyInt_FromLong(CL_END_OF_SEQUENCE); |
|
1531 if (x == NULL || PyDict_SetItemString(d, "END_OF_SEQUENCE", x) < 0) |
|
1532 return; |
|
1533 Py_DECREF(x); |
|
1534 #endif |
|
1535 #ifdef CL_ENUM_VALUE |
|
1536 x = PyInt_FromLong(CL_ENUM_VALUE); |
|
1537 if (x == NULL || PyDict_SetItemString(d, "ENUM_VALUE", x) < 0) |
|
1538 return; |
|
1539 Py_DECREF(x); |
|
1540 #endif |
|
1541 #ifdef CL_EXACT_COMPRESSION_RATIO |
|
1542 x = PyInt_FromLong(CL_EXACT_COMPRESSION_RATIO); |
|
1543 if (x == NULL || PyDict_SetItemString(d, "EXACT_COMPRESSION_RATIO", x) < 0) |
|
1544 return; |
|
1545 Py_DECREF(x); |
|
1546 #endif |
|
1547 #ifdef CL_EXTERNAL_DEVICE |
|
1548 x = PyInt_FromLong((long) CL_EXTERNAL_DEVICE); |
|
1549 if (x == NULL || PyDict_SetItemString(d, "EXTERNAL_DEVICE", x) < 0) |
|
1550 return; |
|
1551 Py_DECREF(x); |
|
1552 #endif |
|
1553 #ifdef CL_FLOATING_ENUM_VALUE |
|
1554 x = PyInt_FromLong(CL_FLOATING_ENUM_VALUE); |
|
1555 if (x == NULL || PyDict_SetItemString(d, "FLOATING_ENUM_VALUE", x) < 0) |
|
1556 return; |
|
1557 Py_DECREF(x); |
|
1558 #endif |
|
1559 #ifdef CL_FLOATING_RANGE_VALUE |
|
1560 x = PyInt_FromLong(CL_FLOATING_RANGE_VALUE); |
|
1561 if (x == NULL || PyDict_SetItemString(d, "FLOATING_RANGE_VALUE", x) < 0) |
|
1562 return; |
|
1563 Py_DECREF(x); |
|
1564 #endif |
|
1565 #ifdef CL_FORMAT |
|
1566 x = PyInt_FromLong(CL_FORMAT); |
|
1567 if (x == NULL || PyDict_SetItemString(d, "FORMAT", x) < 0) |
|
1568 return; |
|
1569 Py_DECREF(x); |
|
1570 #endif |
|
1571 #ifdef CL_FORMAT_ABGR |
|
1572 x = PyInt_FromLong(CL_FORMAT_ABGR); |
|
1573 if (x == NULL || PyDict_SetItemString(d, "FORMAT_ABGR", x) < 0) |
|
1574 return; |
|
1575 Py_DECREF(x); |
|
1576 #endif |
|
1577 #ifdef CL_FORMAT_BGR |
|
1578 x = PyInt_FromLong(CL_FORMAT_BGR); |
|
1579 if (x == NULL || PyDict_SetItemString(d, "FORMAT_BGR", x) < 0) |
|
1580 return; |
|
1581 Py_DECREF(x); |
|
1582 #endif |
|
1583 #ifdef CL_FORMAT_BGR233 |
|
1584 x = PyInt_FromLong(CL_FORMAT_BGR233); |
|
1585 if (x == NULL || PyDict_SetItemString(d, "FORMAT_BGR233", x) < 0) |
|
1586 return; |
|
1587 Py_DECREF(x); |
|
1588 #endif |
|
1589 #ifdef CL_FORMAT_GRAYSCALE |
|
1590 x = PyInt_FromLong(CL_FORMAT_GRAYSCALE); |
|
1591 if (x == NULL || PyDict_SetItemString(d, "FORMAT_GRAYSCALE", x) < 0) |
|
1592 return; |
|
1593 Py_DECREF(x); |
|
1594 #endif |
|
1595 #ifdef CL_FORMAT_MONO |
|
1596 x = PyInt_FromLong(CL_FORMAT_MONO); |
|
1597 if (x == NULL || PyDict_SetItemString(d, "FORMAT_MONO", x) < 0) |
|
1598 return; |
|
1599 Py_DECREF(x); |
|
1600 #endif |
|
1601 #ifdef CL_FORMAT_RBG323 |
|
1602 x = PyInt_FromLong(CL_FORMAT_RBG323); |
|
1603 if (x == NULL || PyDict_SetItemString(d, "FORMAT_RBG323", x) < 0) |
|
1604 return; |
|
1605 Py_DECREF(x); |
|
1606 #endif |
|
1607 #ifdef CL_FORMAT_STEREO_INTERLEAVED |
|
1608 x = PyInt_FromLong(CL_FORMAT_STEREO_INTERLEAVED); |
|
1609 if (x == NULL || PyDict_SetItemString(d, "FORMAT_STEREO_INTERLEAVED", x) < 0) |
|
1610 return; |
|
1611 Py_DECREF(x); |
|
1612 #endif |
|
1613 #ifdef CL_FORMAT_XBGR |
|
1614 x = PyInt_FromLong(CL_FORMAT_XBGR); |
|
1615 if (x == NULL || PyDict_SetItemString(d, "FORMAT_XBGR", x) < 0) |
|
1616 return; |
|
1617 Py_DECREF(x); |
|
1618 #endif |
|
1619 #ifdef CL_FORMAT_YCbCr |
|
1620 x = PyInt_FromLong(CL_FORMAT_YCbCr); |
|
1621 if (x == NULL || PyDict_SetItemString(d, "FORMAT_YCbCr", x) < 0) |
|
1622 return; |
|
1623 Py_DECREF(x); |
|
1624 #endif |
|
1625 #ifdef CL_FORMAT_YCbCr422 |
|
1626 x = PyInt_FromLong(CL_FORMAT_YCbCr422); |
|
1627 if (x == NULL || PyDict_SetItemString(d, "FORMAT_YCbCr422", x) < 0) |
|
1628 return; |
|
1629 Py_DECREF(x); |
|
1630 #endif |
|
1631 #ifdef CL_FORMAT_YCbCr422DC |
|
1632 x = PyInt_FromLong(CL_FORMAT_YCbCr422DC); |
|
1633 if (x == NULL || PyDict_SetItemString(d, "FORMAT_YCbCr422DC", x) < 0) |
|
1634 return; |
|
1635 Py_DECREF(x); |
|
1636 #endif |
|
1637 #ifdef CL_FRAME |
|
1638 x = PyInt_FromLong(CL_FRAME); |
|
1639 if (x == NULL || PyDict_SetItemString(d, "FRAME", x) < 0) |
|
1640 return; |
|
1641 Py_DECREF(x); |
|
1642 #endif |
|
1643 #ifdef CL_FRAMES_PER_CHUNK |
|
1644 x = PyInt_FromLong(CL_FRAMES_PER_CHUNK); |
|
1645 if (x == NULL || PyDict_SetItemString(d, "FRAMES_PER_CHUNK", x) < 0) |
|
1646 return; |
|
1647 Py_DECREF(x); |
|
1648 #endif |
|
1649 #ifdef CL_FRAME_BUFFER_SIZE |
|
1650 x = PyInt_FromLong(CL_FRAME_BUFFER_SIZE); |
|
1651 if (x == NULL || PyDict_SetItemString(d, "FRAME_BUFFER_SIZE", x) < 0) |
|
1652 return; |
|
1653 Py_DECREF(x); |
|
1654 #endif |
|
1655 #ifdef CL_FRAME_BUFFER_SIZE_ZERO |
|
1656 x = PyInt_FromLong(CL_FRAME_BUFFER_SIZE_ZERO); |
|
1657 if (x == NULL || PyDict_SetItemString(d, "FRAME_BUFFER_SIZE_ZERO", x) < 0) |
|
1658 return; |
|
1659 Py_DECREF(x); |
|
1660 #endif |
|
1661 #ifdef CL_FRAME_INDEX |
|
1662 x = PyInt_FromLong(CL_FRAME_INDEX); |
|
1663 if (x == NULL || PyDict_SetItemString(d, "FRAME_INDEX", x) < 0) |
|
1664 return; |
|
1665 Py_DECREF(x); |
|
1666 #endif |
|
1667 #ifdef CL_FRAME_RATE |
|
1668 x = PyInt_FromLong(CL_FRAME_RATE); |
|
1669 if (x == NULL || PyDict_SetItemString(d, "FRAME_RATE", x) < 0) |
|
1670 return; |
|
1671 Py_DECREF(x); |
|
1672 #endif |
|
1673 #ifdef CL_FRAME_SIZE |
|
1674 x = PyInt_FromLong(CL_FRAME_SIZE); |
|
1675 if (x == NULL || PyDict_SetItemString(d, "FRAME_SIZE", x) < 0) |
|
1676 return; |
|
1677 Py_DECREF(x); |
|
1678 #endif |
|
1679 #ifdef CL_FRAME_TYPE |
|
1680 x = PyInt_FromLong(CL_FRAME_TYPE); |
|
1681 if (x == NULL || PyDict_SetItemString(d, "FRAME_TYPE", x) < 0) |
|
1682 return; |
|
1683 Py_DECREF(x); |
|
1684 #endif |
|
1685 #ifdef CL_G711_ALAW |
|
1686 x = PyInt_FromLong(CL_G711_ALAW); |
|
1687 if (x == NULL || PyDict_SetItemString(d, "G711_ALAW", x) < 0) |
|
1688 return; |
|
1689 Py_DECREF(x); |
|
1690 #endif |
|
1691 #ifdef CL_G711_ALAW_SOFTWARE |
|
1692 x = PyInt_FromLong(CL_G711_ALAW_SOFTWARE); |
|
1693 if (x == NULL || PyDict_SetItemString(d, "G711_ALAW_SOFTWARE", x) < 0) |
|
1694 return; |
|
1695 Py_DECREF(x); |
|
1696 #endif |
|
1697 #ifdef CL_G711_ULAW |
|
1698 x = PyInt_FromLong(CL_G711_ULAW); |
|
1699 if (x == NULL || PyDict_SetItemString(d, "G711_ULAW", x) < 0) |
|
1700 return; |
|
1701 Py_DECREF(x); |
|
1702 #endif |
|
1703 #ifdef CL_G711_ULAW_SOFTWARE |
|
1704 x = PyInt_FromLong(CL_G711_ULAW_SOFTWARE); |
|
1705 if (x == NULL || PyDict_SetItemString(d, "G711_ULAW_SOFTWARE", x) < 0) |
|
1706 return; |
|
1707 Py_DECREF(x); |
|
1708 #endif |
|
1709 #ifdef CL_GRAYSCALE |
|
1710 x = PyInt_FromLong(CL_GRAYSCALE); |
|
1711 if (x == NULL || PyDict_SetItemString(d, "GRAYSCALE", x) < 0) |
|
1712 return; |
|
1713 Py_DECREF(x); |
|
1714 #endif |
|
1715 #ifdef CL_HDCC |
|
1716 x = PyInt_FromLong(CL_HDCC); |
|
1717 if (x == NULL || PyDict_SetItemString(d, "HDCC", x) < 0) |
|
1718 return; |
|
1719 Py_DECREF(x); |
|
1720 #endif |
|
1721 #ifdef CL_HDCC_SAMPLES_PER_TILE |
|
1722 x = PyInt_FromLong(CL_HDCC_SAMPLES_PER_TILE); |
|
1723 if (x == NULL || PyDict_SetItemString(d, "HDCC_SAMPLES_PER_TILE", x) < 0) |
|
1724 return; |
|
1725 Py_DECREF(x); |
|
1726 #endif |
|
1727 #ifdef CL_HDCC_SOFTWARE |
|
1728 x = PyInt_FromLong(CL_HDCC_SOFTWARE); |
|
1729 if (x == NULL || PyDict_SetItemString(d, "HDCC_SOFTWARE", x) < 0) |
|
1730 return; |
|
1731 Py_DECREF(x); |
|
1732 #endif |
|
1733 #ifdef CL_HDCC_TILE_THRESHOLD |
|
1734 x = PyInt_FromLong(CL_HDCC_TILE_THRESHOLD); |
|
1735 if (x == NULL || PyDict_SetItemString(d, "HDCC_TILE_THRESHOLD", x) < 0) |
|
1736 return; |
|
1737 Py_DECREF(x); |
|
1738 #endif |
|
1739 #ifdef CL_HEADER_START_CODE |
|
1740 x = PyInt_FromLong(CL_HEADER_START_CODE); |
|
1741 if (x == NULL || PyDict_SetItemString(d, "HEADER_START_CODE", x) < 0) |
|
1742 return; |
|
1743 Py_DECREF(x); |
|
1744 #endif |
|
1745 #ifdef CL_IMAGEINFO_FIELDMASK |
|
1746 x = PyInt_FromLong(CL_IMAGEINFO_FIELDMASK); |
|
1747 if (x == NULL || PyDict_SetItemString(d, "IMAGEINFO_FIELDMASK", x) < 0) |
|
1748 return; |
|
1749 Py_DECREF(x); |
|
1750 #endif |
|
1751 #ifdef CL_IMAGE_CROP_BOTTOM |
|
1752 x = PyInt_FromLong(CL_IMAGE_CROP_BOTTOM); |
|
1753 if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_BOTTOM", x) < 0) |
|
1754 return; |
|
1755 Py_DECREF(x); |
|
1756 #endif |
|
1757 #ifdef CL_IMAGE_CROP_LEFT |
|
1758 x = PyInt_FromLong(CL_IMAGE_CROP_LEFT); |
|
1759 if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_LEFT", x) < 0) |
|
1760 return; |
|
1761 Py_DECREF(x); |
|
1762 #endif |
|
1763 #ifdef CL_IMAGE_CROP_RIGHT |
|
1764 x = PyInt_FromLong(CL_IMAGE_CROP_RIGHT); |
|
1765 if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_RIGHT", x) < 0) |
|
1766 return; |
|
1767 Py_DECREF(x); |
|
1768 #endif |
|
1769 #ifdef CL_IMAGE_CROP_TOP |
|
1770 x = PyInt_FromLong(CL_IMAGE_CROP_TOP); |
|
1771 if (x == NULL || PyDict_SetItemString(d, "IMAGE_CROP_TOP", x) < 0) |
|
1772 return; |
|
1773 Py_DECREF(x); |
|
1774 #endif |
|
1775 #ifdef CL_IMAGE_HEIGHT |
|
1776 x = PyInt_FromLong(CL_IMAGE_HEIGHT); |
|
1777 if (x == NULL || PyDict_SetItemString(d, "IMAGE_HEIGHT", x) < 0) |
|
1778 return; |
|
1779 Py_DECREF(x); |
|
1780 #endif |
|
1781 #ifdef CL_IMAGE_WIDTH |
|
1782 x = PyInt_FromLong(CL_IMAGE_WIDTH); |
|
1783 if (x == NULL || PyDict_SetItemString(d, "IMAGE_WIDTH", x) < 0) |
|
1784 return; |
|
1785 Py_DECREF(x); |
|
1786 #endif |
|
1787 #ifdef CL_IMPACT_CODEC_CONTROL |
|
1788 x = PyInt_FromLong(CL_IMPACT_CODEC_CONTROL); |
|
1789 if (x == NULL || PyDict_SetItemString(d, "IMPACT_CODEC_CONTROL", x) < 0) |
|
1790 return; |
|
1791 Py_DECREF(x); |
|
1792 #endif |
|
1793 #ifdef CL_IMPACT_FRAME_INTERLEAVE |
|
1794 x = PyInt_FromLong(CL_IMPACT_FRAME_INTERLEAVE); |
|
1795 if (x == NULL || PyDict_SetItemString(d, "IMPACT_FRAME_INTERLEAVE", x) < 0) |
|
1796 return; |
|
1797 Py_DECREF(x); |
|
1798 #endif |
|
1799 #ifdef CL_IMPACT_NUM_PARAMS |
|
1800 x = PyInt_FromLong(CL_IMPACT_NUM_PARAMS); |
|
1801 if (x == NULL || PyDict_SetItemString(d, "IMPACT_NUM_PARAMS", x) < 0) |
|
1802 return; |
|
1803 Py_DECREF(x); |
|
1804 #endif |
|
1805 #ifdef CL_INTERNAL_FORMAT |
|
1806 x = PyInt_FromLong(CL_INTERNAL_FORMAT); |
|
1807 if (x == NULL || PyDict_SetItemString(d, "INTERNAL_FORMAT", x) < 0) |
|
1808 return; |
|
1809 Py_DECREF(x); |
|
1810 #endif |
|
1811 #ifdef CL_INTERNAL_IMAGE_HEIGHT |
|
1812 x = PyInt_FromLong(CL_INTERNAL_IMAGE_HEIGHT); |
|
1813 if (x == NULL || PyDict_SetItemString(d, "INTERNAL_IMAGE_HEIGHT", x) < 0) |
|
1814 return; |
|
1815 Py_DECREF(x); |
|
1816 #endif |
|
1817 #ifdef CL_INTERNAL_IMAGE_WIDTH |
|
1818 x = PyInt_FromLong(CL_INTERNAL_IMAGE_WIDTH); |
|
1819 if (x == NULL || PyDict_SetItemString(d, "INTERNAL_IMAGE_WIDTH", x) < 0) |
|
1820 return; |
|
1821 Py_DECREF(x); |
|
1822 #endif |
|
1823 #ifdef CL_INTRA |
|
1824 x = PyInt_FromLong(CL_INTRA); |
|
1825 if (x == NULL || PyDict_SetItemString(d, "INTRA", x) < 0) |
|
1826 return; |
|
1827 Py_DECREF(x); |
|
1828 #endif |
|
1829 #ifdef CL_JPEG |
|
1830 x = PyInt_FromLong(CL_JPEG); |
|
1831 if (x == NULL || PyDict_SetItemString(d, "JPEG", x) < 0) |
|
1832 return; |
|
1833 Py_DECREF(x); |
|
1834 #endif |
|
1835 #ifdef CL_JPEG_COSMO |
|
1836 x = PyInt_FromLong(CL_JPEG_COSMO); |
|
1837 if (x == NULL || PyDict_SetItemString(d, "JPEG_COSMO", x) < 0) |
|
1838 return; |
|
1839 Py_DECREF(x); |
|
1840 #endif |
|
1841 #ifdef CL_JPEG_ERROR |
|
1842 x = PyInt_FromLong(CL_JPEG_ERROR); |
|
1843 if (x == NULL || PyDict_SetItemString(d, "JPEG_ERROR", x) < 0) |
|
1844 return; |
|
1845 Py_DECREF(x); |
|
1846 #endif |
|
1847 #ifdef CL_JPEG_IMPACT |
|
1848 x = PyInt_FromLong(CL_JPEG_IMPACT); |
|
1849 if (x == NULL || PyDict_SetItemString(d, "JPEG_IMPACT", x) < 0) |
|
1850 return; |
|
1851 Py_DECREF(x); |
|
1852 #endif |
|
1853 #ifdef CL_JPEG_NUM_PARAMS |
|
1854 x = PyInt_FromLong(CL_JPEG_NUM_PARAMS); |
|
1855 if (x == NULL || PyDict_SetItemString(d, "JPEG_NUM_PARAMS", x) < 0) |
|
1856 return; |
|
1857 Py_DECREF(x); |
|
1858 #endif |
|
1859 #ifdef CL_JPEG_QUALITY_FACTOR |
|
1860 x = PyInt_FromLong(CL_JPEG_QUALITY_FACTOR); |
|
1861 if (x == NULL || PyDict_SetItemString(d, "JPEG_QUALITY_FACTOR", x) < 0) |
|
1862 return; |
|
1863 Py_DECREF(x); |
|
1864 #endif |
|
1865 #ifdef CL_JPEG_QUANTIZATION_TABLES |
|
1866 x = PyInt_FromLong(CL_JPEG_QUANTIZATION_TABLES); |
|
1867 if (x == NULL || PyDict_SetItemString(d, "JPEG_QUANTIZATION_TABLES", x) < 0) |
|
1868 return; |
|
1869 Py_DECREF(x); |
|
1870 #endif |
|
1871 #ifdef CL_JPEG_SOFTWARE |
|
1872 x = PyInt_FromLong(CL_JPEG_SOFTWARE); |
|
1873 if (x == NULL || PyDict_SetItemString(d, "JPEG_SOFTWARE", x) < 0) |
|
1874 return; |
|
1875 Py_DECREF(x); |
|
1876 #endif |
|
1877 #ifdef CL_JPEG_STREAM_HEADERS |
|
1878 x = PyInt_FromLong(CL_JPEG_STREAM_HEADERS); |
|
1879 if (x == NULL || PyDict_SetItemString(d, "JPEG_STREAM_HEADERS", x) < 0) |
|
1880 return; |
|
1881 Py_DECREF(x); |
|
1882 #endif |
|
1883 #ifdef CL_KEYFRAME |
|
1884 x = PyInt_FromLong(CL_KEYFRAME); |
|
1885 if (x == NULL || PyDict_SetItemString(d, "KEYFRAME", x) < 0) |
|
1886 return; |
|
1887 Py_DECREF(x); |
|
1888 #endif |
|
1889 #ifdef CL_KEYFRAME_DISTANCE |
|
1890 x = PyInt_FromLong(CL_KEYFRAME_DISTANCE); |
|
1891 if (x == NULL || PyDict_SetItemString(d, "KEYFRAME_DISTANCE", x) < 0) |
|
1892 return; |
|
1893 Py_DECREF(x); |
|
1894 #endif |
|
1895 #ifdef CL_LAST_FRAME_INDEX |
|
1896 x = PyInt_FromLong(CL_LAST_FRAME_INDEX); |
|
1897 if (x == NULL || PyDict_SetItemString(d, "LAST_FRAME_INDEX", x) < 0) |
|
1898 return; |
|
1899 Py_DECREF(x); |
|
1900 #endif |
|
1901 #ifdef CL_LAYER |
|
1902 x = PyInt_FromLong(CL_LAYER); |
|
1903 if (x == NULL || PyDict_SetItemString(d, "LAYER", x) < 0) |
|
1904 return; |
|
1905 Py_DECREF(x); |
|
1906 #endif |
|
1907 #ifdef CL_LUMA_THRESHOLD |
|
1908 x = PyInt_FromLong(CL_LUMA_THRESHOLD); |
|
1909 if (x == NULL || PyDict_SetItemString(d, "LUMA_THRESHOLD", x) < 0) |
|
1910 return; |
|
1911 Py_DECREF(x); |
|
1912 #endif |
|
1913 #ifdef CL_MAX_NUMBER_OF_AUDIO_ALGORITHMS |
|
1914 x = PyInt_FromLong(CL_MAX_NUMBER_OF_AUDIO_ALGORITHMS); |
|
1915 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_AUDIO_ALGORITHMS", x) < 0) |
|
1916 return; |
|
1917 Py_DECREF(x); |
|
1918 #endif |
|
1919 #ifdef CL_MAX_NUMBER_OF_FORMATS |
|
1920 x = PyInt_FromLong(CL_MAX_NUMBER_OF_FORMATS); |
|
1921 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_FORMATS", x) < 0) |
|
1922 return; |
|
1923 Py_DECREF(x); |
|
1924 #endif |
|
1925 #ifdef CL_MAX_NUMBER_OF_ORIGINAL_FORMATS |
|
1926 x = PyInt_FromLong(CL_MAX_NUMBER_OF_ORIGINAL_FORMATS); |
|
1927 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_ORIGINAL_FORMATS", x) < 0) |
|
1928 return; |
|
1929 Py_DECREF(x); |
|
1930 #endif |
|
1931 #ifdef CL_MAX_NUMBER_OF_PARAMS |
|
1932 x = PyInt_FromLong(CL_MAX_NUMBER_OF_PARAMS); |
|
1933 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_PARAMS", x) < 0) |
|
1934 return; |
|
1935 Py_DECREF(x); |
|
1936 #endif |
|
1937 #ifdef CL_MAX_NUMBER_OF_VIDEO_ALGORITHMS |
|
1938 x = PyInt_FromLong(CL_MAX_NUMBER_OF_VIDEO_ALGORITHMS); |
|
1939 if (x == NULL || PyDict_SetItemString(d, "MAX_NUMBER_OF_VIDEO_ALGORITHMS", x) < 0) |
|
1940 return; |
|
1941 Py_DECREF(x); |
|
1942 #endif |
|
1943 #ifdef CL_MONO |
|
1944 x = PyInt_FromLong(CL_MONO); |
|
1945 if (x == NULL || PyDict_SetItemString(d, "MONO", x) < 0) |
|
1946 return; |
|
1947 Py_DECREF(x); |
|
1948 #endif |
|
1949 #ifdef CL_MPEG1_AUDIO_AWARE |
|
1950 x = PyInt_FromLong(CL_MPEG1_AUDIO_AWARE); |
|
1951 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_AWARE", x) < 0) |
|
1952 return; |
|
1953 Py_DECREF(x); |
|
1954 #endif |
|
1955 #ifdef CL_MPEG1_AUDIO_LAYER |
|
1956 x = PyInt_FromLong(CL_MPEG1_AUDIO_LAYER); |
|
1957 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_LAYER", x) < 0) |
|
1958 return; |
|
1959 Py_DECREF(x); |
|
1960 #endif |
|
1961 #ifdef CL_MPEG1_AUDIO_LAYER_I |
|
1962 x = PyInt_FromLong(CL_MPEG1_AUDIO_LAYER_I); |
|
1963 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_LAYER_I", x) < 0) |
|
1964 return; |
|
1965 Py_DECREF(x); |
|
1966 #endif |
|
1967 #ifdef CL_MPEG1_AUDIO_LAYER_II |
|
1968 x = PyInt_FromLong(CL_MPEG1_AUDIO_LAYER_II); |
|
1969 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_LAYER_II", x) < 0) |
|
1970 return; |
|
1971 Py_DECREF(x); |
|
1972 #endif |
|
1973 #ifdef CL_MPEG1_AUDIO_MODE |
|
1974 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE); |
|
1975 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE", x) < 0) |
|
1976 return; |
|
1977 Py_DECREF(x); |
|
1978 #endif |
|
1979 #ifdef CL_MPEG1_AUDIO_MODE_DUAL |
|
1980 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_DUAL); |
|
1981 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_DUAL", x) < 0) |
|
1982 return; |
|
1983 Py_DECREF(x); |
|
1984 #endif |
|
1985 #ifdef CL_MPEG1_AUDIO_MODE_JOINT |
|
1986 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_JOINT); |
|
1987 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_JOINT", x) < 0) |
|
1988 return; |
|
1989 Py_DECREF(x); |
|
1990 #endif |
|
1991 #ifdef CL_MPEG1_AUDIO_MODE_SINGLE |
|
1992 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_SINGLE); |
|
1993 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_SINGLE", x) < 0) |
|
1994 return; |
|
1995 Py_DECREF(x); |
|
1996 #endif |
|
1997 #ifdef CL_MPEG1_AUDIO_MODE_STEREO |
|
1998 x = PyInt_FromLong(CL_MPEG1_AUDIO_MODE_STEREO); |
|
1999 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_MODE_STEREO", x) < 0) |
|
2000 return; |
|
2001 Py_DECREF(x); |
|
2002 #endif |
|
2003 #ifdef CL_MPEG1_AUDIO_SOFTWARE |
|
2004 x = PyInt_FromLong(CL_MPEG1_AUDIO_SOFTWARE); |
|
2005 if (x == NULL || PyDict_SetItemString(d, "MPEG1_AUDIO_SOFTWARE", x) < 0) |
|
2006 return; |
|
2007 Py_DECREF(x); |
|
2008 #endif |
|
2009 #ifdef CL_MPEG1_END_OF_STREAM |
|
2010 x = PyInt_FromLong(CL_MPEG1_END_OF_STREAM); |
|
2011 if (x == NULL || PyDict_SetItemString(d, "MPEG1_END_OF_STREAM", x) < 0) |
|
2012 return; |
|
2013 Py_DECREF(x); |
|
2014 #endif |
|
2015 #ifdef CL_MPEG1_ERROR |
|
2016 x = PyInt_FromLong(CL_MPEG1_ERROR); |
|
2017 if (x == NULL || PyDict_SetItemString(d, "MPEG1_ERROR", x) < 0) |
|
2018 return; |
|
2019 Py_DECREF(x); |
|
2020 #endif |
|
2021 #ifdef CL_MPEG1_NUM_PARAMS |
|
2022 x = PyInt_FromLong(CL_MPEG1_NUM_PARAMS); |
|
2023 if (x == NULL || PyDict_SetItemString(d, "MPEG1_NUM_PARAMS", x) < 0) |
|
2024 return; |
|
2025 Py_DECREF(x); |
|
2026 #endif |
|
2027 #ifdef CL_MPEG1_VIDEO_M |
|
2028 x = PyInt_FromLong(CL_MPEG1_VIDEO_M); |
|
2029 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_M", x) < 0) |
|
2030 return; |
|
2031 Py_DECREF(x); |
|
2032 #endif |
|
2033 #ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X |
|
2034 x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X); |
|
2035 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_X", x) < 0) |
|
2036 return; |
|
2037 Py_DECREF(x); |
|
2038 #endif |
|
2039 #ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y |
|
2040 x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y); |
|
2041 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_B_Y", x) < 0) |
|
2042 return; |
|
2043 Py_DECREF(x); |
|
2044 #endif |
|
2045 #ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X |
|
2046 x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X); |
|
2047 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_X", x) < 0) |
|
2048 return; |
|
2049 Py_DECREF(x); |
|
2050 #endif |
|
2051 #ifdef CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y |
|
2052 x = PyInt_FromLong(CL_MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y); |
|
2053 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_MAX_MOTION_VECTOR_LENGTH_P_Y", x) < 0) |
|
2054 return; |
|
2055 Py_DECREF(x); |
|
2056 #endif |
|
2057 #ifdef CL_MPEG1_VIDEO_N |
|
2058 x = PyInt_FromLong(CL_MPEG1_VIDEO_N); |
|
2059 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_N", x) < 0) |
|
2060 return; |
|
2061 Py_DECREF(x); |
|
2062 #endif |
|
2063 #ifdef CL_MPEG1_VIDEO_SOFTNESS |
|
2064 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS); |
|
2065 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS", x) < 0) |
|
2066 return; |
|
2067 Py_DECREF(x); |
|
2068 #endif |
|
2069 #ifdef CL_MPEG1_VIDEO_SOFTNESS_MAXIMUM |
|
2070 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS_MAXIMUM); |
|
2071 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS_MAXIMUM", x) < 0) |
|
2072 return; |
|
2073 Py_DECREF(x); |
|
2074 #endif |
|
2075 #ifdef CL_MPEG1_VIDEO_SOFTNESS_MEDIUM |
|
2076 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS_MEDIUM); |
|
2077 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS_MEDIUM", x) < 0) |
|
2078 return; |
|
2079 Py_DECREF(x); |
|
2080 #endif |
|
2081 #ifdef CL_MPEG1_VIDEO_SOFTNESS_NONE |
|
2082 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTNESS_NONE); |
|
2083 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTNESS_NONE", x) < 0) |
|
2084 return; |
|
2085 Py_DECREF(x); |
|
2086 #endif |
|
2087 #ifdef CL_MPEG1_VIDEO_SOFTWARE |
|
2088 x = PyInt_FromLong(CL_MPEG1_VIDEO_SOFTWARE); |
|
2089 if (x == NULL || PyDict_SetItemString(d, "MPEG1_VIDEO_SOFTWARE", x) < 0) |
|
2090 return; |
|
2091 Py_DECREF(x); |
|
2092 #endif |
|
2093 #ifdef CL_MPEG_VIDEO |
|
2094 x = PyInt_FromLong(CL_MPEG_VIDEO); |
|
2095 if (x == NULL || PyDict_SetItemString(d, "MPEG_VIDEO", x) < 0) |
|
2096 return; |
|
2097 Py_DECREF(x); |
|
2098 #endif |
|
2099 #ifdef CL_MULTIRATE_AWARE |
|
2100 x = PyInt_FromLong(CL_MULTIRATE_AWARE); |
|
2101 if (x == NULL || PyDict_SetItemString(d, "MULTIRATE_AWARE", x) < 0) |
|
2102 return; |
|
2103 Py_DECREF(x); |
|
2104 #endif |
|
2105 #ifdef CL_MVC1 |
|
2106 x = PyInt_FromLong(CL_MVC1); |
|
2107 if (x == NULL || PyDict_SetItemString(d, "MVC1", x) < 0) |
|
2108 return; |
|
2109 Py_DECREF(x); |
|
2110 #endif |
|
2111 #ifdef CL_MVC1_SOFTWARE |
|
2112 x = PyInt_FromLong(CL_MVC1_SOFTWARE); |
|
2113 if (x == NULL || PyDict_SetItemString(d, "MVC1_SOFTWARE", x) < 0) |
|
2114 return; |
|
2115 Py_DECREF(x); |
|
2116 #endif |
|
2117 #ifdef CL_MVC2 |
|
2118 x = PyInt_FromLong(CL_MVC2); |
|
2119 if (x == NULL || PyDict_SetItemString(d, "MVC2", x) < 0) |
|
2120 return; |
|
2121 Py_DECREF(x); |
|
2122 #endif |
|
2123 #ifdef CL_MVC2_BLENDING |
|
2124 x = PyInt_FromLong(CL_MVC2_BLENDING); |
|
2125 if (x == NULL || PyDict_SetItemString(d, "MVC2_BLENDING", x) < 0) |
|
2126 return; |
|
2127 Py_DECREF(x); |
|
2128 #endif |
|
2129 #ifdef CL_MVC2_BLENDING_OFF |
|
2130 x = PyInt_FromLong(CL_MVC2_BLENDING_OFF); |
|
2131 if (x == NULL || PyDict_SetItemString(d, "MVC2_BLENDING_OFF", x) < 0) |
|
2132 return; |
|
2133 Py_DECREF(x); |
|
2134 #endif |
|
2135 #ifdef CL_MVC2_BLENDING_ON |
|
2136 x = PyInt_FromLong(CL_MVC2_BLENDING_ON); |
|
2137 if (x == NULL || PyDict_SetItemString(d, "MVC2_BLENDING_ON", x) < 0) |
|
2138 return; |
|
2139 Py_DECREF(x); |
|
2140 #endif |
|
2141 #ifdef CL_MVC2_CHROMA_THRESHOLD |
|
2142 x = PyInt_FromLong(CL_MVC2_CHROMA_THRESHOLD); |
|
2143 if (x == NULL || PyDict_SetItemString(d, "MVC2_CHROMA_THRESHOLD", x) < 0) |
|
2144 return; |
|
2145 Py_DECREF(x); |
|
2146 #endif |
|
2147 #ifdef CL_MVC2_EDGE_THRESHOLD |
|
2148 x = PyInt_FromLong(CL_MVC2_EDGE_THRESHOLD); |
|
2149 if (x == NULL || PyDict_SetItemString(d, "MVC2_EDGE_THRESHOLD", x) < 0) |
|
2150 return; |
|
2151 Py_DECREF(x); |
|
2152 #endif |
|
2153 #ifdef CL_MVC2_ERROR |
|
2154 x = PyInt_FromLong(CL_MVC2_ERROR); |
|
2155 if (x == NULL || PyDict_SetItemString(d, "MVC2_ERROR", x) < 0) |
|
2156 return; |
|
2157 Py_DECREF(x); |
|
2158 #endif |
|
2159 #ifdef CL_MVC2_LUMA_THRESHOLD |
|
2160 x = PyInt_FromLong(CL_MVC2_LUMA_THRESHOLD); |
|
2161 if (x == NULL || PyDict_SetItemString(d, "MVC2_LUMA_THRESHOLD", x) < 0) |
|
2162 return; |
|
2163 Py_DECREF(x); |
|
2164 #endif |
|
2165 #ifdef CL_MVC2_SOFTWARE |
|
2166 x = PyInt_FromLong(CL_MVC2_SOFTWARE); |
|
2167 if (x == NULL || PyDict_SetItemString(d, "MVC2_SOFTWARE", x) < 0) |
|
2168 return; |
|
2169 Py_DECREF(x); |
|
2170 #endif |
|
2171 #ifdef CL_MVC3_QUALITY_LEVEL |
|
2172 x = PyInt_FromLong(CL_MVC3_QUALITY_LEVEL); |
|
2173 if (x == NULL || PyDict_SetItemString(d, "MVC3_QUALITY_LEVEL", x) < 0) |
|
2174 return; |
|
2175 Py_DECREF(x); |
|
2176 #endif |
|
2177 #ifdef CL_MVC3_SOFTWARE |
|
2178 x = PyInt_FromLong(CL_MVC3_SOFTWARE); |
|
2179 if (x == NULL || PyDict_SetItemString(d, "MVC3_SOFTWARE", x) < 0) |
|
2180 return; |
|
2181 Py_DECREF(x); |
|
2182 #endif |
|
2183 #ifdef CL_NEXT_NOT_AVAILABLE |
|
2184 x = PyInt_FromLong(CL_NEXT_NOT_AVAILABLE); |
|
2185 if (x == NULL || PyDict_SetItemString(d, "NEXT_NOT_AVAILABLE", x) < 0) |
|
2186 return; |
|
2187 Py_DECREF(x); |
|
2188 #endif |
|
2189 #ifdef CL_NOISE_MARGIN |
|
2190 x = PyInt_FromLong(CL_NOISE_MARGIN); |
|
2191 if (x == NULL || PyDict_SetItemString(d, "NOISE_MARGIN", x) < 0) |
|
2192 return; |
|
2193 Py_DECREF(x); |
|
2194 #endif |
|
2195 #ifdef CL_NONE |
|
2196 x = PyInt_FromLong(CL_NONE); |
|
2197 if (x == NULL || PyDict_SetItemString(d, "NONE", x) < 0) |
|
2198 return; |
|
2199 Py_DECREF(x); |
|
2200 #endif |
|
2201 #ifdef CL_NUMBER_OF_FORMATS |
|
2202 x = PyInt_FromLong(CL_NUMBER_OF_FORMATS); |
|
2203 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_FORMATS", x) < 0) |
|
2204 return; |
|
2205 Py_DECREF(x); |
|
2206 #endif |
|
2207 #ifdef CL_NUMBER_OF_FRAMES |
|
2208 x = PyInt_FromLong(CL_NUMBER_OF_FRAMES); |
|
2209 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_FRAMES", x) < 0) |
|
2210 return; |
|
2211 Py_DECREF(x); |
|
2212 #endif |
|
2213 #ifdef CL_NUMBER_OF_PARAMS |
|
2214 x = PyInt_FromLong(CL_NUMBER_OF_PARAMS); |
|
2215 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_PARAMS", x) < 0) |
|
2216 return; |
|
2217 Py_DECREF(x); |
|
2218 #endif |
|
2219 #ifdef CL_NUMBER_OF_PARAMS_FREEZE |
|
2220 x = PyInt_FromLong(CL_NUMBER_OF_PARAMS_FREEZE); |
|
2221 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_PARAMS_FREEZE", x) < 0) |
|
2222 return; |
|
2223 Py_DECREF(x); |
|
2224 #endif |
|
2225 #ifdef CL_NUMBER_OF_VIDEO_FORMATS |
|
2226 x = PyInt_FromLong(CL_NUMBER_OF_VIDEO_FORMATS); |
|
2227 if (x == NULL || PyDict_SetItemString(d, "NUMBER_OF_VIDEO_FORMATS", x) < 0) |
|
2228 return; |
|
2229 Py_DECREF(x); |
|
2230 #endif |
|
2231 #ifdef CL_ORIENTATION |
|
2232 x = PyInt_FromLong(CL_ORIENTATION); |
|
2233 if (x == NULL || PyDict_SetItemString(d, "ORIENTATION", x) < 0) |
|
2234 return; |
|
2235 Py_DECREF(x); |
|
2236 #endif |
|
2237 #ifdef CL_ORIGINAL_FORMAT |
|
2238 x = PyInt_FromLong(CL_ORIGINAL_FORMAT); |
|
2239 if (x == NULL || PyDict_SetItemString(d, "ORIGINAL_FORMAT", x) < 0) |
|
2240 return; |
|
2241 Py_DECREF(x); |
|
2242 #endif |
|
2243 #ifdef CL_PARAM_OUT_OF_RANGE |
|
2244 x = PyInt_FromLong(CL_PARAM_OUT_OF_RANGE); |
|
2245 if (x == NULL || PyDict_SetItemString(d, "PARAM_OUT_OF_RANGE", x) < 0) |
|
2246 return; |
|
2247 Py_DECREF(x); |
|
2248 #endif |
|
2249 #ifdef CL_PIXEL_ASPECT |
|
2250 x = PyInt_FromLong(CL_PIXEL_ASPECT); |
|
2251 if (x == NULL || PyDict_SetItemString(d, "PIXEL_ASPECT", x) < 0) |
|
2252 return; |
|
2253 Py_DECREF(x); |
|
2254 #endif |
|
2255 #ifdef CL_PREDICTED |
|
2256 x = PyInt_FromLong(CL_PREDICTED); |
|
2257 if (x == NULL || PyDict_SetItemString(d, "PREDICTED", x) < 0) |
|
2258 return; |
|
2259 Py_DECREF(x); |
|
2260 #endif |
|
2261 #ifdef CL_PREROLL |
|
2262 x = PyInt_FromLong(CL_PREROLL); |
|
2263 if (x == NULL || PyDict_SetItemString(d, "PREROLL", x) < 0) |
|
2264 return; |
|
2265 Py_DECREF(x); |
|
2266 #endif |
|
2267 #ifdef CL_QUALITY_FACTOR |
|
2268 x = PyInt_FromLong(CL_QUALITY_FACTOR); |
|
2269 if (x == NULL || PyDict_SetItemString(d, "QUALITY_FACTOR", x) < 0) |
|
2270 return; |
|
2271 Py_DECREF(x); |
|
2272 #endif |
|
2273 #ifdef CL_QUALITY_LEVEL |
|
2274 x = PyInt_FromLong(CL_QUALITY_LEVEL); |
|
2275 if (x == NULL || PyDict_SetItemString(d, "QUALITY_LEVEL", x) < 0) |
|
2276 return; |
|
2277 Py_DECREF(x); |
|
2278 #endif |
|
2279 #ifdef CL_QUALITY_SPATIAL |
|
2280 x = PyInt_FromLong(CL_QUALITY_SPATIAL); |
|
2281 if (x == NULL || PyDict_SetItemString(d, "QUALITY_SPATIAL", x) < 0) |
|
2282 return; |
|
2283 Py_DECREF(x); |
|
2284 #endif |
|
2285 #ifdef CL_QUALITY_TEMPORAL |
|
2286 x = PyInt_FromLong(CL_QUALITY_TEMPORAL); |
|
2287 if (x == NULL || PyDict_SetItemString(d, "QUALITY_TEMPORAL", x) < 0) |
|
2288 return; |
|
2289 Py_DECREF(x); |
|
2290 #endif |
|
2291 #ifdef CL_QUANTIZATION_TABLES |
|
2292 x = PyInt_FromLong(CL_QUANTIZATION_TABLES); |
|
2293 if (x == NULL || PyDict_SetItemString(d, "QUANTIZATION_TABLES", x) < 0) |
|
2294 return; |
|
2295 Py_DECREF(x); |
|
2296 #endif |
|
2297 #ifdef CL_RANGE_VALUE |
|
2298 x = PyInt_FromLong(CL_RANGE_VALUE); |
|
2299 if (x == NULL || PyDict_SetItemString(d, "RANGE_VALUE", x) < 0) |
|
2300 return; |
|
2301 Py_DECREF(x); |
|
2302 #endif |
|
2303 #ifdef CL_RGB |
|
2304 x = PyInt_FromLong(CL_RGB); |
|
2305 if (x == NULL || PyDict_SetItemString(d, "RGB", x) < 0) |
|
2306 return; |
|
2307 Py_DECREF(x); |
|
2308 #endif |
|
2309 #ifdef CL_RGB332 |
|
2310 x = PyInt_FromLong(CL_RGB332); |
|
2311 if (x == NULL || PyDict_SetItemString(d, "RGB332", x) < 0) |
|
2312 return; |
|
2313 Py_DECREF(x); |
|
2314 #endif |
|
2315 #ifdef CL_RGB8 |
|
2316 x = PyInt_FromLong(CL_RGB8); |
|
2317 if (x == NULL || PyDict_SetItemString(d, "RGB8", x) < 0) |
|
2318 return; |
|
2319 Py_DECREF(x); |
|
2320 #endif |
|
2321 #ifdef CL_RGBA |
|
2322 x = PyInt_FromLong(CL_RGBA); |
|
2323 if (x == NULL || PyDict_SetItemString(d, "RGBA", x) < 0) |
|
2324 return; |
|
2325 Py_DECREF(x); |
|
2326 #endif |
|
2327 #ifdef CL_RGBX |
|
2328 x = PyInt_FromLong(CL_RGBX); |
|
2329 if (x == NULL || PyDict_SetItemString(d, "RGBX", x) < 0) |
|
2330 return; |
|
2331 Py_DECREF(x); |
|
2332 #endif |
|
2333 #ifdef CL_RLE |
|
2334 x = PyInt_FromLong(CL_RLE); |
|
2335 if (x == NULL || PyDict_SetItemString(d, "RLE", x) < 0) |
|
2336 return; |
|
2337 Py_DECREF(x); |
|
2338 #endif |
|
2339 #ifdef CL_RLE24 |
|
2340 x = PyInt_FromLong(CL_RLE24); |
|
2341 if (x == NULL || PyDict_SetItemString(d, "RLE24", x) < 0) |
|
2342 return; |
|
2343 Py_DECREF(x); |
|
2344 #endif |
|
2345 #ifdef CL_RLE24_SOFTWARE |
|
2346 x = PyInt_FromLong(CL_RLE24_SOFTWARE); |
|
2347 if (x == NULL || PyDict_SetItemString(d, "RLE24_SOFTWARE", x) < 0) |
|
2348 return; |
|
2349 Py_DECREF(x); |
|
2350 #endif |
|
2351 #ifdef CL_RLE_SOFTWARE |
|
2352 x = PyInt_FromLong(CL_RLE_SOFTWARE); |
|
2353 if (x == NULL || PyDict_SetItemString(d, "RLE_SOFTWARE", x) < 0) |
|
2354 return; |
|
2355 Py_DECREF(x); |
|
2356 #endif |
|
2357 #ifdef CL_RTR |
|
2358 x = PyInt_FromLong(CL_RTR); |
|
2359 if (x == NULL || PyDict_SetItemString(d, "RTR", x) < 0) |
|
2360 return; |
|
2361 Py_DECREF(x); |
|
2362 #endif |
|
2363 #ifdef CL_RTR1 |
|
2364 x = PyInt_FromLong(CL_RTR1); |
|
2365 if (x == NULL || PyDict_SetItemString(d, "RTR1", x) < 0) |
|
2366 return; |
|
2367 Py_DECREF(x); |
|
2368 #endif |
|
2369 #ifdef CL_RTR_QUALITY_LEVEL |
|
2370 x = PyInt_FromLong(CL_RTR_QUALITY_LEVEL); |
|
2371 if (x == NULL || PyDict_SetItemString(d, "RTR_QUALITY_LEVEL", x) < 0) |
|
2372 return; |
|
2373 Py_DECREF(x); |
|
2374 #endif |
|
2375 #ifdef CL_SAMPLES_PER_TILE |
|
2376 x = PyInt_FromLong(CL_SAMPLES_PER_TILE); |
|
2377 if (x == NULL || PyDict_SetItemString(d, "SAMPLES_PER_TILE", x) < 0) |
|
2378 return; |
|
2379 Py_DECREF(x); |
|
2380 #endif |
|
2381 #ifdef CL_SCHEME_BUSY |
|
2382 x = PyInt_FromLong(CL_SCHEME_BUSY); |
|
2383 if (x == NULL || PyDict_SetItemString(d, "SCHEME_BUSY", x) < 0) |
|
2384 return; |
|
2385 Py_DECREF(x); |
|
2386 #endif |
|
2387 #ifdef CL_SCHEME_NOT_AVAILABLE |
|
2388 x = PyInt_FromLong(CL_SCHEME_NOT_AVAILABLE); |
|
2389 if (x == NULL || PyDict_SetItemString(d, "SCHEME_NOT_AVAILABLE", x) < 0) |
|
2390 return; |
|
2391 Py_DECREF(x); |
|
2392 #endif |
|
2393 #ifdef CL_SPEED |
|
2394 x = PyInt_FromLong(CL_SPEED); |
|
2395 if (x == NULL || PyDict_SetItemString(d, "SPEED", x) < 0) |
|
2396 return; |
|
2397 Py_DECREF(x); |
|
2398 #endif |
|
2399 #ifdef CL_STEREO_INTERLEAVED |
|
2400 x = PyInt_FromLong(CL_STEREO_INTERLEAVED); |
|
2401 if (x == NULL || PyDict_SetItemString(d, "STEREO_INTERLEAVED", x) < 0) |
|
2402 return; |
|
2403 Py_DECREF(x); |
|
2404 #endif |
|
2405 #ifdef CL_STREAM_HEADERS |
|
2406 x = PyInt_FromLong(CL_STREAM_HEADERS); |
|
2407 if (x == NULL || PyDict_SetItemString(d, "STREAM_HEADERS", x) < 0) |
|
2408 return; |
|
2409 Py_DECREF(x); |
|
2410 #endif |
|
2411 #ifdef CL_TILE_THRESHOLD |
|
2412 x = PyInt_FromLong(CL_TILE_THRESHOLD); |
|
2413 if (x == NULL || PyDict_SetItemString(d, "TILE_THRESHOLD", x) < 0) |
|
2414 return; |
|
2415 Py_DECREF(x); |
|
2416 #endif |
|
2417 #ifdef CL_TOP_DOWN |
|
2418 x = PyInt_FromLong(CL_TOP_DOWN); |
|
2419 if (x == NULL || PyDict_SetItemString(d, "TOP_DOWN", x) < 0) |
|
2420 return; |
|
2421 Py_DECREF(x); |
|
2422 #endif |
|
2423 #ifdef CL_ULAW |
|
2424 x = PyInt_FromLong(CL_ULAW); |
|
2425 if (x == NULL || PyDict_SetItemString(d, "ULAW", x) < 0) |
|
2426 return; |
|
2427 Py_DECREF(x); |
|
2428 #endif |
|
2429 #ifdef CL_UNCOMPRESSED |
|
2430 x = PyInt_FromLong(CL_UNCOMPRESSED); |
|
2431 if (x == NULL || PyDict_SetItemString(d, "UNCOMPRESSED", x) < 0) |
|
2432 return; |
|
2433 Py_DECREF(x); |
|
2434 #endif |
|
2435 #ifdef CL_UNCOMPRESSED_AUDIO |
|
2436 x = PyInt_FromLong(CL_UNCOMPRESSED_AUDIO); |
|
2437 if (x == NULL || PyDict_SetItemString(d, "UNCOMPRESSED_AUDIO", x) < 0) |
|
2438 return; |
|
2439 Py_DECREF(x); |
|
2440 #endif |
|
2441 #ifdef CL_UNCOMPRESSED_VIDEO |
|
2442 x = PyInt_FromLong(CL_UNCOMPRESSED_VIDEO); |
|
2443 if (x == NULL || PyDict_SetItemString(d, "UNCOMPRESSED_VIDEO", x) < 0) |
|
2444 return; |
|
2445 Py_DECREF(x); |
|
2446 #endif |
|
2447 #ifdef CL_UNKNOWN_SCHEME |
|
2448 x = PyInt_FromLong(CL_UNKNOWN_SCHEME); |
|
2449 if (x == NULL || PyDict_SetItemString(d, "UNKNOWN_SCHEME", x) < 0) |
|
2450 return; |
|
2451 Py_DECREF(x); |
|
2452 #endif |
|
2453 #ifdef CL_VIDEO |
|
2454 x = PyInt_FromLong(CL_VIDEO); |
|
2455 if (x == NULL || PyDict_SetItemString(d, "VIDEO", x) < 0) |
|
2456 return; |
|
2457 Py_DECREF(x); |
|
2458 #endif |
|
2459 #ifdef CL_Y |
|
2460 x = PyInt_FromLong(CL_Y); |
|
2461 if (x == NULL || PyDict_SetItemString(d, "Y", x) < 0) |
|
2462 return; |
|
2463 Py_DECREF(x); |
|
2464 #endif |
|
2465 #ifdef CL_YCbCr |
|
2466 x = PyInt_FromLong(CL_YCbCr); |
|
2467 if (x == NULL || PyDict_SetItemString(d, "YCbCr", x) < 0) |
|
2468 return; |
|
2469 Py_DECREF(x); |
|
2470 #endif |
|
2471 #ifdef CL_YCbCr422 |
|
2472 x = PyInt_FromLong(CL_YCbCr422); |
|
2473 if (x == NULL || PyDict_SetItemString(d, "YCbCr422", x) < 0) |
|
2474 return; |
|
2475 Py_DECREF(x); |
|
2476 #endif |
|
2477 #ifdef CL_YCbCr422DC |
|
2478 x = PyInt_FromLong(CL_YCbCr422DC); |
|
2479 if (x == NULL || PyDict_SetItemString(d, "YCbCr422DC", x) < 0) |
|
2480 return; |
|
2481 Py_DECREF(x); |
|
2482 #endif |
|
2483 #ifdef CL_YCbCr422HC |
|
2484 x = PyInt_FromLong(CL_YCbCr422HC); |
|
2485 if (x == NULL || PyDict_SetItemString(d, "YCbCr422HC", x) < 0) |
|
2486 return; |
|
2487 Py_DECREF(x); |
|
2488 #endif |
|
2489 #ifdef CL_YUV |
|
2490 x = PyInt_FromLong(CL_YUV); |
|
2491 if (x == NULL || PyDict_SetItemString(d, "YUV", x) < 0) |
|
2492 return; |
|
2493 Py_DECREF(x); |
|
2494 #endif |
|
2495 #ifdef CL_YUV422 |
|
2496 x = PyInt_FromLong(CL_YUV422); |
|
2497 if (x == NULL || PyDict_SetItemString(d, "YUV422", x) < 0) |
|
2498 return; |
|
2499 Py_DECREF(x); |
|
2500 #endif |
|
2501 #ifdef CL_YUV422DC |
|
2502 x = PyInt_FromLong(CL_YUV422DC); |
|
2503 if (x == NULL || PyDict_SetItemString(d, "YUV422DC", x) < 0) |
|
2504 return; |
|
2505 Py_DECREF(x); |
|
2506 #endif |
|
2507 #ifdef CL_YUV422HC |
|
2508 x = PyInt_FromLong(CL_YUV422HC); |
|
2509 if (x == NULL || PyDict_SetItemString(d, "YUV422HC", x) < 0) |
|
2510 return; |
|
2511 Py_DECREF(x); |
|
2512 #endif |
|
2513 #ifdef AWCMP_STEREO |
|
2514 x = PyInt_FromLong(AWCMP_STEREO); |
|
2515 if (x == NULL || PyDict_SetItemString(d, "AWCMP_STEREO", x) < 0) |
|
2516 return; |
|
2517 Py_DECREF(x); |
|
2518 #endif |
|
2519 #ifdef AWCMP_JOINT_STEREO |
|
2520 x = PyInt_FromLong(AWCMP_JOINT_STEREO); |
|
2521 if (x == NULL || PyDict_SetItemString(d, "AWCMP_JOINT_STEREO", x) < 0) |
|
2522 return; |
|
2523 Py_DECREF(x); |
|
2524 #endif |
|
2525 #ifdef AWCMP_INDEPENDENT |
|
2526 x = PyInt_FromLong(AWCMP_INDEPENDENT); |
|
2527 if (x == NULL || PyDict_SetItemString(d, "AWCMP_INDEPENDENT", x) < 0) |
|
2528 return; |
|
2529 Py_DECREF(x); |
|
2530 #endif |
|
2531 #ifdef AWCMP_FIXED_RATE |
|
2532 x = PyInt_FromLong(AWCMP_FIXED_RATE); |
|
2533 if (x == NULL || PyDict_SetItemString(d, "AWCMP_FIXED_RATE", x) < 0) |
|
2534 return; |
|
2535 Py_DECREF(x); |
|
2536 #endif |
|
2537 #ifdef AWCMP_CONST_QUAL |
|
2538 x = PyInt_FromLong(AWCMP_CONST_QUAL); |
|
2539 if (x == NULL || PyDict_SetItemString(d, "AWCMP_CONST_QUAL", x) < 0) |
|
2540 return; |
|
2541 Py_DECREF(x); |
|
2542 #endif |
|
2543 #ifdef AWCMP_LOSSLESS |
|
2544 x = PyInt_FromLong(AWCMP_LOSSLESS); |
|
2545 if (x == NULL || PyDict_SetItemString(d, "AWCMP_LOSSLESS", x) < 0) |
|
2546 return; |
|
2547 Py_DECREF(x); |
|
2548 #endif |
|
2549 #ifdef AWCMP_MPEG_LAYER_I |
|
2550 x = PyInt_FromLong(AWCMP_MPEG_LAYER_I); |
|
2551 if (x == NULL || PyDict_SetItemString(d, "AWCMP_MPEG_LAYER_I", x) < 0) |
|
2552 return; |
|
2553 Py_DECREF(x); |
|
2554 #endif |
|
2555 #ifdef AWCMP_MPEG_LAYER_II |
|
2556 x = PyInt_FromLong(AWCMP_MPEG_LAYER_II); |
|
2557 if (x == NULL || PyDict_SetItemString(d, "AWCMP_MPEG_LAYER_II", x) < 0) |
|
2558 return; |
|
2559 Py_DECREF(x); |
|
2560 #endif |
|
2561 |
|
2562 (void) clSetErrorHandler(cl_ErrorHandler); |
|
2563 } |