static char * convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf, size_t bufsize, PyObject **freelist) { char *format = *p_format; char c = *format++; #ifdef Py_USING_UNICODE PyObject *uarg; #endif switch (c) { case 'b': { /* unsigned byte -- very short int */ char *p = va_arg(*p_va, char *); long ival; if (float_argument_error(arg)) return converterr("integer<b>", arg, msgbuf, bufsize); ival = PyInt_AsLong(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<b>", arg, msgbuf, bufsize); else if (ival < 0) { PyErr_SetString(PyExc_OverflowError, "unsigned byte integer is less than minimum"); return converterr("integer<b>", arg, msgbuf, bufsize); } else if (ival > UCHAR_MAX) { PyErr_SetString(PyExc_OverflowError, "unsigned byte integer is greater than maximum"); return converterr("integer<b>", arg, msgbuf, bufsize); } else *p = (unsigned char) ival; break; } case 'B': {/* byte sized bitfield - both signed and unsigned values allowed */ char *p = va_arg(*p_va, char *); long ival; if (float_argument_error(arg)) return converterr("integer<B>", arg, msgbuf, bufsize); ival = PyInt_AsUnsignedLongMask(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<B>", arg, msgbuf, bufsize); else *p = (unsigned char) ival; break; } case 'h': {/* signed short int */ short *p = va_arg(*p_va, short *); long ival; if (float_argument_error(arg)) return converterr("integer<h>", arg, msgbuf, bufsize); ival = PyInt_AsLong(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<h>", arg, msgbuf, bufsize); else if (ival < SHRT_MIN) { PyErr_SetString(PyExc_OverflowError, "signed short integer is less than minimum"); return converterr("integer<h>", arg, msgbuf, bufsize); } else if (ival > SHRT_MAX) { PyErr_SetString(PyExc_OverflowError, "signed short integer is greater than maximum"); return converterr("integer<h>", arg, msgbuf, bufsize); } else *p = (short) ival; break; } case 'H': { /* short int sized bitfield, both signed and unsigned allowed */ unsigned short *p = va_arg(*p_va, unsigned short *); long ival; if (float_argument_error(arg)) return converterr("integer<H>", arg, msgbuf, bufsize); ival = PyInt_AsUnsignedLongMask(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<H>", arg, msgbuf, bufsize); else *p = (unsigned short) ival; break; } case 'i': {/* signed int */ int *p = va_arg(*p_va, int *); long ival; if (float_argument_error(arg)) return converterr("integer<i>", arg, msgbuf, bufsize); ival = PyInt_AsLong(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<i>", arg, msgbuf, bufsize); else if (ival > INT_MAX) { PyErr_SetString(PyExc_OverflowError, "signed integer is greater than maximum"); return converterr("integer<i>", arg, msgbuf, bufsize); } else if (ival < INT_MIN) { PyErr_SetString(PyExc_OverflowError, "signed integer is less than minimum"); return converterr("integer<i>", arg, msgbuf, bufsize); } else *p = ival; break; } case 'I': { /* int sized bitfield, both signed and unsigned allowed */ unsigned int *p = va_arg(*p_va, unsigned int *); unsigned int ival; if (float_argument_error(arg)) return converterr("integer<I>", arg, msgbuf, bufsize); ival = PyInt_AsUnsignedLongMask(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<I>", arg, msgbuf, bufsize); else *p = ival; break; } case 'l': {/* long int */ long *p = va_arg(*p_va, long *); long ival; if (float_argument_error(arg)) return converterr("integer<l>", arg, msgbuf, bufsize); ival = PyInt_AsLong(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<l>", arg, msgbuf, bufsize); else *p = ival; break; } case 'k': { /* long sized bitfield */ unsigned long *p = va_arg(*p_va, unsigned long *); unsigned long ival; if (PyInt_Check(arg)) ival = PyInt_AsUnsignedLongMask(arg); else if (PyLong_Check(arg)) ival = PyLong_AsUnsignedLongMask(arg); else return converterr("integer<k>", arg, msgbuf, bufsize); *p = ival; break; } #ifdef HAVE_LONG_LONG case 'L': {/* PY_LONG_LONG */ PY_LONG_LONG *p = va_arg( *p_va, PY_LONG_LONG * ); PY_LONG_LONG ival = PyLong_AsLongLong( arg ); if( ival == (PY_LONG_LONG)-1 && PyErr_Occurred() ) { return converterr("long<L>", arg, msgbuf, bufsize); } else { *p = ival; } break; } case 'K': { /* long long sized bitfield */ unsigned PY_LONG_LONG *p = va_arg(*p_va, unsigned PY_LONG_LONG *); unsigned PY_LONG_LONG ival; if (PyInt_Check(arg)) ival = PyInt_AsUnsignedLongMask(arg); else if (PyLong_Check(arg)) ival = PyLong_AsUnsignedLongLongMask(arg); else return converterr("integer<K>", arg, msgbuf, bufsize); *p = ival; break; } #endif case 'f': {/* float */ float *p = va_arg(*p_va, float *); double dval = PyFloat_AsDouble(arg); if (PyErr_Occurred()) return converterr("float<f>", arg, msgbuf, bufsize); else *p = (float) dval; break; } case 'd': {/* double */ double *p = va_arg(*p_va, double *); double dval = PyFloat_AsDouble(arg); if (PyErr_Occurred()) return converterr("float<d>", arg, msgbuf, bufsize); else *p = dval; break; } #ifndef WITHOUT_COMPLEX case 'D': {/* complex double */ Py_complex *p = va_arg(*p_va, Py_complex *); Py_complex cval; cval = PyComplex_AsCComplex(arg); if (PyErr_Occurred()) return converterr("complex<D>", arg, msgbuf, bufsize); else *p = cval; break; } #endif /* WITHOUT_COMPLEX */ case 'c': {/* char */ char *p = va_arg(*p_va, char *); if (PyString_Check(arg) && PyString_Size(arg) == 1) *p = PyString_AS_STRING(arg)[0]; else return converterr("char", arg, msgbuf, bufsize); break; } case 's': {/* string */ if (*format == '#') { void **p = (void **)va_arg(*p_va, char **); int *q = va_arg(*p_va, int *); if (PyString_Check(arg)) { *p = PyString_AS_STRING(arg); *q = PyString_GET_SIZE(arg); } #ifdef Py_USING_UNICODE else if (PyUnicode_Check(arg)) { uarg = UNICODE_DEFAULT_ENCODING(arg); if (uarg == NULL) return converterr(CONV_UNICODE, arg, msgbuf, bufsize); *p = PyString_AS_STRING(uarg); *q = PyString_GET_SIZE(uarg); } #endif else { /* any buffer-like object */ char *buf; int count = convertbuffer(arg, p, &buf); if (count < 0) return converterr(buf, arg, msgbuf, bufsize); *q = count; } format++; } else { char **p = va_arg(*p_va, char **); if (PyString_Check(arg)) *p = PyString_AS_STRING(arg); #ifdef Py_USING_UNICODE else if (PyUnicode_Check(arg)) { uarg = UNICODE_DEFAULT_ENCODING(arg); if (uarg == NULL) return converterr(CONV_UNICODE, arg, msgbuf, bufsize); *p = PyString_AS_STRING(uarg); } #endif else return converterr("string", arg, msgbuf, bufsize); if ((int)strlen(*p) != PyString_Size(arg)) return converterr("string without null bytes", arg, msgbuf, bufsize); } break; }
static char * convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf, size_t bufsize, PyObject **freelist) { char *format = *p_format; char c = *format++; switch (c) { case 'b': { /* unsigned byte -- very short int */ char *p = va_arg(*p_va, char *); long ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsLong(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<b>", arg, msgbuf, bufsize); else if (ival < 0) { PyErr_SetString(PyExc_OverflowError, "unsigned byte integer is less than minimum"); return converterr("integer<b>", arg, msgbuf, bufsize); } else if (ival > UCHAR_MAX) { PyErr_SetString(PyExc_OverflowError, "unsigned byte integer is greater than maximum"); return converterr("integer<b>", arg, msgbuf, bufsize); } else *p = (unsigned char) ival; break; } case 'B': {/* byte sized bitfield - both signed and unsigned values allowed */ char *p = va_arg(*p_va, char *); long ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsUnsignedLongMask(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<B>", arg, msgbuf, bufsize); else *p = (unsigned char) ival; break; } case 'h': {/* signed short int */ short *p = va_arg(*p_va, short *); long ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsLong(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<h>", arg, msgbuf, bufsize); else if (ival < SHRT_MIN) { PyErr_SetString(PyExc_OverflowError, "signed short integer is less than minimum"); return converterr("integer<h>", arg, msgbuf, bufsize); } else if (ival > SHRT_MAX) { PyErr_SetString(PyExc_OverflowError, "signed short integer is greater than maximum"); return converterr("integer<h>", arg, msgbuf, bufsize); } else *p = (short) ival; break; } case 'H': { /* short int sized bitfield, both signed and unsigned allowed */ unsigned short *p = va_arg(*p_va, unsigned short *); long ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsUnsignedLongMask(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<H>", arg, msgbuf, bufsize); else *p = (unsigned short) ival; break; } case 'i': {/* signed int */ int *p = va_arg(*p_va, int *); long ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsLong(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<i>", arg, msgbuf, bufsize); else if (ival > INT_MAX) { PyErr_SetString(PyExc_OverflowError, "signed integer is greater than maximum"); return converterr("integer<i>", arg, msgbuf, bufsize); } else if (ival < INT_MIN) { PyErr_SetString(PyExc_OverflowError, "signed integer is less than minimum"); return converterr("integer<i>", arg, msgbuf, bufsize); } else *p = ival; break; } case 'I': { /* int sized bitfield, both signed and unsigned allowed */ unsigned int *p = va_arg(*p_va, unsigned int *); unsigned int ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsUnsignedLongMask(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<I>", arg, msgbuf, bufsize); else *p = ival; break; } case 'l': {/* long int */ long *p = va_arg(*p_va, long *); long ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsLong(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<l>", arg, msgbuf, bufsize); else *p = ival; break; } case 'k': { /* long sized bitfield */ unsigned long *p = va_arg(*p_va, unsigned long *); unsigned long ival; if (PyInt_Check(arg)) ival = PyInt_AsUnsignedLongMask(arg); else if (PyLong_Check(arg)) ival = PyLong_AsUnsignedLongMask(arg); else return converterr("integer<k>", arg, msgbuf, bufsize); *p = ival; break; } case 'f': {/* float */ float *p = va_arg(*p_va, float *); double dval = PyFloat_AsDouble(arg); if (PyErr_Occurred()) return converterr("float<f>", arg, msgbuf, bufsize); else *p = (float) dval; break; } case 'd': {/* double */ double *p = va_arg(*p_va, double *); double dval = PyFloat_AsDouble(arg); if (PyErr_Occurred()) return converterr("float<d>", arg, msgbuf, bufsize); else *p = dval; break; } case 'c': {/* char */ char *p = va_arg(*p_va, char *); if (PyString_Check(arg) && PyString_Size(arg) == 1) *p = PyString_AS_STRING(arg)[0]; else return converterr("char", arg, msgbuf, bufsize); break; } case 's': {/* string */ if (*format == '#') { void **p = (void **)va_arg(*p_va, char **); int *q = va_arg(*p_va, int *); if (PyString_Check(arg)) { *p = PyString_AS_STRING(arg); *q = PyString_GET_SIZE(arg); } else { /* any buffer-like object */ char *buf; int count = convertbuffer(arg, p, &buf); if (count < 0) return converterr(buf, arg, msgbuf, bufsize); *q = count; } format++; } else { char **p = va_arg(*p_va, char **); if (PyString_Check(arg)) *p = PyString_AS_STRING(arg); else return converterr("string", arg, msgbuf, bufsize); if ((int)strlen(*p) != PyString_Size(arg)) return converterr("string without null bytes", arg, msgbuf, bufsize); } break; }
int init_colors(count_handle * handle, sv_storageinfo * pstorage, int * ppsize, int * pxzoom) { sv_storageinfo storage; unsigned char black[16]; unsigned char white[16]; unsigned char grey[16]; int psize; int xzoom; int i; memcpy(&storage, pstorage, sizeof(sv_storageinfo)); switch(storage.colormode) { case SV_COLORMODE_MONO: case SV_COLORMODE_CHROMA: psize = storage.nbits==8 ? 1 : 3; memset(&white, 0xEB, sizeof(white)); memset(&black, 0x10, sizeof(black)); memset(&grey, 0x80, sizeof(grey)); xzoom = (storage.nbits==8)?5:2; break; case SV_COLORMODE_YUV2QT: psize = storage.nbits==8 ? 2 : 6; for(i = 0; i < sizeof(grey); i+=2) { white[i ] = 0xeb; white[i+1] = 0x00; black[i ] = 0x10; black[i+1] = 0x00; grey [i ] = 0x80; grey [i+1] = 0x00; } xzoom = (storage.nbits==8)?4:2; break; case SV_COLORMODE_YUV422: psize = storage.nbits==8 ? 2 : 6; for(i = 0; i < sizeof(grey); i+=2) { white[i ] = 0x80; white[i+1] = 0xEB; black[i ] = 0x80; black[i+1] = 0x10; grey [i ] = 0x80; grey [i+1] = 0x80; } xzoom = (storage.nbits==8)?4:2; break; case SV_COLORMODE_RGB_BGR: case SV_COLORMODE_RGB_RGB: psize = 3; memset(&white, 0xEB, sizeof(white)); memset(&black, 0x10, sizeof(black)); memset(&grey, 0x80, sizeof(grey)); xzoom = (storage.nbits==8)?5:4; break; case SV_COLORMODE_YUV422A: if(storage.nbits == 8) { psize = 3; } else if(storage.nbits == 10) { psize = 3; } else { psize = 6; } for(i = 0; i < sizeof(grey)-2; i+=3) { white[i ] = 0x80; white[i+1] = 0xEB; white[i+2] = handle->alpha; black[i ] = 0x80; black[i+1] = 0x10; black[i+2] = 0; grey[i ] = 0x80; grey[i+1] = 0x80; grey[i+2] = 0; } xzoom = (storage.nbits==8)?5:4; break; case SV_COLORMODE_YUV444: if(storage.nbits == 8) { psize = 3; } else if(storage.nbits == 10) { psize = 3; } else { psize = 6; } for(i = 0; i < sizeof(grey)-2; i+=3) { white[i ] = 0x80; white[i+1] = 0xEB; white[i+2] = 0x80; black[i ] = 0x80; black[i+1] = 0x10; black[i+2] = 0x80; } memset(&grey, 0x80, sizeof(grey)); xzoom = (storage.nbits==8)?5:4; break; case SV_COLORMODE_ABGR: case SV_COLORMODE_ARGB: case SV_COLORMODE_BGRA: case SV_COLORMODE_RGBA: if(storage.nbits == 8) { psize = 4; xzoom = 5; } else if(storage.nbits == 10) { psize = 12; xzoom = 2; } else { psize = 6; xzoom = 5; } switch(storage.colormode) { case SV_COLORMODE_ABGR: case SV_COLORMODE_ARGB: for(i = 0; i < sizeof(grey)-3; i+=4) { white[i ] = handle->alpha; white[i+1] = 0xEB; white[i+2] = 0xEB; white[i+3] = 0xEB; black[i ] = 0; black[i+1] = 0x10; black[i+2] = 0x10; black[i+3] = 0x10; grey[i ] = 0; grey[i+1] = 0x80; grey[i+2] = 0x80; grey[i+3] = 0x80; } break; case SV_COLORMODE_BGRA: case SV_COLORMODE_RGBA: for(i = 0; i < sizeof(grey)-3; i+=4) { white[i ] = 0xEB; white[i+1] = 0xEB; white[i+2] = 0xEB; white[i+3] = handle->alpha; black[i ] = 0x10; black[i+1] = 0x10; black[i+2] = 0x10; black[i+3] = 0; grey[i ] = 0x80; grey[i+1] = 0x80; grey[i+2] = 0x80; grey[i+3] = 0; } break; } break; case SV_COLORMODE_YUV444A: psize = storage.nbits==8 ? 4 : 12; // 4 * 4 / 3 for(i = 0; i < sizeof(grey)-3; i+=4) { white[i ] = 0x80; white[i+1] = 0xEB; white[i+2] = 0x80; white[i+3] = handle->alpha; black[i ] = 0x80; black[i+1] = 0x10; black[i+2] = 0x80; black[i+3] = 0; grey[i ] = 0x80; grey[i+1] = 0x80; grey[i+2] = 0x80; grey[i+3] = 0; } xzoom = (storage.nbits==8)?5:2; break; default: printf("Colormode mode %d not supported\n", storage.colormode); return FALSE; } convertbuffer(&storage, &grey[0], psize, &handle->greyfill[0], NULL); convertbuffer(&storage, &white[0], psize, &handle->white[0], NULL); convertbuffer(&storage, &black[0], psize, &handle->black[0], &handle->minsize); if(ppsize) { *ppsize = psize; } if(pxzoom) { *pxzoom = xzoom; } return TRUE; }